diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/compiler/compiler.zc | 124 | ||||
| -rw-r--r-- | src/lib/std.zc | 128 |
2 files changed, 198 insertions, 54 deletions
diff --git a/src/compiler/compiler.zc b/src/compiler/compiler.zc index 7619b64..ac504d7 100644 --- a/src/compiler/compiler.zc +++ b/src/compiler/compiler.zc @@ -3987,6 +3987,44 @@ int dtype() { } return 0; } +// the struct whose body or methods are being compiled, when it declares constants: a bare +// name there is looked up as Struct.name before the global scope +char* mstruct; +// does a constant declaration start in a struct body? const NAME = e; const T NAME = e; +// (a field of a const type has no initializer, so the = tells them apart) +int struct_const_start() { + if (!is_id(s_const)) return 0; + peekat(0); if (pk_tk != T_ID) return 0; + peekat(1); + if (pk_tk == T_OP && pk_tv == s_eq) return 1; + if (pk_tk == T_ID) { peekat(2); return pk_tk == T_OP && pk_tv == s_eq; } + if (pk_tk == T_OP && pk_tv == s_star) { peekat(2); if (pk_tk != T_ID) return 0; peekat(3); return pk_tk == T_OP && pk_tv == s_eq; } + return 0; +} +// const NAME = e, NAME = e; inside struct sn: a compile-time constant named Struct.NAME that takes no +// space in the layout. the optional type is read and dropped, as in gconst. +int struct_const(char* sn) { + int off, s; char* cn; + next(); + if (tk == T_ID) { peekat(0); if (pk_tk == T_ID || (pk_tk == T_OP && pk_tv == s_star)) ptype(); } + mstruct = sn; + while (1) { + off = toff; cn = name(); + s = lookup(methname(sn, cn)); + if (s >= ubase && s >= 0) serrn(cn, "is defined twice in this struct"); + expect(s_eq); + s = addsym(methname(sn, cn), K_CONST, cexpr()); + rs_put(off, RS_SYM, rs_sym(s), s); + if (!is_op(s_comma) && !is_op(s_semi)) { // a call or a variable's value follows what cprim could read + serr("a struct constant must be a constant expression"); + while (!is_op(s_semi) && !is_op(s_rb) && tk != T_EOF) next(); + break; + } + if (!accept(s_comma)) break; + } + accept(s_semi); + return 0; +} // struct name { type field, ... } or struct name<A, B> { ... } // the struct keyword. fields go in a scratch buffer first (name, type pairs), // then are laid out: each field takes tsz(type) words, so offsets are words. @@ -3995,7 +4033,7 @@ int dtype() { // and call its siblings. a generic struct keeps its fields unresolved and // can't have methods; each instance is laid out later by tresolve. int kw_struct() { - char* n; word t; int s, nf = 0; word buf = chk_resize(0, 0, 64); int bufcap = 64, i; word fs; int off = 0, gen = 0, ft, nm = 0, mcap = STRUCT_METHODS; char** mn = chk_resize(0, 0, mcap); word mq = chk_resize(0, 0, mcap), mst = chk_resize(0, 0, mcap), mty = chk_resize(0, 0, mcap), mrt = chk_resize(0, 0, mcap), mrg = chk_resize(0, 0, mcap); int bo, k, stat = 0; char* fname = 0; + char* n; word t; int s, nf = 0; word buf = chk_resize(0, 0, 64); int bufcap = 64, i; word fs; int off = 0, gen = 0, ft, nm = 0, mcap = STRUCT_METHODS; char** mn = chk_resize(0, 0, mcap); word mq = chk_resize(0, 0, mcap), mst = chk_resize(0, 0, mcap), mty = chk_resize(0, 0, mcap), mrt = chk_resize(0, 0, mcap), mrg = chk_resize(0, 0, mcap); int bo, k, stat = 0; char* fname = 0; char* msv = mstruct; next(); n = module_symbol(name()); if (is_op(s_lt)) { // generic @@ -4017,6 +4055,7 @@ int kw_struct() { while (!is_op(s_rb)) { if (tk == T_EOF) { die("missing }"); break; } stat = 0; + if (struct_const_start()) { struct_const(n); continue; } if (is_id(s_unchecked)) { next(); stat = 2; } if (is_id(s_static)) { // static fn name(params) { body }, or static T name(params) { body }: a function of the struct, called as Struct.name(args), with no this next(); @@ -4105,6 +4144,7 @@ int kw_struct() { i = 0; while (i < nm) { fn_method_compile = 1; methdef(n, mn[i], mq[i], mst[i], mty[i], mrt[i], mrg[i]); fn_method_compile = 0; i++; } mdg = 0; + mstruct = msv; return s; } // ---- methods ---- @@ -6890,6 +6930,7 @@ int primary() { return C_PLAIN; } s = source_lookup(n); + if (mstruct && !ginst) { ms = lookup(methname(mstruct, n)); if (ms >= 0 && skind[ms] == K_CONST) s = ms; } if (s < 0 && rt.eq_w(n, "new")) s = source_lookup(s_new); if (s >= 0) rs_put(toff, RS_SYM, rs_sym(s), s); if (s >= 0 && skind[s] == K_KW) { @@ -6902,8 +6943,8 @@ int primary() { c = toff + toklen; next(); if (probe_off >= 0 && cmode && !dry && !ginst && incdepth == 0 && probe_off >= c && ((tk == T_ID && probe_off <= toff + toklen) || (tk != T_ID && probe_off <= toff))) { probe_static = n; probe_has = 3; chkabort = 1; } - k = toff; mn = name(); - ms = lookup(methname(n, mn)); + k = toff; sv = tpack(); mn = name(); + ms = lookup(methname(sname[s], mn)); if (ms >= 0) rs_put(k, RS_SYM, rs_sym(ms), ms); if (ms >= 0 && skind[ms] == K_CONST) { // Enum.MEMBER xvk = 1; xvv = sval[ms]; @@ -6919,7 +6960,11 @@ int primary() { if (!is_op(s_lp)) die("a static function is called with ( after its name"); return call(ms); } - serrn(mn, "is not a static function of this struct"); + if (!panic && !dry) { + c = tpack(); tunpack(sv); // the error sits on the member name, where the quick fix replaces it + errat(); rt.put_s(mn); rt.put_s(": is not a static function of this struct"); suggest_member(sname[s], 0, mn, 1); errend(); + tunpack(c); + } lit(0); xty = tword; return C_PLAIN; @@ -7039,7 +7084,7 @@ int incdec(int post, int dlt) { word field(int c) { int readonly = treadonly(xty); if_value = 0; - int n, fieldoff; word st; + int n, fieldoff, fieldpos, sv; word st; word borrowed = xaf, base_mask = effect_mask(c); af_use(xaf, tpack(), c); xaf = 0; xvk = 0; int i, b = xbor, k = 0, scanned = 0, ms, de, pmatch = 0; de = toff + toklen; next(); @@ -7048,7 +7093,7 @@ word field(int c) { if (tk == T_ID) { if (probe_off <= toff + toklen) pmatch = 1; } else if (probe_off <= toff) pmatch = 1; } - n = name(); fieldoff = nameoff; + fieldpos = tpack(); n = name(); fieldoff = nameoff; st = xty; if (st[0] == TY_ARR || st[0] == TY_DYN) { if (pmatch) probe_member(st); @@ -7113,7 +7158,11 @@ word field(int c) { } if (scanned) i = fldi; else i = tfindfield(st, n); if (i < 0) { - if (!panic && !dry) { errat(); tprint(st); rt.put_s(" has no field "); rt.put_s(n); errend(); } + if (!panic && !dry) { + sv = tpack(); tunpack(fieldpos); // the error sits on the field name, where the quick fix replaces it + errat(); tprint(st); rt.put_s(" has no field "); rt.put_s(n); suggest_member(st[2], st, n, 0); errend(); + tunpack(sv); + } xty = tword; lv = 1; lvk = LV_OTHER; xbor = -1; return C_PLAIN; } rs_put(fieldoff, RS_FIELD, field_decl(st, n), st[4][i * 3 + 1]); @@ -7741,6 +7790,7 @@ word cprim() { if (accept(s_lp)) { v = cexpr(); expect(s_rp); return v; } if (tk == T_ID) { s = lookup(tv); + if (mstruct && !ginst) { mc = lookup(methname(mstruct, tv)); if (mc >= 0 && skind[mc] == K_CONST) s = mc; } if (s >= 0 && (skind[s] == K_CONST || skind[s] == K_GARR || (skind[s] == K_FN && (sflag[s] & F_DEF)) || skind[s] == K_GVAR)) { next(); return sval[s]; @@ -9665,6 +9715,66 @@ int similar(int n) { if (bd > lim) return 0; return best; } +// the field or method of struct sn closest to n (statics is 0), or the static function or constant +// (statics is 1), when it is close enough to be a likely typo. the limits are those of similar. +char* similar_member(char* sn, word st, char* n, int statics) { + int j, bd = 99, dist, k, ln = rt.len_w(sn), lim = rt.len_w(n) / 3, nf; char* best = 0; char* tail; + if (rt.len_w(n) < 3) return 0; + if (lim < 1) lim = 1; + if (lim > 3) lim = 3; + if (!statics && st && st[0] == TY_STRUCT) { + nf = st[3]; k = 0; + while (k < nf) { + tail = st[4][k * 3]; dist = editdist(n, tail); + if (dist == 2 && swapped(n, tail)) dist = 1; + if (dist > 0 && dist < bd) { bd = dist; best = tail; } + k++; + } + } + j = 0; + while (j < nsym) { + k = skind[j]; + if (((k == K_FN && ((sflag[j] & F_STATIC) != 0) == statics) || (statics && k == K_CONST)) && rt.len_w(sname[j]) > ln + 1 && sname[j][ln] == '.') { + tail = sname[j] + ln + 1; + if (has_prefix(sname[j], sn, ln) && !has_dot(tail)) { + dist = editdist(n, tail); + if (dist == 2 && swapped(n, tail)) dist = 1; + if (dist > 0 && dist < bd) { bd = dist; best = tail; } + } + } + j++; + } + if (bd > lim) return 0; + return best; +} +// are a and b the same but for two neighbouring chars swapped (itao for itoa)? a swap counts as one typo. +int swapped(char* a, char* b) { + int i = 0, la = rt.len_w(a); + if (la != rt.len_w(b)) return 0; + while (a[i] && a[i] == b[i]) i++; + if (!a[i] || !a[i + 1] || a[i] != b[i + 1] || a[i + 1] != b[i]) return 0; + i = i + 2; + while (a[i] && a[i] == b[i]) i++; + return !a[i]; +} +// does s start with the first n chars of p? +int has_prefix(char* s, char* p, int n) { + int i = 0; + while (i < n && s[i] == p[i]) i++; + return i == n; +} +// does the string contain a dot? +int has_dot(char* s) { + int i = 0; + while (s[i]) { if (s[i] == '.') return 1; i++; } + return 0; +} +// ends an error message with "; did you mean 'x'?" when a member of struct sn is close to n +int suggest_member(char* sn, word st, char* n, int statics) { + char* best = similar_member(sn, st, n, statics); + if (best) { rt.put_s("; did you mean '"); rt.put_s(best); rt.put_s("'?"); } + return 0; +} // a copy of s[a..e) as a string char* lib_copy(char* s, int a, int e) { char* b = chk_resize(0, 0, e - a + 1); rt.copy_w(b, s + a, e - a); b[e - a] = 0; diff --git a/src/lib/std.zc b/src/lib/std.zc index f0bc390..33ab1e9 100644 --- a/src/lib/std.zc +++ b/src/lib/std.zc @@ -20,9 +20,14 @@ include rt, run; // these and the runtime calls it before main, if the program has one (an // image built by build_image, or a check-mode document, does not). +// the number of command line arguments, set by libinit(). int argc; +// the command line arguments, one string each. argv[0] is the program path, +// or <eval> when the source came from stdin. char*[?] argv; +// the number of environment entries, set by libinit(). int envc; +// the environment, one NAME=value string per entry, set by libinit(). char*[?] envp; // one entry of a vector syscall, as a fresh string, or 0 past the end. @@ -64,25 +69,24 @@ int libinit() { // capture.start() redirects everything the program writes into a string and // returns it. writes go to the buffer instead of the terminal until end() // stops it, so the buffer is a string once end() has run: -// let buf = capture.start(); +// let buf = std.capture.start(); // rt.put_s("hello world!"); // nothing on the terminal -// capture.end(buf); -// rt.put_s(buf); // hello world +// std.capture.end(buf); +// rt.put_s(buf); // hello world! +// the buffer holds 256 characters, and output past that is dropped. // one capture at a time, and the buffer belongs to whoever holds it. - struct capture { - // redirects program output into a collector-managed character buffer. - // returns the buffer; call end(buffer) before reading its terminator. - // returns: the buffer used for this capture + // starts a capture: output goes into a new buffer instead of the terminal. + // returns: the buffer, managed by the collector; read it after end(buffer) static char* start() { int cap = 256; rt.outmode = 2; rt.outn = 0; rt.outcap = cap; rt.outbuf = rt.new(cap); return rt.outbuf; } - // stops output capture, terminates the buffer, and returns the collected text. - // buffer: the buffer returned by start - // returns: the same buffer, now terminated + // stops the capture and ends the buffer with a 0. + // buffer: the buffer that start returned + // returns: the same buffer, now a string static char* end(char* buffer) { rt.outbuf[rt.outn] = 0; rt.outmode = 0; rt.outbuf = 0; rt.outn = 0; rt.outcap = 0; @@ -92,6 +96,8 @@ struct capture { // ---- character strings ---- +// helpers for char* strings: one character per word, ended by a 0 word. +// called as std.Text.name(args). struct Text { // the number written in decimal at the start of s. a leading '-' makes it // negative and the first character that is not a digit ends it. @@ -106,7 +112,7 @@ struct Text { // writes n in decimal into dst, with a 0 after it. // n: the number - // dst: where the text goes; 24 words is always enough + // dst: where the text goes; 21 words is always enough (20 characters and the 0) // returns: how many characters were written, not counting the 0 static int itoa(int n, char* dst) { int b[24], i = 0, j = 0, neg = 0; @@ -120,7 +126,7 @@ struct Text { return j; } - // joins two strings. + // joins two strings into dst. // dst: where the result goes, with room for both and a 0; not a or b // a: the first string // b: the second string @@ -248,9 +254,8 @@ struct Text { // ---- numbers ---- -// plain integer helpers. none of them can fail: an out of range result wraps -// the same way the arithmetic does. - +// plain integer helpers, called as std.Num.name(args). none of them can fail: +// an out of range result wraps the same way the arithmetic does. struct Num { // the absolute value of n, using wrapping word arithmetic. the minimum // word remains negative because its positive value cannot fit in a word. @@ -298,7 +303,8 @@ struct Num { return a; } - // b raised to the power e. e below 0 gives 1; the result wraps as a word. + // b raised to the power e, by one multiply per step of e, so a large e is slow. + // e below 0 gives 1, and the result wraps as a word. // b: the base // e: the exponent // returns: b to the power e, or 1 when e is negative @@ -333,18 +339,18 @@ struct Num { // ---- the host ---- -// the argument block for Host.raw: the number, then its six arguments. +// the argument block for Host.raw: word 0 is the syscall number, words 1 to 6 +// are its arguments. Host.raw fills it on each call. int rawblk[7]; +// calls into the host that runs the vm: the environment, the clock, files and +// raw system calls. called as std.Host.name(args). struct Host { // calls any linux system call on the host. this is the escape hatch below // the named helpers: the number is the kernel's, so the meaning of each - // argument depends on the call. a pointer argument is an address in the - // program's memory, and only the host reads it, so a string or buffer has - // to be passed as its address. - // it runs the call on the real machine, not inside the vm, so a program - // that uses it can do whatever the process can do. only use it where that - // is wanted. + // argument depends on the call. the words reach the kernel unchanged, so a + // pointer is a host address to it, not a place in the vm's memory. the call + // runs on the real machine, so only use it where that is wanted. // nr: the syscall number (x86-64 and arm64 numbers differ, so check the host) // a..f: the six arguments, unused ones 0 // returns: the kernel's result, -errno on failure, or -1 on unsupported hosts @@ -354,18 +360,20 @@ struct Host { return rt.syscall(rt.SYS_RAW, rawblk, 0, 0); } - // the value of an environment variable. + // copies the value of an environment variable into dst, as a 0-terminated string. // name: the variable's name - // dst: where the value goes, a zero-terminated character string - // n: how many words dst has - // returns: the length of the value, -1 if the variable is not set + // dst: where the value goes + // n: the size of dst in words, the 0 included + // returns: how many characters were copied, at most n - 1, so a longer value + // is cut short; -1 if the variable is not set or n is below 1 static int env(char* name, char* dst, int n) { return rt.syscall(rt.SYS_GETENV, name, dst, n); } // the clock. // returns: the time in seconds since 1970 static int now() { return rt.syscall(rt.SYS_TIME, 0, 0, 0); } - // writes a string to a file, replacing what was there. + // writes a string to a file, replacing what was there. the file is created if + // it is missing. // path: the file's name // s: the text to write // returns: how many bytes were written, -1 if the file could not be opened @@ -380,9 +388,8 @@ struct Host { // ---- byte strings ---- -// the same helpers for packed byte strings. character-string helpers above are unchanged. -// a packed byte string has type bstr; len_s reads its stored byte length. - +// the same helpers as Text, for packed byte strings of type bstr (b"..." +// literals). len reads the stored byte length. called as std.Bytes.name(args). struct Bytes { // reads a decimal number at the start of s; a leading '-' makes it // negative, and the first non-digit ends the number. @@ -392,7 +399,7 @@ struct Bytes { // like Text.itoa, but the text is made fresh. // n: the number - // returns: a new byte string + // returns: a new byte string, managed by the collector; the caller does not free it static bstr itoa(int n) { return rt.n_to_s(n); } // like Text.starts, for byte strings. @@ -448,14 +455,15 @@ struct Bytes { return 1; } - // like Host.env, for byte strings. + // like Host.env, for byte strings. the value is written into the bytes of dst, + // and the length of dst is not changed, so make dst big enough first. // name: the variable's name, a byte string - // dst: the packed byte string whose payload receives the value - // n: the maximum number of bytes to write - // returns: the length of the value, -1 if the variable is not set + // dst: the byte string that receives the value + // n: the most bytes dst may use, the 0 after the value included + // returns: how many bytes were copied, at most n - 1; -1 if the variable is not set or n is below 1 static int env(bstr name, bstr dst, int n) { return rt.bgetenv(name, dst, n); } - // like Host.writefile, for a byte string. + // like Host.writefile, for a byte string. the file is replaced, or created. // path: the file's name, a byte string // s: the bytes to write // returns: how many bytes were written, -1 if the file could not be opened @@ -470,16 +478,17 @@ struct Bytes { // ---- arenas ---- -// a region that is freed all at once. +// a region of n words that Arena.alloc hands out and Arena.reset frees all at once. // n: its capacity in words; values below 1 allocate one word // returns: the arena, owned by the caller int .u arena(int n) { return rt.arena_new(n); } +// helpers for an arena made by std.arena. called as std.Arena.name(args). struct Arena { // takes n zeroed words from an arena. // a: the arena // n: how many words - // returns: the first word, or 0 when n words do not fit + // returns: the first word; 0 when n words do not fit, or n is negative static int alloc(word a, int n) { return rt.arena_alloc(a, n); } // gives every block of an arena back at once. pointers returned by alloc @@ -491,10 +500,10 @@ struct Arena { // ---- growable byte buffers ---- -// a byte buffer stores its length and capacity in two words, followed by the -// bytes, packed. +// makes an empty byte buffer with room for n bytes. the buffer keeps its length +// and capacity in two words, followed by the bytes, packed. // n: the capacity in bytes; a negative value is treated as 0 -// returns: an empty buffer with that capacity, owned by the caller +// returns: the buffer, owned by the caller word .u bnew(int n) { int words; word p; @@ -506,25 +515,27 @@ word .u bnew(int n) { return u*p; } +// byte buffers made by bnew. the length grows as bytes are set, up to the +// capacity, which is fixed. called as std.Buf.name(args). struct Buf { // how many bytes a buffer holds. - // b: the buffer + // b: the buffer, from bnew // returns: its length static int length(word b) { return b[0]; } // how many bytes a buffer can hold. - // b: the buffer + // b: the buffer, from bnew // returns: its capacity static int capacity(word b) { return b[1]; } // one byte of a buffer. // b: the buffer // i: the position - // returns: the byte, 0 when i is outside the buffer + // returns: the byte, 0 when i is outside the buffer (below 0, or at or past the length) static int get(word b, int i) { if (i < 0 || i >= b[0]) return 0; return rt.ld8(rt.addr_b(b + 2) + i); } - // sets one byte of a buffer. setting the byte at the current length makes the - // buffer one longer. + // sets one byte of a buffer. a write at or past the length makes the length + // i + 1, and the bytes skipped over are left at 0. // b: the buffer // i: the position, below the capacity // v: the value; only its low 8 bits are kept @@ -542,28 +553,41 @@ struct Buf { // with the collector, so freeing the input does not invalidate the result. // the first index equal to value, or -1 when no element matches. +// source: the array, only read +// value: the element to find int array_find<T>(fixed T[?].m source, T value) { int length = len(source); for (int i = 0; i < length; i++) if (source[i] == value) return i; return -1; } // true when an element equals value. +// source: the array, only read +// value: the element to find int array_contains<T>(fixed T[?].m source, T value) { return array_find(source, value) >= 0; } // the first index whose predicate is true, or -1 when none matches. +// source: the array, only read +// predicate: called on each element; nonzero means a match int array_find_if<T>(fixed T[?].m source, int(T).m predicate) { int length = len(source); for (int i = 0; i < length; i++) if (predicate(source[i])) return i; return -1; } // true when any element satisfies predicate; false for an empty array. +// source: the array, only read +// predicate: called on each element; nonzero means a match int array_any<T>(fixed T[?].m source, int(T).m predicate) { return array_find_if(source, predicate) >= 0; } // true when every element satisfies predicate, including an empty array. +// source: the array, only read +// predicate: called on each element; nonzero means a match +// returns: 1 or 0 int array_all<T>(fixed T[?].m source, int(T).m predicate) { int length = len(source); for (int i = 0; i < length; i++) if (!predicate(source[i])) return 0; return 1; } // the number of elements satisfying predicate. +// source: the array, only read +// predicate: called on each element; nonzero means a match int array_count<T>(fixed T[?].m source, int(T).m predicate) { int length = len(source); int count = 0; @@ -572,6 +596,9 @@ int array_count<T>(fixed T[?].m source, int(T).m predicate) { } // apply transform once to each element and return the transformed array. // the result element type follows the callback's return type. +// source: the array, only read +// transform: called once on each element, in order +// returns: a new array of the results, owned by the caller U[?].u array_map<T,U>(fixed T[?].m source, U(T).m transform) { int length = len(source); U[?] result = rt.new(U[?]); @@ -579,6 +606,9 @@ U[?].u array_map<T,U>(fixed T[?].m source, U(T).m transform) { return result; } // copy elements satisfying predicate into a new array, preserving order. +// source: the array, only read +// predicate: called on each element; nonzero keeps it +// returns: the new array, owned by the caller T[?].u array_filter<T>(fixed T[?].m source, int(T).m predicate) { int length = len(source); T[?] result = rt.new(T[?]); @@ -587,6 +617,10 @@ T[?].u array_filter<T>(fixed T[?].m source, int(T).m predicate) { } // fold elements from left to right, starting with initial; an empty array // returns initial without calling combine. +// source: the array, only read +// initial: the starting value +// combine: called as combine(total, element) for each element, in order +// returns: the folded value A array_reduce<T,A>(fixed T[?].m source, A initial, A(A,T).m combine) { int length = len(source); for (int i = 0; i < length; i++) initial = combine(initial, source[i]); |
