nomen-lang 0.0.10 → 0.0.12

package/core/System/Array.nm

@@ -38,10 +38,35 @@ pub struct Array<T>: Viewable {
 		```
 		```
 		#arch: aarch64
-		// x19 = self (first elem), x1 = index
+		// x19 = self (first elem), x1 = index, x8 = return buf for structs
 		mov x2, #T_SIZE
 		mul x1, x1, x2
+		cmp x2, #8
+		b.eq .L_at_8
+		b.gt .L_at_copy
+		cmp x2, #1
+		b.eq .L_at_1
+		cmp x2, #2
+		b.eq .L_at_2
+		ldr w0, [x19, x1]
+		b .L_at_end
+		.L_at_8:
 		ldr x0, [x19, x1]
+		b .L_at_end
+		.L_at_1:
+		ldrb w0, [x19, x1]
+		b .L_at_end
+		.L_at_2:
+		ldrh w0, [x19, x1]
+		b .L_at_end
+		// Struct element (T_SIZE > 8): copy the slot bytes into the x8
+		// sret buffer and return its address (Buffer.load_T convention).
+		.L_at_copy:
+		mov x0, x8
+		add x1, x19, x1
+		bl _memcpy
+		mov x0, x8
+		.L_at_end:
 		```
 	}
 
@@ -53,8 +78,35 @@ pub struct Array<T>: Viewable {
 		```
 		```
 		#arch: aarch64
-		// x19 = self (first elem)
+		// x19 = self (first elem), x8 = return buf for structs
+		mov x3, #T_SIZE
+		cmp x3, #8
+		b.eq .L_first_8
+		b.gt .L_first_copy
+		cmp x3, #1
+		b.eq .L_first_1
+		cmp x3, #2
+		b.eq .L_first_2
+		ldr w0, [x19]
+		b .L_first_end
+		.L_first_8:
 		ldr x0, [x19]
+		b .L_first_end
+		.L_first_1:
+		ldrb w0, [x19]
+		b .L_first_end
+		.L_first_2:
+		ldrh w0, [x19]
+		b .L_first_end
+		// Struct element (T_SIZE > 8): copy the first slot's bytes into
+		// the x8 sret buffer and return its address.
+		.L_first_copy:
+		mov x0, x8
+		mov x1, x19
+		mov x2, x3
+		bl _memcpy
+		mov x0, x8
+		.L_first_end:
 		```
 	}
 
@@ -75,18 +127,35 @@ pub struct Array<T>: Viewable {
 		```
 		```
 		#arch: aarch64
-		// x19 = self (first elem), x1 = index, x2 = value
+		// x19 = self (first elem), x1 = index, x2 = value (address if struct)
 		mov x3, #T_SIZE
 		mul x1, x1, x3
-		// Only use the 8-byte store when T_SIZE is exactly 8 (int/string/ptr).
-		// For smaller types (char/bool/int8/etc.) strb/strh/str w/ would
-		// clobber adjacent slots, so fall through to a size-aware store.
 		cmp x3, #8
-		b.ne .L_set_byte
+		b.eq .L_set_8
+		b.gt .L_set_copy
+		cmp x3, #1
+		b.eq .L_set_1
+		cmp x3, #2
+		b.eq .L_set_2
+		str w2, [x19, x1]
+		b .L_set_done
+		.L_set_8:
 		str x2, [x19, x1]
 		b .L_set_done
-		.L_set_byte:
+		.L_set_1:
 		strb w2, [x19, x1]
+		b .L_set_done
+		.L_set_2:
+		strh w2, [x19, x1]
+		b .L_set_done
+		// Struct element (T_SIZE > 8): x2 holds the ADDRESS of the value
+		// bytes — memcpy them into the slot (Buffer.store_T convention).
+		.L_set_copy:
+		mov x0, x19
+		add x0, x0, x1
+		mov x1, x2
+		mov x2, x3
+		bl _memcpy
 		.L_set_done:
 		```
 	}
@@ -99,12 +168,38 @@ pub struct Array<T>: Viewable {
 		```
 		```
 		#arch: aarch64
-		// x19 = self (first elem), length at [x19 - 8]
+		// x19 = self (first elem), length at [x19 - 8], x8 = return buf for structs
 		ldr x0, [x19, #-8]
 		sub x0, x0, #1
 		mov x1, #T_SIZE
 		mul x0, x0, x1
+		cmp x1, #8
+		b.eq .L_at_end_8
+		b.gt .L_at_end_copy
+		cmp x1, #1
+		b.eq .L_at_end_1
+		cmp x1, #2
+		b.eq .L_at_end_2
+		ldr w0, [x19, x0]
+		b .L_at_end_done
+		.L_at_end_8:
 		ldr x0, [x19, x0]
+		b .L_at_end_done
+		.L_at_end_1:
+		ldrb w0, [x19, x0]
+		b .L_at_end_done
+		.L_at_end_2:
+		ldrh w0, [x19, x0]
+		b .L_at_end_done
+		// Struct element (T_SIZE > 8): x0 = byte offset of the last slot —
+		// copy its bytes into the x8 sret buffer and return its address.
+		.L_at_end_copy:
+		mov x2, x1
+		add x1, x19, x0
+		mov x0, x8
+		bl _memcpy
+		mov x0, x8
+		.L_at_end_done:
 		```
 	}
 

package/core/System/Buffer.nm

@@ -370,8 +370,26 @@ pub struct Buffer<T> {
 		add x0, x0, x1
 		cmp x3, #8
 		b.gt .Lbuffer_load_T_copy
+		// Width-matched load (zero-extends) — an 8-byte ldr on a sub-8
+		// element would read past the slab's end and leave garbage in the
+		// upper bits.
+		cmp x3, #1
+		b.eq .Lbuffer_load_T_1
+		cmp x3, #2
+		b.eq .Lbuffer_load_T_2
+		cmp x3, #4
+		b.eq .Lbuffer_load_T_4
 		ldr x0, [x0]
 		b .Lbuffer_load_T_end
+		.Lbuffer_load_T_1:
+		ldrb w0, [x0]
+		b .Lbuffer_load_T_end
+		.Lbuffer_load_T_2:
+		ldrh w0, [x0]
+		b .Lbuffer_load_T_end
+		.Lbuffer_load_T_4:
+		ldr w0, [x0]
+		b .Lbuffer_load_T_end
 		.Lbuffer_load_T_copy:
 		mov x1, x0
 		mov x0, x8
@@ -395,8 +413,25 @@ pub struct Buffer<T> {
 		add x0, x0, x1
 		cmp x3, #8
 		b.gt .Lbuffer_store_T_copy
+		// Sub-8 element types must use a width-matched store: an 8-byte str
+		// would clobber the following slots (and run past the slab's end).
+		cmp x3, #1
+		b.eq .Lbuffer_store_T_1
+		cmp x3, #2
+		b.eq .Lbuffer_store_T_2
+		cmp x3, #4
+		b.eq .Lbuffer_store_T_4
 		str x2, [x0]
 		b .Lbuffer_store_T_end
+		.Lbuffer_store_T_1:
+		strb w2, [x0]
+		b .Lbuffer_store_T_end
+		.Lbuffer_store_T_2:
+		strh w2, [x0]
+		b .Lbuffer_store_T_end
+		.Lbuffer_store_T_4:
+		str w2, [x0]
+		b .Lbuffer_store_T_end
 		.Lbuffer_store_T_copy:
 		mov x1, x2
 		mov x2, x3
@@ -405,6 +440,115 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Move a value out of a T_SIZE-sized slot: return it and zero the slot so the
+	// buffer no longer holds a (possibly owning) copy. Declared `mov out T` so
+	// the result is treated as OWNED by the borrow checker — the slot is
+	// relinquished, so the caller is the sole remaining owner. The value
+	// counterpart of ClassBuffer.move_int — used by List.pop for any value T.
+	inline func move_T = (ref self, int i: i >= 0 && i < self.cap, mov out T) {
+		```
+		#arch: c
+		T* _slots = (T*)(unsigned long long)self->data;
+		T _tmp = _slots[i];
+		memset((void*)&_slots[i], 0, T_SIZE);
+		return _tmp;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = i, x8 = return buf when T_SIZE > 8
+		ldr x4, [x19, #8]
+		mov x3, #T_SIZE
+		madd x5, x1, x3, xzr
+		add x5, x4, x5
+		cmp x3, #8
+		b.gt .Lbuffer_move_T_copy
+		// Width-matched load + zero-clear: an 8-byte access on a sub-8
+		// element would zero the following slots and run past the slab.
+		cmp x3, #1
+		b.eq .Lbuffer_move_T_1
+		cmp x3, #2
+		b.eq .Lbuffer_move_T_2
+		cmp x3, #4
+		b.eq .Lbuffer_move_T_4
+		ldr x0, [x5]
+		str xzr, [x5]
+		b .Lbuffer_move_T_end
+		.Lbuffer_move_T_1:
+		ldrb w0, [x5]
+		strb wzr, [x5]
+		b .Lbuffer_move_T_end
+		.Lbuffer_move_T_2:
+		ldrh w0, [x5]
+		strh wzr, [x5]
+		b .Lbuffer_move_T_end
+		.Lbuffer_move_T_4:
+		ldr w0, [x5]
+		str wzr, [x5]
+		b .Lbuffer_move_T_end
+		.Lbuffer_move_T_copy:
+		mov x0, x8
+		mov x1, x5
+		mov x2, x3
+		stp x5, x3, [sp, #-16]!
+		bl _memcpy
+		ldp x5, x3, [sp], #16
+		mov x0, x5
+		mov x1, #0
+		mov x2, x3
+		bl _memset
+		mov x0, x8
+		.Lbuffer_move_T_end:
+		```
+	}
+
+	// Store into a T_SIZE-sized slot, overwriting the previous value. For
+	// trivially-destructible value structs this is a plain overwrite. For
+	// owning value structs (with string fields), the build phase replaces this
+	// body with a specialised version that calls T_destroy on the old slot
+	// value, then deep-copies (strdup per string field). See
+	// owning_buffer_specialize.ts (both backends). ClassBuffer.replace_T
+	// destroys+frees class slots soundly.
+	inline func replace_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_replace_T_copy
+		// Width-matched store: an 8-byte str on a sub-8 element would
+		// clobber the following slots and run past the slab's end.
+		cmp x3, #1
+		b.eq .Lbuffer_replace_T_1
+		cmp x3, #2
+		b.eq .Lbuffer_replace_T_2
+		cmp x3, #4
+		b.eq .Lbuffer_replace_T_4
+		str x2, [x0]
+		b .Lbuffer_replace_T_end
+		.Lbuffer_replace_T_1:
+		strb w2, [x0]
+		b .Lbuffer_replace_T_end
+		.Lbuffer_replace_T_2:
+		strh w2, [x0]
+		b .Lbuffer_replace_T_end
+		.Lbuffer_replace_T_4:
+		str w2, [x0]
+		b .Lbuffer_replace_T_end
+		.Lbuffer_replace_T_copy:
+		mov x1, x2
+		mov x2, x3
+		bl _memcpy
+		.Lbuffer_replace_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

package/core/System/ClassBuffer.nm

@@ -91,6 +91,115 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// T_SIZE-aware aliases of the _int primitives. ClassBuffer only ever holds
+	// 8-byte class pointers (T_SIZE is 8), so these are behaviorally identical
+	// to their _int counterparts — they exist so List<T> can call a single
+	// uniform `_T` API whether T is a value struct (Buffer) or a class
+	// (ClassBuffer, after the Buffer<T> field is rewritten). Bodies use 8-byte
+	// slots, matching _int.
+
+	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)(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 .Lcb_grow_T_end
+		mov x3, #4
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		cmp x3, x1
+		b.ge .Lcb_grow_T_got
+		.Lcb_grow_T_loop:
+		lsl x3, x3, #1
+		cmp x3, x1
+		b.lt .Lcb_grow_T_loop
+		.Lcb_grow_T_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
+		.Lcb_grow_T_end:
+		ldr x0, [x19, #16]
+		```
+	}
+
+	inline func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
+		```
+		#arch: c
+		return (void*)((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_T = (ref self, int i: i >= 0 && i < self.cap, T val: val != 0) {
+		```
+		#arch: c
+		((long*)(unsigned long long)self->data)[i] = (long)val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		str x2, [x0]
+		```
+	}
+
+	// Move a class pointer out of a slot: return it and zero the slot so the
+	// buffer no longer references it. Declared `mov out T` so the borrow
+	// checker treats the result as OWNED — the slot is relinquished, so the
+	// caller is the sole remaining owner. This is the owning-extract primitive
+	// (parallel to List.pop); use it (not load_T) when transferring ownership
+	// out of a ClassBuffer slot, or moving a value into a fresh owning
+	// container — load_T returns a BORROW (the slot is unchanged) and storing
+	// it elsewhere would create shared ownership (double-free at destroy).
+	inline func move_T = (ref self, int i: i >= 0 && i < self.cap, mov out T) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		void *val = (void*)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]
+		```
+	}
+
 	inline func store_int = (ref self, int i: i >= 0 && i < self.cap, int val: val != 0) {
 		```
 		#arch: c
@@ -156,6 +265,40 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// T-typed alias of replace_int: free the outgoing class pointer (destroy +
+	// free) then store the new one. Used by List.set so the uniform `_T` API
+	// preserves ownership for class elements.
+	func replace_T = (ref self, int i: i >= 0 && i < self.cap, T val: val != 0) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		if (slots[i]) {
+			T_destroy((void*)slots[i]);
+			free((void*)slots[i]);
+		}
+		slots[i] = (long)val;
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		str x22, [sp, #-16]!
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x21, x0, x3
+		mov x20, x2
+		ldr x0, [x21]
+		cbz x0, .Lcb_replace_T_store
+		mov x22, x0
+		bl T_destroy
+		mov x0, x22
+		bl _free
+		.Lcb_replace_T_store:
+		str x20, [x21]
+		ldr x22, [sp], #16
+		ldp x20, x21, [sp], #16
+		```
+	}
+
 	// A non-owning (ptr, len) slice [start, end) over this buffer's class
 	// pointers, returned as a `view T` (T is a class, so each element is an
 	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors

package/core/System/Graph.nm

@@ -16,9 +16,8 @@ pub struct Graph<T>: Enumerable {
 
 	pub func add_node = (ref self, mov T value) {
 		var int idx = self.node_count
-		self.values.grow_int(idx + 1)
-		var int v = value
-		self.values.store_int(idx, v)
+		self.values.grow_T(idx + 1)
+		self.values.store_T(idx, value)
 		self.head_edge.grow_int(idx + 1)
 		self.head_edge.store_int(idx, -1)
 		self.node_count = self.node_count + 1
@@ -51,11 +50,11 @@ pub struct Graph<T>: Enumerable {
 	}
 
 	pub func first = (self: self.node_count > 0, out T) {
-		return self.values.load_int(0)
+		return self.values.load_T(0)
 	}
 
 	pub func at = (self, int idx: idx >= 0 && idx < self.node_count, out T) {
-		return self.values.load_int(idx)
+		return self.values.load_T(idx)
 	}
 
 	pub func node_length = (self, out int) {

package/core/System/Init.nm

@@ -1,9 +1,11 @@
 /**
- * Program startup state — the argument count and argument list passed to `main`
+ * Program startup state — the argument count and argument list passed to `main`,
+ * plus whether stdout is a terminal (for renderer selection).
  **/
 pub struct Init {
 	var int argc
 	var string[16] args
+	var bool is_tty
 }
 
 /**

package/core/System/LinkedList.nm

@@ -15,9 +15,8 @@ pub struct LinkedList<T>: Enumerable {
 
 	pub func add = (ref self, mov T value) {
 		var int idx = self.count
-		self.values.grow_int(idx + 1)
-		var int v = value
-		self.values.store_int(idx, v)
+		self.values.grow_T(idx + 1)
+		self.values.store_T(idx, value)
 		self.nexts.grow_int(idx + 1)
 		self.nexts.store_int(idx, -1)
 		self.prevs.grow_int(idx + 1)
@@ -51,11 +50,11 @@ pub struct LinkedList<T>: Enumerable {
 	}
 
 	pub func first = (self: self.count > 0, out T) {
-		return self.values.load_int(0)
+		return self.values.load_T(0)
 	}
 
 	pub func at = (self, int idx: idx >= 0 && idx < self.count, out T) {
-		return self.values.load_int(idx)
+		return self.values.load_T(idx)
 	}
 
 	pub func length = (self, out int) {

package/core/System/List.nm

@@ -12,23 +12,23 @@ pub struct List<T>: Viewable {
 			if old_cap >= 4 {
 				new_cap = old_cap * 2
 			}
-			self.items.grow_int(new_cap)
+			self.items.grow_T(new_cap)
 		}
-		self.items.store_int(self.length, value)
+		self.items.store_T(self.length, value)
 		self.length += 1
 	}
 
 	pub func pop = (ref self, mov out T) {
 		if self.length <= 0 {
-			return 0
+			return self.items.move_T(0)
 		}
 		var int idx = self.length - 1
 		self.length = idx
-		return self.items.move_int(idx)
+		return self.items.move_T(idx)
 	}
 
 	pub func at = (self, int i: i >= 0 && i < self.length, out T) {
-		return self.items.load_int(i)
+		return self.items.load_T(i)
 	}
 
 	// A non-owning `view T` over [start, end). Delegates to the backing Buffer's
@@ -38,7 +38,25 @@ pub struct List<T>: Viewable {
 	}
 
 	pub func set = (ref self, int i: i >= 0 && i < self.length, mov T value) {
-		var int v = value
-		self.items.replace_int(i, v)
+		self.items.replace_T(i, value)
+	}
+
+	// A deep copy: a fresh List<T> with an independent copy of every element.
+	// For owning element types (strings, owning value structs) each slot in the
+	// copy owns its own heap data (Buffer deep-copies on store), so the source
+	// and the copy share nothing. Not available for class/trait element types
+	// (the copy would share the stored instances — the checker rejects it).
+	// The element is bound to a local before push — the monomorphized body is
+	// never re-checked, so it can't rely on check-time call-arg hoisting for
+	// struct element types.
+	pub func copy = (self, out List<T>) {
+		var List<T> dst = List<T>()
+		var int i = 0
+		while i < self.length {
+			var T v = self.at(i)
+			dst.push(v)
+			i += 1
+		}
+		return dst
 	}
 }