nomen-lang 0.2.3 → 0.4.0

package/core/System/Text/CharIndex.nm

@@ -0,0 +1,144 @@
+// A run-length index of character widths for O(log n) random access.
+//
+// ASCII text needs no records at all (width-1 runs are implicit); only runs
+// of multi-byte characters are stored, each as {byte_index, char_start,
+// width, count}. All lookups binary-search the runs, so repeated indexed
+// access stays logarithmic no matter how often callers re-walk. The index
+// borrows its source (no copy of the text).
+
+/**
+ * A run of consecutive same-width multi-byte characters
+ **/
+pub struct CharRun {
+	var int byte_index
+	var int char_start
+	var int width
+	var int count
+}
+
+/**
+ * A run-length character-width index (construct with `CharIndex(text)`,
+ * then `byte_offset_of` / `char_index_of` / `char_at` in O(log runs))
+ **/
+pub struct CharIndex {
+	var view string source
+	var List<CharRun> runs = List<CharRun>()
+	var int char_count = 0
+
+	pub func #init = (self, view string source) {
+		self.source = source
+		var int pos = 0
+		var int len = source.length
+		var int chars = 0
+		var int open_at = -1
+		var int open_width = 0
+		var int open_start = 0
+		var int open_count = 0
+		while pos < len {
+			var int w = Utf8.width_at(source, pos)
+			switch {
+				case w == 1 {
+					if open_at >= 0 {
+						self.runs.push(CharRun(open_at, open_start, open_width, open_count))
+						open_at = -1
+					}
+					pos = pos + 1
+					chars = chars + 1
+				}
+				case open_at >= 0 && w == open_width {
+					open_count = open_count + 1
+					pos = pos + w
+					chars = chars + 1
+				}
+				else {
+					if open_at >= 0 {
+						self.runs.push(CharRun(open_at, open_start, open_width, open_count))
+					}
+					open_at = pos
+					open_start = chars
+					open_width = w
+					open_count = 1
+					pos = pos + w
+					chars = chars + 1
+				}
+			}
+		}
+		if open_at >= 0 {
+			self.runs.push(CharRun(open_at, open_start, open_width, open_count))
+		}
+		self.char_count = chars
+	}
+
+	// Index built over source in one pass. Construct directly —
+	// `CharIndex(text)` borrows the caller's text with no copy.
+	pub func byte_offset_of = (self, int char_index, out int) {
+		if char_index < 0 || char_index >= self.char_count {
+			panic("character index out of range")
+		}
+		var int found = self.rightmost_run(char_index, true)
+		if found < 0 {
+			// No run starts at or before it: pure ASCII prefix.
+			return char_index
+		}
+		var r = self.runs.at_or_panic(found)
+		if char_index < r.char_start + r.count {
+			return r.byte_index + (char_index - r.char_start) * r.width
+		}
+		var int after_chars = r.char_start + r.count
+		var int after_bytes = r.byte_index + r.count * r.width
+		return after_bytes + (char_index - after_chars)
+	}
+
+	// Character index containing byte_offset. A mid-character offset floors
+	// into its character; byte_offset == source.length maps to char_count.
+	// Panics if byte_offset is out of [0, source.length].
+	pub func char_index_of = (self, int byte_offset, out int) {
+		if byte_offset < 0 || byte_offset > self.source.length {
+			panic("byte offset out of range")
+		}
+		if byte_offset == self.source.length {
+			return self.char_count
+		}
+		var int found = self.rightmost_run(byte_offset, false)
+		if found < 0 {
+			return byte_offset
+		}
+		var r = self.runs.at_or_panic(found)
+		if byte_offset < r.byte_index + r.count * r.width {
+			return r.char_start + (byte_offset - r.byte_index) / r.width
+		}
+		var int after_chars = r.char_start + r.count
+		var int after_bytes = r.byte_index + r.count * r.width
+		return after_chars + (byte_offset - after_bytes)
+	}
+
+	// Decoded code point of the char_index-th character. Panics if
+	// char_index is out of [0, char_count).
+	pub func char_at = (self, int char_index, out int) {
+		var int at = self.byte_offset_of(char_index)
+		var d = Utf8.decode_at(self.source, at)
+		return d.code_point
+	}
+	// Rightmost run whose key (char_start when by_char, else byte_index) is
+	// <= target, or -1 when all runs start after it.
+	func rightmost_run = (self, int target, bool by_char, out int) {
+		var int lo = 0
+		var int hi = self.runs.length - 1
+		var int found = -1
+		while lo <= hi {
+			var int mid = (lo + hi) / 2
+			var r = self.runs.at_or_panic(mid)
+			var int key = r.char_start
+			if !by_char {
+				key = r.byte_index
+			}
+			if key <= target {
+				found = mid
+				lo = mid + 1
+			} else {
+				hi = mid - 1
+			}
+		}
+		return found
+	}
+}

package/core/System/Text/Chars.nm

@@ -0,0 +1,32 @@
+// A single-pass cursor over a string's Unicode scalar values.
+//
+// The cursor borrows its source (no copy) and decodes lazily: each `next`
+// costs one decode step. For repeated random access, build a CharIndex
+// instead — re-walking from scratch on every access is O(n) per lookup.
+
+/**
+ * A single-pass cursor over Unicode scalar values (`has_next`/`next`)
+ **/
+pub struct Chars {
+	var view string source
+	var int byte_pos = 0
+
+	pub func #init = (self, view string source) {
+		self.source = source
+	}
+
+	pub func has_next = (self, out bool) {
+		return self.byte_pos < self.source.length
+	}
+
+	// The code point at the cursor, advancing past it. Malformed sequences
+	// yield U+FFFD. Panics when exhausted — check has_next first.
+	pub func next = (ref self, out int) {
+		if self.byte_pos >= self.source.length {
+			panic("Chars exhausted; check has_next first")
+		}
+		var d = Utf8.decode_at(self.source, self.byte_pos)
+		self.byte_pos = self.byte_pos + d.byte_length
+		return d.code_point
+	}
+}

package/core/System/Text/JsonTree.nm

@@ -28,71 +28,43 @@ pub struct JsonTree {
 
 	func alloc_node = (ref self, out int) {
 		var int idx = self.count
-		self.nodes.grow_T(idx + 1)
+		self.nodes.grow(idx + 1)
 		self.count = idx + 1
 		var default = JsonNode()
-		self.nodes.store_T(idx, default)
+		self.nodes.store(idx, default)
 		// store_T deep-copies the owning `text` field (strdup of the shared
 		// empty-string literal) into the slot. JsonTree manages node texts
 		// manually (set_text strdup's into the slab; free_text/release frees
 		// them; NULL means "no text"), so the slot must start NULL — free the
-		// strdup'd default and NULL it, or reset() would leak it. idx is x1.
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		free(nodes[idx].text.ptr);
-		nodes[idx].text.ptr = 0;
-		nodes[idx].text.len = 0;
-		```
-		```
-		#arch: aarch64
-		// x19 = self. count is at self+32 and already equals idx+1 here, so
-		// idx = count - 1. nodes.data at self+16, JsonNode size 56 (fat text),
-		// text at +16 (ptr) / +24 (len).
-		ldr x0, [x19, #16]
-		ldr x1, [x19, #32]
-		sub x1, x1, #1
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x1, [x0]
-		str xzr, [x0]
-		str xzr, [x0, #8]
-		cbz x1, .Lalloc_node_text_skip
-		mov x0, x1
-		bl _free
-		.Lalloc_node_text_skip:
-		```
+		// strdup'd default and NULL it, or reset() would leak it. The slab
+		// slot layout: 56-byte JsonNode elements — 7 words — with the text
+		// pair at words 2 and 3 of each element.
+		unsafe {
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			var uint64 old = slots[t]
+			if old != 0 {
+				free(old)
+			}
+			slots[t] = 0
+			slots[t + 1] = 0
+		}
 		return idx
 	}
 
 	// Free a node's strdup'd text pointer (set_text writes a heap pointer via
 	// raw strdup; this mirrors it). idx is x1, following set_text's layout.
 	func free_text = (ref self, int idx) {
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		if (nodes[idx].text.ptr) { free(nodes[idx].text.ptr); nodes[idx].text.ptr = 0; nodes[idx].text.len = 0; }
-		```
-		```
-		#arch: aarch64
-		// x19 = self, x1 = idx. Compute &nodes[idx].text (JsonNode size 56).
-		ldr x0, [x19, #16]
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x2, [x0]
-		cbz x2, .Ljsontree_free_text_skip
-		str x0, [sp, #-16]!
-		mov x0, x2
-		bl _free
-		ldr x0, [sp], #16
-		str xzr, [x0]
-		str xzr, [x0, #8]
-		.Ljsontree_free_text_skip:
-		```
+		unsafe {
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			var uint64 p = slots[t]
+			if p != 0 {
+				free(p)
+				slots[t] = 0
+				slots[t + 1] = 0
+			}
+		}
 	}
 
 	// Free every strdup'd text pointer before reusing the slab, otherwise
@@ -121,84 +93,64 @@ pub struct JsonTree {
 	// emitted behind the _raw_ adapter, so `text` arrives as a thin char*;
 	// aarch64 receives the pair x2 = ptr, x3 = len.)
 	func set_text = (ref self, int idx, string text) {
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		nodes[idx].text.ptr = strdup(text);
-		nodes[idx].text.len = (long)strlen(text);
-		```
-		```
-		#arch: aarch64
-		// x19 = self, x1 = idx, x2 = text.ptr, x3 = text.len
-		// nodes.data is at self+16 (JsonTree.vt[0] + Buffer.vt[8])
-		// text field is at offset 16 in JsonNode (vt[0] + kind[8]); the fat
-		// field is ptr@+16, len@+24; sizeof(JsonNode) = 56.
-		sub sp, sp, #32
-		str x1, [sp, #0]
-		str x3, [sp, #8]
-		mov x0, x2
-		bl _strdup
-		str x0, [sp, #16]
-		ldr x0, [x19, #16]
-		ldr x1, [sp, #0]
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x1, [sp, #16]
-		str x1, [x0]
-		ldr x1, [sp, #8]
-		str x1, [x0, #8]
-		add sp, sp, #32
-		```
+		unsafe {
+			var int len = text.length
+			var uint64 buf = malloc(len + 1)
+			memcpy(buf, (text as ptr char) as uint64, len)
+			memset(buf + len, 0, 1)
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			slots[t] = buf
+			slots[t + 1] = len
+		}
 	}
 
 	func set_kind = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		n.kind = val
-		self.nodes.store_T(idx, n)
+		self.nodes.store(idx, n)
 	}
 
 	func set_child = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		n.child = val
-		self.nodes.store_T(idx, n)
+		self.nodes.store(idx, n)
 	}
 
 	func set_next = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		n.next = val
-		self.nodes.store_T(idx, n)
+		self.nodes.store(idx, n)
 	}
 
 	func set_val = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		n.val = val
-		self.nodes.store_T(idx, n)
+		self.nodes.store(idx, n)
 	}
 
 	func get_kind = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		return n.kind
 	}
 
 	func get_text = (self, int idx, out string) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		return n.text
 	}
 
 	func get_child = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		return n.child
 	}
 
 	func get_next = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		return n.next
 	}
 
 	func get_val = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load_T(idx)
+		var JsonNode n = self.nodes.load(idx)
 		return n.val
 	}
 }