nomen-lang 0.0.7 → 0.0.8

package/core/System/StringBuilder.nm

@@ -0,0 +1,249 @@
+// StringBuilder: a growable byte buffer for incrementally building strings.
+//
+// Appending is O(1) amortized (geometric growth), and `to_string` finalizes
+// the buffer in place (no extra copy). Used by Regex.replace_all and the
+// Json parse/stringify paths to avoid the O(n^2) cost of repeated `string +`
+// concatenation, where each `+` mallocs and copies the whole accumulator.
+
+/**
+ * A growable byte buffer for incrementally building strings (O(1) amortized append)
+ **/
+pub struct StringBuilder {
+	var uint64 data = 0
+	var len = 0
+	var cap = 0
+
+	// Ensure capacity for at least `needed` bytes. Grows geometrically.
+	func ensure = (ref self, int needed) {
+		```
+		#arch: c
+		if (self->cap >= needed) return;
+		int new_cap = self->cap;
+		if (new_cap == 0) new_cap = 16;
+		while (new_cap < needed) new_cap *= 2;
+		self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, new_cap);
+		self->cap = new_cap;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = needed
+		ldr x2, [x19, #24]        // cap
+		cmp x2, x1
+		b.ge .Lsb_ensure_end
+		// pick new_cap
+		mov x3, #16
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		.Lsb_ensure_loop:
+		cmp x3, x1
+		b.ge .Lsb_ensure_grow
+		lsl x3, x3, #1
+		b .Lsb_ensure_loop
+		.Lsb_ensure_grow:
+		// save needed (x1) and new_cap (x3) across realloc
+		sub sp, sp, #32
+		str x1, [sp, #0]
+		str x3, [sp, #8]
+		str x2, [sp, #16]         // old cap (unused after, but keeps stack aligned)
+		ldr x0, [x19, #8]         // data
+		mov x1, x3
+		bl _realloc
+		str x0, [sp, #24]         // saved new data ptr
+		ldr x1, [sp, #8]          // new_cap
+		str x1, [x19, #24]        // cap = new_cap
+		ldr x0, [sp, #24]
+		str x0, [x19, #8]         // data = realloc result
+		add sp, sp, #32
+		.Lsb_ensure_end:
+		```
+	}
+
+	// Append a single byte (char).
+	func append_char = (ref self, char c) {
+		```
+		#arch: c
+		int idx = self->len;
+		if (idx + 1 >= self->cap) {
+			int nc = self->cap;
+			if (nc == 0) nc = 16;
+			while (nc < idx + 2) nc *= 2;
+			self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, nc);
+			self->cap = nc;
+		}
+		((unsigned char*)(unsigned long long)self->data)[idx] = (unsigned char)c;
+		self->len = idx + 1;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, w1 = c (low byte)
+		// Save c across the ensure/grow call.
+		sub sp, sp, #16
+		str w1, [sp, #0]
+		ldr x1, [x19, #16]        // len
+		add x1, x1, #2            // need len + 2 bytes (char + null terminator room)
+		// inline ensure
+		ldr x2, [x19, #24]        // cap
+		cmp x2, x1
+		b.ge .Lsb_ac_store
+		mov x3, #16
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		.Lsb_ac_loop:
+		cmp x3, x1
+		b.ge .Lsb_ac_grow
+		lsl x3, x3, #1
+		b .Lsb_ac_loop
+		.Lsb_ac_grow:
+		str x3, [x19, #24]        // cap = new_cap
+		ldr x0, [x19, #8]
+		mov x1, x3
+		bl _realloc
+		str x0, [x19, #8]
+		.Lsb_ac_store:
+		ldr w1, [sp, #0]          // c
+		ldr x0, [x19, #8]         // data
+		ldr x2, [x19, #16]        // len
+		strb w1, [x0, x2]
+		add x2, x2, #1
+		str x2, [x19, #16]        // len = len + 1
+		add sp, sp, #16
+		```
+	}
+
+	// Append a null-terminated string.
+	func append_string = (ref self, string s) {
+		```
+		#arch: c
+		int sl = strlen(s);
+		int needed = self->len + sl + 1;
+		if (needed > self->cap) {
+			int nc = self->cap;
+			if (nc == 0) nc = 16;
+			while (nc < needed) nc *= 2;
+			self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, nc);
+			self->cap = nc;
+		}
+		memcpy((unsigned char*)(unsigned long long)self->data + self->len, s, sl);
+		self->len = self->len + sl;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = s
+		// Save s across strlen/realloc.
+		mov x0, x1
+		sub sp, sp, #32
+		str x0, [sp, #0]
+		bl _strlen
+		str x0, [sp, #8]          // sl
+		ldr x1, [x19, #16]        // len
+		add x1, x1, x0            // len + sl
+		add x1, x1, #1            // +1 for null room
+		// inline ensure(x1)
+		ldr x2, [x19, #24]
+		cmp x2, x1
+		b.ge .Lsb_as_copy
+		mov x3, #16
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		.Lsb_as_loop:
+		cmp x3, x1
+		b.ge .Lsb_as_grow
+		lsl x3, x3, #1
+		b .Lsb_as_loop
+		.Lsb_as_grow:
+		str x3, [x19, #24]
+		ldr x0, [x19, #8]
+		mov x1, x3
+		bl _realloc
+		str x0, [x19, #8]
+		.Lsb_as_copy:
+		// memcpy(data + len, s, sl)
+		ldr x1, [sp, #8]          // sl
+		ldr x0, [x19, #8]         // data
+		ldr x2, [x19, #16]        // len
+		add x0, x0, x2            // dest = data + len
+		ldr x1, [sp, #0]          // src = s
+		ldr x2, [sp, #8]          // n = sl
+		bl _memcpy
+		// len = len + sl
+		ldr x0, [x19, #16]
+		ldr x1, [sp, #8]
+		add x0, x0, x1
+		str x0, [x19, #16]
+		add sp, sp, #32
+		```
+	}
+
+	// Finalize: null-terminate, return the byte buffer as a string, and
+	// release ownership (sets `data` to 0 so the destructor won't free it).
+	func to_string = (ref self, out string) {
+		```
+		#arch: c
+		int idx = self->len;
+		int needed = idx + 1;
+		if (needed > self->cap) {
+			int nc = self->cap;
+			if (nc == 0) nc = 16;
+			while (nc < needed) nc *= 2;
+			self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, nc);
+			self->cap = nc;
+		}
+		((unsigned char*)(unsigned long long)self->data)[idx] = 0;
+		unsigned long long result = self->data;
+		self->data = 0;
+		return (char*)result;
+		```
+		```
+		#arch: aarch64
+		// x19 = self
+		ldr x1, [x19, #16]        // len
+		add x1, x1, #1            // need len + 1
+		ldr x2, [x19, #24]
+		cmp x2, x1
+		b.ge .Lsb_ts_store
+		mov x3, #16
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		.Lsb_ts_loop:
+		cmp x3, x1
+		b.ge .Lsb_ts_grow
+		lsl x3, x3, #1
+		b .Lsb_ts_loop
+		.Lsb_ts_grow:
+		str x3, [x19, #24]
+		ldr x0, [x19, #8]
+		mov x1, x3
+		bl _realloc
+		str x0, [x19, #8]
+		.Lsb_ts_store:
+		ldr x0, [x19, #8]         // x0 = data (this is what we return)
+		ldr x1, [x19, #16]        // len
+		strb wzr, [x0, x1]        // data[len] = 0
+		// transfer ownership: clear self->data. x0 retains the old ptr.
+		str xzr, [x19, #8]
+		```
+	}
+
+	// Drop the buffer without finalizing (free the byte buffer outright).
+	func #destroy = () {
+		```
+		#arch: c
+		if (self->data) {
+			free((void*)(unsigned long long)self->data);
+			self->data = 0;
+			self->len = 0;
+			self->cap = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lsb_destroy_end
+		bl _free
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
+		str xzr, [x19, #24]
+		.Lsb_destroy_end:
+		```
+	}
+}

package/core/System/Stringable.nm

@@ -0,0 +1,8 @@
+/**
+ * A trait for values that can be converted to a string via `to_string`
+ **/
+pub trait Stringable {
+	func to_string = (self, out string) {
+		return ""
+	}
+}

package/core/System/Task.nm

@@ -0,0 +1,263 @@
+// Task runtime — thread-pool-backed execution primitive.
+//
+// Spawned tasks run on a shared worker pool. The pool starts at a
+// configurable size (default 4, via Task.set_pool_size before the first
+// spawn) and grows on demand up to 64 workers when every worker is busy,
+// preventing deadlocks from nested spawns. The pool drains and joins all
+// workers at process exit; Task.shutdown_pool does this explicitly.
+//
+// The pool infrastructure (types, worker loop, submit, shutdown, cancel
+// thread-local) lives in build_spawn_node and is emitted as file-scope C
+// on the first spawn — not in Task's own methods — so that Task can be
+// generic without duplicating the pool per instantiation.
+//
+// See ASYNC.md for the design.
+
+/**
+ * A handle to an asynchronously-running computation, backed by a shared thread pool
+ **/
+pub class Task<T> : Sendable {
+	pub var uint64 handle = 0
+	pub var done = false
+	pub var uint64 result_slot = 0
+	pub var uint64 cancel_flag = 0
+	pub var uint64 future = 0
+
+	// Block until the task finishes. Idempotent — calling twice is safe, and
+	// a Task captured from a nursery spawn can be waited on here AND joined
+	// by the nursery at block exit (both wait on the same shared future).
+	pub func wait = (ref self) {
+		```
+		#arch: c
+		if (self->future) {
+			__nomen_future_wait((struct nomen_future *)self->future);
+		} else if (self->handle && !self->done) {
+			void *ret;
+			pthread_join((pthread_t)self->handle, &ret);
+			self->handle = 0;
+			self->done = 1;
+		}
+		```
+		```
+		#arch: aarch64
+		// if (self->future) goto wait_future
+		ldr x0, [x19, #40]
+		cbz x0, .Lwait_handle
+		bl ___nomen_future_wait
+		b .Lwait_done
+		.Lwait_handle:
+		// else if (self->handle && !self->done)
+		ldr x0, [x19, #8]
+		cbz x0, .Lwait_done
+		ldrb w1, [x19, #16]
+		cbnz w1, .Lwait_done
+		// pthread_join((pthread_t)self->handle, &ret)
+		sub sp, sp, #16
+		mov x1, sp
+		bl _pthread_join
+		add sp, sp, #16
+		// self->handle = 0; self->done = 1
+		str xzr, [x19, #8]
+		mov w0, #1
+		strb w0, [x19, #16]
+		.Lwait_done:
+		```
+	}
+
+	// Block until the task finishes, then return its result as T.
+	// The spawn build phase allocates a heap slot (owned by the future) and
+	// the trampoline writes the function's return value there before exiting.
+	// For tasks with no return value (void functions), returns the zero value.
+	pub func result = (ref self, out T) {
+		```
+		#arch: c
+		if (self->future) {
+			__nomen_future_wait((struct nomen_future *)self->future);
+		} else if (self->handle && !self->done) {
+			void *ret;
+			pthread_join((pthread_t)self->handle, &ret);
+			self->handle = 0;
+			self->done = 1;
+		}
+		return *(T *)self->result_slot;
+		```
+		```
+		#arch: aarch64
+		// Wait for completion (same as wait method)
+		ldr x0, [x19, #40]
+		cbz x0, .Lresult_handle
+		bl ___nomen_future_wait
+		b .Lresult_read
+		.Lresult_handle:
+		ldr x0, [x19, #8]
+		cbz x0, .Lresult_read
+		ldrb w1, [x19, #16]
+		cbnz w1, .Lresult_read
+		sub sp, sp, #16
+		mov x1, sp
+		bl _pthread_join
+		add sp, sp, #16
+		str xzr, [x19, #8]
+		mov w0, #1
+		strb w0, [x19, #16]
+		.Lresult_read:
+		// return *(T *)self->result_slot
+		ldr x0, [x19, #24]
+		ldr x0, [x0]
+		```
+	}
+
+	// Block until the task finishes, then return its result as a uint64.
+	// Convenience for the common case; same as result() for uint64 tasks.
+	pub func result_uint64 = (ref self, out uint64) {
+		```
+		#arch: c
+		if (self->future) {
+			__nomen_future_wait((struct nomen_future *)self->future);
+		} else if (self->handle && !self->done) {
+			void *ret;
+			pthread_join((pthread_t)self->handle, &ret);
+			self->handle = 0;
+			self->done = 1;
+		}
+		return *(unsigned long long *)self->result_slot;
+		```
+		```
+		#arch: aarch64
+		// Wait for completion
+		ldr x0, [x19, #40]
+		cbz x0, .Lru64_handle
+		bl ___nomen_future_wait
+		b .Lru64_read
+		.Lru64_handle:
+		ldr x0, [x19, #8]
+		cbz x0, .Lru64_read
+		ldrb w1, [x19, #16]
+		cbnz w1, .Lru64_read
+		sub sp, sp, #16
+		mov x1, sp
+		bl _pthread_join
+		add sp, sp, #16
+		str xzr, [x19, #8]
+		mov w0, #1
+		strb w0, [x19, #16]
+		.Lru64_read:
+		// return *(unsigned long long *)self->result_slot
+		ldr x0, [x19, #24]
+		ldr x0, [x0]
+		```
+	}
+
+	// Request that the task stop. Cooperative — the task observes this via
+	// `Task.current_cancelled()` at its own checkpoints. No preemption.
+	pub func cancel = (ref self) {
+		```
+		#arch: c
+		if (self->cancel_flag) {
+			*(unsigned long long *)self->cancel_flag = 1;
+		}
+		```
+		```
+		#arch: aarch64
+		// if (self->cancel_flag) *(self->cancel_flag) = 1
+		ldr x0, [x19, #32]
+		cbz x0, .Lcancel_done
+		mov x1, #1
+		str x1, [x0]
+		.Lcancel_done:
+		```
+	}
+
+	// Has the currently-running task been asked to cancel? Returns false
+	// when called from outside any spawned task (e.g. main thread).
+	pub func current_cancelled = (out bool) {
+		```
+		#arch: c
+		return __nomen_current_cancel_flag && *__nomen_current_cancel_flag;
+		```
+		```
+		#arch: aarch64_use_c
+		return __nomen_current_cancel_flag && *__nomen_current_cancel_flag;
+		```
+	}
+
+	// Configure the worker pool size. Must be called before the first spawn
+	// — once the pool is initialized (lazily on first submit), the initial
+	// size is fixed (the pool still grows on demand up to 64 workers when
+	// every worker is busy). No-op if called after init (silent; check the
+	// return value to detect). Returns 1 if the size was set, 0 otherwise.
+	pub func set_pool_size = (int n, out int) {
+		```
+		#arch: c
+		if (__nomen_pool_init || n <= 0) return 0;
+		__nomen_pool_size = n;
+		return 1;
+		```
+		```
+		#arch: aarch64
+		// x0 = n (first arg)
+		// if (__nomen_pool_init || n <= 0) return 0
+		adrp x1, ___nomen_pool_init@PAGE
+		add x1, x1, ___nomen_pool_init@PAGEOFF
+		ldr w2, [x1]
+		cbnz w2, .Lsps_zero
+		cmp x0, #0
+		b.le .Lsps_zero
+		// __nomen_pool_size = n
+		adrp x1, ___nomen_pool_size@PAGE
+		add x1, x1, ___nomen_pool_size@PAGEOFF
+		str w0, [x1]
+		mov x0, #1
+		b .Lsps_done
+		.Lsps_zero:
+		mov x0, #0
+		.Lsps_done:
+		```
+	}
+
+	// Shut the worker pool down: drain the queue, join every worker, and
+	// free the pool. Runs automatically at process exit (registered via
+	// atexit on first submit), so outstanding fire-and-forget tasks always
+	// complete before exit. Call explicitly to join all outstanding tasks
+	// before continuing; the pool re-initializes on the next spawn.
+	// Do NOT call from a spawned task (a worker joining its coworkers
+	// deadlocks).
+	pub func shutdown_pool = () {
+		```
+		#arch: c
+		__nomen_pool_shutdown();
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_pool_shutdown
+		```
+	}
+
+	// Release this handle's reference to the future. The future owns the
+	// result slot and cancel flag; it (and they) are freed only when the
+	// last reference — this handle, the running trampoline, or a tracking
+	// nursery — is released. The Task instance itself is freed by the
+	// auto-free pass after #destroy returns.
+	pub func #destroy = () {
+		```
+		#arch: c
+		if (self->future) {
+			__nomen_future_release((struct nomen_future *)self->future);
+			self->future = 0;
+			self->result_slot = 0;
+			self->cancel_flag = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		// if (self->future) { release; zero fields }
+		ldr x0, [x19, #40]
+		cbz x0, .Ldestroy_done
+		bl ___nomen_future_release
+		str xzr, [x19, #40]
+		str xzr, [x19, #24]
+		str xzr, [x19, #32]
+		.Ldestroy_done:
+		```
+	}
+}