Finch/src/embedded.fch

// The runtime and the standard library, as text. Made by tools/pack.fch: don't edit it, run bootstrap/build.sh.
// Used when the compiler can't find runtime/ and std/ next to itself.

fn names() -> []str {
    []str list
    list.push("runtime/finch_rt.c")
    list.push("std/json.fch")
    list.push("std/path.fch")
    list.push("std/proc.fch")
    list.push("std/proc_windows.fch")
    list.push("std/time.fch")
    list.push("std/time_windows.fch")
    list.push("std/finch_win.h")
    return list
}

fn texts() -> []str {
    []str list
    list.push("// The Finch runtime: string and array helpers, input, files and runtime errors.\n// It is embedded in the compiler, compiled once into a cache folder, and linked\n// statically into every Finch program. Everything here is plain C with no state.\n//\n// Layout shared with the compiler (src/codegen.cpp):\n//   str  = { char *ptr; int64 len; int64 cap }   ptr is always NUL-terminated\n//          cap > 0  : heap memory owned by the value (cap bytes allocated)\n//          cap == 0 : a string literal, valid forever, never written to\n//          cap == -1: borrowed from C, must be copied before it is kept\n//   []T  = { T *ptr;   int64 len; int64 cap }    owns ptr when cap > 0\n//   map[K]V: see \"maps\" below\n\n#include <ctype.h>\n#include <errno.h>\n#include <math.h>\n#include <stdarg.h>\n#include <stdint.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#ifndef _WIN32\n#include <sys/wait.h>\n#endif\n\ntypedef struct {\n    char *ptr;\n    int64_t len;\n    int64_t cap;\n} FStr;\n\ntypedef struct {\n    void *ptr;\n    int64_t len;\n    int64_t cap;\n} FArr;\n\nstatic char empty[1] = \"\";\n\n// ---------- runtime errors ----------\n\n// A program that loads Finch libraries (finch build --shared) can take runtime errors over\n// instead of the process exiting: finch_module_on_fatal(handler) in each library. The handler\n// gets the message and must not return (longjmp out, or exit itself).\nstatic void (*fatal_hook)(const char *msg);\nvoid finch_on_fatal(void (*hook)(const char *msg)) { fatal_hook = hook; }\n\nstatic __attribute__((noreturn)) void fatal(const char *msg) {\n    if (fatal_hook) fatal_hook(msg);\n    fflush(stdout);\n    fprintf(stderr, \"%s\\n\", msg);\n    exit(1);\n}\n\n__attribute__((noreturn, cold)) void finch_panic(const char *file, int64_t line, const char *msg) {\n    char full[1024];\n    snprintf(full, sizeof full, \"%s:%lld: runtime error: %s\", file, (long long)line, msg);\n    fflush(stdout);\n    fatal(full);\n}\n\n__attribute__((noreturn, cold)) void finch_panic_index(const char *file, int64_t line, int64_t i, int64_t len) {\n    char msg[128];\n    snprintf(msg, sizeof msg, \"index %lld is out of range (the length is %lld)\", (long long)i, (long long)len);\n    finch_panic(file, line, msg);\n}\n\nstatic void *must(void *p) {\n    if (!p) {\n        fflush(stdout);\n        fatal(\"runtime error: out of memory\");\n    }\n    return p;\n}\n\nvoid *finch_alloc(int64_t n) { return must(malloc(n ? (size_t)n : 1)); }\nvoid *finch_zalloc(int64_t n) { return must(calloc(1, n ? (size_t)n : 1)); }\n\n// ---------- strings ----------\n\nstatic void str_heap(FStr *out, const char *p, int64_t len) {\n    char *m = finch_alloc(len + 1);\n    if (len) memcpy(m, p, (size_t)len);\n    m[len] = 0;\n    out->ptr = m;\n    out->len = len;\n    out->cap = len + 1;\n}\n\nstatic void str_static(FStr *out, const char *lit) {\n    out->ptr = (char *)lit;\n    out->len = (int64_t)strlen(lit);\n    out->cap = 0;\n}\n\n// A copy that can be kept: literals are shared, everything else is duplicated.\nvoid finch_str_copy(FStr *out, const FStr *s) {\n    if (s->cap == 0) *out = *s;\n    else str_heap(out, s->ptr, s->len);\n}\n\n// Make `s` writable (before s[i] = c).\nvoid finch_str_own(FStr *s) {\n    if (s->cap > 0) return;\n    FStr t;\n    str_heap(&t, s->ptr, s->len);\n    *s = t;\n}\n\nvoid finch_str_drop(FStr *s) {\n    if (s->cap > 0) free(s->ptr);\n}\n\nvoid finch_str_from_c(FStr *out, const char *p) {\n    if (!p) {\n        str_static(out, empty);\n        return;\n    }\n    out->ptr = (char *)p;\n    out->len = (int64_t)strlen(p);\n    out->cap = -1;\n}\n\nvoid finch_str_concat(FStr *out, const FStr *a, const FStr *b) {\n    int64_t len = a->len + b->len;\n    char *m = finch_alloc(len + 1);\n    memcpy(m, a->ptr, (size_t)a->len);\n    memcpy(m + a->len, b->ptr, (size_t)b->len);\n    m[len] = 0;\n    out->ptr = m;\n    out->len = len;\n    out->cap = len + 1;\n}\n\nint finch_str_eq(const FStr *a, const FStr *b) {\n    return a->len == b->len && memcmp(a->ptr, b->ptr, (size_t)a->len) == 0;\n}\n\nint64_t finch_str_cmp(const FStr *a, const FStr *b) {\n    int64_t n = a->len < b->len ? a->len : b->len;\n    int c = memcmp(a->ptr, b->ptr, (size_t)n);\n    if (c) return c < 0 ? -1 : 1;\n    return a->len < b->len ? -1 : a->len > b->len;\n}\n\nvoid finch_str_from_int(FStr *out, int64_t v) {\n    char buf[32];\n    int n = snprintf(buf, sizeof buf, \"%lld\", (long long)v);\n    str_heap(out, buf, n);\n}\n\nvoid finch_str_from_uint(FStr *out, uint64_t v) {\n    char buf[32];\n    int n = snprintf(buf, sizeof buf, \"%llu\", (unsigned long long)v);\n    str_heap(out, buf, n);\n}\n\n// The shortest text that reads back as the same number (as an f32 when `single`):\n// 0.1 -> \"0.1\", 1.0/3 -> \"0.3333333333333333\", 1e8 -> \"100000000\", 1e20 -> \"1e+20\".\nstatic int fmt_float(char *buf, size_t size, double v, int single) {\n    if (isnan(v)) return snprintf(buf, size, \"nan\");\n    if (isinf(v)) return snprintf(buf, size, v < 0 ? \"-inf\" : \"inf\");\n    int p = 1;\n    for (; p < 17; p++) {\n        snprintf(buf, size, \"%.*e\", p - 1, v);\n        double back = strtod(buf, NULL);\n        if (single ? (float)back == (float)v : back == v) break;\n    }\n    int exp = atoi(strchr(buf, 'e') + 1);\n    if (exp < -5 || exp >= 17) return snprintf(buf, size, \"%.*g\", p, v);\n    int decimals = p - 1 - exp;\n    return snprintf(buf, size, \"%.*f\", decimals > 0 ? decimals : 0, v);\n}\n\nvoid finch_str_from_float(FStr *out, double v) {\n    char buf[64];\n    int n = fmt_float(buf, sizeof buf, v, 0);\n    str_heap(out, buf, n);\n}\n\nvoid finch_str_from_f32(FStr *out, double v) {\n    char buf[64];\n    int n = fmt_float(buf, sizeof buf, v, 1);\n    str_heap(out, buf, n);\n}\n\n// str(x, 2): a fixed number of digits after the point\nvoid finch_str_fixed(FStr *out, double v, int64_t digits) {\n    char buf[400];\n    if (digits < 0) digits = 0;\n    if (digits > 60) digits = 60;\n    int n = snprintf(buf, sizeof buf, \"%.*f\", (int)digits, v);\n    str_heap(out, buf, n);\n}\n\nvoid finch_print_float(double v, int32_t single) {\n    char buf[64];\n    fmt_float(buf, sizeof buf, v, single);\n    fputs(buf, stdout);\n}\n\nvoid finch_str_from_char(FStr *out, char c) { str_heap(out, &c, 1); }\n\nvoid finch_str_from_bool(FStr *out, int b) { str_static(out, b ? \"true\" : \"false\"); }\n\nstatic void number_error(char *msg, size_t size, const FStr *s, const char *kind) {\n    snprintf(msg, size, \"can't turn \\\"%.*s\\\" into %s\", (int)(s->len > 100 ? 100 : s->len), s->ptr ? s->ptr : \"\", kind);\n}\n\nstatic int parse_int(const FStr *s, int64_t *out) {\n    const char *p = s->ptr ? s->ptr : \"\";\n    while (isspace((unsigned char)*p)) p++;\n    char *end;\n    errno = 0;\n    long long v = strtoll(p, &end, 10);\n    while (isspace((unsigned char)*end)) end++;\n    *out = v;\n    return !(end == p || *end || errno == ERANGE);\n}\n\nstatic int parse_float(const FStr *s, double *out) {\n    const char *p = s->ptr ? s->ptr : \"\";\n    while (isspace((unsigned char)*p)) p++;\n    char *end;\n    double v = strtod(p, &end);\n    while (isspace((unsigned char)*end)) end++;\n    *out = v;\n    return !(end == p || *end);\n}\n\nint64_t finch_str_to_int(const FStr *s, const char *file, int64_t line) {\n    int64_t v;\n    if (!parse_int(s, &v)) {\n        char msg[200];\n        number_error(msg, sizeof msg, s, \"int\");\n        finch_panic(file, line, msg);\n    }\n    return v;\n}\n\ndouble finch_str_to_float(const FStr *s, const char *file, int64_t line) {\n    double v;\n    if (!parse_float(s, &v)) {\n        char msg[200];\n        number_error(msg, sizeof msg, s, \"float\");\n        finch_panic(file, line, msg);\n    }\n    return v;\n}\n\n// ---------- errors as values: int(s) or 0, try read_file(p) ... ----------\n// Each gives back 1 on success; on failure 0, with the message in *err.\n\nstatic void set_error(FStr *err, const char *msg) { str_heap(err, msg, (int64_t)strlen(msg)); }\n\nint finch_str_try_int(const FStr *s, int64_t *out, FStr *err) {\n    if (parse_int(s, out)) return 1;\n    char msg[200];\n    number_error(msg, sizeof msg, s, \"int\");\n    set_error(err, msg);\n    *out = 0;\n    return 0;\n}\n\nint finch_str_try_float(const FStr *s, double *out, FStr *err) {\n    if (parse_float(s, out)) return 1;\n    char msg[200];\n    number_error(msg, sizeof msg, s, \"float\");\n    set_error(err, msg);\n    *out = 0;\n    return 0;\n}\n\nstatic void file_error(FStr *err, const char *what, const FStr *path) {\n    char msg[300];\n    snprintf(msg, sizeof msg, \"can't %s the file \\\"%.*s\\\": %s\", what, (int)(path->len > 200 ? 200 : path->len),\n             path->ptr ? path->ptr : \"\", strerror(errno));\n    set_error(err, msg);\n}\n\n// when `fn main() -> !` fails\nvoid finch_report_error(const FStr *msg) {\n    fflush(stdout);\n    fprintf(stderr, \"error: %.*s\\n\", (int)msg->len, msg->ptr ? msg->ptr : \"\");\n    finch_str_drop((FStr *)msg);\n}\n\nvoid finch_str_sub(FStr *out, const FStr *s, int64_t start, int64_t end, const char *file, int64_t line) {\n    if (start < 0 || end > s->len || start > end) {\n        char msg[160];\n        snprintf(msg, sizeof msg, \"sub(%lld, %lld) is out of range (the length is %lld)\", (long long)start,\n                 (long long)end, (long long)s->len);\n        finch_panic(file, line, msg);\n    }\n    str_heap(out, s->ptr + start, end - start);\n}\n\nint64_t finch_str_find(const FStr *s, const FStr *t) {\n    if (t->len == 0) return 0;\n    for (int64_t i = 0; i + t->len <= s->len; i++)\n        if (s->ptr[i] == t->ptr[0] && memcmp(s->ptr + i, t->ptr, (size_t)t->len) == 0) return i;\n    return -1;\n}\n\nint finch_str_starts(const FStr *s, const FStr *t) {\n    return t->len <= s->len && memcmp(s->ptr, t->ptr, (size_t)t->len) == 0;\n}\n\nint finch_str_ends(const FStr *s, const FStr *t) {\n    return t->len <= s->len && memcmp(s->ptr + s->len - t->len, t->ptr, (size_t)t->len) == 0;\n}\n\nvoid finch_str_trim(FStr *out, const FStr *s) {\n    int64_t a = 0, b = s->len;\n    while (a < b && isspace((unsigned char)s->ptr[a])) a++;\n    while (b > a && isspace((unsigned char)s->ptr[b - 1])) b--;\n    str_heap(out, s->ptr + a, b - a);\n}\n\nvoid finch_str_upper(FStr *out, const FStr *s) {\n    str_heap(out, s->ptr, s->len);\n    for (int64_t i = 0; i < out->len; i++) out->ptr[i] = (char)toupper((unsigned char)out->ptr[i]);\n}\n\nvoid finch_str_lower(FStr *out, const FStr *s) {\n    str_heap(out, s->ptr, s->len);\n    for (int64_t i = 0; i < out->len; i++) out->ptr[i] = (char)tolower((unsigned char)out->ptr[i]);\n}\n\nvoid finch_str_replace(FStr *out, const FStr *s, const FStr *from, const FStr *to) {\n    if (from->len == 0) {\n        str_heap(out, s->ptr, s->len);\n        return;\n    }\n    int64_t count = 0;\n    for (int64_t i = 0; i + from->len <= s->len;) {\n        if (memcmp(s->ptr + i, from->ptr, (size_t)from->len) == 0) {\n            count++;\n            i += from->len;\n        } else {\n            i++;\n        }\n    }\n    int64_t len = s->len + count * (to->len - from->len);\n    char *m = finch_alloc(len + 1), *w = m;\n    for (int64_t i = 0; i < s->len;) {\n        if (i + from->len <= s->len && memcmp(s->ptr + i, from->ptr, (size_t)from->len) == 0) {\n            memcpy(w, to->ptr, (size_t)to->len);\n            w += to->len;\n            i += from->len;\n        } else {\n            *w++ = s->ptr[i++];\n        }\n    }\n    *w = 0;\n    out->ptr = m;\n    out->len = len;\n    out->cap = len + 1;\n}\n\nstatic void arr_push_str(FArr *a, const char *p, int64_t len);\n\n// \"a,b,,c\".split(\",\") -> [\"a\", \"b\", \"\", \"c\"]; split(\"\") gives single characters.\nvoid finch_str_split(FArr *out, const FStr *s, const FStr *sep) {\n    out->ptr = NULL;\n    out->len = out->cap = 0;\n    if (sep->len == 0) {\n        for (int64_t i = 0; i < s->len; i++) arr_push_str(out, s->ptr + i, 1);\n        return;\n    }\n    int64_t start = 0;\n    for (int64_t i = 0; i + sep->len <= s->len;) {\n        if (memcmp(s->ptr + i, sep->ptr, (size_t)sep->len) == 0) {\n            arr_push_str(out, s->ptr + start, i - start);\n            i += sep->len;\n            start = i;\n        } else {\n            i++;\n        }\n    }\n    arr_push_str(out, s->ptr + start, s->len - start);\n}\n\nvoid finch_str_join(FStr *out, const FArr *parts, const FStr *sep) {\n    const FStr *p = parts->ptr;\n    int64_t len = 0;\n    for (int64_t i = 0; i < parts->len; i++) len += p[i].len + (i ? sep->len : 0);\n    char *m = finch_alloc(len + 1), *w = m;\n    for (int64_t i = 0; i < parts->len; i++) {\n        if (i) {\n            memcpy(w, sep->ptr, (size_t)sep->len);\n            w += sep->len;\n        }\n        memcpy(w, p[i].ptr, (size_t)p[i].len);\n        w += p[i].len;\n    }\n    *w = 0;\n    out->ptr = m;\n    out->len = len;\n    out->cap = len + 1;\n}\n\nvoid finch_str_repeat(FStr *out, const FStr *s, int64_t n) {\n    if (n < 0) n = 0;\n    int64_t len = s->len * n;\n    char *m = finch_alloc(len + 1);\n    for (int64_t i = 0; i < n; i++) memcpy(m + i * s->len, s->ptr, (size_t)s->len);\n    m[len] = 0;\n    out->ptr = m;\n    out->len = len;\n    out->cap = len + 1;\n}\n\nvoid finch_str_from_bytes(FStr *out, const FArr *bytes) { str_heap(out, bytes->ptr, bytes->len); }\n\n// ---------- building text: print(x) and str(x) of arrays, maps and structs ----------\n// A buffer starts as an empty str and grows on the heap.\n\nvoid finch_buf_add(FStr *b, const char *p, int64_t n) {\n    if (b->len + n + 1 > b->cap) {\n        int64_t cap = b->cap > 0 ? b->cap * 2 : 32;\n        while (cap < b->len + n + 1) cap *= 2;\n        b->ptr = must(realloc(b->cap > 0 ? b->ptr : NULL, (size_t)cap));\n        b->cap = cap;\n    }\n    if (n) memcpy(b->ptr + b->len, p, (size_t)n);\n    b->len += n;\n    b->ptr[b->len] = 0;\n}\n\nstatic void buf_fmt(FStr *b, const char *fmt, ...) __attribute__((format(printf, 2, 3)));\nstatic void buf_fmt(FStr *b, const char *fmt, ...) {\n    char t[64];\n    va_list ap;\n    va_start(ap, fmt);\n    int n = vsnprintf(t, sizeof t, fmt, ap);\n    va_end(ap);\n    finch_buf_add(b, t, n);\n}\n\nvoid finch_buf_int(FStr *b, int64_t v) { buf_fmt(b, \"%lld\", (long long)v); }\nvoid finch_buf_uint(FStr *b, uint64_t v) { buf_fmt(b, \"%llu\", (unsigned long long)v); }\nvoid finch_buf_float(FStr *b, double v) {\n    char t[64];\n    finch_buf_add(b, t, fmt_float(t, sizeof t, v, 0));\n}\nvoid finch_buf_f32(FStr *b, double v) {\n    char t[64];\n    finch_buf_add(b, t, fmt_float(t, sizeof t, v, 1));\n}\nvoid finch_buf_bool(FStr *b, int v) { finch_buf_add(b, v ? \"true\" : \"false\", v ? 4 : 5); }\nvoid finch_buf_ptr(FStr *b, const void *p) {\n    if (p) buf_fmt(b, \"0x%llx\", (unsigned long long)(uintptr_t)p);\n    else finch_buf_add(b, \"null\", 4);\n}\n\nvoid finch_buf_char(FStr *b, char c, int quoted) {\n    if (quoted) finch_buf_add(b, \"'\", 1);\n    finch_buf_add(b, &c, 1);\n    if (quoted) finch_buf_add(b, \"'\", 1);\n}\n\nvoid finch_buf_str(FStr *b, const FStr *s, int quoted) {\n    if (quoted) finch_buf_add(b, \"\\\"\", 1);\n    finch_buf_add(b, s->ptr, s->len);\n    if (quoted) finch_buf_add(b, \"\\\"\", 1);\n}\n\n// print the buffer and free it\nvoid finch_buf_print(FStr *b) {\n    if (b->len) fwrite(b->ptr, 1, (size_t)b->len, stdout);\n    if (b->cap > 0) free(b->ptr);\n}\n\n// ---------- arrays ----------\n\nvoid finch_arr_reserve(FArr *a, int64_t need, int64_t es) {\n    if (need <= a->cap) return;\n    int64_t cap = a->cap * 2;\n    if (cap < 4) cap = 4;\n    if (cap < need) cap = need;\n    a->ptr = must(realloc(a->cap > 0 ? a->ptr : NULL, (size_t)(cap * es)));\n    a->cap = cap;\n}\n\nvoid finch_arr_make(FArr *out, int64_t len, int64_t es) {\n    if (len < 0) len = 0;\n    out->ptr = len ? finch_zalloc(len * es) : NULL;\n    out->len = len;\n    out->cap = len;\n}\n\n// grow or shrink to `len`; new elements are zero\nvoid finch_arr_resize(FArr *a, int64_t len, int64_t es) {\n    if (len < 0) len = 0;\n    finch_arr_reserve(a, len, es);\n    if (len > a->len) memset((char *)a->ptr + a->len * es, 0, (size_t)((len - a->len) * es));\n    a->len = len;\n}\n\n// a byte-for-byte copy of the elements (the compiler deep-copies owning elements afterwards)\nvoid finch_arr_clone_raw(FArr *out, const FArr *a, int64_t es) {\n    out->len = a->len;\n    out->cap = a->len;\n    out->ptr = a->len ? finch_alloc(a->len * es) : NULL;\n    if (a->len) memcpy(out->ptr, a->ptr, (size_t)(a->len * es));\n}\n\nvoid finch_arr_free(FArr *a) {\n    if (a->cap > 0) free(a->ptr);\n}\n\n// open a hole at i (0 <= i <= len), len grows by one\nvoid finch_arr_insert_gap(FArr *a, int64_t i, int64_t es, const char *file, int64_t line) {\n    if (i < 0 || i > a->len) finch_panic_index(file, line, i, a->len);\n    finch_arr_reserve(a, a->len + 1, es);\n    char *p = a->ptr;\n    memmove(p + (i + 1) * es, p + i * es, (size_t)((a->len - i) * es));\n    a->len++;\n}\n\n// close the hole at i (the element was already moved out), len shrinks by one\nvoid finch_arr_remove_gap(FArr *a, int64_t i, int64_t es) {\n    char *p = a->ptr;\n    memmove(p + i * es, p + (i + 1) * es, (size_t)((a->len - i - 1) * es));\n    a->len--;\n}\n\nstatic void arr_push_str(FArr *a, const char *p, int64_t len) {\n    finch_arr_reserve(a, a->len + 1, (int64_t)sizeof(FStr));\n    str_heap((FStr *)a->ptr + a->len, p, len);\n    a->len++;\n}\n\nvoid finch_bytes_from_str(FArr *out, const FStr *s) {\n    out->len = out->cap = s->len;\n    out->ptr = s->len ? finch_alloc(s->len) : NULL;\n    if (s->len) memcpy(out->ptr, s->ptr, (size_t)s->len);\n}\n\n// ---------- program arguments, input and files ----------\n\nvoid finch_args(FArr *out, int argc, char **argv) {\n    out->len = out->cap = argc;\n    out->ptr = finch_alloc((int64_t)sizeof(FStr) * (argc ? argc : 1));\n    for (int i = 0; i < argc; i++) str_heap((FStr *)out->ptr + i, argv[i], (int64_t)strlen(argv[i]));\n}\n\n// after main: the arguments go\nvoid finch_args_free(FArr *a) {\n    for (int64_t i = 0; i < a->len; i++) finch_str_drop((FStr *)a->ptr + i);\n    finch_arr_free(a);\n}\n\n// input(\"Name? \") prints the prompt and reads one line, without the newline.\nvoid finch_input(FStr *out, const FStr *prompt) {\n    if (prompt->len) fwrite(prompt->ptr, 1, (size_t)prompt->len, stdout);\n    fflush(stdout);\n    // read one line of any length (getline isn't available everywhere)\n    size_t size = 128, n = 0;\n    char *line = finch_alloc((int64_t)size);\n    int c, got = 0;\n    while ((c = fgetc(stdin)) != EOF) {\n        got = 1;\n        if (c == '\\n') break;\n        if (n + 1 >= size) line = must(realloc(line, size *= 2));\n        line[n++] = (char)c;\n    }\n    if (!got) {\n        free(line);\n        str_static(out, empty);\n        return;\n    }\n    while (n > 0 && line[n - 1] == '\\r') n--;\n    line[n] = 0;\n    out->ptr = line;\n    out->len = (int64_t)n;\n    out->cap = (int64_t)size;\n}\n\nint finch_file_exists(const FStr *path) {\n    FILE *f = fopen(path->ptr, \"rb\");\n    if (f) fclose(f);\n    return f != NULL;\n}\n\nint finch_try_read_file(FStr *out, const FStr *path, FStr *err) {\n    FILE *f = fopen(path->ptr ? path->ptr : \"\", \"rb\");\n    if (!f) {\n        file_error(err, \"read\", path);\n        return 0;\n    }\n    fseek(f, 0, SEEK_END);\n    long size = ftell(f);\n    fseek(f, 0, SEEK_SET);\n    char *m = finch_alloc(size + 1);\n    size_t got = fread(m, 1, (size_t)size, f);\n    fclose(f);\n    m[got] = 0;\n    out->ptr = m;\n    out->len = (int64_t)got;\n    out->cap = size + 1;\n    return 1;\n}\n\nvoid finch_read_file(FStr *out, const FStr *path, const char *file, int64_t line) {\n    FILE *f = fopen(path->ptr ? path->ptr : \"\", \"rb\");\n    if (!f) {\n        char msg[300];\n        snprintf(msg, sizeof msg, \"can't read the file \\\"%.*s\\\": %s\", (int)(path->len > 200 ? 200 : path->len),\n                 path->ptr, strerror(errno));\n        finch_panic(file, line, msg);\n    }\n    fseek(f, 0, SEEK_END);\n    long size = ftell(f);\n    fseek(f, 0, SEEK_SET);\n    char *m = finch_alloc(size + 1);\n    size_t got = fread(m, 1, (size_t)size, f);\n    fclose(f);\n    m[got] = 0;\n    out->ptr = m;\n    out->len = (int64_t)got;\n    out->cap = size + 1;\n}\n\n// shell(\"ls -l\"): run a command, give back its exit code\nint64_t finch_shell(const FStr *cmd) {\n    fflush(stdout);\n    int status = system(cmd->ptr ? cmd->ptr : \"\");\n#ifdef _WIN32\n    return status;  // Windows gives the exit code directly\n#else\n    if (status == -1) return -1;\n    if (WIFEXITED(status)) return WEXITSTATUS(status);\n    return 128 + (WIFSIGNALED(status) ? WTERMSIG(status) : 0);\n#endif\n}\n\nint finch_delete_file(const FStr *path) { return remove(path->ptr ? path->ptr : \"\") == 0; }\n\nint finch_try_delete_file(const FStr *path, FStr *err) {\n    if (remove(path->ptr ? path->ptr : \"\") == 0) return 1;\n    file_error(err, \"delete\", path);\n    return 0;\n}\n\n// stdin/stdout/stderr are macros on some systems (Windows), so Finch asks for them here\nvoid *finch_std_stream(int i) { return i == 0 ? (void *)stdin : i == 1 ? (void *)stdout : (void *)stderr; }\n\nint finch_write_file(const FStr *path, const FStr *text) {\n    FILE *f = fopen(path->ptr ? path->ptr : \"\", \"wb\");\n    if (!f) return 0;\n    size_t put = text->len ? fwrite(text->ptr, 1, (size_t)text->len, f) : 0;\n    return fclose(f) == 0 && put == (size_t)text->len;\n}\n\nint finch_try_write_file(const FStr *path, const FStr *text, FStr *err) {\n    errno = 0;\n    if (finch_write_file(path, text)) return 1;\n    if (!errno) errno = EIO;\n    file_error(err, \"write\", path);\n    return 0;\n}\n\n// ---------- maps ----------\n// map[K]V = { entries; len; used; cap; index; icap; adds }\n//   entries: `used` slots of es bytes, each { uint64 hash; K key; V value }, in insertion order.\n//            A removed entry keeps its slot (hash 0) until the next resize packs the slots.\n//   index:   icap slots (a power of two, at least 2 * cap): -1 empty, -2 removed, else an entry number.\n//   adds:    how many keys were ever added; a `for` over the map stops with an error if it changes.\n// The compiler stores, copies and drops keys and values; the runtime only finds and places entries.\n// Keys are compared byte for byte (numbers, chars, bools) or as text (kstr).\n\ntypedef struct {\n    char *entries;\n    int64_t len, used, cap;\n    int64_t *index;\n    int64_t icap;\n    int64_t adds;\n} FMap;\n\nstatic uint64_t map_hash(const void *key, int64_t ks, int kstr) {\n    const unsigned char *p;\n    size_t n;\n    if (kstr) {\n        const FStr *s = key;\n        p = (const unsigned char *)s->ptr;\n        n = (size_t)s->len;\n    } else {\n        p = key;\n        n = (size_t)ks;\n    }\n    uint64_t h = 1469598103934665603ULL;  // FNV-1a, then mixed so the low bits spread well\n    for (size_t i = 0; i < n; i++) {\n        h ^= p[i];\n        h *= 1099511628211ULL;\n    }\n    h ^= h >> 31;\n    h *= 0xbf58476d1ce4e5b9ULL;\n    h ^= h >> 29;\n    return h | 1;  // 0 marks a removed entry\n}\n\nstatic int map_key_eq(const char *a, const void *b, int64_t ks, int kstr) {\n    if (!kstr) return memcmp(a, b, (size_t)ks) == 0;\n    const FStr *x = (const FStr *)a, *y = b;\n    return x->len == y->len && (x->len == 0 || memcmp(x->ptr, y->ptr, (size_t)x->len) == 0);\n}\n\nstatic void map_reindex(FMap *m, int64_t es) {\n    if (m->len != m->used) {  // pack the slots of removed entries away\n        int64_t j = 0;\n        for (int64_t i = 0; i < m->used; i++) {\n            char *e = m->entries + i * es;\n            if (*(uint64_t *)e == 0) continue;\n            if (i != j) memmove(m->entries + j * es, e, (size_t)es);\n            j++;\n        }\n        m->used = j;\n    }\n    int64_t icap = 16;\n    while (icap < m->cap * 2) icap *= 2;\n    free(m->index);\n    m->index = finch_alloc(icap * (int64_t)sizeof(int64_t));\n    memset(m->index, 0xff, (size_t)icap * sizeof(int64_t));\n    m->icap = icap;\n    for (int64_t i = 0; i < m->used; i++) {\n        uint64_t h = *(uint64_t *)(m->entries + i * es);\n        int64_t s = (int64_t)(h & (uint64_t)(icap - 1));\n        while (m->index[s] != -1) s = (s + 1) & (icap - 1);\n        m->index[s] = i;\n    }\n}\n\n// the entry number of `key`, or -1\nint64_t finch_map_find(const FMap *m, const void *key, int64_t es, int64_t ks, int32_t kstr) {\n    if (m->len == 0) return -1;\n    uint64_t h = map_hash(key, ks, kstr);\n    for (int64_t s = (int64_t)(h & (uint64_t)(m->icap - 1));; s = (s + 1) & (m->icap - 1)) {\n        int64_t i = m->index[s];\n        if (i == -1) return -1;\n        if (i < 0) continue;\n        char *e = m->entries + i * es;\n        if (*(uint64_t *)e == h && map_key_eq(e + 8, key, ks, kstr)) return i;\n    }\n}\n\n// The entry for `key`. A new one is zeroed except its hash (*added = 1); the compiler then stores the key.\nint64_t finch_map_slot(FMap *m, const void *key, int64_t es, int64_t ks, int32_t kstr, int32_t *added) {\n    int64_t i = finch_map_find(m, key, es, ks, kstr);\n    *added = i < 0;\n    if (i >= 0) return i;\n    if (m->used == m->cap) {\n        if (m->len * 4 < m->cap * 3) {  // many removed slots: pack them instead of growing\n            map_reindex(m, es);\n        } else {\n            m->cap = m->cap ? m->cap * 2 : 8;\n            m->entries = must(realloc(m->entries, (size_t)(m->cap * es)));\n            map_reindex(m, es);\n        }\n    }\n    uint64_t h = map_hash(key, ks, kstr);\n    i = m->used++;\n    char *e = m->entries + i * es;\n    memset(e, 0, (size_t)es);\n    *(uint64_t *)e = h;\n    int64_t s = (int64_t)(h & (uint64_t)(m->icap - 1));\n    while (m->index[s] >= 0) s = (s + 1) & (m->icap - 1);\n    m->index[s] = i;\n    m->len++;\n    m->adds++;\n    return i;\n}\n\n// Forget entry i (its key and value were already dropped by the compiler).\nvoid finch_map_remove_at(FMap *m, int64_t i, int64_t es) {\n    char *e = m->entries + i * es;\n    uint64_t h = *(uint64_t *)e;\n    int64_t s = (int64_t)(h & (uint64_t)(m->icap - 1));\n    while (m->index[s] != i) s = (s + 1) & (m->icap - 1);\n    m->index[s] = -2;\n    *(uint64_t *)e = 0;\n    if (--m->len == 0) {\n        m->used = 0;\n        memset(m->index, 0xff, (size_t)m->icap * sizeof(int64_t));\n    }\n}\n\nvoid finch_map_clear(FMap *m) {\n    m->len = m->used = 0;\n    if (m->index) memset(m->index, 0xff, (size_t)m->icap * sizeof(int64_t));\n}\n\nvoid finch_map_free(FMap *m) {\n    free(m->entries);\n    free(m->index);\n}\n\n// A copy of the slots and the index; the compiler then copies the keys and values that own memory.\nvoid finch_map_clone_raw(FMap *out, const FMap *m, int64_t es) {\n    *out = *m;\n    if (!m->cap) return;\n    out->entries = finch_alloc(m->cap * es);\n    memcpy(out->entries, m->entries, (size_t)(m->used * es));\n    out->index = finch_alloc(m->icap * (int64_t)sizeof(int64_t));\n    memcpy(out->index, m->index, (size_t)m->icap * sizeof(int64_t));\n}\n\n__attribute__((noreturn, cold)) void finch_map_changed(const char *file, int64_t line) {\n    finch_panic(file, line, \"a key was added to the map while looping over it (collect the new keys, and add them after the loop)\");\n}\n\n__attribute__((noreturn, cold)) void finch_map_missing(const char *file, int64_t line, const FStr *key) {\n    char msg[200];\n    snprintf(msg, sizeof msg, \"the key %.*s is not in the map (check with .has(key), or use .get(key, default))\",\n             (int)(key->len > 100 ? 100 : key->len), key->ptr ? key->ptr : \"\");\n    finch_panic(file, line, msg);\n}\n")
    list.push("// JSON: read it, build it, write it.\n//\n//   import json\n//\n//   doc := try json.parse(\"{\\\"name\\\": \\\"Finch\\\", \\\"tags\\\": [\\\"fast\\\", \\\"small\\\"], \\\"stars\\\": 5}\")\n//   print(doc.get(\"name\").str_or(\"\"))             Finch\n//   print(doc.get(\"tags\").at(1).str_or(\"\"))       small\n//   print(doc.get(\"stars\").int_or(0))             5\n//   print(doc.get(\"missing\").is_null())           true       (a missing key is null, so chains never fail)\n//\n//   out := json.new_object()\n//   out.set(\"ok\", json.new_bool(true))\n//   list := json.new_list()\n//   list.push(json.new_number(1.5))\n//   out.set(\"values\", list)\n//   print(json.stringify(out))                    {\"ok\":true,\"values\":[1.5]}\n//   print(json.pretty(out))                       the same, over several lines\n\nenum Kind { Null, Bool, Number, Text, List, Object }\n\n// One JSON value. `kind` says which of the other fields it uses: flag for Bool, num for Number,\n// text for Text, items for List, and items with keys (the same length, in the same order) for Object.\nstruct Json {\n    Kind kind\n    bool flag\n    float num\n    str text\n    []Json items\n    []str keys\n}\n\nfn new_null() -> Json {\n    return Json(kind: Kind.Null)\n}\n\nfn new_bool(bool b) -> Json {\n    return Json(kind: Kind.Bool, flag: b)\n}\n\nfn new_number(float n) -> Json {\n    return Json(kind: Kind.Number, num: n)\n}\n\nfn new_text(str s) -> Json {\n    return Json(kind: Kind.Text, text: s)\n}\n\nfn new_list() -> Json {\n    return Json(kind: Kind.List)\n}\n\nfn new_object() -> Json {\n    return Json(kind: Kind.Object)\n}\n\n// ---------- looking inside ----------\n\nfn Json.is_null() -> bool {\n    return self.kind == Kind.Null\n}\n\n// the number of elements of a list, of keys of an object, of bytes of a text; 0 for the rest\nfn Json.len() -> int {\n    return match self.kind {\n        List, Object -> self.items.len\n        Text -> self.text.len\n        else -> 0\n    }\n}\n\nfn Json.has(str key) -> bool {\n    return self.kind == Kind.Object && self.keys.contains(key)\n}\n\n// the value of a key of an object; null if there is none (or this is not an object)\nfn Json.get(str key) -> Json {\n    if self.kind != Kind.Object {\n        return new_null()\n    }\n    i := self.keys.find(key)\n    if i < 0 {\n        return new_null()\n    }\n    return self.items[i]\n}\n\n// the element of a list; null if there is none\nfn Json.at(int i) -> Json {\n    if self.kind != Kind.List || i < 0 || i >= self.items.len {\n        return new_null()\n    }\n    return self.items[i]\n}\n\n// the value if it is of that kind, else what was given\nfn Json.str_or(str fallback) -> str {\n    if self.kind == Kind.Text {\n        return self.text\n    }\n    return fallback\n}\n\nfn Json.float_or(float fallback) -> float {\n    if self.kind == Kind.Number {\n        return self.num\n    }\n    return fallback\n}\n\nfn Json.int_or(int fallback) -> int {\n    if self.kind == Kind.Number {\n        return int(self.num)\n    }\n    return fallback\n}\n\nfn Json.bool_or(bool fallback) -> bool {\n    if self.kind == Kind.Bool {\n        return self.flag\n    }\n    return fallback\n}\n\n// the keys of an object, in the order they were written\nfn Json.names() -> []str {\n    return self.keys\n}\n\n// ---------- building ----------\n\n// add to the end of a list\nfn Json.push(Json v) {\n    self.items.push(v)\n}\n\n// give a key a value in an object; a key that is already there is replaced\nfn Json.set(str key, Json v) {\n    i := self.keys.find(key)\n    if i >= 0 {\n        self.items[i] = v\n        return\n    }\n    self.keys.push(key)\n    self.items.push(v)\n}\n\n// ---------- writing ----------\n\nfn quote(str s) -> str {\n    []str parts = [\"\\\"\"]\n    for c in s {\n        n := int(c)\n        if c == '\"' {\n            parts.push(\"\\\\\\\"\")\n        } else if c == '\\\\' {\n            parts.push(\"\\\\\\\\\")\n        } else if c == '\\n' {\n            parts.push(\"\\\\n\")\n        } else if c == '\\r' {\n            parts.push(\"\\\\r\")\n        } else if c == '\\t' {\n            parts.push(\"\\\\t\")\n        } else if n < 32 {\n            parts.push(\"\\\\u00\" + hexdigit(n / 16) + hexdigit(n % 16))\n        } else {\n            parts.push(str(c))\n        }\n    }\n    parts.push(\"\\\"\")\n    return parts.join(\"\")\n}\n\nfn hexdigit(int n) -> str {\n    digits := \"0123456789abcdef\"\n    return str(digits[n])\n}\n\nfn number_text(float n) -> str {\n    if n == float(int(n)) && n > -1000000000000000.0 && n < 1000000000000000.0 {\n        return str(int(n))\n    }\n    return str(n)\n}\n\nstruct Writer {\n    []str out\n}\n\nfn write(Json j, str indent, str pad, ptr[Writer] w) {\n    nl := \"\"\n    inner := \"\"\n    sep := \",\"\n    colon := \":\"\n    if indent.len > 0 {\n        nl = \"\\n\"\n        inner = pad + indent\n        colon = \": \"\n    }\n    match j.kind {\n        Null -> w.out.push(\"null\")\n        Bool -> {\n            if j.flag {\n                w.out.push(\"true\")\n            } else {\n                w.out.push(\"false\")\n            }\n        }\n        Number -> w.out.push(number_text(j.num))\n        Text -> w.out.push(quote(j.text))\n        List -> {\n            if j.items.len == 0 {\n                w.out.push(\"[]\")\n                return\n            }\n            w.out.push(\"[\" + nl)\n            for i, item in j.items {\n                if i > 0 {\n                    w.out.push(sep + nl)\n                }\n                w.out.push(inner)\n                write(item, indent, inner, w)\n            }\n            w.out.push(nl + pad + \"]\")\n        }\n        Object -> {\n            if j.items.len == 0 {\n                w.out.push(\"{}\")\n                return\n            }\n            w.out.push(\"{\" + nl)\n            for i, item in j.items {\n                if i > 0 {\n                    w.out.push(sep + nl)\n                }\n                w.out.push(inner + quote(j.keys[i]) + colon)\n                write(item, indent, inner, w)\n            }\n            w.out.push(nl + pad + \"}\")\n        }\n    }\n}\n\n// the value as text on one line\nfn stringify(Json j) -> str {\n    w := Writer()\n    write(j, \"\", \"\", addr(w))\n    return w.out.join(\"\")\n}\n\n// the value as text over several lines, indented by two spaces\nfn pretty(Json j) -> str {\n    w := Writer()\n    write(j, \"  \", \"\", addr(w))\n    return w.out.join(\"\")\n}\n\n// ---------- reading ----------\n\nstruct Reader {\n    str src\n    int i\n}\n\n// the line and column of a position, for a message\nfn where(ptr[Reader] r) -> str {\n    line := 1\n    col := 1\n    for k in 0..r.i {\n        if k < r.src.len && r.src[k] == '\\n' {\n            line += 1\n            col = 1\n        } else {\n            col += 1\n        }\n    }\n    return \"line \" + str(line) + \", column \" + str(col)\n}\n\nfn peek(ptr[Reader] r) -> char {\n    if r.i < r.src.len {\n        return r.src[r.i]\n    }\n    return char(0)\n}\n\nfn skip_space(ptr[Reader] r) {\n    while r.i < r.src.len && (r.src[r.i] == ' ' || r.src[r.i] == '\\n' || r.src[r.i] == '\\t' || r.src[r.i] == '\\r') {\n        r.i += 1\n    }\n}\n\nfn unexpected(ptr[Reader] r, str wanted) -> str {\n    if r.i >= r.src.len {\n        return \"json: the text ends where \" + wanted + \" should be (\" + where(r) + \")\"\n    }\n    return \"json: found '\" + str(r.src[r.i]) + \"' where \" + wanted + \" should be (\" + where(r) + \")\"\n}\n\n// does `word` come next?\nfn comes(ptr[Reader] r, str word) -> bool {\n    return r.src.len - r.i >= word.len && r.src.sub(r.i, r.i + word.len) == word\n}\n\nfn expect_word(ptr[Reader] r, str word) -> ! {\n    if !comes(r, word) {\n        return error(unexpected(r, \"'\" + word + \"'\"))\n    }\n    r.i += word.len\n}\n\nfn hex_value(char c) -> int {\n    if c >= '0' && c <= '9' {\n        return int(c) - int('0')\n    }\n    if c >= 'a' && c <= 'f' {\n        return int(c) - int('a') + 10\n    }\n    if c >= 'A' && c <= 'F' {\n        return int(c) - int('A') + 10\n    }\n    return -1\n}\n\n// a code point as UTF-8\nfn utf8(int cp) -> str {\n    []u8 b\n    if cp < 128 {\n        b.push(u8(cp))\n    } else if cp < 2048 {\n        b.push(u8(192 + cp / 64))\n        b.push(u8(128 + cp % 64))\n    } else if cp < 65536 {\n        b.push(u8(224 + cp / 4096))\n        b.push(u8(128 + (cp / 64) % 64))\n        b.push(u8(128 + cp % 64))\n    } else {\n        b.push(u8(240 + cp / 262144))\n        b.push(u8(128 + (cp / 4096) % 64))\n        b.push(u8(128 + (cp / 64) % 64))\n        b.push(u8(128 + cp % 64))\n    }\n    return str(b)\n}\n\nfn read_hex4(ptr[Reader] r) -> int! {\n    n := 0\n    for k in 0..4 {\n        if r.i >= r.src.len || hex_value(r.src[r.i]) < 0 {\n            return error(unexpected(r, \"a hexadecimal digit\"))\n        }\n        n = n * 16 + hex_value(r.src[r.i])\n        r.i += 1\n    }\n    return n\n}\n\nfn read_string(ptr[Reader] r) -> str! {\n    r.i += 1                    // the opening quote\n    []str parts\n    start := r.i\n    while true {\n        if r.i >= r.src.len {\n            return error(\"json: a text is never closed (\" + where(r) + \")\")\n        }\n        c := r.src[r.i]\n        if c == '\"' {\n            parts.push(r.src.sub(start, r.i))\n            r.i += 1\n            return parts.join(\"\")\n        }\n        if int(c) < 32 {\n            return error(\"json: a line break or control character inside a text (\" + where(r) + \")\")\n        }\n        if c != '\\\\' {\n            r.i += 1\n            continue\n        }\n        parts.push(r.src.sub(start, r.i))\n        r.i += 1\n        e := peek(r)\n        r.i += 1\n        if e == 'n' {\n            parts.push(\"\\n\")\n        } else if e == 't' {\n            parts.push(\"\\t\")\n        } else if e == 'r' {\n            parts.push(\"\\r\")\n        } else if e == 'b' {\n            parts.push(utf8(8))\n        } else if e == 'f' {\n            parts.push(utf8(12))\n        } else if e == '\"' || e == '\\\\' || e == '/' {\n            parts.push(str(e))\n        } else if e == 'u' {\n            cp := try read_hex4(r)\n            // a pair of 😀 stands for one character above U+FFFF\n            if cp >= 55296 && cp < 56320 && comes(r, \"\\\\u\") {\n                r.i += 2\n                low := try read_hex4(r)\n                cp = 65536 + (cp - 55296) * 1024 + (low - 56320)\n            }\n            parts.push(utf8(cp))\n        } else {\n            return error(\"json: unknown escape \\\\\" + str(e) + \" in a text (\" + where(r) + \")\")\n        }\n        start = r.i\n    }\n}\n\nfn read_number(ptr[Reader] r) -> Json! {\n    start := r.i\n    if peek(r) == '-' {\n        r.i += 1\n    }\n    while r.i < r.src.len && ((r.src[r.i] >= '0' && r.src[r.i] <= '9') || r.src[r.i] == '.' || r.src[r.i] == 'e' || r.src[r.i] == 'E' || r.src[r.i] == '+' || r.src[r.i] == '-') {\n        r.i += 1\n    }\n    n := float(r.src.sub(start, r.i)) or {\n        r.i = start\n        return error(unexpected(r, \"a number\"))\n    }\n    return new_number(n)\n}\n\nfn read_value(ptr[Reader] r) -> Json! {\n    skip_space(r)\n    c := peek(r)\n    if r.i >= r.src.len {\n        return error(unexpected(r, \"a value\"))\n    }\n    if c == '{' {\n        obj := new_object()\n        r.i += 1\n        skip_space(r)\n        if peek(r) == '}' {\n            r.i += 1\n            return obj\n        }\n        while true {\n            skip_space(r)\n            if peek(r) != '\"' {\n                return error(unexpected(r, \"a key in quotes\"))\n            }\n            key := try read_string(r)\n            skip_space(r)\n            if peek(r) != ':' {\n                return error(unexpected(r, \"':'\"))\n            }\n            r.i += 1\n            v := try read_value(r)\n            obj.set(key, v)\n            skip_space(r)\n            if peek(r) == ',' {\n                r.i += 1\n                continue\n            }\n            if peek(r) == '}' {\n                r.i += 1\n                return obj\n            }\n            return error(unexpected(r, \"',' or '}'\"))\n        }\n    }\n    if c == '[' {\n        list := new_list()\n        r.i += 1\n        skip_space(r)\n        if peek(r) == ']' {\n            r.i += 1\n            return list\n        }\n        while true {\n            v := try read_value(r)\n            list.push(v)\n            skip_space(r)\n            if peek(r) == ',' {\n                r.i += 1\n                continue\n            }\n            if peek(r) == ']' {\n                r.i += 1\n                return list\n            }\n            return error(unexpected(r, \"',' or ']'\"))\n        }\n    }\n    if c == '\"' {\n        s := try read_string(r)\n        return new_text(s)\n    }\n    if c == 't' {\n        try expect_word(r, \"true\")\n        return new_bool(true)\n    }\n    if c == 'f' {\n        try expect_word(r, \"false\")\n        return new_bool(false)\n    }\n    if c == 'n' {\n        try expect_word(r, \"null\")\n        return new_null()\n    }\n    if c == '-' || (c >= '0' && c <= '9') {\n        return try read_number(r)\n    }\n    return error(unexpected(r, \"a value\"))\n}\n\n// the JSON in `text`; an error with the line and column where it went wrong\nfn parse(str text) -> Json! {\n    r := Reader(src: text)\n    v := try read_value(addr(r))\n    skip_space(addr(r))\n    if r.i < r.src.len {\n        return error(unexpected(addr(r), \"the end of the text\"))\n    }\n    return v\n}\n")
    list.push("// Paths, as text. Elements are separated by \"/\".\n//\n//   import path\n//   path.join(\"a\", \"b.txt\")        a/b.txt\n//   path.base(\"/tmp/x/a.tar.gz\")   a.tar.gz       path.stem(...)  a.tar       path.ext(...)  .gz\n//   path.dir(\"/tmp/x/a.txt\")       /tmp/x\n//   path.clean(\"a//b/../c/./d\")    a/c/d\n\n// a and b with one separator between; an absolute b replaces a\nfn join(str a, str b) -> str {\n    if a.len == 0 {\n        return b\n    }\n    if b.len == 0 {\n        return a\n    }\n    if b[0] == '/' {\n        return b\n    }\n    if a[a.len - 1] == '/' {\n        return a + b\n    }\n    return a + \"/\" + b\n}\n\nfn is_abs(str p) -> bool {\n    return p.len > 0 && p[0] == '/'\n}\n\n// the last element: \"a/b.txt\" -> \"b.txt\", \"a/b/\" -> \"b\", \"\" -> \".\", \"/\" -> \"/\"\nfn base(str p) -> str {\n    if p.len == 0 {\n        return \".\"\n    }\n    end := p.len\n    while end > 1 && p[end - 1] == '/' {\n        end -= 1\n    }\n    if end == 1 && p[0] == '/' {\n        return \"/\"\n    }\n    start := end\n    while start > 0 && p[start - 1] != '/' {\n        start -= 1\n    }\n    return p.sub(start, end)\n}\n\n// everything before the last element: \"a/b.txt\" -> \"a\", \"b.txt\" -> \".\", \"/b\" -> \"/\"\nfn dir(str p) -> str {\n    end := p.len\n    while end > 1 && p[end - 1] == '/' {\n        end -= 1\n    }\n    i := end\n    while i > 0 && p[i - 1] != '/' {\n        i -= 1\n    }\n    if i == 0 {\n        return \".\"\n    }\n    while i > 1 && p[i - 1] == '/' {\n        i -= 1\n    }\n    return p.sub(0, i)\n}\n\n// the part of the last element from its last dot: \"a.tar.gz\" -> \".gz\"; \"\" when there is none\nfn ext(str p) -> str {\n    b := base(p)\n    i := b.len\n    while i > 0 && b[i - 1] != '.' {\n        i -= 1\n    }\n    if i <= 1 {                 // no dot, or a name that only starts with one (.bashrc)\n        return \"\"\n    }\n    return b.sub(i - 1, b.len)\n}\n\n// the last element without its extension\nfn stem(str p) -> str {\n    b := base(p)\n    e := ext(p)\n    return b.sub(0, b.len - e.len)\n}\n\n// the elements of a path: \"/a/b/c\" -> [\"a\", \"b\", \"c\"]\nfn parts(str p) -> []str {\n    []str out\n    for piece in p.split(\"/\") {\n        if piece.len > 0 {\n            out.push(piece)\n        }\n    }\n    return out\n}\n\n// the shortest path with the same meaning: no \"//\", no \".\", and \"..\" resolved where it can be\nfn clean(str p) -> str {\n    if p.len == 0 {\n        return \".\"\n    }\n    abs := is_abs(p)\n    []str out\n    for piece in parts(p) {\n        if piece == \".\" {\n            continue\n        }\n        if piece == \"..\" {\n            if out.len > 0 && out[out.len - 1] != \"..\" {\n                out.pop()\n            } else if !abs {\n                out.push(\"..\")\n            }\n            continue\n        }\n        out.push(piece)\n    }\n    joined := out.join(\"/\")\n    if abs {\n        return \"/\" + joined\n    }\n    if joined.len == 0 {\n        return \".\"\n    }\n    return joined\n}\n")
    list.push("// Programs: run a command, read what it printed, look at the environment.\n//\n//   import proc\n//   code := proc.run(\"make\")                  the exit code; what the command prints goes to the screen\n//   text := try proc.output(\"git describe\")   what the command printed; an error if it failed\n//   proc.env(\"HOME\", \"/\")                     an environment variable, or the second value if it is not set\nimport \"stdlib.h\"\nimport \"unistd.h\"\nimport \"time.h\"\n\n// run a command; its output goes to the screen. Gives its exit code.\nfn run(str command) -> int {\n    return shell(command)\n}\n\n// run a command and give what it printed. Fails, with its output as the message, if it exits with an error.\nfn output(str command) -> str! {\n    tmp := \"/tmp/finch_out_\" + str(getpid()) + \"_\" + str(int(time(null)))\n    code := shell(\"(\" + command + \") > '\" + tmp + \"' 2>&1\")\n    text := read_file(tmp) or \"\"\n    delete_file(tmp)\n    if code != 0 {\n        return error(\"'\" + command + \"' exited with code \" + str(code) + \": \" + text.trim())\n    }\n    return text\n}\n\nfn env(str name, str fallback) -> str {\n    v := getenv(name)\n    if v.len == 0 {\n        return fallback\n    }\n    return v\n}\n\nfn pid() -> int {\n    return int(getpid())\n}\n\n// the folder the program is running in\nfn cwd() -> str {\n    []char buf\n    for i in 0..4096 {\n        buf.push(char(0))\n    }\n    getcwd(buf.ptr, 4096)\n    return str(buf.ptr)\n}\n")
    list.push("// Programs, for Windows. The same functions as proc.fch (that file is for Linux and macOS).\nimport \"stdlib.h\"\nimport \"process.h\"\nimport \"direct.h\"\nimport \"time.h\"\n\nfn run(str command) -> int {\n    return shell(command)\n}\n\nfn output(str command) -> str! {\n    tmp := proc_env(\"TEMP\", \".\") + \"\\\\finch_out_\" + str(getpid()) + \"_\" + str(int(time(null)))\n    code := shell(command + \" > \\\"\" + tmp + \"\\\" 2>&1\")\n    text := read_file(tmp) or \"\"\n    delete_file(tmp)\n    if code != 0 {\n        return error(\"'\" + command + \"' exited with code \" + str(code) + \": \" + text.trim())\n    }\n    return text\n}\n\nfn proc_env(str name, str fallback) -> str {\n    v := getenv(name)\n    if v.len == 0 {\n        return fallback\n    }\n    return v\n}\n\nfn env(str name, str fallback) -> str {\n    return proc_env(name, fallback)\n}\n\nfn pid() -> int {\n    return int(getpid())\n}\n\nfn cwd() -> str {\n    []char buf\n    for i in 0..4096 {\n        buf.push(char(0))\n    }\n    getcwd(buf.ptr, 4096)\n    return str(buf.ptr)\n}\n")
    list.push("// Time: the clock, sleeping, and dates.\n//\n//   import time\n//   start := time.millis()          milliseconds from a clock that only goes forward (to measure with)\n//   time.sleep(250)                 wait a quarter of a second\n//   time.now()                      seconds since 1970-01-01 00:00 UTC\n//   d := time.date(time.now())      the parts: d.year, d.month, d.day, d.hour, d.minute, d.second\n//   time.format(time.now(), \"%Y-%m-%d %H:%M\")      as text, in the computer's time zone\nimport \"time.h\"\n\nstruct Date {\n    int year\n    int month       // 1 to 12\n    int day         // 1 to 31\n    int hour\n    int minute\n    int second\n    int weekday     // 0 is Sunday\n    int yearday     // 1 to 366\n}\n\n// seconds since 1970-01-01 00:00 UTC\nfn now() -> int {\n    return int(time(null))\n}\n\n// milliseconds on a clock that only goes forward: for measuring how long something took\nfn millis() -> int {\n    timespec ts\n    clock_gettime(CLOCK_MONOTONIC, addr(ts))\n    return int(ts.tv_sec) * 1000 + int(ts.tv_nsec) / 1000000\n}\n\nfn sleep(int ms) {\n    timespec ts\n    ts.tv_sec = ms / 1000\n    ts.tv_nsec = (ms % 1000) * 1000000\n    nanosleep(addr(ts), null)\n}\n\nfn parts(tm t) -> Date {\n    return Date(year: int(t.tm_year) + 1900, month: int(t.tm_mon) + 1, day: int(t.tm_mday), hour: int(t.tm_hour),\n                minute: int(t.tm_min), second: int(t.tm_sec), weekday: int(t.tm_wday), yearday: int(t.tm_yday) + 1)\n}\n\n// the date and time of a moment, in UTC\nfn date(int unix) -> Date {\n    tm t\n    i64 stamp = unix\n    gmtime_r(addr(stamp), addr(t))\n    return parts(t)\n}\n\n// the date and time of a moment, in the computer's time zone\nfn local(int unix) -> Date {\n    tm t\n    i64 stamp = unix\n    localtime_r(addr(stamp), addr(t))\n    return parts(t)\n}\n\n// a moment as text, in the computer's time zone: %Y year, %m month, %d day, %H hour, %M minute, %S second\n// (the rest of C's strftime works too: %A weekday name, %B month name, ...)\nfn format(int unix, str pattern) -> str {\n    tm t\n    i64 stamp = unix\n    localtime_r(addr(stamp), addr(t))\n    []char buf\n    for i in 0..256 {\n        buf.push(char(0))\n    }\n    strftime(buf.ptr, 256, pattern, addr(t))\n    return str(buf.ptr)\n}\n\n// the number of days in a month (month is 1 to 12)\nfn days_in_month(int year, int month) -> int {\n    if month == 2 {\n        if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) {\n            return 29\n        }\n        return 28\n    }\n    if month == 4 || month == 6 || month == 9 || month == 11 {\n        return 30\n    }\n    return 31\n}\n")
    list.push("// Time, for Windows. The same functions as time.fch (that file is for Linux and macOS).\nimport \"time.h\"\nimport \"finch_win.h\"\n\nstruct Date {\n    int year\n    int month       // 1 to 12\n    int day         // 1 to 31\n    int hour\n    int minute\n    int second\n    int weekday     // 0 is Sunday\n    int yearday     // 1 to 366\n}\n\nfn now() -> int {\n    return int(time(null))\n}\n\n// milliseconds on a clock that only goes forward (the performance counter: GetTickCount64 ticks every 15 ms)\nfn millis() -> int {\n    i64 count = 0\n    i64 freq = 1\n    QueryPerformanceFrequency(addr(freq))\n    QueryPerformanceCounter(addr(count))\n    return int(count / freq) * 1000 + int(count % freq) * 1000 / int(freq)\n}\n\nfn sleep(int ms) {\n    Sleep(u32(ms))\n}\n\nfn parts(tm t) -> Date {\n    return Date(year: int(t.tm_year) + 1900, month: int(t.tm_mon) + 1, day: int(t.tm_mday), hour: int(t.tm_hour),\n                minute: int(t.tm_min), second: int(t.tm_sec), weekday: int(t.tm_wday), yearday: int(t.tm_yday) + 1)\n}\n\nfn date(int unix) -> Date {\n    tm t\n    i64 stamp = unix\n    _gmtime64_s(addr(t), addr(stamp))\n    return parts(t)\n}\n\nfn local(int unix) -> Date {\n    tm t\n    i64 stamp = unix\n    _localtime64_s(addr(t), addr(stamp))\n    return parts(t)\n}\n\nfn format(int unix, str pattern) -> str {\n    tm t\n    i64 stamp = unix\n    _localtime64_s(addr(t), addr(stamp))\n    []char buf\n    for i in 0..256 {\n        buf.push(char(0))\n    }\n    strftime(buf.ptr, 256, pattern, addr(t))\n    return str(buf.ptr)\n}\n\nfn days_in_month(int year, int month) -> int {\n    if month == 2 {\n        if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) {\n            return 29\n        }\n        return 28\n    }\n    if month == 4 || month == 6 || month == 9 || month == 11 {\n        return 30\n    }\n    return 31\n}\n")
    list.push("/* The Windows functions std/time_windows.fch needs. Declared here, not by including <windows.h>:\n   libclang can't parse that header with MinGW's intrinsics. Both are in kernel32. */\nunsigned long long GetTickCount64(void);\nvoid Sleep(unsigned long milliseconds);\nint QueryPerformanceCounter(long long *count);\nint QueryPerformanceFrequency(long long *frequency);\n")
    return list
}