nomen-lang 0.4.0 → 0.5.0

package/core/System/Nursery.nm

@@ -5,18 +5,19 @@
 // An `async` block names its nursery (`async pool { }`), binding a Nursery
 // variable in scope. That variable is passed to helper functions with `ref`
 // and is the receiver of `pool.spawn(fn(args))`. The Nursery wraps the
-// per-invocation tracking state of the `async { }` block — a pointer to the
-// futures array and a pointer to the count slot, both on the async block's
-// stack frame — so it is only valid for the lifetime of its enclosing block
-// (which is exactly the structured-concurrency invariant: the block cannot
-// exit until every spawned task, including those spawned through a passed
-// Nursery, has finished).
+// per-invocation tracking state of the `async { }` block — pointers to the
+// futures list's storage slot, the registered count, and the capacity (the
+// list starts empty and grows by realloc; the compiler's registration helper
+// writes through these pointers) — so it is only valid for the lifetime of
+// its enclosing block (which is exactly the structured-concurrency
+// invariant: the block cannot exit until every spawned task, including those
+// spawned through a passed Nursery, has finished).
 //
 // Config rides on the declaration: `async pool = Nursery(timeout: 2000) { }`.
 //
 // `name.spawn(fn(args))` is special-cased by the compiler (it needs the spawn
-// trampoline machinery), so it is NOT a regular method declared here. The two
-// fields are the full runtime contract.
+// trampoline machinery), so it is NOT a regular method declared here. The
+// three fields are the full runtime contract.
 
 /**
  * The capability for spawning into a caller's `async` block; owns and tracks its tasks
@@ -24,4 +25,5 @@
 pub struct Nursery: Sendable {
 	pub var uint64 futures_ptr = 0
 	pub var uint64 count_ptr = 0
+	pub var uint64 cap_ptr = 0
 }

package/core/System/Stream/Http.nm

@@ -1,12 +1,16 @@
 /**
- * A minimal blocking HTTP/1.1 client.
+ * A minimal HTTP/1.1 client built on Tcp.
  *
  * Plain `http://` only — no TLS (an `https://` URL cannot be served; use a
  * TLS proxy or wait for a TLS-capable transport). Construct an instance,
- * call `get`/`post` (which block until the full response is received), then
- * read the `status` field for the response's status code. Fallible calls
- * return a `Result` whose error side is an `HttpError`; `status` is 0 when
- * DNS resolution or the connection fails.
+ * call `get`/`post`, then read the `status` field for the response's status
+ * code. Fallible calls return a `Result` whose error side is an `HttpError`;
+ * `status` is 0 when DNS resolution or the connection fails.
+ *
+ * Every wait rides Tcp's netpoller hook: inside a Fiber the request parks
+ * (freeing its worker) instead of blocking — the same `Http` code scales
+ * from one call to thousands of concurrent fibers. See ASYNC.md
+ * Phase 3.
  *
  * URLs may carry an explicit port (`http://host:8080/path`); the default is
  * 80 and the default path is `/`. `post` sends `body` with a
@@ -27,8 +31,9 @@ pub struct Http {
 	pub var int status = 0
 
 	// Internal failure code from the most recent request: 0 = success,
-	// 1 = DNS resolution, 2 = socket creation, 3 = connect. Raw #arch bodies
-	// set it, the Result-returning wrappers map it to HttpError.
+	// 1 = DNS resolution, 2 = socket creation, 3 = connect, 6 = send failed.
+	// Mirrors Tcp's codes on the connect path; the Result-returning wrappers
+	// map it to HttpError.
 	var int error = 0
 
 	// Maps the raw failure code to its HttpError case.
@@ -53,449 +58,93 @@ pub struct Http {
 	// method string ("GET" / "POST"); a leading 'P' selects POST semantics
 	// (sends `body` and the Content-* headers). Sets self->status (0 on
 	// failure) and self->error, and returns the response body (empty string
-	// on failure). The raw body mallocs the response — `move out string`
-	// transfers ownership to the caller.
+	// on failure).
 	func raw_exchange = (ref self, string method, string url, string body, move out string) {
-		```
-		#arch: c
-		#scope: file
-		#include <sys/socket.h>
-		#include <netdb.h>
-		#include <unistd.h>
-		#include <string.h>
-		#include <stdlib.h>
-		```
-		```
-		#arch: c
-		// Fat-string ABI: params are (ptr, len) pairs; consume the .ptr
-		// halves at each FFI boundary.
-		const char *scheme = strstr(url.ptr, "://");
-		const char *hp = scheme ? scheme + 3 : url.ptr;
-		const char *colon = strchr(hp, ':');
-		const char *slash = strchr(hp, '/');
-		char host[256];
-		int port = 80;
-		const char *path = "/";
-
-		if (colon && (!slash || colon < slash)) {
-			int hlen = (int)(colon - hp);
-			if (hlen > 255) hlen = 255;
-			memcpy(host, hp, hlen);
-			host[hlen] = 0;
-			port = atoi(colon + 1);
-		} else {
-			const char *end = slash ? slash : hp + strlen(hp);
-			int hlen = (int)(end - hp);
-			if (hlen > 255) hlen = 255;
-			memcpy(host, hp, hlen);
-			host[hlen] = 0;
+		// Parse the URL: [http://]host[:port][/path]
+		var int host_start = 0
+		if url.starts_with("http://") {
+			host_start = 7
 		}
-		if (slash) path = slash;
-
-		struct addrinfo hints, *res;
-		memset(&hints, 0, sizeof(hints));
-		hints.ai_family = AF_INET;
-		hints.ai_socktype = SOCK_STREAM;
-		char portstr[16];
-		snprintf(portstr, sizeof(portstr), "%d", port);
-		if (getaddrinfo(host, portstr, &hints, &res) != 0) {
-			self->status = 0;
-			self->error = 1;
-			return (nomen_string){ strdup(""), 0 };
+		var int slash = url.index_of_from("/", host_start)
+		var int colon = url.index_of_from(":", host_start)
+		var int host_end = url.length
+		if slash >= 0 {
+			host_end = slash
+		}
+		var int name_end = host_end
+		if colon >= 0 {
+			if colon < host_end {
+				name_end = colon
+			}
 		}
-		int sock = socket(AF_INET, SOCK_STREAM, 0);
-		if (sock < 0) {
-			freeaddrinfo(res);
-			self->status = 0;
-			self->error = 2;
-			return (nomen_string){ strdup(""), 0 };
+		var int port = 80
+		if name_end != host_end {
+			var string port_text = url.substring(name_end + 1, host_end)
+			port = int.parse(port_text)
 		}
-		if (connect(sock, res->ai_addr, res->ai_addrlen) < 0) {
-			freeaddrinfo(res);
-			close(sock);
-			self->status = 0;
-			self->error = 3;
-			return (nomen_string){ strdup(""), 0 };
+		var string host = url.substring(host_start, name_end)
+		var string path = "/"
+		if slash >= 0 {
+			path = url.substring(slash, url.length)
 		}
-		freeaddrinfo(res);
 
-		char req[1600];
-		int off = snprintf(req, sizeof(req),
-			"%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n",
-			method.ptr, path, host);
-		if (method.ptr[0] == 'P') {
-			int blen = (int)body.len;
-			off += snprintf(req + off, sizeof(req) - off,
-				"Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\n\r\n",
-				blen);
-			send(sock, req, off, 0);
-			send(sock, body.ptr, blen, 0);
+		// Connect — parks a fiber while the handshake completes.
+		var Tcp conn = Tcp.connect(host, port)
+		if conn.fd < 0 {
+			self.status = 0
+			self.error = conn.error
+			return ""
+		}
+
+		// Build the request head.
+		var string request = method + " " + path + " HTTP/1.1\r\nHost: " + host + "\r\nConnection: close\r\n"
+		if method.starts_with("P") {
+			request = request + "Content-Type: application/x-www-form-urlencoded\r\nContent-Length: \{body.length}\r\n\r\n"
 		} else {
-			off += snprintf(req + off, sizeof(req) - off, "\r\n");
-			send(sock, req, off, 0);
+			request = request + "\r\n"
 		}
 
-		int cap = 4096, len = 0;
-		char *buf = (char*)malloc(cap);
-		int n;
-		while ((n = recv(sock, buf + len, cap - len - 1, 0)) > 0) {
-			len += n;
-			if (len + 1 >= cap) {
-				cap *= 2;
-				buf = (char*)realloc(buf, cap);
+		// Send — parks while the socket back-pressures.
+		var bool sent = conn.send(request)
+		if sent {
+			if method.starts_with("P") {
+				sent = conn.send(body)
 			}
 		}
-		buf[len] = 0;
-		close(sock);
-
-		int code = 0;
-		if (len >= 12 && strncmp(buf, "HTTP/", 5) == 0) {
-			code = atoi(buf + 9);
+		if !sent {
+			conn.close()
+			self.status = 0
+			self.error = 6
+			return ""
 		}
-		self->status = code;
-		self->error = 0;
 
-		char *body_start = strstr(buf, "\r\n\r\n");
-		if (body_start) {
-			char *result = strdup(body_start + 4);
-			long rlen = (long)len - (long)(body_start + 4 - buf);
-			free(buf);
-			return (nomen_string){ result, rlen };
+		// Receive until the peer closes (how Connection: close HTTP works).
+		// (Named `wire`, not `response`: the aarch64 build-global moved-set is
+		// name-keyed, and a bare `return response` here would suppress the
+		// return-path free of get/post's own `response` local — see the
+		// FOLLOWUP.md entry.)
+		var string wire = conn.recv_all()
+		conn.close()
+
+		self.error = 0
+		// Status line: "HTTP/1.x NNN ..." — the code lives at bytes 9..12.
+		if wire.starts_with("HTTP/") && wire.length >= 12 {
+			var string code_text = wire.substring(9, 12)
+			self.status = int.parse(code_text)
+		} else {
+			self.status = 0
 		}
-		return (nomen_string){ buf, len };
-		```
-		```
-		#arch: aarch64
-		// Fat-string ABI: x0=self(->x19); method=(x1,x2), url=(x3,x4),
-		// body=(x5,x6) — only the ptr halves are consumed below, plus
-		// body.len (stashed at #200) for Content-Length/send.
-		// Struct layout: self->status at [x19, #8], self->error at
-		// [x19, #16] (1 = dns, 2 = socket, 3 = connect; cleared on success).
-		// macOS arm64 passes variadic args on the caller stack at [sp+0..], so
-		// [sp+0..47] is reserved scratch for snprintf variadic args and the
-		// addrinfo hints live above it. Stack frame (2048 bytes):
-		//   #0   variadic scratch (snprintf args)
-		//   #48  hints (struct addrinfo, 48 bytes)
-		//   #96  res*            #104 sock fd
-		//   #112 port            #120 hp (host start)
-		//   #128 method          #136 url
-		//   #144 body            #152 path
-		//   #160 colon/blen/buf  #168 slash/cap
-		//   #176 hostlen/req_off #184 portstr (16)
-		//   #208 host buffer (256)   #464 request buffer (1584)
-		sub sp, sp, #2048
-		str x1, [sp, #128]
-		str x3, [sp, #136]
-		str x5, [sp, #144]
-		str x6, [sp, #200]           // body len
-		mov x0, #80
-		str x0, [sp, #112]
-		adr x0, .Lhttp_slash
-		str x0, [sp, #152]
-
-		// hp = (strstr(url, "://") ?: url) + 3 when scheme present
-		ldr x0, [sp, #136]
-		adr x1, .Lhttp_scheme
-		bl _strstr
-		cbz x0, .Lhttp_sethp
-		add x0, x0, #3
-		.Lhttp_sethp:
-		str x0, [sp, #120]
-
-		// colon = strchr(hp, ':'); slash = strchr(hp, '/')
-		ldr x0, [sp, #120]
-		mov x1, #0x3A
-		bl _strchr
-		str x0, [sp, #160]
-		ldr x0, [sp, #120]
-		mov x1, #0x2F
-		bl _strchr
-		str x0, [sp, #168]
 
-		// if (colon && (!slash || colon < slash)) -> port branch
-		ldr x0, [sp, #160]
-		cbz x0, .Lhttp_np
-		ldr x1, [sp, #168]
-		cbz x1, .Lhttp_port
-		cmp x0, x1
-		b.lo .Lhttp_port
-		.Lhttp_np:
-		// hostlen = slash ? (slash - hp) : strlen(hp); path = slash
-		ldr x0, [sp, #168]
-		cbz x0, .Lhttp_np_strlen
-		ldr x1, [sp, #120]
-		sub x0, x0, x1
-		str x0, [sp, #176]
-		ldr x0, [sp, #168]
-		str x0, [sp, #152]
-		b .Lhttp_cph
-		.Lhttp_np_strlen:
-		ldr x0, [sp, #120]
-		bl _strlen
-		str x0, [sp, #176]
-		b .Lhttp_cph
-		.Lhttp_port:
-		// hostlen = colon - hp; port = atoi(colon + 1)
-		ldr x0, [sp, #120]
-		ldr x1, [sp, #160]
-		sub x0, x1, x0
-		str x0, [sp, #176]
-		ldr x0, [sp, #160]
-		add x0, x0, #1
-		bl _atoi
-		str x0, [sp, #112]
-		ldr x0, [sp, #168]
-		cbz x0, .Lhttp_cph
-		str x0, [sp, #152]
-
-		// hostlen = min(hostlen, 255); memcpy(hostbuf, hp, hostlen); hostbuf[hostlen]=0
-		.Lhttp_cph:
-		ldr x0, [sp, #176]
-		mov x9, #255
-		cmp x0, x9
-		csel x0, x0, x9, ls
-		str x0, [sp, #176]
-		add x0, sp, #208
-		ldr x1, [sp, #120]
-		ldr x2, [sp, #176]
-		bl _memcpy
-		add x0, sp, #208
-		ldr x1, [sp, #176]
-		strb wzr, [x0, x1]
-
-		// memset(&hints, 0, 48); hints.ai_family=AF_INET(2); hints.ai_socktype=SOCK_STREAM(1)
-		add x0, sp, #48
-		mov x1, xzr
-		mov x2, #48
-		bl _memset
-		mov w0, #2
-		str w0, [sp, #52]
-		mov w0, #1
-		str w0, [sp, #56]
-		// snprintf(portstr, 16, "%ld", port) — variadic arg on stack at [sp+0]
-		ldr x9, [sp, #112]
-		str x9, [sp, #0]
-		add x0, sp, #184
-		mov x1, #16
-		adr x2, .Lhttp_fmt_ld
-		bl _snprintf
-		// getaddrinfo(host, portstr, &hints, &res)
-		add x0, sp, #208
-		add x1, sp, #184
-		add x2, sp, #48
-		add x3, sp, #96
-		bl _getaddrinfo
-		cbnz w0, .Lhttp_dnsfail
-
-		// sock = socket(AF_INET, SOCK_STREAM, 0)
-		mov x0, #2
-		mov x1, #1
-		mov x2, xzr
-		bl _socket
-		cmp w0, #0
-		b.ge .Lhttp_sockok
-		ldr x0, [sp, #96]
-		bl _freeaddrinfo
-		mov x9, #2
-		str x9, [x19, #16]
-		b .Lhttp_fail
-		.Lhttp_sockok:
-		str w0, [sp, #104]
-		// connect(sock, res->ai_addr (off 32), res->ai_addrlen (off 16))
-		ldr x9, [sp, #96]
-		ldr x1, [x9, #32]
-		ldr w2, [x9, #16]
-		ldr w0, [sp, #104]
-		bl _connect
-		cmp w0, #0
-		b.ge .Lhttp_connected
-		ldr x0, [sp, #96]
-		bl _freeaddrinfo
-		ldr w0, [sp, #104]
-		bl _close
-		mov x9, #3
-		str x9, [x19, #16]
-		b .Lhttp_fail
-		.Lhttp_connected:
-		ldr x0, [sp, #96]
-		bl _freeaddrinfo
-
-		// off = snprintf(req, 1584, common_fmt, method, path, host)
-		// variadic args on stack: method@[0], path@[8], host@[16]
-		ldr x9, [sp, #128]
-		str x9, [sp, #0]
-		ldr x9, [sp, #152]
-		str x9, [sp, #8]
-		add x9, sp, #208
-		str x9, [sp, #16]
-		add x0, sp, #464
-		mov x1, #1584
-		adr x2, .Lhttp_reqcommon
-		bl _snprintf
-		sxtw x0, w0
-		str x0, [sp, #176]
-
-		// if method[0] == 'P' (0x50) -> POST
-		ldr x0, [sp, #128]
-		ldrb w0, [x0]
-		cmp w0, #0x50
-		b.ne .Lhttp_getsend
-
-		// POST: blen = body.len (fat half); append Content-Length; send both
-		ldr x9, [sp, #200]
-		str x9, [sp, #160]
-		// snprintf(req+off, 1584-off, reqpost, blen) — blen on stack at [sp+0]
-		ldr x9, [sp, #160]
-		str x9, [sp, #0]
-		add x0, sp, #464
-		ldr x1, [sp, #176]
-		add x0, x0, x1
-		mov x1, #1584
-		ldr x2, [sp, #176]
-		sub x1, x1, x2
-		adr x2, .Lhttp_reqpost
-		bl _snprintf
-		sxtw x0, w0
-		ldr x1, [sp, #176]
-		add x1, x1, x0
-		str x1, [sp, #176]
-		ldr w0, [sp, #104]
-		add x1, sp, #464
-		ldr x2, [sp, #176]
-		mov x3, xzr
-		bl _send
-		ldr w0, [sp, #104]
-		ldr x1, [sp, #144]
-		ldr x2, [sp, #200]
-		mov x3, xzr
-		bl _send
-		b .Lhttp_recv
-
-		.Lhttp_getsend:
-		// GET: append trailing "\r\n" (no variadic) and send
-		add x0, sp, #464
-		ldr x1, [sp, #176]
-		add x0, x0, x1
-		mov x1, #1584
-		ldr x2, [sp, #176]
-		sub x1, x1, x2
-		adr x2, .Lhttp_crlf
-		bl _snprintf
-		sxtw x0, w0
-		ldr x1, [sp, #176]
-		add x1, x1, x0
-		str x1, [sp, #176]
-		ldr w0, [sp, #104]
-		add x1, sp, #464
-		ldr x2, [sp, #176]
-		mov x3, xzr
-		bl _send
-
-		// recv loop: buf = malloc(4096); grow as needed
-		.Lhttp_recv:
-		mov x0, #4096
-		bl _malloc
-		str x0, [sp, #160]
-		mov x0, #4096
-		str x0, [sp, #168]
-		str xzr, [sp, #96]
-		.Lhttp_recvloop:
-		ldr w0, [sp, #104]
-		ldr x1, [sp, #160]
-		ldr x2, [sp, #96]
-		add x1, x1, x2
-		ldr x2, [sp, #168]
-		ldr x3, [sp, #96]
-		sub x2, x2, x3
-		sub x2, x2, #1
-		mov x3, xzr
-		bl _recv
-		cmp x0, #0
-		ble .Lhttp_recvdone
-		ldr x1, [sp, #96]
-		add x1, x1, x0
-		str x1, [sp, #96]
-		add x2, x1, #1
-		ldr x3, [sp, #168]
-		cmp x2, x3
-		blt .Lhttp_recvloop
-		ldr x0, [sp, #168]
-		lsl x0, x0, #1
-		str x0, [sp, #168]
-		mov x1, x0
-		ldr x0, [sp, #160]
-		bl _realloc
-		str x0, [sp, #160]
-		b .Lhttp_recvloop
-
-		.Lhttp_recvdone:
-		// buf[len] = 0; close(sock)
-		ldr x0, [sp, #160]
-		ldr x1, [sp, #96]
-		strb wzr, [x0, x1]
-		ldr w0, [sp, #104]
-		bl _close
-		// success: clear error before storing the status code
-		str xzr, [x19, #16]
-		// self->status = atoi(buf + 9)
-		ldr x0, [sp, #160]
-		add x0, x0, #9
-		bl _atoi
-		sxtw x0, w0
-		str x0, [x19, #8]
-		// body_start = strstr(buf, "\r\n\r\n"); fat returns carry lens.
-		ldr x0, [sp, #160]
-		adr x1, .Lhttp_hdrsep
-		bl _strstr
-		cbz x0, .Lhttp_retbuf
-		// result = strdup(body_start + 4); rlen = len - (body_start+4-buf)
-		add x9, x0, #4
-		ldr x10, [sp, #160]
-		sub x9, x9, x10
-		ldr x10, [sp, #96]
-		sub x9, x10, x9              // rlen
-		str x9, [sp, #168]
-		add x0, x0, #4
-		bl _strdup
-		ldr x1, [sp, #168]
-		str x0, [sp, #112]
-		ldr x0, [sp, #160]
-		bl _free
-		ldr x0, [sp, #112]
-		add sp, sp, #2048
-		b .return_Http_raw_exchange
-		.Lhttp_retbuf:
-		ldr x0, [sp, #160]
-		ldr x1, [sp, #96]
-		add sp, sp, #2048
-		b .return_Http_raw_exchange
-		.Lhttp_dnsfail:
-		mov x9, #1
-		str x9, [x19, #16]
-		b .Lhttp_fail
-		.Lhttp_fail:
-		str xzr, [x19, #8]
-		adr x0, .Lhttp_empty
-		bl _strdup
-		mov x1, #0
-		add sp, sp, #2048
-		b .return_Http_raw_exchange
-
-		.Lhttp_scheme: .asciz "://"
-		.Lhttp_slash: .asciz "/"
-		.Lhttp_fmt_ld: .asciz "%ld"
-		.Lhttp_crlf: .asciz "\r\n"
-		.Lhttp_hdrsep: .asciz "\r\n\r\n"
-		.Lhttp_empty: .asciz ""
-		.Lhttp_reqcommon: .asciz "%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n"
-		.Lhttp_reqpost: .asciz "Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %ld\r\n\r\n"
-		.p2align 2
-		```
-		return ""
+		// Body starts after the blank header/body separator line.
+		var int sep = wire.index_of("\r\n\r\n")
+		if sep >= 0 {
+			return wire.substring(sep + 4, wire.length)
+		}
+		return wire
 	}
 
-	// Issue a blocking GET request to `url`. `.ok(body)` with the response
-	// body and `self.status` set to the response's status code, or
+	// Issue a GET request to `url`. `.ok(body)` with the response body and
+	// `self.status` set to the response's status code, or
 	// `.error(HttpError)` (`status` is 0).
 	pub func get = (ref self, string url, out Result<string, HttpError>) {
 		const string response = self.raw_exchange("GET", url, "")
@@ -505,7 +154,7 @@ pub struct Http {
 		return Result.error(Http.error_of(self.error))
 	}
 
-	// Issue a blocking POST request to `url` with `body` as the payload.
+	// Issue a POST request to `url` with `body` as the payload.
 	// `.ok(body)` with the response body and `self.status` set to the
 	// response's status code, or `.error(HttpError)` (`status` is 0).
 	pub func post = (ref self, string url, string body, out Result<string, HttpError>) {