nomen-lang 0.0.7 → 0.0.8

package/core/System/Buffer.nm

@@ -0,0 +1,526 @@
+// Buffer<T>: a flat buffer of value slots of type T. The value counterpart to
+// ClassBuffer<T>: no per-element freeing, store_int unconstrained. When T is a
+// class, the monomorphizer rewrites a Buffer<T> field to ClassBuffer<T>.
+/**
+ * A flat, low-level buffer of value slots of type T — the backing store for arrays and collections
+ **/
+pub struct Buffer<T> {
+	var uint64 data = 0
+	var cap = 0
+
+	func alloc = (ref self, int size, out int: out >= size) {
+		```
+		#arch: c
+		self->cap = size;
+		self->data = (unsigned long long)(unsigned int*)calloc(size, sizeof(unsigned int));
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		str x1, [x19, #16]
+		mov x0, x1
+		mov x1, #4
+		bl _calloc
+		str x0, [x19, #8]
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func grow = (ref self, int needed, out int: out >= needed) {
+		```
+		#arch: c
+		if (self->cap >= needed) return self->cap;
+		int new_cap = self->cap;
+		if (new_cap == 0) new_cap = 8;
+		while (new_cap < needed) new_cap *= 2;
+		self->data = (unsigned long long)(unsigned int*)realloc((unsigned int*)(unsigned long long)self->data, new_cap * sizeof(unsigned int));
+		memset((unsigned int*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(unsigned int));
+		self->cap = new_cap;
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		ldr x2, [x19, #16]
+		cmp x2, x1
+		b.ge .Lbuffer_grow_end
+		mov x3, #8
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		cmp x3, x1
+		b.ge .Lbuffer_grow_got
+		.Lbuffer_grow_loop:
+		lsl x3, x3, #1
+		cmp x3, x1
+		b.lt .Lbuffer_grow_loop
+		.Lbuffer_grow_got:
+		sub sp, sp, #16
+		str x2, [sp, #0]
+		str x3, [sp, #8]
+		ldr x0, [x19, #8]
+		lsl x1, x3, #2
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x2, [sp, #0]
+		ldr x3, [sp, #8]
+		add sp, sp, #16
+		str x3, [x19, #16]
+		add x0, x0, x2, lsl #2
+		mov x1, #0
+		sub x2, x3, x2
+		lsl x2, x2, #2
+		bl _memset
+		.Lbuffer_grow_end:
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func zero = (ref self, int len) {
+		```
+		#arch: c
+		memset((unsigned int*)(unsigned long long)self->data, 0, len * sizeof(unsigned int));
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x2, x1, #2
+		mov x1, #0
+		bl _memset
+		```
+	}
+
+	inline func load = (self, int i: i >= 0 && i < self.cap, out uint32) {
+		```
+		#arch: c
+		return ((unsigned int*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x1, x1, #2
+		add x0, x0, x1
+		ldr w0, [x0]
+		and x0, x0, #0xFFFFFFFF
+		```
+	}
+
+	inline func store = (ref self, int i: i >= 0 && i < self.cap, uint32 val) {
+		```
+		#arch: c
+		((unsigned int*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #2
+		add x0, x0, x3
+		str w2, [x0]
+		```
+	}
+
+	inline func store_or = (ref self, int i: i >= 0 && i < self.cap, uint32 val) {
+		```
+		#arch: c
+		((unsigned int*)(unsigned long long)self->data)[i] |= val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #2
+		add x0, x0, x3
+		ldr w3, [x0]
+		orr w3, w3, w2
+		str w3, [x0]
+		```
+	}
+
+	func alloc_int = (ref self, int size, out int: out >= size) {
+		```
+		#arch: c
+		self->cap = size;
+		self->data = (unsigned long long)(long*)calloc(size, sizeof(long));
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		str x1, [x19, #16]
+		mov x0, x1
+		mov x1, #8
+		bl _calloc
+		str x0, [x19, #8]
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func grow_int = (ref self, int needed, out int: out >= needed) {
+		```
+		#arch: c
+		if (self->cap >= needed) return self->cap;
+		int new_cap = self->cap;
+		if (new_cap == 0) new_cap = 4;
+		while (new_cap < needed) new_cap *= 2;
+		self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
+		memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
+		self->cap = new_cap;
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		ldr x2, [x19, #16]
+		cmp x2, x1
+		b.ge .Lbuffer_grow_int_end
+		mov x3, #4
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		cmp x3, x1
+		b.ge .Lbuffer_grow_int_got
+		.Lbuffer_grow_int_loop:
+		lsl x3, x3, #1
+		cmp x3, x1
+		b.lt .Lbuffer_grow_int_loop
+		.Lbuffer_grow_int_got:
+		sub sp, sp, #16
+		str x2, [sp, #0]
+		str x3, [sp, #8]
+		ldr x0, [x19, #8]
+		lsl x1, x3, #3
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x2, [sp, #0]
+		ldr x3, [sp, #8]
+		add sp, sp, #16
+		str x3, [x19, #16]
+		add x0, x0, x2, lsl #3
+		mov x1, #0
+		sub x2, x3, x2
+		lsl x2, x2, #3
+		bl _memset
+		.Lbuffer_grow_int_end:
+		ldr x0, [x19, #16]
+		```
+	}
+
+	inline func load_int = (self, int i: i >= 0 && i < self.cap, out int) {
+		```
+		#arch: c
+		return ((long*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x1, x1, #3
+		add x0, x0, x1
+		ldr x0, [x0]
+		```
+	}
+
+	inline func store_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+		```
+		#arch: c
+		((long*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		str x2, [x0]
+		```
+	}
+
+	// Move a value out of a slot: return it and clear the slot to 0. This is
+	// the ownership-extracting primitive (used by e.g. List.pop) — unlike
+	// load_int (a borrow read), it relinquishes the slot so the buffer no
+	// longer owns the value.
+	inline func move_int = (ref self, int i: i >= 0 && i < self.cap, out int) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		long val = slots[i];
+		slots[i] = 0;
+		return val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x3, x0, x3
+		ldr x0, [x3]
+		str xzr, [x3]
+		```
+	}
+
+	// Store into a slot, freeing the previous value when the buffer holds
+	// owned class pointers (has_class_refs). For non-class buffers this is a
+	// plain store, so it is safe to use anywhere store_int would be.
+	inline func replace_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+		```
+		#arch: c
+		((long*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		str x2, [x0]
+		```
+	}
+
+	inline func zero_int = (ref self, int len) {
+		```
+		#arch: c
+		memset((long*)(unsigned long long)self->data, 0, len * sizeof(long));
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x2, x1, #3
+		mov x1, #0
+		bl _memset
+		```
+	}
+
+	// T_SIZE-aware primitives for value-struct elements. Slab is sized in
+	// multiples of T_SIZE; load/store use memcpy so multi-word structs work
+	// correctly. Classes route to ClassBuffer<T> (per-element destroy), so T
+	// reaching here is always a value type (primitive or struct).
+
+	func alloc_T = (ref self, int size, out int: out >= size) {
+		```
+		#arch: c
+		self->cap = size;
+		self->data = (unsigned long long)(T*)calloc(size, T_SIZE);
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		str x1, [x19, #16]
+		mov x0, x1
+		mov x1, #T_SIZE
+		bl _calloc
+		str x0, [x19, #8]
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func grow_T = (ref self, int needed, out int: out >= needed) {
+		```
+		#arch: c
+		if (self->cap >= needed) return self->cap;
+		int new_cap = self->cap;
+		if (new_cap == 0) new_cap = 4;
+		while (new_cap < needed) new_cap *= 2;
+		self->data = (unsigned long long)(T*)realloc((T*)(unsigned long long)self->data, new_cap * T_SIZE);
+		memset((char*)(unsigned long long)self->data + self->cap * T_SIZE, 0, (new_cap - self->cap) * T_SIZE);
+		self->cap = new_cap;
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		ldr x2, [x19, #16]
+		cmp x2, x1
+		b.ge .Lbuffer_grow_T_end
+		mov x3, #4
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		cmp x3, x1
+		b.ge .Lbuffer_grow_T_got
+		.Lbuffer_grow_T_loop:
+		lsl x3, x3, #1
+		cmp x3, x1
+		b.lt .Lbuffer_grow_T_loop
+		.Lbuffer_grow_T_got:
+		sub sp, sp, #32
+		str x2, [sp, #0]
+		str x3, [sp, #8]
+		mov x4, #T_SIZE
+		str x4, [sp, #16]
+		ldr x0, [x19, #8]
+		madd x1, x3, x4, xzr
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x2, [sp, #0]
+		ldr x3, [sp, #8]
+		ldr x4, [sp, #16]
+		add sp, sp, #32
+		str x3, [x19, #16]
+		ldr x0, [x19, #8]
+		mul x5, x2, x4
+		add x0, x0, x5
+		sub x2, x3, x2
+		mul x2, x2, x4
+		mov x1, #0
+		bl _memset
+		.Lbuffer_grow_T_end:
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
+		```
+		#arch: c
+		return ((T*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = i, x8 = return buf for structs
+		ldr x0, [x19, #8]
+		mov x3, #T_SIZE
+		madd x1, x1, x3, xzr
+		add x0, x0, x1
+		cmp x3, #8
+		b.gt .Lbuffer_load_T_copy
+		ldr x0, [x0]
+		b .Lbuffer_load_T_end
+		.Lbuffer_load_T_copy:
+		mov x1, x0
+		mov x0, x8
+		mov x2, x3
+		bl _memcpy
+		.Lbuffer_load_T_end:
+		```
+	}
+
+	func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
+		```
+		#arch: c
+		((T*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = i, x2 = val (value if T_SIZE<=8, address if struct)
+		ldr x0, [x19, #8]
+		mov x3, #T_SIZE
+		madd x1, x1, x3, xzr
+		add x0, x0, x1
+		cmp x3, #8
+		b.gt .Lbuffer_store_T_copy
+		str x2, [x0]
+		b .Lbuffer_store_T_end
+		.Lbuffer_store_T_copy:
+		mov x1, x2
+		mov x2, x3
+		bl _memcpy
+		.Lbuffer_store_T_end:
+		```
+	}
+
+	// A non-owning (ptr, len) slice [start, end) over this buffer's element
+	// storage, returned as a `view T`. It borrows from self: it may not outlive
+	// self's scope and is invalidated if self is reassigned. This is the single
+	// primitive every other slice (Array<T>, List<T>, user containers) builds
+	// on — higher layers just `return self.items.slice(start, end)`.
+	func slice = (self, int start: start >= 0, int end: end >= start, out view T) {
+		```
+		#arch: c
+		nomen_view _r;
+		_r.ptr = (void*)((T*)(unsigned long long)self->data + start);
+		_r.len = (long)(end - start);
+		return _r;
+		```
+		```
+		#arch: aarch64
+		// x19 = self (Buffer struct ptr), x1 = start, x2 = end.
+		// self->data lives at [x19, #8]. Return (ptr, len) in x0/x1.
+		ldr x0, [x19, #8]
+		mov x3, #T_SIZE
+		madd x0, x1, x3, x0
+		sub x1, x2, x1
+		```
+	}
+
+	inline func zero_T = (ref self, int len) {
+		```
+		#arch: c
+		memset((T*)(unsigned long long)self->data, 0, len * T_SIZE);
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		mov x2, #T_SIZE
+		mul x2, x1, x2
+		mov x1, #0
+		bl _memset
+		```
+	}
+
+	inline func store_or_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+		```
+		#arch: c
+		((long*)(unsigned long long)self->data)[i] |= val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		ldr x3, [x0]
+		orr x3, x3, x2
+		str x3, [x0]
+		```
+	}
+
+	func alloc_float = (ref self, int size, out int: out >= size) {
+		```
+		#arch: c
+		self->cap = size;
+		self->data = (unsigned long long)(double*)calloc(size, sizeof(double));
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		str x1, [x19, #16]
+		mov x0, x1
+		mov x1, #8
+		bl _calloc
+		str x0, [x19, #8]
+		ldr x0, [x19, #16]
+		```
+	}
+
+	inline func load_float = (self, int i: i >= 0 && i < self.cap, out float) {
+		```
+		#arch: c
+		return ((double*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x1, x1, #3
+		add x0, x0, x1
+		ldr x0, [x0]
+		```
+	}
+
+	inline func store_float = (ref self, int i: i >= 0 && i < self.cap, float val) {
+		```
+		#arch: c
+		((double*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		str x2, [x0]
+		```
+	}
+
+	func #destroy = () {
+		```
+		#arch: c
+		if (self->data) free((unsigned int*)(unsigned long long)self->data);
+		self->data = 0;
+		self->cap = 0;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lbuffer_destroy_end
+		bl _free
+		.Lbuffer_destroy_end:
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
+		```
+	}
+}

package/core/System/Channel.nm

@@ -0,0 +1,198 @@
+// Channel — thread-safe single-direction queue for passing values between
+// tasks. Unbounded, FIFO, blocking receive.
+//
+// Stores uint64 values (Nomen values are pointer-sized on every target we
+// care about). A typed Channel<T> wrapper can come later — the storage story
+// is identical, only the call-site types change.
+//
+// Default stance in Nomen is "no shared mutable state" — channels are the
+// preferred way for tasks to communicate. See ASYNC.md.
+
+/**
+ * A thread-safe, blocking FIFO queue for passing values between tasks
+ **/
+pub class Channel: Sendable {
+	pub var uint64 mu = 0
+	pub var uint64 not_empty_cv = 0
+	pub var uint64 head = 0
+	pub var uint64 tail = 0
+
+	pub func #init = (self) {
+		```
+		#arch: c
+		#scope: file
+		#include <pthread.h>
+		struct nomen_channel_node {
+			unsigned long long value;
+			struct nomen_channel_node *next;
+		};
+		```
+		```
+		#arch: c
+		self->mu = (unsigned long long)malloc(sizeof(pthread_mutex_t));
+		self->not_empty_cv = (unsigned long long)malloc(sizeof(pthread_cond_t));
+		pthread_mutex_init((pthread_mutex_t *)self->mu, NULL);
+		pthread_cond_init((pthread_cond_t *)self->not_empty_cv, NULL);
+		self->head = 0;
+		self->tail = 0;
+		```
+		```
+		#arch: aarch64
+		mov x0, #64
+		bl _malloc
+		str x0, [x19, #8]
+		mov x1, #0
+		bl _pthread_mutex_init
+		mov x0, #64
+		bl _malloc
+		str x0, [x19, #16]
+		mov x1, #0
+		bl _pthread_cond_init
+		str xzr, [x19, #24]
+		str xzr, [x19, #32]
+		```
+	}
+
+	pub func send = (self, uint64 value) {
+		```
+		#arch: c
+		struct nomen_channel_node *n = (struct nomen_channel_node *)malloc(sizeof(struct nomen_channel_node));
+		n->value = value;
+		n->next = NULL;
+		pthread_mutex_lock((pthread_mutex_t *)self->mu);
+		if (self->tail) {
+			((struct nomen_channel_node *)self->tail)->next = n;
+		} else {
+			self->head = (unsigned long long)n;
+		}
+		self->tail = (unsigned long long)n;
+		pthread_cond_signal((pthread_cond_t *)self->not_empty_cv);
+		pthread_mutex_unlock((pthread_mutex_t *)self->mu);
+		```
+		```
+		#arch: aarch64
+		// x19 = self (set by prologue), x1 = value
+		str x1, [sp, #-16]!       // save value on stack
+		mov x0, #16
+		bl _malloc                // x0 = node
+		ldr x1, [sp], #16         // restore value
+		str x1, [x0, #0]          // node->value = value
+		str xzr, [x0, #8]         // node->next = NULL
+		str x0, [sp, #-16]!       // save node on stack
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_lock
+		ldr x2, [sp], #16         // restore node
+		ldr x1, [x19, #32]        // tail
+		cbz x1, .Lchannel_send_empty
+		str x2, [x1, #8]          // tail->next = node
+		b .Lchannel_send_enqueued
+		.Lchannel_send_empty:
+		str x2, [x19, #24]        // head = node
+		.Lchannel_send_enqueued:
+		str x2, [x19, #32]        // tail = node
+		ldr x0, [x19, #16]        // not_empty_cv
+		bl _pthread_cond_signal
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_unlock
+		```
+	}
+
+	pub func receive = (self, out uint64) {
+		```
+		#arch: c
+		pthread_mutex_lock((pthread_mutex_t *)self->mu);
+		while (!self->head) {
+			pthread_cond_wait((pthread_cond_t *)self->not_empty_cv, (pthread_mutex_t *)self->mu);
+		}
+		struct nomen_channel_node *n = (struct nomen_channel_node *)self->head;
+		self->head = (unsigned long long)n->next;
+		if (!self->head) self->tail = 0;
+		unsigned long long v = n->value;
+		free(n);
+		pthread_mutex_unlock((pthread_mutex_t *)self->mu);
+		return v;
+		```
+		```
+		#arch: aarch64
+		// x19 = self (set by prologue)
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_lock
+		.Lchannel_receive_wait:
+		ldr x1, [x19, #24]        // head
+		cbnz x1, .Lchannel_receive_got
+		ldr x0, [x19, #16]        // not_empty_cv
+		ldr x1, [x19, #8]         // mu
+		bl _pthread_cond_wait
+		b .Lchannel_receive_wait
+		.Lchannel_receive_got:
+		// x1 = node
+		ldr x2, [x1, #8]          // node->next
+		str x2, [x19, #24]        // head = node->next
+		cbnz x2, .Lchannel_receive_not_empty
+		str xzr, [x19, #32]       // tail = 0
+		.Lchannel_receive_not_empty:
+		ldr x0, [x1, #0]          // x0 = value
+		str x0, [sp, #-16]!       // push value
+		mov x0, x1                // x0 = node (for free)
+		bl _free
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_unlock
+		ldr x0, [sp], #16         // pop value → x0 (return)
+		```
+	}
+
+	pub func #destroy = () {
+		```
+		#arch: c
+		if (self->mu) {
+			// Drain any pending nodes.
+			struct nomen_channel_node *n = (struct nomen_channel_node *)self->head;
+			while (n) {
+				struct nomen_channel_node *next = n->next;
+				free(n);
+				n = next;
+			}
+			pthread_mutex_destroy((pthread_mutex_t *)self->mu);
+			pthread_cond_destroy((pthread_cond_t *)self->not_empty_cv);
+			free((void *)self->mu);
+			free((void *)self->not_empty_cv);
+			self->mu = 0;
+			self->not_empty_cv = 0;
+			self->head = 0;
+			self->tail = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self (set by prologue)
+		ldr x0, [x19, #8]         // self->mu
+		cbz x0, .Lchannel_destroy_done
+		// Drain nodes
+		ldr x1, [x19, #24]        // head
+		.Lchannel_destroy_drain:
+		cbz x1, .Lchannel_destroy_drained
+		ldr x2, [x1, #8]          // next (before free clobbers it)
+		str x2, [sp, #-16]!       // save next on stack
+		bl _free
+		ldr x1, [sp], #16         // restore next
+		b .Lchannel_destroy_drain
+		.Lchannel_destroy_drained:
+		// Destroy mutex and condvar
+		ldr x0, [x19, #8]
+		bl _pthread_mutex_destroy
+		ldr x0, [x19, #16]
+		bl _pthread_cond_destroy
+		// Free mutex and condvar allocations
+		ldr x0, [x19, #8]
+		bl _free
+		ldr x0, [x19, #16]
+		bl _free
+		// Zero all fields
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
+		str xzr, [x19, #24]
+		str xzr, [x19, #32]
+		.Lchannel_destroy_done:
+		```
+	}
+}