nomen-lang 0.2.3 → 0.4.0

package/core/System/String.nm

@@ -3,6 +3,19 @@
 // result is re-wrapped with its length.
 extern func strdup = (string s, move out string)
 
+// Raw memory externs — the allocation primitives every `unsafe` Nomen body
+// across core (Buffer, StringBuilder, Array, ...) is built on. This file is
+// part of the always-linked base types, so the declarations are visible to
+// every core file regardless of pull order. Free externs emit under an
+// `extern_<name>` label that wraps the identically-named C symbol, so these
+// can never collide with it (docs/CORE_RAW.md roadmap items 1+2).
+extern func calloc = (int count, int size, out uint64)
+extern func malloc = (int bytes, out uint64)
+extern func realloc = (uint64 address, int bytes, out uint64)
+extern func free = (uint64 address)
+extern func memcpy = (uint64 dst, uint64 src, int bytes, out uint64)
+extern func memset = (uint64 dst, int value, int bytes, out uint64)
+
 /**
  * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes
  **/
@@ -18,29 +31,47 @@ pub struct string: Stringable, Hashable, Equatable {
 		return h
 	}
 
-	// Returns an OWNED copy of self (`move out string`). Both backends hand
-	// back a fresh allocation the caller frees — never an alias of self's
-	// storage — so the result can outlive the receiver (e.g. escape a match
-	// branch that reclaims the scrutinee temp). Goes through the `strdup`
-	// extern: the adapter marshals self.ptr to libc and re-wraps the copy
-	// with its length.
+	// Returns an OWNED byte-exact copy of self (`move out string`). Fresh
+	// allocation, never an alias of self's storage — the result can outlive
+	// the receiver (e.g. escape a match branch that reclaims the scrutinee
+	// temp). Copies by tracked length, so embedded NULs survive (an extern
+	// strdup boundary would re-synthesize length via strlen and truncate).
 	pub func to_string = (self, move out string) {
-		return strdup(self)
-	}
-
-	pub func at = (self, int index: index >= 0 && index < self.length, out char) {
 		```
 		#arch: c
-		return self[index];
+		// Fat-string ABI: copy self.len bytes; no strlen anywhere.
+		char* buf = (char*)malloc(self.len + 1);
+		memcpy(buf, self.ptr, self.len);
+		buf[self.len] = 0;
+		return (nomen_string){ buf, self.len };
 		```
 		```
 		#arch: aarch64
-		// Fat-string ABI: x19 = self ptr, x20 = self len; index in x2
-		// (self's pair occupies slots 0-1).
-		ldrb w0, [x19, x2]
+		// x19/x20 = self (ptr, len). malloc + memcpy of known length;
+		// memcpy returns the dst in x0, which becomes the return ptr half.
+		sub sp, sp, #16
+		str x20, [sp, #0]
+		add x0, x20, #1
+		bl _malloc
+		mov x1, x19
+		mov x2, x20
+		bl _memcpy
+		ldr x1, [sp, #0]
+		add x2, x0, x1
+		strb wzr, [x2]            // NUL-terminate for libc consumers
+		add sp, sp, #16
 		```
 	}
 
+	// The indexing primitive everything string code builds on — `unsafe`
+	// Nomen, single-sourced for both backends. `self as ptr char` is the fat
+	// value's backing bytes (the thin `char*` the raw blocks used to poke).
+	pub func at = (self, int index: index >= 0 && index < self.length, out char) {
+		unsafe {
+			return (self as ptr char)[index]
+		}
+	}
+
 	// Bounds-checked access: `fallback` when index is outside
 	// [0, self.length).
 	pub func at_or = (self, int index, char fallback, out char) {
@@ -71,8 +102,9 @@ pub struct string: Stringable, Hashable, Equatable {
 	) {
 		```
 		#arch: c
+		// Fat-string ABI: slice out of the tracked buffer — no NUL scan.
 		nomen_view _r;
-		_r.ptr = (void*)(self + start);
+		_r.ptr = (void*)(self.ptr + start);
 		_r.len = (long)(end - start);
 		return _r;
 		```
@@ -87,21 +119,17 @@ pub struct string: Stringable, Hashable, Equatable {
 	}
 
 	pub func set = (ref self, int index: index >= 0 && index < self.length, char value) {
-		```
-		#arch: c
-		(*self)[index] = value;
-		```
-		```
-		#arch: aarch64
-		// x19 = self (pointer), x1 = index, w2 = value
-		strb w2, [x19, x1]
-		```
+		unsafe {
+			(self as ptr char)[index] = value
+		}
 	}
 
 	pub func #op_eq = (self, string other, out bool) {
 		```
 		#arch: c
-		return strcmp(self, other) == 0;
+		// Length-aware compare: equal lengths + equal bytes. Embedded
+		// NULs are data, not terminators (strcmp truncated at the first).
+		return self.len == other.len && memcmp(self.ptr, other.ptr, self.len) == 0;
 		```
 		```
 		#arch: aarch64
@@ -127,12 +155,15 @@ pub struct string: Stringable, Hashable, Equatable {
 	pub func #op_add = (self, string other, out string) {
 		```
 		#arch: c
-		int left_len = strlen(self);
-		int right_len = strlen(other);
-		char* result = malloc(left_len + right_len + 1);
-		strcpy(result, self);
-		strcat(result, other);
-		return result;
+		// Fat-string ABI: one malloc sized by the tracked lens, two
+		// memcpys, NUL-terminate for libc consumers. No strlen/strcpy.
+		long left_len = self.len;
+		long right_len = other.len;
+		char* result = (char*)malloc(left_len + right_len + 1);
+		memcpy(result, self.ptr, left_len);
+		memcpy(result + left_len, other.ptr, right_len);
+		result[left_len + right_len] = 0;
+		return (nomen_string){ result, left_len + right_len };
 		```
 		```
 		#arch: aarch64
@@ -165,16 +196,17 @@ pub struct string: Stringable, Hashable, Equatable {
 	pub func #op_mul = (self, int count, out string) {
 		```
 		#arch: c
-		size_t str_len = strlen(self);
+		// Fat-string ABI: memcpy loop of the tracked stride. No strlen.
+		size_t str_len = self.len;
 		size_t total = str_len * (size_t)count + 1;
 		char* buf = malloc(total);
 		char* p = buf;
 		for (int i = 0; i < count; i++) {
-			memcpy(p, self, str_len);
+			memcpy(p, self.ptr, str_len);
 			p += str_len;
 		}
 		*p = 0;
-		return buf;
+		return (nomen_string){ buf, total - 1 };
 		```
 		```
 		#arch: aarch64
@@ -209,4 +241,238 @@ pub struct string: Stringable, Hashable, Equatable {
 		ldp x20, x21, [sp], #16
 		```
 	}
+
+	// Replace the first non-overlapping occurrence of needle with
+	// replacement. No match — or an empty needle — returns an owned copy
+	// of self. Views pass straight in (no `to_string` copy): both sides
+	// are only ever read.
+	pub func replace_first = (self, view string needle, view string replacement, out string) {
+		var sb = StringBuilder()
+		var int i = 0
+		var int n = self.length
+		var int nlen = needle.length
+		var bool replaced = nlen == 0
+		while i < n {
+			if !replaced && nlen > 0 && i + nlen <= n && match_at(self, needle, i) {
+				sb.append_string_view(replacement)
+				i = i + nlen
+				replaced = true
+			} else {
+				sb.append_char(self.at(i))
+				i = i + 1
+			}
+		}
+		return sb.to_string()
+	}
+
+	// Replace all non-overlapping occurrences of needle with replacement,
+	// left to right. Same edge behavior as replace_first.
+	pub func replace_all = (self, view string needle, view string replacement, out string) {
+		var sb = StringBuilder()
+		var int i = 0
+		var int n = self.length
+		var int nlen = needle.length
+		while i < n {
+			if nlen > 0 && i + nlen <= n && match_at(self, needle, i) {
+				sb.append_string_view(replacement)
+				i = i + nlen
+			} else {
+				sb.append_char(self.at(i))
+				i = i + 1
+			}
+		}
+		return sb.to_string()
+	}
+
+	// First index of `needle` in self, or -1 when absent. An empty needle
+	// matches at 0 (JavaScript indexOf semantics).
+	pub func index_of = (self, view string needle, out int) {
+		return self.index_of_from(needle, 0)
+	}
+
+	// First index of `needle` at or after byte offset `from`, or -1. `from`
+	// is clamped into [0, self.length]; an empty needle returns the clamped
+	// `from`, so a `from` past the end yields self.length for the empty
+	// needle and -1 otherwise.
+	pub func index_of_from = (self, view string needle, int from, out int) {
+		var int f = from
+		if f < 0 {
+			f = 0
+		}
+		if f > self.length {
+			f = self.length
+		}
+		if needle.length == 0 {
+			return f
+		}
+		var int last = self.length - needle.length
+		var int i = f
+		while i <= last; i += 1 {
+			if match_at(self, needle, i) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	// Whether `needle` occurs anywhere in self.
+	pub func contains = (self, view string needle, out bool) {
+		return self.index_of(needle) >= 0
+	}
+
+	// Whether self begins with `prefix`.
+	pub func starts_with = (self, view string prefix, out bool) {
+		if prefix.length > self.length {
+			return false
+		}
+		return match_at(self, prefix, 0)
+	}
+
+	// Whether self ends with `suffix`.
+	pub func ends_with = (self, view string suffix, out bool) {
+		if suffix.length > self.length {
+			return false
+		}
+		return match_at(self, suffix, self.length - suffix.length)
+	}
+
+	// The code of the byte at `index`, or -1 when out of bounds — the
+	// JavaScript charCodeAt NaN case as a plain int parsers can test.
+	// The code of the byte at `index`. Like `at`, the constraint makes
+	// out-of-bounds reads unrepresentable: a literal index is verified at
+	// compile time, and a dynamic index must be proven in-range by flow
+	// facts (a `while i < self.length` loop or an `if` guard) — an
+	// unverifiable call is a compile error. For a sentinel read, use
+	// `char_code_at_or`; for a trapping read, `char_code_at_or_panic`.
+	pub func char_code_at = (self, int index: index >= 0 && index < self.length, out int) {
+		return self.at(index) as int
+	}
+
+	// The code of the byte at `index`, with `fallback` when index is
+	// outside [0, self.length).
+	pub func char_code_at_or = (self, int index, int fallback, out int) {
+		if index >= 0 && index < self.length {
+			return self.at(index) as int
+		}
+		return fallback
+	}
+
+	// The code of the byte at `index`; traps when index is outside
+	// [0, self.length) — out-of-range is a bug, not a case.
+	pub func char_code_at_or_panic = (self, int index, out int) {
+		if index >= 0 && index < self.length {
+			return self.at(index) as int
+		}
+		panic("index out of range")
+	}
+
+	// Owned copy of self[start, end) with both bounds clamped into
+	// [0, self.length] and an inverted pair swapped (JavaScript substring
+	// semantics: out-of-range operands can never trap).
+	pub func substring = (self, int start, int end, out string) {
+		var int a = start
+		var int b = end
+		if a < 0 {
+			a = 0
+		}
+		if a > self.length {
+			a = self.length
+		}
+		if b > self.length {
+			b = self.length
+		}
+		if b < a {
+			b = a
+		}
+		var view v = self.slice(a, b)
+		return v.to_string()
+	}
+
+	// Owned copy of self with leading and trailing ASCII whitespace
+	// (tab, LF, VT, FF, CR, space) removed. All-whitespace yields "".
+	pub func trim = (self, out string) {
+		var int start = 0
+		while start < self.length; start += 1 {
+			if !self.at(start).is_ascii_space() {
+				break
+			}
+		}
+		var int end = self.length
+		while end > start; end -= 1 {
+			if !self.at(end - 1).is_ascii_space() {
+				break
+			}
+		}
+		var view v = self.slice(start, end)
+		return v.to_string()
+	}
+
+	// Owned copy of self with trailing ASCII whitespace removed.
+	pub func trim_end = (self, out string) {
+		var int end = self.length
+		while end > 0; end -= 1 {
+			if !self.at(end - 1).is_ascii_space() {
+				break
+			}
+		}
+		var view v = self.slice(0, end)
+		return v.to_string()
+	}
+
+	// Owned copy of self with leading ASCII whitespace removed.
+	pub func trim_start = (self, out string) {
+		var int start = 0
+		while start < self.length; start += 1 {
+			if !self.at(start).is_ascii_space() {
+				break
+			}
+		}
+		var view v = self.slice(start, self.length)
+		return v.to_string()
+	}
+
+	// Owned ASCII-lowercased copy of self (A-Z mapped to a-z; all other
+	// bytes — including UTF-8 sequences — pass through unchanged).
+	pub func to_lowercase = (self, out string) {
+		var sb = StringBuilder()
+		var int i = 0
+		while i < self.length; i += 1 {
+			var int code = self.at(i) as int
+			if code > 64 && code < 91 {
+				code += 32
+			}
+			sb.append_char(code as char)
+		}
+		return sb.to_string()
+	}
+
+	// Owned ASCII-uppercased copy of self (a-z mapped to A-Z; all other
+	// bytes — including UTF-8 sequences — pass through unchanged).
+	pub func to_uppercase = (self, out string) {
+		var sb = StringBuilder()
+		var int i = 0
+		while i < self.length; i += 1 {
+			var int code = self.at(i) as int
+			if code > 96 && code < 123 {
+				code -= 32
+			}
+			sb.append_char(code as char)
+		}
+		return sb.to_string()
+	}
+}
+
+// needle matches text at byte offset pos (caller guarantees pos + len fits;
+// the trailing guard makes the bound explicit so `.at` verifies).
+func match_at = (view string text, view string needle, int pos, out bool) {
+	var int i = 0
+	var int nlen = needle.length
+	var int n = text.length
+	while i < nlen && pos + i < n {
+		if text.at(pos + i) != needle.at(i) {
+			return false
+		}
+		i = i + 1
+	}
+	return i == nlen
 }

package/core/System/StringBuilder.nm

@@ -14,48 +14,19 @@ pub struct StringBuilder {
 	var cap = 0
 
 	// Ensure capacity for at least `needed` bytes. Grows geometrically.
+	// Plain Nomen + the memory externs — no pointer arithmetic needed, so
+	// this doesn't even require an unsafe context.
 	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:
-		```
+		if self.cap >= needed {
+			return
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 16
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap)
+		self.cap = new_cap
 	}
 
 	// Append a single byte (char).
@@ -110,65 +81,43 @@ pub struct StringBuilder {
 		```
 	}
 
-	// Append a null-terminated string.
+	// Append a null-terminated string. `unsafe` Nomen single-sourced for
+	// both backends: the fat pair's pointer half feeds memcpy directly, and
+	// the tracked length replaces the strlen the old C body paid.
 	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;
+		unsafe {
+			var int sl = s.length
+			self.ensure(self.len + sl + 1)
+			memcpy(self.data + self.len, (s as ptr char) as uint64, sl)
+			self.len = self.len + sl
+		}
+	}
+
+	// Append a view's bytes without materializing it: `append_string` takes
+	// an owned string, so passing a slice would need a `to_string` copy per
+	// call. Views lower to the same (ptr, len) fat pair, so the bytes are
+	// memcpy'd straight out of the borrowed buffer (used by
+	// `string.replace_first`/`replace_all`).
+	pub func append_string_view = (ref self, view string s) {
+		unsafe {
+			var int sl = s.length
+			self.ensure(self.len + sl + 1)
+			memcpy(self.data + self.len, (s as ptr char) as uint64, sl)
+			self.len = self.len + sl
+		}
+	}
+
+	// Replace the buffer's contents with a copy of `s`'s bytes. The only
+	// way to start a StringBuilder from a slice without a `to_string()`
+	// copy: the view's bytes are copied once into fresh storage, so the
+	// result is owned and independent of the source.
+	pub func seed = (ref self, view string s) {
+		unsafe {
+			var int sl = s.length
+			self.ensure(sl + 1)
+			memcpy(self.data, (s as ptr char) as uint64, sl)
+			self.len = sl
 		}
-		memcpy((unsigned char*)(unsigned long long)self->data + self->len, s, sl);
-		self->len = self->len + sl;
-		```
-		```
-		#arch: aarch64
-		// Fat-string ABI: x19 = self; s = (x1 ptr, x2 len). The length is
-		// already in a register — no strlen.
-		sub sp, sp, #32
-		str x1, [sp, #0]          // s ptr
-		str x2, [sp, #8]          // sl
-		ldr x1, [x19, #16]        // len
-		add x1, x1, x2            // 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.ptr, sl)
-		ldr x0, [x19, #8]         // data
-		ldr x1, [x19, #16]        // len
-		add x0, x0, x1            // dest = data + len
-		ldr x1, [sp, #0]          // src = s ptr
-		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
@@ -188,7 +137,7 @@ pub struct StringBuilder {
 		((unsigned char*)(unsigned long long)self->data)[idx] = 0;
 		unsigned long long result = self->data;
 		self->data = 0;
-		return (char*)result;
+		return (nomen_string){ (char*)result, (long)idx };
 		```
 		```
 		#arch: aarch64
@@ -224,24 +173,11 @@ pub struct StringBuilder {
 
 	// 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;
+		if self.data != 0 {
+			free(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:
-		```
 	}
 }