path: root/src/lsp/server.zc

// ============================================================================
// server.zc: the language server. it is appended to the genome after the
// compiler (cat src/runtime/rt.zc src/compiler/compiler.zc src/lsp/server.zc | zc0), so it does not
// analyze zc with a second implementation of the grammar: it runs the
// compiler itself over the document, in check mode (see chk_unit in
// compiler.zc), and reports what the compiler said. a parse word, an
// operator or a type the document defines changes how the rest of the
// document is read, for the checker and for the highlighter, because both are
// the compiler. it speaks json-rpc on stdin and stdout, and when stdin is not
// a protocol stream but a source file it prints the diagnostics as text.
// ============================================================================

// the first constant the server declares: the blob cut for a document starts
// here (blob_load, compiler.zc), so this name must stay the first one of the server.
const int LSP_SERVER = 1;

// the compiler's own functions, declared here so this file checks on its own
// in an editor: the build places them in front of this file, so these lines only
// promise what is already defined there
int chk_unit(int src, int buf, int cap, int sets, int lim);
int hl_begin(int src);
int hl_end();

// ---- memory ----
// nothing here has a fixed address. a document is a heap block of its text, the
// diagnostics and the check's name sets are blocks too, and a check collects
// what the last one left behind (chk_unit). a document compiles into the
// program region from 0 up to CODE_END, which is the map's own.

const int DGCAP = 12000;
word dgb, sets; int jsize, tcap;
int dgbcap = DGCAP;

const int MAXDOC = 16, URIW = 160;

// ---- output ----
// every message is written twice: once to count its bytes for the header,
// once for real. wc is the only thing that touches the terminal.
int wmode, wcnt;
// writes one byte of output. while a message is being sized the byte is only
// counted; otherwise it goes to the terminal.
int wc(int c) {
	if (wmode) wcnt++; else raw_c(c);
	return 0;
}
// writes a zero-terminated word string, one byte per character.
int ws(word s) {
	int i = 0;
	while (s[i]) { wc(s[i]); i++; }
	return 0;
}
// writes n in decimal, with a minus sign when it is negative.
int wn(int n) {
	[24]word b; int i = 0;
	if (n < 0) { wc('-'); n = 0 - n; }
	while (1) { b[i] = '0' + n % 10; i++; n = n / 10; if (!n) break; }
	while (i) { i--; wc(b[i]); }
	return 0;
}
// writes byte c inside a json string: quotes and backslashes are escaped, and
// the control characters become their escapes (\n, \t, \u00xx) so the text stays one line.
int wesc(int c) {
	if (c == 34) { wc(92); wc(34); return 0; }
	if (c == 92) { wc(92); wc(92); return 0; }
	if (c == 10) { wc(92); wc('n'); return 0; }
	if (c == 13) { wc(92); wc('r'); return 0; }
	if (c == 9) { wc(92); wc('t'); return 0; }
	if (c < 32) {
		ws("\\u00");
		wc("0123456789abcdef"[c >> 4]);
		wc("0123456789abcdef"[c & 15]);
		return 0;
	}
	wc(c);
	return 0;
}
// a json string from n chars at p, one per word
int wjs(word p, int n) {
	int i = 0;
	wc(34);
	while (i < n) { wesc(p[i]); i++; }
	wc(34);
	return 0;
}
// sends one message. gen writes its body: it runs once to count the bytes for the
// Content-Length header, and once more to write them.
int send(int gen) {
	wmode = 1; wcnt = 0; gen();
	wmode = 0;
	ws("Content-Length: "); wn(wcnt); ws("\r\n\r\n");
	gen();
	return 0;
}

// ---- documents ----
// a document is its text, four bytes to a word, in a heap block of its own
// (doff), with a zero word after the last byte so the lexer sees the end. a
// replaced text is a new block, and the old one is garbage for the collector.

int nodoc, doccap = MAXDOC;
word duri, dulen, doff, dsize, dver, dgen, dlive;
// Grow a heap buffer while retaining its contents. Globals keep these buffers rooted.
unchecked word lsp_grow(word old, int count, int capacity) {
	word p = new(capacity);
	fill_w(p, 0, capacity);
	if (old && count) copy_w(p, old, count);
	return p;
}
// Document columns grow together; each URI has its own string allocation.
int docs_grow() {
	int next = doccap * 2;
	duri = lsp_grow(duri, doccap, next); dulen = lsp_grow(dulen, doccap, next);
	doff = lsp_grow(doff, doccap, next); dsize = lsp_grow(dsize, doccap, next);
	dver = lsp_grow(dver, doccap, next); dgen = lsp_grow(dgen, doccap, next);
	dlive = lsp_grow(dlive, doccap, next);
	doccap = next;
	return 0;
}
// the byte at offset i of a text. texts are packed four bytes to a word, low byte first.
word dc(word base, int i) { return (base[i >> 2] >> ((i & 3) * 8)) & 255; }
// the document with the uri p (n bytes long), or -1 when the server has no such document.
int dfind(word p, int n) {
	int i = 0, k;
	while (i < doccap) {
		if (dlive[i] && dulen[i] == n) {
			k = 0;
			while (k < n && duri[i][k] == p[k]) k++;
			if (k == n) return i;
		}
		i++;
	}
	return 0 - 1;
}
// takes a free document slot for the uri p (n bytes long), growing the columns
// when needed. commit_text sets its text after this.
int docnew(word p, int n) {
	int i = 0, k;
	while (1) {
		if (i == doccap) docs_grow();
		if (!dlive[i]) {
			duri[i] = lsp_grow(0, 0, n + 1);
			k = 0; while (k < n) { duri[i][k] = p[k]; k++; }
			dulen[i] = n; dlive[i] = 1; doff[i] = 0; dsize[i] = 0; dver[i] = 0; dgen[i] = 0;
			return i;
		}
		i++;
	}
	return 0 - 1;
}
// the text, its terminator and a spare zero word
int dwords(int n) { return (n >> 2) + 2; }
// ---- the check ----
int chk_i, chk_gen;	// the document the compiler's tables describe, and its generation
// checks document i with the compiler in check mode. the diagnostics are left in
// dgb, and the types of the untyped lets are recorded while it runs (lt_on).
int check_doc(int i) {
	chk_i = i; chk_gen = dgen[i];
	outmode = 1;
	lt_on = 1; lt_n = 0; ltxn = 0; ht_n = 0;
	chk_unit(doff[i], dgb, dgbcap, sets, CODE_END);
	dgb = dgbuf; dgbcap = dgcap;
	lt_on = 0;
	outmode = 0;
	return 0;
}
// the entry of the untyped local declared at byte offset o, or -1
int lt_find(int o) {
	int k = 0;
	while (k < lt_n) { if (lt_off[k] == o) return k; k++; }
	return 0 - 1;
}
int ensure_checked(int i) {
	if (chk_i != i || chk_gen != dgen[i]) check_doc(i);
	return 0;
}

// ---- positions ----
// a cursor over the document that turns byte offsets into the line and the
// utf-16 column the protocol wants. it only moves forward, or starts over.
int pbase, plen, poff, pline, pcol;
// starts the position cursor at the top of document i.
int pc_reset(int i) {
	pbase = doff[i];
	plen = dsize[i];
	poff = 0;
	pline = 0;
	pcol = 0;
	return 0;
}
// moves the position cursor forward to byte offset off, counting lines and the
// utf-16 columns the protocol uses (a character of four bytes takes two columns).
// a cursor that is past off starts over from the top.
int pc_to(int off) {
	int b;
	if (off < poff) { poff = 0; pline = 0; pcol = 0; }
	if (off > plen) off = plen;
	while (poff < off) {
		b = dc(pbase, poff);
		if (b == 10) { pline++; pcol = 0; }
		else if (b < 128 || b >= 192) { if (b >= 240) pcol = pcol + 2; else pcol++; }
		poff++;
	}
	return 0;
}
// the byte offset where the 1-based line l starts, or the end of the text when
// there is no such line.
int line_off(int l) {
	int o = 0;
	while (l > 1 && o < plen) { if (dc(pbase, o) == 10) l--; o++; }
	return o;
}

// ---- diagnostics ----
int gd;			// the document being reported
// writes a json position, {line, character}, for byte offset off.
int wpos(int off) {
	pc_to(off);
	ws("{\"line\":");
	wn(pline);
	ws(",\"character\":");
	wn(pcol);
	wc('}');
	return 0;
}
// writes the publishDiagnostics message for document gd from dgb. each record
// becomes a range (the whole line when the compiler only knew the line), a
// severity and its message.
int gen_diag() {
	int at = 0, first = 1, sev, rln, off, rlen, n, o, e;
	ws("{\"jsonrpc\":\"2.0\",\"method\":\"textDocument/publishDiagnostics\",\"params\":{\"uri\":");
	wjs(duri[gd], dulen[gd]);
	ws(",\"version\":"); wn(dver[gd]);
	ws(",\"diagnostics\":[");
	pc_reset(gd);
	while (at < dgpos) {
		sev = dgb[at]; rln = dgb[at + 1]; off = dgb[at + 2]; rlen = dgb[at + 3]; n = dgb[at + 4];
		if (off < 0) {		// the compiler only knew the line: mark its text
			o = line_off(rln);
			while (o < plen && (dc(pbase, o) == 32 || dc(pbase, o) == 9)) o++;
			e = o;
			while (e < plen && dc(pbase, e) != 10) e++;
			if (e > o && dc(pbase, e - 1) == 13) e--;
		} else {
			o = off; e = off + rlen;
			if (o >= plen) {	// the end of the file: the last thing before it
				o = plen;
				while (o > 0 && (dc(pbase, o - 1) == 32 || dc(pbase, o - 1) == 10 || dc(pbase, o - 1) == 13 || dc(pbase, o - 1) == 9)) {
					o--;
				}
				if (o > 0) o--;
				e = o + 1;
			}
			if (e <= o) e = o + 1;
		}
		if (e > plen) e = plen;
		if (o > e) o = e;
		if (!first) wc(',');
		first = 0;
		ws("{\"range\":{\"start\":"); wpos(o); ws(",\"end\":"); wpos(e);
		ws("},\"severity\":"); wn(sev); ws(",\"source\":\"zc\",\"message\":");
		wjs(dgb + at + 5, n);
		wc('}');
		at = at + 5 + n;
	}
	ws("]}}");
	return 0;
}
// sends the diagnostics of document i.
int publish(int i) {
	gd = i;
	send(gen_diag);
	return 0;
}

// ---- semantic tokens ----
// the legend: keyword type function variable string number operator comment
// parameter property macro enumMember
const int TT_KW = 0, TT_TYPE = 1, TT_FN = 2, TT_VAR = 3, TT_STR = 4, TT_NUM = 5, TT_OP = 6, TT_COM = 7, TT_PARAM = 8, TT_PROP = 9, TT_MACRO = 10, TT_ENUM = 11;
int tfirst, tprevl, tprevc;
// one token on one line
int tok_out(int off, int end, int ty) {
	int l, c, len;
	pc_to(off); l = pline; c = pcol;
	pc_to(end); len = pcol - c;
	if (len <= 0) return 0;
	if (!tfirst) wc(',');
	tfirst = 0;
	if (l == tprevl) { wn(0); wc(','); wn(c - tprevc); } else { wn(l - tprevl); wc(','); wn(c); }
	wc(','); wn(len); wc(','); wn(ty); ws(",0");
	tprevl = l; tprevc = c;
	return 0;
}
// a range that may cross lines is cut at the line ends
int range_out(int off, int end, int ty) {
	int e;
	while (off < end) {
		e = off;
		while (e < end && dc(pbase, e) != 10) e++;
		if (e > off && dc(pbase, e - 1) == 13) tok_out(off, e - 1, ty); else tok_out(off, e, ty);
		off = e + 1;
	}
	return 0;
}
// between two tokens there is only space and comments
int gap_out(int from, int to) {
	int o = from, e, c;
	while (o < to) {
		c = dc(pbase, o);
		if (c == '/' && dc(pbase, o + 1) == '/') {
			e = o; while (e < to && dc(pbase, e) != 10) e++;
			range_out(o, e, TT_COM); o = e;
		} else if (c == '/' && dc(pbase, o + 1) == '*') {
			e = o + 2;
			while (e < plen && !(dc(pbase, e) == '*' && dc(pbase, e + 1) == '/')) e++;
			e = e + 2; if (e > plen) e = plen;
			range_out(o, e, TT_COM); o = e;
		} else o++;
	}
	return 0;
}
// is c an operator character, which the highlighter marks as an operator.
int isopc(int c) {
	word s = "+-*/%=<>!&|^~?@#$";
	int i = 0;
	while (s[i]) { if (s[i] == c) return 1; i++; }
	return 0;
}
// is the name n one of the words the highlighter shows as keywords even when the
// compiler has no record for it.
int iskeyword(int n) {
	return n == s_fn || n == s_var || n == s_const || n == s_else || n == s_as || n == s_unchecked || n == s_immediate
		|| n == s_case || n == s_default || n == s_do || n == s_while || n == s_enum || n == s_include || n == s_memdebug
		|| n == s_enhance || n == s_micro || n == s_vm || n == s_struct || n == s_type || n == s_typecheck;
}
// the record of the name at byte offset o (see rs_note in the compiler), or -1.
// the records are sorted by offset, so this is a binary search.
int rs_find(int o) {
	int lo = 0, hi = rsn - 1, mid, v;
	while (lo <= hi) {
		mid = (lo + hi) / 2;
		v = rsrec[mid * RS_W];
		if (v == o) return mid;
		if (v < o) lo = mid + 1; else hi = mid - 1;
	}
	return 0 - 1;
}
// rs_cur is the cursor of the highlighter's pass over the records, which move
// forward with the tokens.
int rs_cur;
// the class of an identifier at byte offset o: what the compiler resolved it to
// when it checked the document, so a local named like a built-in is a variable.
// classify guesses from the name alone, and only serves names with no record.
int rs_class(int o, int n, int pt, int pv) {
	int r = -1, k, v, sk;
	while (rs_cur < rsn && rsrec[rs_cur * RS_W] < o) rs_cur++;
	if (rs_cur < rsn && rsrec[rs_cur * RS_W] == o) r = rs_cur;
	if (r < 0) return classify(n, pt, pv);
	k = rsrec[r * RS_W + 1];
	if (k == RS_LOCAL) return TT_VAR;
	if (k == RS_PARAM) return TT_PARAM;
	if (k == RS_FIELD) return TT_PROP;
	v = rsrec[r * RS_W + 2];
	sk = v & 15;
	if (sk == K_KW) { if (v & 16) return TT_MACRO; return TT_KW; }
	if (sk == K_TYPE) return TT_TYPE;
	if (sk == K_FN) { if (v & 32) return TT_FN; return TT_VAR; }
	if (sk == K_ENH) return TT_FN;
	if (sk == K_CONST) return TT_ENUM;
	return TT_VAR;
}
// the class of an identifier. pt, pv: the token before it
int classify(int n, int pt, int pv) {
	int s, nx = 0;
	// a name after fn is a declaration; a name after . or -> that is called is a method
	if (pt == T_ID && pv == s_fn) return TT_FN;
	if (pt == T_OP && pv == s_dot) {
		if (n == s_m || n == s_d || n == s_u) return TT_KW;
		peek();
		if (pk_tk == T_OP && pk_tv == s_lp) return TT_FN;
		return TT_PROP;
	}
	if (pt == T_OP && pv == s_arrow) {
		peek();
		if (pk_tk == T_OP && pk_tv == s_lp) return TT_FN;
		return TT_PROP;
	}
	if (iskeyword(n)) return TT_KW;
	peek();
	if (pk_tk == T_OP && pk_tv == s_lp) nx = 1;
	s = lookup(n);
	if (s >= 0) {
		if (skind[s] == K_KW) { if (s >= ubase) return TT_MACRO; return TT_KW; }
		if (skind[s] == K_TYPE) return TT_TYPE;
		if (skind[s] == K_FN && !(sflag[s] & F_DEF)) return TT_VAR;	// never defined: the check says so
		if (skind[s] == K_FN || skind[s] == K_ENH) {
			if (nx) return TT_FN;
			if (lsget(1, n)) return TT_PARAM;
			if (lsget(0, n)) return TT_VAR;
			return TT_FN;
		}
		if (skind[s] == K_CONST) return TT_ENUM;
		if (lsget(1, n)) return TT_PARAM;
		return TT_VAR;
	}
	if (lsget(2, n)) return TT_TYPE;
	if (lsget(1, n)) return TT_PARAM;
	if (lsget(0, n)) return TT_VAR;
	if (lsget(3, n)) return TT_PROP;
	return TT_VAR;
}
// writes the semantic tokens of document gd: every token in order, each with the
// class the compiler resolved it to (rs_class), and numbers, strings and operators
// by their kind. comments are left to the editor's own grammar.
int gen_tokens() {
	int last = 0, ty, pt = 0, pv = 0, o, e, c;
	ws("{\"jsonrpc\":\"2.0\",\"id\":"); wid(); ws(",\"result\":{\"data\":[");
	pc_reset(gd);
	tfirst = 1; tprevl = 0; tprevc = 0; rs_cur = 0;
	hl_begin(doff[gd]);
	while (tk != T_EOF) {
		o = toff; e = toff + toklen;
		if (toklen > 0 && o >= last) {
			gap_out(last, o);
			ty = 0 - 1;
			if (tk == T_ID) ty = rs_class(o, tv, pt, pv);
			else if (tk == T_NUM) {
				c = dc(pbase, o);
				if (c == 39) ty = TT_STR; else ty = TT_NUM;
			} else if (tk == T_FLT) ty = TT_NUM;
			else if (tk == T_STR || tk == T_BSTR) ty = TT_STR;
			else if (tk == T_OP) { if (isopc(dc(pbase, o))) ty = TT_OP; }
			if (ty >= 0) range_out(o, e, ty);
			last = e;
		}
		pt = tk; pv = tv;
		next();
	}
	gap_out(last, plen);
	hl_end();
	ws("]}}");
	return 0;
}

// ---- json in ----
// the body of a message is read straight off stdin a char at a time and
// never held whole: the fields the server cares about are picked out as they
// go by, and a document's text is decoded into the store as it arrives.
int jleft, jpk;
int hline, hchar, hn, hoff, hcursor; word hov; int hovcap = 2300; word htb; int htbc = 80, htn, ann_name_at; word hname; int hnamecap = 80; int hdl, hdle, hcs;
word ann_text; int ann_n;
word mbuf, idbuf, jk, kbuf; int mcap = 64, idcap = 64, jkcap = 16, kcap = 40; int mn, idn, idtype; word ubuf; int ucap = URIW; int un, jver, kn;
word tbase; int tn, thave, tover, tuseen;
// the next byte of the json body. the body is read from stdin and stops after
// jleft bytes; -1 means the end. junget returns a byte to the next jgetc.
int jgetc() {
	int c;
	if (jpk != 0 - 2) { c = jpk; jpk = 0 - 2; return c; }
	if (jleft <= 0) return 0 - 1;
	jleft--;
	if (eof()) { jleft = 0; return 0 - 1; }
	return get_c() & 255;
}
// return byte c, so that the next jgetc reads it again.
int junget(int c) { jpk = c; return 0; }
// the next byte of the json body that is not white space.
int jws() {
	int c = jgetc();
	while (c == 32 || c == 9 || c == 10 || c == 13) c = jgetc();
	return c;
}
// where the decoded bytes of a string go
int jput(int sink, int b) {
	word at;
	if (sink == 1) {
		if (mn + 1 >= mcap) { mbuf = lsp_grow(mbuf, mn, mcap * 2); mcap = mcap * 2; }
		mbuf[mn] = b; mn++;
	}
	else if (sink == 2) {
		if (idn + 1 >= idcap) { idbuf = lsp_grow(idbuf, idn, idcap * 2); idcap = idcap * 2; }
		idbuf[idn] = b; idn++;
	}
	else if (sink == 3) {
		if (un + 1 >= ucap) { ubuf = lsp_grow(ubuf, un, ucap * 2); ucap = ucap * 2; }
		ubuf[un] = b; un++;
	}
	else if (sink == 4) {
		if ((tn >> 2) + 2 >= tcap) { tover = 1; return 0; }
		at = tbase + (tn >> 2);
		if ((tn & 3) == 0) at[0] = 0;
		at[0] = at[0] | (b << ((tn & 3) * 8));
		tn++;
	} else if (sink == 5) {
		if (kn + 1 >= kcap) { kbuf = lsp_grow(kbuf, kn, kcap * 2); kcap = kcap * 2; }
		kbuf[kn] = b; kn++;
	}
	return 0;
}
// writes the code point cp as utf-8 into sink (one byte at a time through jput).
int jutf8(int sink, int cp) {
	if (cp < 128) { jput(sink, cp); return 0; }
	if (cp < 2048) { jput(sink, 192 | (cp >> 6)); jput(sink, 128 | (cp & 63)); return 0; }
	if (cp < 65536) {
		jput(sink, 224 | (cp >> 12));
		jput(sink, 128 | ((cp >> 6) & 63));
		jput(sink, 128 | (cp & 63));
		return 0;
	}
	jput(sink, 240 | (cp >> 18));
	jput(sink, 128 | ((cp >> 12) & 63));
	jput(sink, 128 | ((cp >> 6) & 63));
	jput(sink, 128 | (cp & 63));
	return 0;
}
// reads the four hex digits of a \u escape and returns their value. when a byte
// is not a hex digit, the digits read so far are returned and that byte goes back.
int jhex4() {
	int v = 0, i = 0, c, h;
	while (i < 4) {
		c = jgetc(); h = hexv(c);
		if (h < 0) { junget(c); return v; }
		v = v * 16 + h; i++;
	}
	return v;
}
// the rest of a string, the opening quote already read
int jstr(int sink) {
	int c, e, cp, lo;
	while (1) {
		c = jgetc();
		if (c < 0 || c == 34) return 0;
		if (c != 92) { jput(sink, c); continue; }
		e = jgetc();
		if (e == 'n') jput(sink, 10);
		else if (e == 't') jput(sink, 9);
		else if (e == 'r') jput(sink, 13);
		else if (e == 'b') jput(sink, 8);
		else if (e == 'f') jput(sink, 12);
		else if (e == 'u') {
			cp = jhex4();
			if (cp >= 55296 && cp < 56320) {		// a high surrogate: the low half follows as another \u
				c = jgetc();
				if (c == 92) {
					c = jgetc();
					if (c == 'u') { lo = jhex4(); cp = 65536 + ((cp - 55296) << 10) + (lo - 56320); }
				}
			}
			jutf8(sink, cp);
		} else if (e >= 0) jput(sink, e);
	}
	return 0;
}
// the code of the json key in kbuf, for the keys the server reads (0 for the others).
int kcode() {
	if (eq_w(kbuf, "method")) return 1;
	if (eq_w(kbuf, "id")) return 2;
	if (eq_w(kbuf, "params")) return 3;
	if (eq_w(kbuf, "textDocument")) return 4;
	if (eq_w(kbuf, "uri")) return 5;
	if (eq_w(kbuf, "text")) return 6;
	if (eq_w(kbuf, "contentChanges")) return 7;
	if (eq_w(kbuf, "version")) return 8;
	if (eq_w(kbuf, "position")) return 9;
	if (eq_w(kbuf, "line")) return 10;
	if (eq_w(kbuf, "character")) return 11;
	return 0;
}
// is the key code one of the first dep keys on the json path to the value being read.
int janc(int dep, int code) {
	int i = 0;
	while (i < dep) {
		if (jk[i] == code) return 1;
		i++;
	}
	return 0;
}
// reads one json value at nesting depth dep. the keys the server reads (key) go to
// their fields, and objects and arrays are walked for the ones inside them.
int jval(int key, int dep) {
	int c; word k; int sink, neg;
	if (dep >= jkcap) { jk = lsp_grow(jk, jkcap, jkcap * 2); jkcap = jkcap * 2; }
	jk[dep] = key;
	c = jws();
	if (c == '{') {
		while (1) {
			c = jws();
			if (c < 0 || c == '}') return 0;
			if (c == ',') continue;
			if (c != 34) continue;
			kn = 0; jstr(5); kbuf[kn] = 0;
			k = kcode();
			c = jws();		// the colon
			jval(k, dep + 1);
		}
	}
	if (c == '[') {
		while (1) {
			c = jws();
			if (c < 0 || c == ']') return 0;
			// a '}' inside an array is malformed: stop here and leave it for the enclosing object,
			// since a bare value stops at '}' without taking it, and looping would never end
			if (c == '}') { junget(c); return 0; }
			if (c == ',') continue;
			junget(c);
			jval(key, dep + 1);
		}
	}
	if (c == 34) {
		sink = 0;
		if (key == 1 && dep == 1) { sink = 1; mn = 0; }
		else if (key == 2 && dep == 1) { sink = 2; idn = 0; idtype = 2; }
		else if (key == 5 && janc(dep, 4)) { sink = 3; un = 0; tuseen = 1; }
		else if (key == 6 && (janc(dep, 7) || janc(dep, 4))) { sink = 4; thave = 1; tover = 0; tbase = text_start(); tn = 0; }
		jstr(sink);
		if (sink == 1) mbuf[mn] = 0;
		if (sink == 2) idbuf[idn] = 0;
		if (sink == 3) ubuf[un] = 0;
		if (sink == 4) {
			k = tbase + (tn >> 2);		// zero the rest of the last word and the one after it
			if ((tn & 3) == 0) k[0] = 0;
			k[1] = 0;
		}
		return 0;
	}
	if (c < 0) return 0;
	// a number, true, false or null
	sink = 0;
	if (key == 2 && dep == 1) { sink = 2; idn = 0; idtype = 1; }
	k = 0; neg = 0;
	while (c >= 0 && c != ',' && c != '}' && c != ']' && c != 32 && c != 10 && c != 13 && c != 9) {
		if (sink == 2) jput(2, c);
		if ((key == 8 && janc(dep, 4)) || ((key == 10 || key == 11) && janc(dep, 9))) {
			if (c == '-') {
				neg = 1;
			} else if (isdig(c)) k = k * 10 + c - '0';
		}
		c = jgetc();
	}
	junget(c);
	if (sink == 2) {
		idbuf[idn] = 0;
		if (eq_w(idbuf, "null")) idtype = 0;
	}
	if (key == 8 && janc(dep, 4)) { if (neg) k = 0 - k; jver = k; }
	if (key == 10 && janc(dep, 9)) hline = k;
	if (key == 11 && janc(dep, 9)) hchar = k;
	return 0;
}
// the text of a document being read goes into a block that holds the whole
// message: decoded text is never longer than the message it came in
word text_start() {
	tcap = dwords(jsize);
	tbase = new(tcap);
	return tbase;
}

// ---- messages in ----
word lbuf; int lcap = 160; int rfirst = 0 - 1;
// one header line, without the line end. returns its length, or -1 at the end of the input
int rl() {
	int n = 0, c;
	while (1) {
		if (rfirst >= 0) { c = rfirst; rfirst = 0 - 1; }
		else {
			if (eof()) { if (!n) return 0 - 1; return n; }
			c = get_c() & 255;
		}
		if (c == 10) return n;
		if (c != 13) {
			if (n + 1 >= lcap) { lbuf = lsp_grow(lbuf, n, lcap * 2); lcap = lcap * 2; }
			lbuf[n] = c; n++;
		}
	}
	return n;
}
// the lower case of an ascii letter. other bytes are unchanged.
int lower(int c) {
	if (c >= 'A' && c <= 'Z') return c + 32;
	return c;
}
// does the header line in lbuf start with content-length: (in any case).
int is_clen(int n) {
	if (n < 15) return 0;
	word s = "content-length:"; int i = 0;
	while (s[i]) { if (lower(lbuf[i]) != s[i]) return 0; i++; }
	return 1;
}
int inited, shut, quit;
// read one message into the field buffers. returns 0 at the end of the input
int read_message() {
	int n, size = 0 - 1, i;
	while (1) {
		n = rl();
		if (n < 0) return 0;
		if (n == 0) { if (size >= 0) break; else continue; }
		if (is_clen(n)) {
			i = 15; size = 0;
			while (i < n && (lbuf[i] == 32 || lbuf[i] == 9)) i++;
			while (i < n && isdig(lbuf[i])) { size = size * 10 + lbuf[i] - '0'; i++; }
		}
	}
	jleft = size; jpk = 0 - 2; jsize = size;
	mn = 0; mbuf[0] = 0; idn = 0; idbuf[0] = 0; idtype = 0; un = 0; ubuf[0] = 0; jver = 0;
	thave = 0; tover = 0; tuseen = 0; tn = 0; tbase = 0; hline = 0; hchar = 0;
	jval(0, 0);
	while (jleft > 0) jgetc();		// whatever the parser left behind
	return 1;
}

// ---- messages out ----
int wid() {
	if (idtype == 2) {
		wjs(idbuf, idn);
	} else if (idtype == 1) ws(idbuf); else ws("null");
	return 0;
}
// the reply to initialize: the server's capabilities, which are text sync, hover,
// and semantic tokens with their legend.
int gen_init() {
	ws("{\"jsonrpc\":\"2.0\",\"id\":"); wid();
	ws(",\"result\":{\"capabilities\":{\"textDocumentSync\":{\"openClose\":true,\"change\":1,\"save\":{\"includeText\":true}},");
	ws("\"hoverProvider\":true,\"semanticTokensProvider\":{\"legend\":{\"tokenTypes\":[\"keyword\",\"type\",\"function\",\"variable\",\"string\",\"number\",\"operator\",\"comment\",\"parameter\",\"property\",\"macro\",\"enumMember\"],\"tokenModifiers\":[]},\"full\":true}},");
	ws("\"serverInfo\":{\"name\":\"zc\",\"version\":\"2\"}}}");
	return 0;
}
// a reply with a null result, for the request id in the message.
int gen_null() {
	ws("{\"jsonrpc\":\"2.0\",\"id\":");
	wid();
	ws(",\"result\":null}");
	return 0;
}
// the error code the next error reply carries.
int errcode;
// an error reply with the code errcode and a matching message.
int gen_error() {
	ws("{\"jsonrpc\":\"2.0\",\"id\":");
	wid();
	ws(",\"error\":{\"code\":");
	wn(errcode);
	ws(",\"message\":");
	if (errcode == 0 - 32601) ws("\"method not found\""); else ws("\"server not initialized\"");
	ws("}}");
	return 0;
}
// a semantic tokens reply with no tokens, for a document the server does not have.
int gen_empty() {
	ws("{\"jsonrpc\":\"2.0\",\"id\":");
	wid();
	ws(",\"result\":{\"data\":[]}}");
	return 0;
}
// sends an error reply with the code given.
int reply_error(int code) {
	errcode = code;
	send(gen_error);
	return 0;
}

// ---- hover ----
// the documentation of the name under the cursor: the comment lines directly
// above its declaration in the document, or, for what the compiler and the
// standard library define, the docs stored in the image
int hid(int c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'; }
// the identifier at hline, hchar of document i, into hname. returns its length
int hover_word(int i) {
	int base = doff[i], size = dsize[i], o = 0, ln = 0, col = 0, c, step, width, b, e, n = 0;
	hcursor = 0 - 1; hname[0] = 0;
	if (hline < 0 || hchar < 0) return 0;
	while (ln < hline && o < size) { if (dc(base, o) == 10) ln++; o++; }
	if (ln != hline) return 0;
	// the protocol counts utf-16 units; the document stores utf-8 bytes.
	while (col < hchar && o < size) {
		c = dc(base, o);
		if (c == 10 || c == 13) return 0;
		step = 1; width = 1;
		if (c >= 192 && c < 224) step = 2;
		else if (c >= 224 && c < 240) step = 3;
		else if (c >= 240) { step = 4; width = 2; }
		o = o + step; col = col + width;
	}
	if (col != hchar) return 0;
	hcursor = o;
	if (o >= size || !hid(dc(base, o))) return 0;
	b = o;
	while (b > 0 && hid(dc(base, b - 1))) b--;
	e = o;
	while (e < size && hid(dc(base, e))) e++;
	if (e - b + 1 > hnamecap) { hnamecap = e - b + 1; hname = lsp_grow(0, 0, hnamecap); }
	hoff = b;
	while (b < e) { hname[n] = dc(base, b); n++; b++; }
	hname[n] = 0;
	return n;
}
// is c a delimiter that ends the name in a top-level declaration
int hdelim(int c) { return c == '(' || c == '=' || c == ';' || c == ',' || c == '[' || c == '<' || c == '{'; }
// does the line at ls (ending before le) declare hname. only a top-level line
// counts (hover_scan has already checked it starts in column 0). the name is
// the word just before the line's first delimiter, so a keyword or type on the
// line (int, fixed, fn) is never the declared name, and a use of the name
// further along the line is not a declaration
word hover_decl(int base, int ls, int le) {
	int dl = ls, e, b, k = 0;
	while (dl < le && !hdelim(dc(base, dl))) dl++;
	if (dl >= le) return 0;
	e = dl;
	while (e > ls && (dc(base, e - 1) == 32 || dc(base, e - 1) == 9)) e--;
	b = e;
	while (b > ls && hid(dc(base, b - 1))) b--;
	if (b == e) return 0;
	while (hname[k] && b + k < e && dc(base, b + k) == hname[k]) k++;
	return !hname[k] && b + k == e;
}
// the top-level declaration of hname, found by its line: hdl and hdle are the
// line's start and end, and hcs is the start of the comment block directly above
// it (hcs is -1 when none) which runs to the line at hdl. a declaration needs
// no comment, so the signature still shows without one.
int hover_scan(int i) {
	int base = doff[i], size = dsize[i], ls = 0, le, cs = 0 - 1, c0;
	while (ls < size) {
		le = ls;
		while (le < size && dc(base, le) != 10) le++;
		c0 = dc(base, ls);
		if (c0 == '/' && ls + 1 < le && dc(base, ls + 1) == '/') {
			if (cs < 0) cs = ls;
		} else {
			if (le > ls && c0 != 32 && c0 != 9 && hover_decl(base, ls, le)) {
				hdl = ls; hdle = le; hcs = cs;
				return 1;
			}
			cs = 0 - 1;
		}
		ls = le + 1;
	}
	return 0;
}
// one character of the hover text, up to its cap
int hov_put(int c) {
	if (hn == hovcap) { hov = lsp_grow(hov, hn, hovcap * 2); hovcap = hovcap * 2; }
	hov[hn] = c; hn++;
	return 0;
}
// comment ranges are scanned once per document version, outside strings and chars.
int hc_i = -1, hc_gen = -1, hc_n, hc_cap = 64;
word hc_start, hc_end, hc_kind;
int hover_comments(int i) {
	int o = 0, size = dsize[i], base = doff[i], c, start, kind, bol = 1, quote;
	if (hc_i == i && hc_gen == dgen[i]) return 0;
	hc_i = i; hc_gen = dgen[i]; hc_n = 0;
	while (o < size) {
		c = dc(base, o);
		if (c == 10) { bol = 1; o++; continue; }
		if (c == 32 || c == 9 || c == 13) { o++; continue; }
		if (c == 34 || c == 39) {
			quote = c; o++;
			while (o < size && dc(base, o) != quote) { if (dc(base, o) == 92) o++; o++; }
			o++; bol = 0; continue;
		}
		kind = 0; start = o;
		if (c == '/' && dc(base, o + 1) == '/') {
			kind = 1; if (bol) kind = 2;
			o = o + 2; while (o < size && dc(base, o) != 10) o++;
		} else if (c == '/' && dc(base, o + 1) == '*') {
			kind = 3; o = o + 2;
			while (o < size && !(dc(base, o) == '*' && dc(base, o + 1) == '/')) { if (dc(base, o) == 10) bol = 1; o++; }
			if (o < size) o = o + 2;
		} else { o++; bol = 0; continue; }
		if (!hc_start || hc_n == hc_cap) {
			if (hc_start) hc_cap = hc_cap * 2;
			hc_start = lsp_grow(hc_start, hc_n, hc_cap); hc_end = lsp_grow(hc_end, hc_n, hc_cap); hc_kind = lsp_grow(hc_kind, hc_n, hc_cap);
		}
		hc_start[hc_n] = start; hc_end[hc_n] = o; hc_kind[hc_n] = kind; hc_n++;
	}
	return 0;
}
// whitespace between documentation and its target may cross one line, not a blank line.
int doc_gap(int base, int from, int to) {
	int c, lines = 0;
	while (from < to) {
		c = dc(base, from); from++;
		if (c == 10) { lines++; if (lines > 1) return 0; }
		else if (c != 32 && c != 9 && c != 13) return 0;
	}
	return 1;
}
// remove comment delimiters and optional line-leading stars; retain markdown.
int hover_comment_text(int i, int index) {
	int base = doff[i], o = hc_start[index] + 2, end = hc_end[index], bol = 1, c, before = hn;
	if (hc_kind[index] == 3) {
		if (end >= o + 2 && dc(base, end - 2) == '*' && dc(base, end - 1) == '/') end = end - 2;
		if (o < end && dc(base, o) == '*') o++;
	}
	while (o < end && (dc(base, o) == 32 || dc(base, o) == 9 || dc(base, o) == 10 || dc(base, o) == 13)) o++;
	while (end > o && (dc(base, end - 1) == 32 || dc(base, end - 1) == 9 || dc(base, end - 1) == 10 || dc(base, end - 1) == 13)) end--;
	if (o == end) return 0;
	hov_text("\n\n");
	while (o < end) {
		if (bol && hc_kind[index] == 3) {
			while (o < end && (dc(base, o) == 32 || dc(base, o) == 9)) o++;
			if (o < end && dc(base, o) == '*') { o++; if (dc(base, o) == 32) o++; }
			bol = 0;
		}
		if (o >= end) break;
		c = dc(base, o); o++;
		if (c != 13) hov_put(c);
		if (c == 10) bol = 1;
	}
	return hn - before;
}
// attach leading docs and adjacent block docs to this exact declaration name.
int hover_docs(int i, int head, int name, int length) {
	int k, first = -1, last = -1, pos = head, base = doff[i];
	hover_comments(i);
	k = hc_n - 1;
	while (k >= 0 && hc_end[k] > head) k--;
	while (k >= 0 && hc_kind[k] != 1 && doc_gap(base, hc_end[k], pos)) {
		if (last < 0) last = k;
		first = k; pos = hc_start[k]; k--;
	}
	if (first >= 0) { k = first; while (k <= last) { hover_comment_text(i, k); k++; } }
	k = 0;
	while (k < hc_n) {
		if (hc_kind[k] == 3 && (k < first || k > last)) {
			if (hc_start[k] >= head && hc_end[k] <= name && doc_gap(base, hc_end[k], name)) hover_comment_text(i, k);
			else if (hc_start[k] >= name + length && doc_gap(base, name + length, hc_start[k])) hover_comment_text(i, k);
		}
		k++;
	}
	return 0;
}
// the markdown for a declaration: its signature as a code block, then the
// comment block above it, without the slashes, if there is one
int hover_fill(int i) {
	int base = doff[i], o = hdl, c, cs, ls, typed = 0, k, start, end;
	hn = 0;
	while (o < hdle && dc(base, o) != '{' && dc(base, o) != ';' && dc(base, o) != '=') o++;
	while (o > hdl && (dc(base, o - 1) == 32 || dc(base, o - 1) == 9)) o--;
	hov_put('`'); hov_put('`'); hov_put('`'); hov_put('z'); hov_put('c'); hov_put(10);
	c = hdl;
	// an untyped fn: the return type the body gives it replaces the fn
	if (dc(base, hdl) == 'f' && dc(base, hdl + 1) == 'n' && dc(base, hdl + 2) == 32) {
		ensure_annot(i);
		k = hdl + 3;
		while (k < hdle && (dc(base, k) == 32 || dc(base, k) == 9)) k++;
		if (ann_type(i, k)) {
			start = ann_name_at;
			while (start > 0 && dc(ann_text, start - 1) != 10 && dc(ann_text, start - 1) != ';' && dc(ann_text, start - 1) != '}') start--;
			while (start < ann_name_at && (dc(ann_text, start) == 32 || dc(ann_text, start) == 9)) start++;
			end = ann_name_at;
			while (end < ann_n && dc(ann_text, end) != '{' && dc(ann_text, end) != ';') end++;
			while (end > start && (dc(ann_text, end - 1) == 32 || dc(ann_text, end - 1) == 9 || dc(ann_text, end - 1) == 10 || dc(ann_text, end - 1) == 13)) end--;
			k = start; while (k < end) { hov_put(dc(ann_text, k)); k++; }
			hov_text("\n```"); htn = 0; hover_docs(i, hdl, hdl, 0);
			return hn;
		}
		htn = 0;
	}
	while (c < o) { hov_put(dc(base, c)); c++; }
	hov_put(10); hov_put('`'); hov_put('`'); hov_put('`');
	hover_docs(i, hdl, hdl, 0);
	return hn;
}
// the hover reply: the markdown in hov, or null when there is nothing to show.
int gen_hover() {
	ws("{\"jsonrpc\":\"2.0\",\"id\":"); wid();
	if (!hn) { ws(",\"result\":null}"); return 0; }
	ws(",\"result\":{\"contents\":{\"kind\":\"markdown\",\"value\":");
	wjs(hov, hn);
	ws("}}}");
	return 0;
}
// the doc of a name from the image's own symbol blob, or 0. the checks reset the
// symbol table (zc_init, chk_mark), so the docs are read from the blob itself,
// which stays in the image
word blobdoc(word nm) {
	word p = GORG[5]; int k;
	while (*p) {
		if (p[0] == K_DOC && p[3] == 'd' && p[4] == 'o' && p[5] == 'c' && p[6] == ' ') {
			k = 0;
			while (nm[k] && p[7 + k] == nm[k]) k++;
			if (!nm[k] && !p[7 + k]) return p[1];
		}
		p = p + 3 + len_w(p + 3) + 1;
	}
	return 0;
}
// the signature of a name from the image's own symbol blob, or 0
word blobsig(word nm) {
	word p = GORG[5]; int k;
	while (*p) {
		if (p[0] == K_DOC && p[3] == 's' && p[4] == 'i' && p[5] == 'g' && p[6] == ' ') {
			k = 0;
			while (nm[k] && p[7 + k] == nm[k]) k++;
			if (!nm[k] && !p[7 + k]) return p[1];
		}
		p = p + 3 + len_w(p + 3) + 1;
	}
	return 0;
}
// the start of the line before the one starting at ls, or -1 at the top
int hl_prev(int base, int ls) {
	int q;
	if (ls <= 0) return 0 - 1;
	q = ls - 1;
	while (q > 0 && dc(base, q - 1) != 10) q--;
	return q;
}
// the last declaration of hname above the hovered line, inside the top-level
// item that holds it: a parameter of its header, or a local (a line of the form
// type name = ..., so a plain use of the name does not count). the text, marked
// as a parameter or a local, goes into hov as a code block. returns 1 when found.
int hover_local(int i) {
	int base = doff[i], size = dsize[i], hs = 0, ln = 0, o = 0, ts = 0 - 1, q, c, hl, le, e, b, k, a, found = 0, kind = 0, sb = 0, se = 0, da = 0 - 1;
	while (ln < hline && o < size) { if (dc(base, o) == 10) ln++; o++; }
	hs = o;
	// the top-level line: the hovered line if it starts in column 0, else the
	// nearest such line above it (a line that starts in column 0, not a comment)
	q = hs;
	c = dc(base, q);
	if (c != 10 && c != 32 && c != 9 && !(c == '/' && dc(base, q + 1) == '/')) ts = q;
	while (ts < 0) {
		q = hl_prev(base, q);
		if (q < 0) break;
		c = dc(base, q);
		if (c == 10 || c == 32 || c == 9) continue;
		if (c == '/' && dc(base, q + 1) == '/') continue;
		ts = q;
	}
	if (ts < 0) return 0;
	// the header line: a parameter named hname is the last word of its segment
	hl = ts;
	le = hl;
	while (le < size && dc(base, le) != 10 && dc(base, le) != '{' && dc(base, le) != ';') le++;
	o = hl;
	// the segments of the header, one at a time
	o = hl;
	while (o < le && dc(base, o) != '(') o++;
	o++;
	while (o < le) {
		while (o < le && (dc(base, o) == 32 || dc(base, o) == 9)) o++;
		sb = o;
		while (o < le && dc(base, o) != ',' && dc(base, o) != ')') o++;
		se = o;
		while (se > sb && (dc(base, se - 1) == 32 || dc(base, se - 1) == 9)) se--;
		e = se;
		b = e;
		while (b > sb && hid(dc(base, b - 1))) b--;
		if (b < e) {		// a typed parameter has its type before the name, an untyped one is the name alone
			k = 0;
			while (hname[k] && b + k < e && dc(base, b + k) == hname[k]) k++;
			if (!hname[k] && b + k == e) { found = 1; kind = 1; break; }
		}
		if (o < le && dc(base, o) == ')') break;
		o++;
	}
	if (found) { hover_put_sig(base, sb, se, kind, 0 - 1); return 1; }
	// the body: the last declaration of hname from the item's next line through the
	// hovered line (a declaration on the hovered line itself counts)
	o = ts;
	while (o <= hs) {
		le = o;
		while (le < hs && dc(base, le) != 10) le++;
		if (le == hs) while (le < size && dc(base, le) != 10) le++;
		// le is the end of this line; skip the blank and comment lines
		q = o;
		while (q < le && (dc(base, q) == 32 || dc(base, q) == 9)) q++;
		if (q < le && !(dc(base, q) == '/' && dc(base, q + 1) == '/') && q > o && !hl_kw(base, q)) {
			e = hdeclend(base, q, le);
			if (e < le) {
				b = e;
				while (b > q && (dc(base, b - 1) == 32 || dc(base, b - 1) == 9)) b--;
				a = b;
				while (a > q && hid(dc(base, a - 1))) a--;
				if (a < b && a > q) {
					k = 0;
					while (hname[k] && a + k < b && dc(base, a + k) == hname[k]) k++;
					if (!hname[k] && a + k == b && (dc(base, a - 1) == 32 || dc(base, a - 1) == 9)) { found = 1; kind = 2; da = a; sb = q; se = e; while (se > sb && (dc(base, se - 1) == 32 || dc(base, se - 1) == 9)) se--; }
				}
			}
		}
		if (le >= hs) break;
		o = le + 1;
	}
	if (found) {
		k = 0 - 1;
		if (kind == 2) k = lt_find(da);
		hover_put_sig(base, sb, se, kind, k);
		return 1;
	}
	return 0;
}
// does the word from q to e equal w
word hl_is(int base, int q, int e, word w) {
	int k = 0;
	while (w[k] && q + k < e && dc(base, q + k) == w[k]) k++;
	return !w[k] && q + k == e;
}
// does a statement start at q with a keyword that cannot begin a declaration,
// so that "return i;" is not taken for a declaration of i
word hl_kw(int base, int q) {
	int e = q;
	while (hid(dc(base, e))) e++;
	return hl_is(base, q, e, "return") || hl_is(base, q, e, "if") || hl_is(base, q, e, "while") || hl_is(base, q, e, "else") || hl_is(base, q, e, "break") || hl_is(base, q, e, "continue");
}
// where a declaration's name ends on the line from q: at = ; , { ( or a [ that
// follows a name (let b[24]); the [ of a type (fixed []int) is passed over
int hdeclend(int base, int q, int le) {
	int e = q, c;
	while (e < le) {
		c = dc(base, e);
		if (c == '=' || c == ';' || c == ',' || c == '{' || c == '(' || c == ')') return e;
		if (c == '[' && e > q && hid(dc(base, e - 1))) return e;
		e++;
	}
	return le;
}
const int AROUNDS = 6;
word abase, aerr; int nbase, aerrcap;
word afx, aft, amask; int anf, afcap, atcap;
word awp; int awn;
word ann_half;
// the inferred types of the untyped declarations. annotate_doc runs the annotate
// rounds on a document (in doc slot 0, which is put back afterwards), and the
// text it ends with is kept in ann_text. ann_type then finds, for a name the
// document declares untyped, the type annotate gave that name: the text between
// the token before it in the annotated text and the name, after the last ( , { ; or =.
int ann_i = -1, ann_gen = -1, ai_end;
// runs the annotate rounds on document i. the rounds run in doc slot 0, and the
// slots they use are put back afterwards. the text they end with is kept in
// ann_text, with its length in ann_n.
int annotate_doc(int i) {
	int round = 0, n, k, sv_size, sv_live, sv_ulen, sv_gen, sv_slot1 = 0, sv_live1, sv_ulen1, sv_gen1;
	word sv_base, sv_base1;
	sv_base = doff[0]; sv_size = dsize[0]; sv_live = dlive[0]; sv_ulen = dulen[0]; sv_gen = dgen[0];
	sv_base1 = doff[1]; sv_slot1 = dsize[1]; sv_live1 = dlive[1]; sv_ulen1 = dulen[1]; sv_gen1 = dgen[1];
	dlive[0] = 1; dulen[0] = 0;
	doff[0] = doff[i]; dsize[0] = dsize[i]; dgen[0] = sv_gen + 1;
	ifstrict = 1;
	check_doc(0);
	nbase = err_lines(abase);
	while (round < AROUNDS) {
		ifon = 1; check_doc(0); ifon = 0;
		save_facts();
		if (!anf) break;
		k = 0; while (k < anf) { amask[k] = 0; k++; }
		fresh_half();
		try_range(0, anf);
		n = apply_masked(ann_half);
		if (!n) break;
		doff[0] = ann_half; dsize[0] = awn; dgen[0] = dgen[0] + 1;
		round++;
	}
	ifstrict = 0; ifon = 0;
	ann_text = doff[0]; ann_n = dsize[0];
	doff[0] = sv_base; dsize[0] = sv_size; dlive[0] = sv_live; dulen[0] = sv_ulen; dgen[0] = sv_gen;
	doff[1] = sv_base1; dsize[1] = sv_slot1; dlive[1] = sv_live1; dulen[1] = sv_ulen1; dgen[1] = sv_gen1;
	chk_i = -1;
	return 0;
}
// annotate for the current state of document i, once per state of it
int ensure_annot(int i) {
	if (ann_i == i && ann_gen == dgen[i]) return 0;
	annotate_doc(i);
	ann_i = i; ann_gen = dgen[i];
	return 0;
}
// the next identifier of base at or after pos: its start, with its end in ai_end.
// comments, strings and numbers are passed over. -1 when there is none.
int ai_next(word base, int size, int pos) {
	int c, st, q;
	while (pos < size) {
		c = dc(base, pos);
		if (c == '/' && pos + 1 < size && dc(base, pos + 1) == '/') {
			while (pos < size && dc(base, pos) != 10) pos++;
		} else if (c == '/' && pos + 1 < size && dc(base, pos + 1) == '*') {
			pos = pos + 2;
			while (pos < size && !(dc(base, pos) == '*' && dc(base, pos + 1) == '/')) pos++;
			if (pos < size) pos = pos + 2;
		} else if (c == '"' || c == 39) {
			q = c; pos++;
			while (pos < size && dc(base, pos) != q && dc(base, pos) != 10) { if (dc(base, pos) == 92) pos++; pos++; }
			pos++;
		} else if (c >= '0' && c <= '9') {
			while (pos < size && hid(dc(base, pos))) pos++;
		} else if (hid(c)) {
			st = pos;
			while (pos < size && hid(dc(base, pos))) pos++;
			ai_end = pos;
			return st;
		} else pos++;
	}
	return 0 - 1;
}
// do the words a[as..ae) of base a and b[bs..be) of base b read the same
int ai_same(word a, int as, int ae, word b, int bs, int be) {
	int k = 0;
	if (ae - as != be - bs) return 0;
	while (as + k < ae) { if (dc(a, as + k) != dc(b, bs + k)) return 0; k++; }
	return 1;
}
// is the word at s..e fn or let, which annotate replaces with a type
int ai_kw(word base, int s, int e) {
	int k = 0;
	if (e - s == 2 && dc(base, s) == 'f' && dc(base, s + 1) == 'n') return 1;
	if (e - s == 3 && dc(base, s) == 'l' && dc(base, s + 1) == 'e' && dc(base, s + 2) == 't') return 1;
	return k;
}
// is the name at offset o of document i declared untyped: a parameter after ( or
// , and a local after let or a function after fn. only those can gain a type
int ann_untyped(int i, int o) {
	word base = doff[i];
	int p = o - 1;
	while (p >= 0) {
		while (p >= 0 && (dc(base, p) == 32 || dc(base, p) == 9 || dc(base, p) == 10 || dc(base, p) == 13)) p--;
		if (p >= 1 && dc(base, p) == '/' && dc(base, p - 1) == '*') {
			p = p - 2; while (p >= 1 && !(dc(base, p - 1) == '/' && dc(base, p) == '*')) p--;
			p = p - 2;
		} else break;
	}
	if (p < 0) return 0;
	if (dc(base, p) == '(' || dc(base, p) == ',') return 1;
	if (p >= 2 && dc(base, p) == 't' && dc(base, p - 1) == 'e' && dc(base, p - 2) == 'l') return 1;
	if (p >= 1 && dc(base, p) == 'n' && dc(base, p - 1) == 'f') return 1;
	return 0;
}
// the type annotate gave the name declared at offset o of document i, in htb
// (htn bytes), or none. the names of the two texts are walked in step: the
// annotated text has the same names in the same order, plus the types it put in.
int ann_type(int i, int o) {
	word ob = doff[i], ab = ann_text;
	int osz = dsize[i], asz = ann_n, op = 0, ap = 0, prev = 0, os, oe, as, ae, cut, k, n = 0, c;
	htn = 0;
	while (1) {
		os = ai_next(ob, osz, op);
		if (os < 0) return 0;
		oe = ai_end;
		op = oe;
		if (ai_kw(ob, os, oe)) continue;
		while (1) {
			as = ai_next(ab, asz, ap);
			if (as < 0) return 0;
			ae = ai_end;
			ap = ae;
			if (ai_same(ob, os, oe, ab, as, ae)) break;
		}
		if (os == o) {
			ann_name_at = as;
			cut = prev;
			k = prev;
			while (k < as) { c = dc(ab, k); if (c == '(' || c == ',' || c == '{' || c == ';' || c == '=' || c == '}' || c == 10) cut = k + 1; k++; }
			while (cut < as && (dc(ab, cut) == 32 || dc(ab, cut) == 9 || dc(ab, cut) == 10)) cut++;
			k = cut;
			while (k < as) {
				if (dc(ab, k) == '/' && dc(ab, k + 1) == '*') {
					k = k + 2; while (k < as && !(dc(ab, k) == '*' && dc(ab, k + 1) == '/')) k++;
					k = k + 2; continue;
				}
				if (n == htbc) { htb = lsp_grow(htb, n, htbc * 2); htbc = htbc * 2; }
				htb[n] = dc(ab, k); n++; k++;
			}
			while (n > 0 && (htb[n - 1] == 32 || htb[n - 1] == 9 || htb[n - 1] == 10)) n--;
			htn = n;
			if (htn == 2 && htb[0] == 'f' && htb[1] == 'n') htn = 0;	// annotate left a fn alone
			if (htn == 3 && htb[0] == 'l' && htb[1] == 'e' && htb[2] == 't') htn = 0;
			return htn;
		}
		prev = ae;
	}
	return 0;
}
// the markdown of a local or parameter: its declaration text, then what it is
int hover_put_sig(int base, int sb, int se, int kind, int lk) {
	int k = sb;
	hn = 0;
	hov_put('`'); hov_put('`'); hov_put('`'); hov_put('z'); hov_put('c'); hov_put(10);
	while (k < se) { hov_put(dc(base, k)); k++; }
	if (kind == 1) {
		hov_put(' '); hov_put(' '); hov_put('/'); hov_put('/'); hov_put(' '); k = 0; while ("parameter"[k]) { hov_put("parameter"[k]); k++; }
		if (htn > 0) { k = 0; while ("; type "[k]) { hov_put("; type "[k]); k++; } k = 0; while (k < htn) { hov_put(htb[k]); k++; } }
	}
	else {
		hov_put(' '); hov_put(' '); hov_put('/'); hov_put('/'); hov_put(' '); k = 0; while ("local"[k]) { hov_put("local"[k]); k++; }
		if (lk >= 0) { k = 0; while ("; type "[k]) { hov_put("; type "[k]); k++; } k = lt_at[lk]; while (k < lt_at[lk] + lt_len[lk]) { hov_put(ltxt[k]); k++; } }
		else if (htn > 0) { k = 0; while ("; type "[k]) { hov_put("; type "[k]); k++; } k = 0; while (k < htn) { hov_put(htb[k]); k++; } }
	}
	hov_put(10); hov_put('`'); hov_put('`'); hov_put('`');
	return hn;
}
// a genome name: its signature as a code block, then its doc if the image has one
int hover_blob(int i) {
	int ss, ds, k = 0, n = 0;
	ss = blobsig(hname);
	ds = blobdoc(hname);
	hn = 0;
	if (ss) {
		hov_put('`'); hov_put('`'); hov_put('`'); hov_put('z'); hov_put('c'); hov_put(10);
		while (k < len_s(ss)) { hov_put(at_s(ss, k)); k++; }
		hov_put(10); hov_put('`'); hov_put('`'); hov_put('`');
	}
	if (ds) {
		if (ss) { hov_put(10); hov_put(10); }
		k = 0;
		while (k < len_s(ds)) { hov_put(at_s(ds, k)); k++; }
	}
	return hn;
}
// does the hovered word equal w
word hname_is(word w) {
	int k = 0;
	while (w[k] && hname[k] == w[k]) k++;
	return !w[k] && !hname[k];
}
// append a word string, or a compiler type, to the markdown buffer.
int hov_text(word s) { int k = 0; while (s[k]) { hov_put(s[k]); k++; } return 0; }
int hov_type(word t) {
	int sm = outmode, sb = outbuf, sn = outn, sc = outcap, need;
	outmode = 3; outn = 0; tprint(t); need = hn + outn;
	if (need > hovcap) {
		while (need > hovcap) hovcap = hovcap * 2;
		hov = lsp_grow(hov, hn, hovcap);
	}
	outmode = 2; outbuf = hov; outn = hn; outcap = hovcap; tprint(t); hn = outn;
	outmode = sm; outbuf = sb; outn = sn; outcap = sc;
	return 0;
}
// explain composite types without relying on their source spelling.
int hover_type_info(word t) {
	int kind, k;
	if (!t) return 0;
	kind = t[0];
	if (kind == TY_PTR) {
		hov_text("\n\na pointer to `"); hov_type(t[4]); hov_text("`. the pointer occupies one word; the pointed-to storage is separate.");
	} else if (kind == TY_ARR) {
		hov_text("\n\nan array stored in place, with a fixed length of ");
		k = t[3]; hov_number(k); hov_text(" elements of type `"); hov_type(t[4]); hov_text("`. storage: "); hov_number(tsz(t)); hov_text(" words.");
	} else if (kind == TY_DYN) {
		if (t[3]) hov_text("\n\nan array handle with a fixed runtime length. ");
		else hov_text("\n\na growable array handle. ");
		hov_text("element type: `"); hov_type(t[4]); hov_text("`. `len` gives the current length and `cap` gives capacity.");
		if (t[3]) hov_text(" `push`, `pop`, and `resize` cannot change its length.");
	} else if (kind == TY_STRUCT) {
		hov_text("\n\na struct stored in place. storage: "); hov_number(tsz(t)); hov_text(" words.");
		if (t[3] > 0) {
			hov_text("\n\nfields:\n\n```zc\n");
			k = 0;
			while (k < t[3]) { hov_type(t[4][k * 3 + 1]); hov_put(' '); hov_text(t[4][k * 3]); hov_text(";\n"); k++; }
			hov_text("```");
		}
	} else if (kind == TY_FN) hov_text("\n\na callable value. the type lists its result and parameter types.");
	return 0;
}
// decimal numbers in markdown use the ordinary printer through the capture buffer.
int hov_number(int n) {
	int sm = outmode, sb = outbuf, sn = outn, sc = outcap;
	while (hn + 24 > hovcap) { hov = lsp_grow(hov, hn, hovcap * 2); hovcap = hovcap * 2; }
	outmode = 2; outbuf = hov; outn = hn; outcap = hovcap; put_n(n); hn = outn;
	outmode = sm; outbuf = sb; outn = sn; outcap = sc;
	return 0;
}
// a parsed type includes its brackets and stars, so those characters hover too.
int hover_type_span(int i) {
	int k = 0, best = 0 - 1, width = 0, end; word t;
	while (k < ht_n) {
		end = ht_end[k];
		while (end > ht_start[k] && (dc(doff[i], end - 1) == 32 || dc(doff[i], end - 1) == 9 || dc(doff[i], end - 1) == 10 || dc(doff[i], end - 1) == 13)) end--;
		if (hcursor >= ht_start[k] && hcursor < end && end - ht_start[k] > width) { best = k; width = end - ht_start[k]; }
		k++;
	}
	if (best < 0) return 0;
	t = ht_type[best];
	hov_text("```zc\n"); hov_type(t); hov_text("\n```"); hover_type_info(t);
	k = kwtext();
	if (k && (hname_is("word") || hname_is("int") || hname_is("char") || hname_is("bool") || hname_is("void") || hname_is("float") || hname_is("f32") || hname_is("f64") || hname_is("byte") || hname_is("u8") || hname_is("i8") || hname_is("u16") || hname_is("i16") || hname_is("u32") || hname_is("i32"))) {
		while (*k && *k != '~') k++;
		if (*k) { hov_text("\n\n"); hov_text(k + 1); }
	}
	return 1;
}
// the text of a keyword or a built-in word, from the language guide, or 0. this
// one table holds every keyword the compiler registers and the built-ins that
// have their own form. the form comes first, then a ~, then what it does (the ~
// separates the two). a name the table does not hold gets the image's docs.
int kwtext() {
	if (hname_is("word")) return "word~one 64-bit vm word; the default type for untyped integer values and word-sized storage";
	if (hname_is("int")) return "int~one signed, word-sized integer; arrays of int use one word per element";
	if (hname_is("char")) return "char~one word holding a character code; arrays of char use one word per element";
	if (hname_is("bool")) return "bool~one word for a boolean value; comparison and logical operators produce 0 or 1";
	if (hname_is("void")) return "void~marks a function with no meaningful result; the vm still uses a one-word return convention";
	if (hname_is("float")) return "float~one-word ieee binary64 value; arrays of float use one word per element";
	if (hname_is("f64")) return "f64~alias for float, a one-word ieee binary64 value";
	if (hname_is("f32")) return "f32~binary32 value rounded when stored; arrays and pointers pack two elements per word";
	if (hname_is("u8")) return "u8~unsigned 8-bit integer, range 0..255; values narrow on store and arrays or pointers pack eight elements per word";
	if (hname_is("i8")) return "i8~signed 8-bit integer, range -128..127; values narrow on store and arrays or pointers pack eight elements per word";
	if (hname_is("u16")) return "u16~unsigned 16-bit integer, range 0..65535; values narrow on store and arrays or pointers pack four elements per word";
	if (hname_is("i16")) return "i16~signed 16-bit integer, range -32768..32767; values narrow on store and arrays or pointers pack four elements per word";
	if (hname_is("u32")) return "u32~unsigned 32-bit integer, range 0..4294967295; values narrow on store and arrays or pointers pack two elements per word";
	if (hname_is("i32")) return "i32~signed 32-bit integer, range -2147483648..2147483647; values narrow on store and arrays or pointers pack two elements per word";
	if (hname_is("byte")) return "byte~alias for u8, an unsigned 8-bit integer packed in arrays and pointers";
	if (hname_is("fixed")) return "fixed~marks an array whose length cannot change; fixed arrays cannot grow or shrink";
	if (hname_is("new")) return "new(T) or new(T, n)~returns a fresh object on the heap. bound to a local, the local owns it (tagged m) and the block frees it when it ends, so you don't write free yourself.";
	if (hname_is("free")) return "free(d*p)~frees a heap object. the block is kept until the next collection finds nothing pointing at it, and a second free does nothing. free takes an object tagged d, so a checked call is free(d*p).";
	if (hname_is("sizeof")) return "sizeof(e) or sizeof(T)~the size in words, found by compiling the expression dry, so it is not run. a packed array counts (n * bytes + 7) / 8 words.";
	if (hname_is("typeof")) return "typeof(e) or typeof(T)~the type record of an expression or a type, found by compiling it dry. tkind, tsize, tname and the other t functions read it at runtime.";
	if (hname_is("syscall")) return "syscall(op, a, b, c)~a call to the host through the gate word. the ops are SYS_OPEN, SYS_CLOSE, SYS_READ, SYS_WRITE, SYS_GETENV, SYS_TIME and the rest of the named ones, and SYS_RAW (40) runs any linux syscall on the host. o3 code does not go through the gate, so call syscall from ordinary code.";
	if (hname_is("len")) return "len(a)~the number of items in an array, growable or fixed.";
	if (hname_is("cap")) return "cap(a)~the number of items a growable array can hold before it has to grow.";
	if (hname_is("push")) return "push(a, x)~adds x to the end of a growable array, growing it when needed. a growable array owns its items.";
	if (hname_is("pop")) return "pop(a)~removes the last item of a growable array and gives it back.";
	if (hname_is("resize")) return "resize(a, n)~sets the length of a growable array to n, growing or shrinking it.";
	if (hname_is("o3")) return "o3~marks code for the optimizing tier. it goes on a function, a block or a single variable, and its variables live in registers.";
	if (hname_is("fn")) return "fn name(a, b) { }~declares a function whose return is a word. a typed function is written like c, int f(int x) { }.";
	if (hname_is("let")) return "let name = e~declares a local whose type comes from its value. a number stays a plain word, and a pointer or a struct keeps its type.";
	if (hname_is("const")) return "const [type] NAME = e~a named constant. its value is worked out while compiling, so it can size an array or label a case.";
	if (hname_is("else")) return "else~the other branch of an if. after an enhance's body, else names the fallback function that runs where the enhancement can't.";
	if (hname_is("as")) return "e as T~changes the type of an expression without changing its bits.";
	if (hname_is("unchecked")) return "unchecked fn f() { } / unchecked { } / unchecked;~turns the lifetime analyzer off for a function, a block, or the rest of the unit. the code is not checked, so the analyzer's rules don't apply to it.";
	if (hname_is("immediate")) return "immediate fn name() { }~a parse word. it runs during compilation whenever its name shows up as a statement, inside an expression or at the top level.";
	if (hname_is("case")) return "case v:~a label in a switch. each case ends where the next one begins, so cases don't fall through.";
	if (hname_is("default")) return "default:~the arm of a switch that runs when no case matches.";
	if (hname_is("do")) return "do { } while (cond);~a loop that runs its body once before the test.";
	if (hname_is("while")) return "while (cond) { }~a loop that tests the condition before each pass.";
	if (hname_is("for")) return "for (init; cond; step) { }~a loop with its start, test and step written on one line.";
	if (hname_is("if")) return "if (cond) { } else { }~runs one branch or the other, by the condition.";
	if (hname_is("switch")) return "switch (e) { case 1, 2: ... default: ... }~a branch on constant labels. the cases don't fall through, and break leaves early.";
	if (hname_is("break")) return "break;~leaves the innermost loop or switch.";
	if (hname_is("continue")) return "continue;~goes on to the next pass of the innermost loop.";
	if (hname_is("return")) return "return e;~leaves the function with a value. a u object leaves with u*x, and the function's return is then owned.";
	if (hname_is("enum")) return "enum name { A, B = 5 };~global constants. under typecheck on they are a type of their own, and a member can carry fields to make a constructor.";
	if (hname_is("struct")) return "struct name { fields };~a record type. struct name<T> { } makes it generic, one copy for each set of type arguments.";
	if (hname_is("type")) return "type name = T;~an alias for a type, such as type row = [3]int; for a pointer to an array.";
	if (hname_is("include")) return "include \"path\";~reads a file and compiles it at that point, its signatures first.";
	if (hname_is("memdebug")) return "memdebug on; / memdebug off; / memdebug scrub;~header checks, allocation sites and leak reports for the rest of the file. scrub also fills a freed payload with 0xDEAD.";
	if (hname_is("typecheck")) return "typecheck on; / typecheck off;~turns on type checks for the code that follows, enums included.";
	if (hname_is("docs")) return "docs on; / docs off;~keeps the doc comments above declarations in the image, so the language server can show them on hover.";
	if (hname_is("micro")) return "enhance name(args) micro \"recipe\";~the body of an enhancement, written as micro-ops on registers r0 to r15. the inputs arrive in r0 and up, and the outputs leave from r0.";
	if (hname_is("vm")) return "enhance name(args) vm { ... };~the body of an enhancement, written as stack machine asm. it becomes one opcode when the core lifts it.";
	if (hname_is("enhance")) return "enhance name(args) micro \"...\" or vm { ... };~installs a custom opcode at compile time, with up to 8 inputs and 8 outputs. an enhancement with one output can be called like a function.";
	if (hname_is("asm")) return "asm { ... }~a block of stack machine asm, and asm operands can be used inside expressions.";
	if (hname_is("quote")) return "quote { tokens }~a token list as a fresh object. a parse word can read it and build code from it.";
	if (hname_is("extern")) return "extern type name(params);~declares a c function on the host and calls it through the native call.";
	if (hname_is("cfunc")) return "cfunc(f)~a native function pointer that runs the zc function f when c calls it.";
	return 0;
}
// the markdown of a keyword: its form as a code block, then what it does
int kw_put(word s) {
	int k = 0;
	hov_put('`'); hov_put('`'); hov_put('`'); hov_put('z'); hov_put('c'); hov_put(10);
	while (s[k] && s[k] != '~') { hov_put(s[k]); k++; }
	hov_put(10); hov_put('`'); hov_put('`'); hov_put('`');
	if (s[k]) {
		hov_put(10); hov_put(10); k++;
		while (s[k]) { hov_put(s[k]); k++; }
	}
	return hn;
}
// does the line from q declare hname as a method: the name is followed by (, and
// what comes before it is a type, fn or static, and nothing that makes it a call
int hm_decl(int base, int q, int le) {
	int po = q, ns, e, k = 0, c;
	while (po < le && dc(base, po) != '(') po++;
	if (po >= le) return 0;
	e = po;
	ns = e;
	while (ns > q && hid(dc(base, ns - 1))) ns--;
	if (ns == e || ns == q) return 0;
	while (hname[k] && ns + k < e && dc(base, ns + k) == hname[k]) k++;
	if (hname[k] || ns + k != e) return 0;
	if (dc(base, ns - 1) != 32 && dc(base, ns - 1) != 9) return 0;
	k = q;
	while (k < ns) {
		c = dc(base, k);
		if (c == '=' || c == '.' || c == ';' || c == '(' || c == ',' || c == '{' || c == '}') return 0;
		k++;
	}
	if (hl_kw(base, q)) return 0;
	return 1;
}
// the markdown of a method or a static function of a struct: its line as the
// signature, then the comment lines right above it. the methods are indented in
// the struct body, so hover_scan (which reads column 0) does not find them.
// returns 1 when the hovered word is such a name.
int hover_method(int i) {
	int base = doff[i], size = dsize[i], ls = 0, le, q, p, e, k, cs, pv, found = 0, sg, se, n;
	while (ls < size && !found) {
		le = ls;
		while (le < size && dc(base, le) != 10) le++;
		q = ls;
		while (q < le && (dc(base, q) == 32 || dc(base, q) == 9)) q++;
		if (q > ls && hm_decl(base, q, le)) { found = 1; sg = q; se = q; }
		if (!found) ls = le + 1;
	}
	if (!found) return 0;
	// the signature: up to the body, a ; or the end of the line
	se = sg;
	while (se < size && dc(base, se) != 10 && dc(base, se) != '{' && dc(base, se) != ';') se++;
	while (se > sg && (dc(base, se - 1) == 32 || dc(base, se - 1) == 9)) se--;
	hn = 0;
	hov_put('`'); hov_put('`'); hov_put('`'); hov_put('z'); hov_put('c'); hov_put(10);
	k = sg;
	while (k < se) { hov_put(dc(base, k)); k++; }
	hov_put(10); hov_put('`'); hov_put('`'); hov_put('`');
	hover_docs(i, sg, sg, 0);
	return 1;
}
// the markdown of a local at its declaration: the name's declaration line, with
// the type an untyped let was given. o is the byte offset of the declared name.
int hover_named(int i, int o, int kind) {
	int base = doff[i], end = o, head = o, k, entry, untyped; word t = 0;
	while (end < dsize[i] && hid(dc(base, end))) end++;
	if (end == o) return 0;
	untyped = ann_untyped(i, o); htn = 0;
	if (untyped) { ensure_annot(i); ann_type(i, o); ensure_checked(i); }
	entry = lt_find(o);
	if (entry >= 0) t = lt_type[entry];
	k = 0;
	while (k < ht_n) { if (ht_end[k] == o && ht_start[k] < head) head = ht_start[k]; k++; }
	if (untyped && kind != 1) {
		k = o - 1;
		while (k >= 0 && (dc(base, k) == 32 || dc(base, k) == 9)) k--;
		if (k >= 2 && dc(base, k) == 't' && dc(base, k - 1) == 'e' && dc(base, k - 2) == 'l') head = k - 2;
	}
	hn = 0; hov_text("```zc\n");
	if (untyped && kind != 1) hov_text("let ");
	else if (!untyped && t) { hov_type(t); hov_put(' '); }
	k = o; while (k < end) { hov_put(dc(base, k)); k++; }
	if (kind == 1) hov_text("  // parameter");
	else if (kind == 3) hov_text("  // global");
	else if (kind == 4) hov_text("  // field");
	else hov_text("  // local");
	if (htn || entry >= 0) {
		hov_text("; type ");
		if (htn) { k = 0; while (k < htn) { hov_put(htb[k]); k++; } }
		else { k = lt_at[entry]; while (k < lt_at[entry] + lt_len[entry]) { hov_put(ltxt[k]); k++; } }
	}
	hov_text("\n```"); hover_type_info(t); hover_docs(i, head, o, end - o);
	if (hoff != o) hover_docs(i, hoff, hoff, len_w(hname));
	htn = 0;
	return 1;
}
int hover_at_decl(int i, int o) { return hover_named(i, o, 2); }
// storage facts are copied at the reference's position, before later statements
// can change them. unknown facts stay unknown in the preview.
int hover_storage(int r) {
	word p, t = 0; int entry, kind;
	if (r < 0 || !hn) return 0;
	p = rsrec + r * RS_W; kind = p[6];
	if (!kind) {
		if (p[1] == RS_LOCAL || p[1] == RS_PARAM || p[1] == RS_FIELD) {
			entry = lt_find(p[2]); if (entry >= 0) t = lt_type[entry];
		} else if (p[1] == RS_SYM && p[3] >= 0) t = stype[p[3]];
		if (!t || (t[0] != TY_PTR && t[0] != TY_ARR && t[0] != TY_DYN)) return 0;
		hov_text("\n\nsize: ");
		if (t[0] == TY_ARR) { hov_number(t[3]); hov_text(" elements"); }
		else hov_text("unknown");
		hov_text(". lifetime: unknown at this position."); return 0;
	}
	hov_text("\n\nsize: ");
	if (p[4] >= 0) { hov_number(p[4]); hov_text(" elements"); }
	else hov_text("unknown");
	hov_text(". lifetime: ");
	if (p[5] == 2) { hov_text("ended on line "); hov_number(p[8] & 0xFFFFFF); }
	else if (p[5] == 1) {
		if (kind == 1) hov_text("stack storage; ends when its declaring scope exits");
		else hov_text("heap storage; live here, ends when freed or its owner releases it");
	} else hov_text("unknown after a call or control-flow change");
	if (p[7]) { hov_text(". storage begins on line "); hov_number(p[7] & 0xFFFFFF); }
	hov_text("."); return 0;
}
// the hover of a name that is not a local. kind is 1 for a built-in (the guide's
// text, then the image's docs), 2 for a symbol the document declares (its
// declaration, a method, then the image's docs), and 0 when no record says (the
// guide, then the text of the document, as before)
int hover_global(int i, int kind) {
	int kt;
	if (kind != 2) { kt = kwtext(); if (kt) return kw_put(kt); }
	if (kind == 1) { hover_blob(i); return hn; }
	if (hover_scan(i)) { hover_fill(i); return hn; }
	if (hover_method(i)) return hn;
	if (kind == 0 && hover_local(i)) return hn;
	hover_blob(i);
	return hn;
}
// the hover at the cursor. the compiler's record of the name decides what it
// is: a local is its declaration, a parameter the header that names it, and a
// symbol is looked up as that kind of symbol. a name with no record is found by
// its text, as before.
int do_hover(int i) {
	int r, k = 0, v = 0, has_word, s, q, o;
	hn = 0;
	ensure_checked(i);
	has_word = hover_word(i);
	if (hover_type_span(i)) { send(gen_hover); return 0; }
	if (has_word) {
		r = rs_find(hoff);
		if (r >= 0) { k = rsrec[r * RS_W + 1]; v = rsrec[r * RS_W + 2]; }
		if (k == RS_LOCAL && v >= 0) hover_at_decl(i, v);
		else if (k == RS_PARAM && v >= 0) hover_named(i, v, 1);
		else if (k == RS_FIELD && v >= 0) hover_named(i, v, 4);
		else if (k == RS_LOCAL) hover_local(i);
		else if (k == RS_SYM) {
			if ((v & 15) == K_GVAR || (v & 15) == K_GARR) {
				s = rsrec[r * RS_W + 3]; q = 0; o = 0 - 1;
				while (q < rsn) { if (rsrec[q * RS_W + 3] == s && lt_find(rsrec[q * RS_W]) >= 0) { o = rsrec[q * RS_W]; break; } q++; }
				if (o >= 0) hover_named(i, o, 3); else if (v & 16) hover_global(i, 2); else hover_global(i, 1);
			} else if (v & 16) hover_global(i, 2); else hover_global(i, 1);
		}
		else hover_global(i, 0);
		r = rs_find(hoff); hover_storage(r);
	}
	send(gen_hover);
	return 0;
}

// ---- dispatch ----
// the text just read belongs to the document named by the uri
int commit_text() {
	int i;
	if (!thave || !tuseen) return 0 - 1;
	i = dfind(ubuf, un);
	if (i < 0) i = docnew(ubuf, un);
	if (i < 0) return 0 - 1;
	doff[i] = tbase; dsize[i] = tn; dver[i] = jver; dgen[i]++;
	return i;
}
// handles one message: the lifecycle (initialize, shutdown, exit), changes to a
// document (which are checked and published), and the requests for semantic
// tokens and hovers.
int handle() {
	int i;
	if (eq_w(mbuf, "initialize")) { inited = 1; send(gen_init); return 0; }
	if (eq_w(mbuf, "exit")) { quit = 1; return 0; }
	if (eq_w(mbuf, "shutdown")) { shut = 1; send(gen_null); return 0; }
	if (!inited) { if (idtype) reply_error(0 - 32002); return 0; }
	if (eq_w(mbuf, "textDocument/didOpen") || eq_w(mbuf, "textDocument/didChange") || eq_w(mbuf, "textDocument/didSave")) {
		i = commit_text();
		if (i < 0 && tuseen) i = dfind(ubuf, un);
		if (i >= 0) { check_doc(i); publish(i); }
		return 0;
	}
	if (eq_w(mbuf, "textDocument/didClose")) {
		i = dfind(ubuf, un);
		if (i >= 0) {
			dgpos = 0; publish(i);		// an empty list clears its markers
			dlive[i] = 0; dsize[i] = 0; doff[i] = 0; duri[i] = 0;
			chk_i = 0 - 1;
			hc_i = 0 - 1; ann_i = 0 - 1;
		}
		return 0;
	}
	if (eq_w(mbuf, "textDocument/semanticTokens/full")) {
		i = dfind(ubuf, un);
		if (i < 0) { send(gen_empty); return 0; }
		ensure_checked(i);
		gd = i; send(gen_tokens);
		return 0;
	}
	if (eq_w(mbuf, "textDocument/hover")) {
		i = dfind(ubuf, un);
		if (i < 0) { send(gen_null); return 0; }
		do_hover(i);
		return 0;
	}
	if (idtype) reply_error(0 - 32601);
	return 0;
}

// ---- command line ----
// a source file on stdin instead of a protocol stream: print what the
// compiler found, one line each. with --annotate, print the file with the
// types the compiler can see written in
unchecked int load_stdin(int first) {
	int n = 0, c = first, cap = 4096; word nb; int k;
	tbase = new(cap);
	while (c >= 0) {
		if ((n >> 2) + 4 >= cap) {
			nb = new(cap * 2); k = 0;
			while (k < cap) { nb[k] = tbase[k]; k++; }
			tbase = nb; cap = cap * 2;
		}
		if ((n & 3) == 0) tbase[n >> 2] = 0;
		tbase[n >> 2] = tbase[n >> 2] | (c << ((n & 3) * 8));
		n++;
		if (eof()) break;
		c = get_c() & 255;
	}
	if (n & 3) { } else tbase[n >> 2] = 0;
	tbase[(n >> 2) + 1] = 0;
	dlive[0] = 1; doff[0] = tbase; dsize[0] = n; dgen[0] = 1; dulen[0] = 0;
	return n;
}
// zclsp given a source file on stdin prints its diagnostics as file:line:column
// lines, one per error or hint, and says so when there are none.
int cli(int first) {
	int at = 0, i, o;
	load_stdin(first);
	check_doc(0);
	pc_reset(0);
	while (at < dgpos) {
		o = dgb[at + 2];
		if (o < 0) { put_s("line "); put_n(dgb[at + 1]); }
		else { pc_to(o); put_n(pline + 1); put_c(':'); put_n(pcol + 1); }
		if (dgb[at] == 1) put_s(": error: "); else if (dgb[at] == 2) put_s(": warning: "); else put_s(": hint: ");
		i = 0; while (i < dgb[at + 4]) { put_c(dgb[at + 5 + i]); i++; }
		put_c(10);
		at = at + 5 + dgb[at + 4];
	}
	if (!dgpos) put_s("no errors\n");
	return 0;
}

// ---- annotate ----
// zclsp --annotate < file.zc prints the file with the types the compiler can
// see written in: locals from their initializers, parameters from what every
// call passes them or from being used as an address, returns from what the
// function returns (the type facts of compiler.zc). the typechecker is on for
// it, and every edit has to leave the file with no error it didn't have, so
// what comes out compiles wherever the input did. when a batch of edits
// fails, the batch is cut in halves until the bad edits are found and left
// out. run it again and the types it just wrote let the next round see more.
int aw_start(int p) { awp = p; awn = 0; return 0; }
// appends byte c to the output being built at awp (awn bytes so far).
int aw(int c) {
	if ((awn & 3) == 0) awp[awn >> 2] = 0;
	awp[awn >> 2] = awp[awn >> 2] | ((c & 255) << ((awn & 3) * 8));
	awn++;
	return 0;
}
// ends the output being built: a zero word follows the last byte, so it reads as a text.
int aw_end() {
	if ((awn & 3) == 0) awp[awn >> 2] = 0;
	awp[(awn >> 2) + 1] = 0;
	return 0;
}
// the lines of the errors the last check found
int err_lines(word dst) {
	int at = 0, n = 0, need = dgpos / 5 + 1, baseline = dst == abase;
	if (need > aerrcap) {
		while (need > aerrcap) { if (!aerrcap) aerrcap = 512; else aerrcap = aerrcap * 2; }
		abase = lsp_grow(abase, nbase, aerrcap); aerr = lsp_grow(aerr, 0, aerrcap);
	}
	if (baseline) dst = abase; else dst = aerr;
	while (at < dgpos) {
		if (dgb[at] == 1) { dst[n] = dgb[at + 1]; n++; }
		at = at + 5 + dgb[at + 4];
	}
	return n;
}
// is v one of the first n words of set.
int in_set(int v, word set, int n) {
	int i = 0;
	while (i < n) { if (set[i] == v) return 1; i++; }
	return 0;
}
// the facts, in the order of the text
int sort_facts() {
	int i = 1, j; word a, b; int t0, t1, t2, t3;
	while (i < nifx) {
		j = i;
		while (j > 0 && ifx[(j - 1) * 4] > ifx[j * 4]) {
			a = ifx + (j - 1) * 4; b = ifx + j * 4;
			t0 = a[0]; t1 = a[1]; t2 = a[2]; t3 = a[3];
			a[0] = b[0]; a[1] = b[1]; a[2] = b[2]; a[3] = b[3];
			b[0] = t0; b[1] = t1; b[2] = t2; b[3] = t3;
			j--;
		}
		i++;
	}
	return 0;
}
// the facts the last check collected, kept across the checks that follow
int save_facts() {
	int i = 0, nt = 0; word f; int k;
	sort_facts();
	if (nifx > afcap) {
		while (nifx > afcap) { if (!afcap) afcap = 4096; else afcap = afcap * 2; }
		afx = lsp_grow(afx, 0, afcap * 4); amask = lsp_grow(amask, 0, afcap);
	}
	if (nift > atcap) {
		while (nift > atcap) { if (!atcap) atcap = 24000; else atcap = atcap * 2; }
		aft = lsp_grow(aft, 0, atcap);
	}
	anf = 0;
	while (i < nifx) {
		f = ifx + i * 4;
		i++;
		afx[anf * 4] = f[0]; afx[anf * 4 + 1] = f[1]; afx[anf * 4 + 2] = nt; afx[anf * 4 + 3] = f[3];
		k = 0; while (k < f[3]) { aft[nt + k] = ift[f[2] + k]; k++; }
		nt = nt + f[3];
		anf++;
	}
	return 0;
}
// the text of document 0 with the facts in the mask applied, into dst. a fact
// that overlaps the one before it is left out. returns how many went in
int apply_masked(int dst) {
	int i = 0, o = 0; word f; int k, n = 0, size = dsize[0], base = doff[0], last = 0 - 1;
	aw_start(dst);
	while (i < anf) {
		f = afx + i * 4;
		i++;
		if (!amask[i - 1] || f[0] < o || f[0] == last || f[0] + f[1] > size) continue;
		while (o < f[0]) { aw(dc(base, o)); o++; }
		k = 0; while (k < f[3]) { aw(aft[f[2] + k]); k++; }
		o = f[0] + f[1]; last = f[0];
		n++;
	}
	while (o < size) { aw(dc(base, o)); o++; }
	aw_end();
	return n;
}
// the block the masked text is written into: room for the document and every
// replacement, so it never runs out
word fresh_half() {
	int n = dsize[0], i = 0;
	while (i < anf) { n = n + afx[i * 4 + 3]; i++; }
	ann_half = new(dwords(n));
	return ann_half;
}
// does the document with the masked facts applied check with no new error?
int verify() {
	int ne, i;
	apply_masked(ann_half);
	dlive[1] = 1; doff[1] = ann_half; dsize[1] = awn; dgen[1] = dgen[1] + 1; dulen[1] = 0;
	check_doc(1);
	ne = err_lines(aerr);
	i = 0;
	while (i < ne) { if (!in_set(aerr[i], abase, nbase)) return 0; i++; }
	return 1;
}
// take the facts lo .. hi if they fit together, else halve them and try the halves
int try_range(int lo, int hi) {
	int mid, k;
	if (lo >= hi) return 0;
	k = lo; while (k < hi) { amask[k] = 1; k++; }
	if (verify()) return 0;
	k = lo; while (k < hi) { amask[k] = 0; k++; }
	if (hi - lo == 1) return 0;
	mid = (lo + hi) / 2;
	try_range(lo, mid);
	try_range(mid, hi);
	return 0;
}
// zclsp --annotate reads a source file on stdin and prints it with the types the
// compiler can see written in. the rounds run the check with the type facts on,
// keep the edits that add no error, and run again on the text they made.
int annotate(int first) {
	int round = 0, n, i;
	load_stdin(first);
	ifstrict = 1;		// the typechecker runs, so a type that doesn't fit how a name is used is an error
	check_doc(0);
	nbase = err_lines(abase);
	while (round < AROUNDS) {
		ifon = 1; check_doc(0); ifon = 0;
		save_facts();
		if (!anf) break;
		i = 0; while (i < anf) { amask[i] = 0; i++; }
		fresh_half();
		try_range(0, anf);
		n = apply_masked(ann_half);
		if (!n) break;
		doff[0] = ann_half; dsize[0] = awn; dgen[0] = dgen[0] + 1;
		round++;
	}
	ifstrict = 0;
	i = 0;
	while (i < dsize[0]) { put_c(dc(doff[0], i)); i++; }
	return 0;
}
// the first argument: 1 for --annotate, 2 for --types, which lists the edits
// instead of making them
unchecked int cli_mode() {
	int n = syscall(SYS_ARGC, 0, 0, 0), len; word s; int r = 0;
	if (n < 2) return 0;
	len = syscall(SYS_ARG, 1, 0, 0);
	if (len != 10 && len != 7) return 0;
	s = new(len + 1);
	syscall(SYS_ARG, 1, s, len + 1);
	if (s[0] == '-' && s[1] == '-' && s[2] == 'a' && s[3] == 'n' && len == 10) r = 1;
	if (s[0] == '-' && s[1] == '-' && s[2] == 't' && s[3] == 'y' && len == 7) r = 2;
	free(s);
	return r;
}
// zclsp --types < file.zc: one line per edit, line:column, how many characters
// it replaces and the text that goes in
int list_types(int first) {
	int i = 0; word f; int k;
	load_stdin(first);
	ifon = 1; check_doc(0); ifon = 0;
	sort_facts();
	pc_reset(0);
	while (i < nifx) {
		f = ifx + i * 4;
		pc_to(f[0]);
		put_n(pline + 1); put_c(':'); put_n(pcol + 1); put_c(32); put_n(f[1]); put_c(32);
		k = 0; while (k < f[3]) { put_c(ift[f[2] + k]); k++; }
		put_c(10);
		i++;
	}
	return 0;
}

// the entry point of zclsp. the input is either a source file (checked, and its
// diagnostics printed), a file to annotate or to list the types of (--annotate,
// --types), or the json-rpc stream of a language server (when it starts with a
// Content-Length header).
int lsp_main() {
	int c, k;
	docs_on = 0;		// the image was made with docs on; the documents checked here are not docs
	chk_heap = 1;
	dgb = new(DGCAP); sets = new(4 * LSW);
	duri = lsp_grow(0, 0, doccap); dulen = lsp_grow(0, 0, doccap);
	doff = lsp_grow(0, 0, doccap); dsize = lsp_grow(0, 0, doccap);
	dver = lsp_grow(0, 0, doccap); dgen = lsp_grow(0, 0, doccap); dlive = lsp_grow(0, 0, doccap);
	mbuf = lsp_grow(0, 0, mcap); idbuf = lsp_grow(0, 0, idcap); jk = lsp_grow(0, 0, jkcap); kbuf = lsp_grow(0, 0, kcap); lbuf = lsp_grow(0, 0, lcap);
	ubuf = lsp_grow(0, 0, ucap); hov = lsp_grow(0, 0, hovcap); hname = lsp_grow(0, 0, hnamecap); htb = lsp_grow(0, 0, htbc);
	chk_i = 0 - 1; jpk = 0 - 2; rfirst = 0 - 1;
	if (eof()) return 0;
	c = get_c() & 255;
	if (c != 'C' && c != 'c') {
		k = cli_mode();
		if (k == 1) annotate(c); else if (k == 2) list_types(c); else cli(c);
		return 0;
	}
	rfirst = c;
	while (!quit) {
		if (!read_message()) break;
		handle();
	}
	return 0;
}