diff options
Diffstat (limited to 'src/lsp/server.zc')
| -rw-r--r-- | src/lsp/server.zc | 1929 |
1 files changed, 1929 insertions, 0 deletions
diff --git a/src/lsp/server.zc b/src/lsp/server.zc new file mode 100644 index 0000000..98e71c3 --- /dev/null +++ b/src/lsp/server.zc @@ -0,0 +1,1929 @@ +// ============================================================================ +// 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; +} |