nomen-lang 0.8.0 → 0.10.0

package/audit_runtime.c

@@ -51,13 +51,20 @@ typedef struct {
 	unsigned long pad; // keeps the payload 16-byte aligned
 } nomen_audit_header;
 
+// True when the NOMEN_AUDIT_TRACE env var is on. The getenv is not cached —
+// the trace is a developer diagnostic, and alloc/free volumes under it are
+// already dominated by the fprintf.
+static int audit_trace(void) {
+	return getenv("NOMEN_AUDIT_TRACE") != 0;
+}
+
 static void *audit_alloc(unsigned long size) {
 	nomen_audit_header *header = (nomen_audit_header *)malloc(size + sizeof(nomen_audit_header));
 	if (!header) return 0;
 	header->magic = NOMEN_AUDIT_MAGIC;
 	header->size = size;
 	header->state = NOMEN_AUDIT_LIVE;
-	if (getenv("NOMEN_AUDIT_TRACE")) fprintf(stderr, "ALLOC %lu\n", (unsigned long)size);
+	if (audit_trace()) fprintf(stderr, "ALLOC %p %lu\n", (void *)(header + 1), (unsigned long)size);
 	__atomic_add_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
 	return (void *)(header + 1);
 }
@@ -74,7 +81,7 @@ static nomen_audit_header *audit_header(void *ptr) {
 // Retire a block: poison the header first so a second free of the same pointer
 // is recognized as stale, then hand the memory back and drop the count.
 static void audit_release(nomen_audit_header *header) {
-	if (getenv("NOMEN_AUDIT_TRACE")) fprintf(stderr, "FREE %lu\n", (unsigned long)header->size);
+	if (audit_trace()) fprintf(stderr, "FREE %p %lu\n", (void *)(header + 1), (unsigned long)header->size);
 	header->magic = 0;
 	header->state = NOMEN_AUDIT_DEAD;
 	__atomic_sub_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
@@ -157,6 +164,9 @@ void nomen_free_wrap(void *ptr) {
 	// of passing it on, and leave the count alone: an unmatched free is not
 	// evidence that a live block was reclaimed.
 	if (!header || header->state != NOMEN_AUDIT_LIVE) {
+		if (audit_trace())
+			fprintf(stderr, "STALE-FREE %p (%s)\n", ptr,
+					header ? "already freed" : "not an audit allocation");
 		audit_record_stale();
 		audit_report_stale(0);
 		return;

package/core/System/Arena.nm

@@ -51,7 +51,7 @@ pub mv struct Arena<T> {
 	/**
 	 * A fresh arena with no slots.
 	 **/
-	pub func #init = (ref self) {
+	pub func #init = (ref self { free_indices, generations, values }) {
 		self.values = Buffer<T>()
 		self.generations = Buffer<int>()
 		self.free_indices = Buffer<int>()
@@ -63,7 +63,7 @@ pub mv struct Arena<T> {
 	 * Store `value` in a slot (reusing a freed slot when one is available) and
 	 * return a handle to it.
 	 **/
-	pub func alloc = (ref self, mv T value, out ArenaRef<T>) {
+	pub func alloc = (ref self { generations, values }, mv T value, out ArenaRef<T>) {
 		var int index = -1
 		if self.free_count > 0 {
 			// Reuse a freed slot. Its generation was already bumped by `free`,
@@ -77,7 +77,16 @@ pub mv struct Arena<T> {
 			self.generations.store_int(index, 0)
 		}
 		self.values.grow(index + 1)
-		self.values.store(index, value)
+		// The value arrives owned (`mv T value`): move a value-struct element
+		// that OWNS resources into the fresh slot (the caller's storage
+		// zeroes, no deep copy). A non-owning value struct is a legal bare
+		// argument, so it keeps the copying store; strings keep the
+		// deep-copying store too (their pair arrives by value).
+		if T_TAKES_OWNERSHIP {
+			self.values.store_take(index, value)
+		} else {
+			self.values.store(index, value)
+		}
 		var handle = ArenaRef<T>()
 		handle.index = index
 		handle.generation = self.generations.load_int(index)
@@ -88,7 +97,7 @@ pub mv struct Arena<T> {
 	 * Relinquish the slot `handle` points at (its value is reclaimed), bumping the
 	 * generation so every outstanding handle to that slot becomes stale.
 	 **/
-	pub func free = (ref self, ArenaRef<T> handle) {
+	pub func free = (ref self { free_indices, generations, values }, ArenaRef<T> handle) {
 		if !self.is_valid(handle) {
 			panic("arena: free of a stale handle")
 		}
@@ -140,7 +149,7 @@ pub mv struct Arena<T> {
 	/**
 	 * Replace the value `handle` names (same slot, same handle).
 	 **/
-	pub func set = (ref self, ArenaRef<T> handle, mv T value) {
+	pub func set = (ref self { values }, ArenaRef<T> handle, mv T value) {
 		if !self.is_valid(handle) {
 			panic("arena: set through a stale handle")
 		}

package/core/System/Array.nm

@@ -50,7 +50,7 @@ pub struct Array<T>: Viewable {
 	// to express: T_NEEDS_STRDUP is a per-instantiation constant the
 	// monomorphizer substitutes (true for string, false otherwise) and folds,
 	// so each mono body keeps only its arm.
-	pub func set = (ref self, int index: index >= 0 && index < self.length, T value) {
+	pub func set = (ref self {}, int index: index >= 0 && index < self.length, T value) {
 		unsafe {
 			if T_NEEDS_STRDUP {
 				// T is string: a fat value whose backing bytes must be

package/core/System/Atomic.nm

@@ -41,7 +41,7 @@ pub struct Atomic<T> {
 		```
 	}
 
-	pub func store = (ref self, T v) {
+	pub func store = (ref self {}, T v) {
 	```
 		#arch: c
 		__atomic_store_n(&self->word, v, __ATOMIC_SEQ_CST);
@@ -54,7 +54,7 @@ pub struct Atomic<T> {
 	}
 
 	// Adds v and returns the PREVIOUS value (fetch-and-add).
-	pub func fetch_add = (ref self, T v, out T) {
+	pub func fetch_add = (ref self {}, T v, out T) {
 		```
 		#arch: c
 		return __atomic_fetch_add(&self->word, v, __ATOMIC_SEQ_CST);
@@ -67,7 +67,7 @@ pub struct Atomic<T> {
 	}
 
 	// Replaces the value and returns the PREVIOUS one.
-	pub func swap = (ref self, T v, out T) {
+	pub func swap = (ref self {}, T v, out T) {
 		```
 		#arch: c
 		return __atomic_exchange_n(&self->word, v, __ATOMIC_SEQ_CST);

package/core/System/BigInt.nm

@@ -1,25 +1,69 @@
 /**
- * An arbitrary-precision integer
+ * An arbitrary-precision integer (sign-magnitude)
+ *
+ * The sign is a real three-state machine — `zero / positive / negative`,
+ * canonical: `sign == 0` exactly when the magnitude is zero. Every producer
+ * that writes limbs (the constructors, add/sub/mul/div, copy) maintains it;
+ * `cmp` consumes it. Limbs always hold the absolute value.
  **/
 pub mv struct BigInt {
 	var sign = 0
 	var len = 0
 	var digits = Buffer<int>()
 
-	pub func #init = (ref self) {
+	pub func #init = (ref self {}) {
 	}
 
-	pub func #init = (ref self, int val) {
-		self.sign = 1
+	pub func #init = (ref self { digits }, int val) {
 		var int v = val
 		if v < 0 {
-			self.sign = -1
 			v = 0 - v
 		}
 		self.digits.grow_int(4)
 		self.digits.zero_int(self.digits.cap)
 		self.digits.store_int(0, v)
 		self.len = 1
+		if val == 0 {
+			self.sign = 0
+		} else {
+			if val < 0 {
+				self.sign = -1
+			} else {
+				self.sign = 1
+			}
+		}
+	}
+
+	// The canonical sign: 0 for a zero magnitude, ±1 otherwise — derived
+	// from the magnitude so a stale stored sign can never leak into a
+	// comparison or a producer.
+	func eff_sign = (self, out int) {
+		if self.len == 1 && self.get(0) == 0 {
+			return 0
+		}
+		if self.sign < 0 {
+			return -1
+		}
+		return 1
+	}
+
+	// Reset to the canonical zero (len 1, limb 0, sign 0).
+	func set_zero = (ref self { digits }) {
+		self.ensure(1)
+		self.set(0, 0)
+		self.len = 1
+		self.sign = 0
+	}
+
+	// Store a producer's computed sign, canonicalized against the final
+	// magnitude: a zero result is sign 0 no matter what the sign arithmetic
+	// produced (0 * -1 == 0, an equal-magnitude subtraction, a zero quotient).
+	func finish_sign = (ref self {}, int s) {
+		if self.len == 1 && self.get(0) == 0 {
+			self.sign = 0
+			return
+		}
+		self.sign = s
 	}
 
 	// Per-limb get/set stay raw: they are `inline` and splice into the limb
@@ -36,7 +80,7 @@ pub mv struct BigInt {
 		}
 	}
 
-	inline func set = (ref self, int i, uint64 val) {
+	inline func set = (ref self {}, int i, uint64 val) {
 		unsafe {
 			var ptr uint64 limbs = self.digits.data as ptr uint64
 			limbs[i] = val
@@ -65,22 +109,22 @@ pub mv struct BigInt {
 		}
 	}
 
-	inline func set_at = (ref self, uint64 ptr, int i, uint64 val) {
+	inline func set_at = (ref self {}, uint64 ptr, int i, uint64 val) {
 		unsafe {
 			var ptr uint64 limbs = ptr as ptr uint64
 			limbs[i] = val
 		}
 	}
 
-	func ensure = (ref self, int needed) {
+	func ensure = (ref self { digits }, int needed) {
 		self.digits.grow_int(needed)
 	}
 
-	func clear = (ref self, int len) {
+	func clear = (ref self { digits }, int len) {
 		self.digits.zero_int(len)
 	}
 
-	func copy_range_from = (ref self, BigInt src, int start, int count) {
+	func copy_range_from = (ref self { digits }, BigInt src, int start, int count) {
 		self.ensure(count)
 		var i = 0
 		while i < count; i += 1 {
@@ -95,7 +139,7 @@ pub mv struct BigInt {
 		}
 	}
 
-	func add_at = (ref self, BigInt other, int shift) {
+	func add_at = (ref self { digits }, BigInt other, int shift) {
 		self.ensure(other.len + shift + 1)
 		var carry = 0
 		var i = 0
@@ -126,7 +170,7 @@ pub mv struct BigInt {
 		}
 	}
 
-	func sub_at = (ref self, BigInt other, int shift) {
+	func sub_at = (ref self {}, BigInt other, int shift) {
 		var borrow = 0
 		var i = 0
 		while i < other.len; i += 1 {
@@ -212,7 +256,31 @@ pub mv struct BigInt {
 		```
 	}
 
+	// Sign-aware compare: the signs decide first (canonical zero sorts
+	// before every nonzero), and same-sign operands compare by magnitude
+	// with the result flipped for negatives.
 	pub func cmp = (self, BigInt other, out int) {
+		const int sself = self.eff_sign()
+		const int sother = other.eff_sign()
+		if sself != sother {
+			if sself > sother {
+				return 1
+			}
+			return -1
+		}
+		if sself == 0 {
+			return 0
+		}
+		var int mag = self.mag_cmp(other)
+		if sself < 0 {
+			mag = 0 - mag
+		}
+		return mag
+	}
+
+	// Magnitude compare (ignores sign): 1 when |self| > |other|, -1 when
+	// less, 0 when the limbs are equal.
+	func mag_cmp = (self, BigInt other, out int) {
 		if self.len != other.len {
 			if self.len > other.len {
 				return 1
@@ -235,7 +303,65 @@ pub mv struct BigInt {
 		return 0
 	}
 
-	pub func add_to = (ref self, BigInt a, BigInt b) {
+	// The signed sum (and, with flip_b, difference): self = a + b, or
+	// a - b when flip_b. Same-sign operands magnitude-add; opposite-sign
+	// operands subtract the smaller magnitude from the larger and take the
+	// larger's sign; a zero operand degenerates to a copy. This is the one
+	// place the sign machine meets the limb machines — every rule is here,
+	// not duplicated at call sites.
+	func signed_add = (ref self { digits }, BigInt a, BigInt b, bool flip_b) {
+		var int sa = a.eff_sign()
+		var int sb = b.eff_sign()
+		if flip_b {
+			sb = 0 - sb
+		}
+		// A zero operand: the result is the other operand (flipped for a
+		// subtracted zero is still zero — -0 is canonical 0).
+		if sb == 0 {
+			if sa == 0 {
+				self.set_zero()
+				return
+			}
+			self.copy_from(a)
+			self.sign = sa
+			return
+		}
+		if sa == 0 {
+			self.copy_from(b)
+			self.sign = sb
+			return
+		}
+		if sa == sb {
+			self.mag_add_to(a, b)
+			self.sign = sa
+			return
+		}
+		var int mag = a.mag_cmp(b)
+		if mag == 0 {
+			self.set_zero()
+			return
+		}
+		if mag > 0 {
+			self.mag_sub_to(a, b)
+			self.sign = sa
+			return
+		}
+		self.mag_sub_to(b, a)
+		self.sign = sb
+	}
+
+	// self = a + b (signed).
+	pub func add_to = (ref self { digits }, BigInt a, BigInt b) {
+		self.signed_add(a, b, false)
+	}
+
+	// self = a - b (signed; truncating like the limb primitive it wraps).
+	pub func sub_to = (ref self { digits }, BigInt a, BigInt b) {
+		self.signed_add(a, b, true)
+	}
+
+	// Magnitude add: |self| = |a| + |b| (sign untouched — signed_add owns it).
+	func mag_add_to = (ref self { digits }, BigInt a, BigInt b) {
 		if a.len == 1 && b.len == 1 {
 			var uint64 a_val = a.get(0)
 			var uint64 b_val = b.get(0)
@@ -297,7 +423,9 @@ pub mv struct BigInt {
 		}
 	}
 
-	pub func sub_to = (ref self, BigInt a, BigInt b) {
+	// Magnitude subtract: |self| = |a| - |b|; callers guarantee |a| >= |b|
+	// (signed_add orders the operands). Sign untouched.
+	func mag_sub_to = (ref self { digits }, BigInt a, BigInt b) {
 		if a.len == 1 && b.len == 1 {
 			self.ensure(1)
 			self.set(0, a.get(0) - b.get(0))
@@ -342,7 +470,10 @@ pub mv struct BigInt {
 		}
 	}
 
-	pub func mul_to = (ref self, BigInt a, BigInt b, ref BigInt scratch) {
+	pub func mul_to = (ref self { digits }, BigInt a, BigInt b, ref BigInt scratch { digits }) {
+		// The product's sign, computed before anything can alias-mutate the
+		// operands (self may alias a or b).
+		const int mul_sign = a.eff_sign() * b.eff_sign()
 		if a.len == 1 || b.len == 1 {
 			var uint64 sv
 			var int other_len
@@ -406,6 +537,7 @@ pub mv struct BigInt {
 			if self.len == 0 {
 				self.len = 1
 			}
+			self.finish_sign(mul_sign)
 			return
 		}
 
@@ -458,6 +590,7 @@ pub mv struct BigInt {
 				}
 			}
 			self.len = last_nonzero
+			self.finish_sign(mul_sign)
 			return
 		}
 
@@ -530,11 +663,18 @@ pub mv struct BigInt {
 			}
 			self.len = self.len - 1
 		}
+		self.finish_sign(mul_sign)
 	}
 
 	// self = quotient, a = dividend, b = divisor, remainder = remainder
 	// Uses remainder's internal buffer as working space
-	pub func div_to = (ref self, BigInt a, BigInt b, ref BigInt remainder) {
+	//
+	// Truncating division (C semantics): the quotient takes the product of
+	// the operands' signs, the remainder takes the dividend's, and both are
+	// canonicalized (a zero quotient/remainder is sign 0).
+	pub func div_to = (ref self { digits }, BigInt a, BigInt b, ref BigInt remainder { digits }) {
+		const int q_sign = a.eff_sign() * b.eff_sign()
+		const int r_sign = a.eff_sign()
 		if b.len == 1 {
 			const uint64 divisor = b.get(0)
 			self.ensure(a.len)
@@ -580,9 +720,11 @@ pub mv struct BigInt {
 			if self.len == 0 {
 				self.len = 1
 			}
+			self.finish_sign(q_sign)
 			remainder.len = 1
 			remainder.ensure(1)
 			remainder.set(0, rem)
+			remainder.finish_sign(r_sign)
 			return
 		}
 
@@ -596,6 +738,7 @@ pub mv struct BigInt {
 			self.ensure(1)
 			self.set(0, 0)
 			self.len = 1
+			self.sign = 0
 			remainder.ensure(a.len)
 			remainder.clear(remainder.digits.cap)
 			var ci = 0
@@ -603,6 +746,7 @@ pub mv struct BigInt {
 				remainder.set(ci, a.get(ci))
 			}
 			remainder.len = a.len
+			remainder.finish_sign(r_sign)
 			return
 		}
 
@@ -800,6 +944,7 @@ pub mv struct BigInt {
 			}
 			self.len -= 1
 		}
+		self.finish_sign(q_sign)
 
 		// Extract remainder from working dividend (normalized at wd_off..wd_off+n-1)
 		// Shift right by 'shift' to un-normalize
@@ -826,6 +971,7 @@ pub mv struct BigInt {
 			}
 			remainder.len = remainder.len - 1
 		}
+		remainder.finish_sign(r_sign)
 	}
 
 	pub func to_digit = (self, out int) {
@@ -835,32 +981,45 @@ pub mv struct BigInt {
 		return -1
 	}
 
-	pub func copy_from = (ref self, BigInt other) {
+	pub func copy_from = (ref self { digits }, BigInt other) {
 		self.ensure(other.len)
 		self.len = other.len
-		self.sign = other.sign
 		var i = 0
 		while i < other.len; i += 1 {
 			self.set(i, other.get(i))
 		}
+		// The copied value's canonical sign — 0 for a copied zero, ±1 from
+		// the source otherwise (never the raw stored field).
+		self.sign = other.eff_sign()
 	}
 
-	pub func set_int = (ref self, int val) {
-		self.sign = 1
+	pub func set_int = (ref self { digits }, int val) {
 		var int v = val
 		if v < 0 {
-			self.sign = -1
 			v = 0 - v
 		}
 		self.ensure(1)
 		self.digits.store_int(0, v)
 		self.len = 1
+		if val == 0 {
+			self.sign = 0
+		} else {
+			if val < 0 {
+				self.sign = -1
+			} else {
+				self.sign = 1
+			}
+		}
 	}
 
-	pub func set_u64 = (ref self, uint64 val) {
-		self.sign = 1
+	pub func set_u64 = (ref self { digits }, uint64 val) {
 		self.ensure(1)
 		self.set(0, val)
 		self.len = 1
+		if val == 0 {
+			self.sign = 0
+		} else {
+			self.sign = 1
+		}
 	}
 }