kit

common.c (24004B)

---

 /* Pure libc bits with no OS-specific behavior: the heap vtable, the
  * stderr diag sink, stdout/fd writers, and the small printf/errf/alloc
  * helpers that route through stdio + malloc. Compiled on every host. */
 
 #include <kit/profile.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "env_internal.h"
 
 /* ---------------- heap (libc-backed) ---------------- */
 
 /* Heap allocator metrics, reusing the KitProfiler counter machinery. The heap
  * is the process-wide allocation chokepoint (arenas and pools all bottom out
  * here), so it counts into the profiler pointed to by KitHeap.user — driver_env
  * wires that to a profiler when KIT_METRICS is set, leaving it NULL (one
  * branch, no work) otherwise. Counters live in the embedder-owned external id
  * range so the kit-core counter enum stays untouched; names are attached once
  * via kit_profiler_define_counter and read back by the generic counter dump.
  * The ~32 KiB threshold approximates an arena block (default block is 64 KiB),
  * the dominant large-allocation source. */
 enum {
   HEAP_C_ALLOCS = KIT_PROFILE_COUNTER_EXTERNAL_FIRST,
   HEAP_C_ALLOC_KIB,
   HEAP_C_LARGE_ALLOCS, /* >= 32 KiB, ~arena blocks */
   HEAP_C_REALLOCS,     /* grows (the only realloc kit issues) */
   HEAP_C_REALLOC_MOVES,
   HEAP_C_FREES,
 };
 
 static void driver_heap_metrics_define(KitProfiler* pr) {
   if (!pr) return;
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_ALLOCS,
                               "heap.allocs");
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_ALLOC_KIB,
                               "heap.alloc_kib");
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_LARGE_ALLOCS,
                               "heap.large_allocs");
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_REALLOCS,
                               "heap.reallocs");
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_REALLOC_MOVES,
                               "heap.realloc_moves");
   kit_profiler_define_counter(pr, (KitProfileCounter)HEAP_C_FREES,
                               "heap.frees");
 }
 
 /* Process-wide compile metrics, opt-in via KIT_METRICS. One KitProfiler backs
  * both the heap-allocator counters (wired through KitHeap.user, below) and the
  * libkit scope timers/counters (wired through DriverEnv.profiler ->
  * KitContext.profiler, so the metrics_scope and metrics_count calls the
  * optimizer, linker, and JIT already emit accumulate here). The heap is global,
  * so its
  * stats are too; this stays NULL/inert unless KIT_METRICS asks for it. */
 static KitProfiler* g_metrics_prof;
 static int g_metrics_inited;
 
 static void driver_metrics_dump(void) {
   KitProfiler* pr = g_metrics_prof;
   uint32_t id;
   if (!pr) return;
   fprintf(stderr, "kit metrics:\n");
   /* Scope timers first (raw host cycle-counter ticks + call count), in id order
    * so the compile pipeline reads top-to-bottom. Names resolve through the
    * kit-core scope table; unnamed scopes are skipped silently. */
   for (id = 1; id < KIT_PROFILE_ID_COUNT; ++id) {
     uint64_t count = kit_profiler_scope_count(pr, (KitProfileScope)id);
     uint64_t ticks = kit_profiler_scope_ticks(pr, (KitProfileScope)id);
     const char* name;
     if (!count) continue;
     name = kit_profiler_scope_name(pr, (KitProfileScope)id);
     if (!name) continue;
     fprintf(stderr, "  %s %llu ticks (%llu calls)\n", name,
             (unsigned long long)ticks, (unsigned long long)count);
   }
   /* Then every non-zero counter (heap.* in the external range, opt.* and link.*
    * in the kit range). */
   for (id = 1; id < KIT_PROFILE_ID_COUNT; ++id) {
     uint64_t value = kit_profiler_counter_value(pr, (KitProfileCounter)id);
     const char* name;
     if (!value) continue;
     name = kit_profiler_counter_name(pr, (KitProfileCounter)id);
     if (!name) continue;
     fprintf(stderr, "  %s=%llu\n", name, (unsigned long long)value);
   }
 }
 
 KitProfiler* driver_metrics_profiler(void) {
   const char* e;
   if (g_metrics_inited) return g_metrics_prof;
   g_metrics_inited = 1;
   e = getenv("KIT_METRICS");
   if (!(e && e[0] && e[0] != '0')) return NULL;
   /* Raw libc alloc (not through the vtable) so the profiler storage itself is
    * not counted and there is no reentrancy. */
   g_metrics_prof = (KitProfiler*)calloc(1, sizeof(*g_metrics_prof));
   if (!g_metrics_prof) return NULL;
   driver_heap_metrics_define(g_metrics_prof);
   /* Wire the heap counter sink unless something already claimed it. */
   if (!g_heap_libc.user) g_heap_libc.user = g_metrics_prof;
   atexit(driver_metrics_dump);
   return g_metrics_prof;
 }
 
 static void* heap_libc_alloc(KitHeap* h, size_t size, size_t align) {
   KitProfiler* pr;
   (void)align; /* malloc satisfies all max_align_t alignments */
   /* Lazily arm metrics for any allocation that precedes driver_env_init (the
    * usual arming site); idempotent and a single branch once inited. */
   if (!g_metrics_inited) (void)driver_metrics_profiler();
   pr = h ? (KitProfiler*)h->user : NULL;
   if (pr && size) {
     kit_profiler_count(pr, (KitProfileCounter)HEAP_C_ALLOCS, 1);
     kit_profiler_count(pr, (KitProfileCounter)HEAP_C_ALLOC_KIB, size >> 10);
     if (size >= 32u * 1024u)
       kit_profiler_count(pr, (KitProfileCounter)HEAP_C_LARGE_ALLOCS, 1);
   }
   return size ? malloc(size) : NULL;
 }
 
 static void* heap_libc_realloc(KitHeap* h, void* p, size_t old_size,
                                size_t new_size, size_t align) {
   KitProfiler* pr = h ? (KitProfiler*)h->user : NULL;
   void* np;
   (void)old_size;
   (void)align;
   if (pr) kit_profiler_count(pr, (KitProfileCounter)HEAP_C_REALLOCS, 1);
   np = realloc(p, new_size);
   if (pr && p && np && np != p)
     kit_profiler_count(pr, (KitProfileCounter)HEAP_C_REALLOC_MOVES, 1);
   return np;
 }
 
 static void heap_libc_free(KitHeap* h, void* p, size_t size) {
   KitProfiler* pr = h ? (KitProfiler*)h->user : NULL;
   (void)size;
   if (pr && p) kit_profiler_count(pr, (KitProfileCounter)HEAP_C_FREES, 1);
   free(p);
 }
 
 KitHeap g_heap_libc = {
     heap_libc_alloc,
     heap_libc_realloc,
     heap_libc_free,
     NULL,
 };
 
 /* ---------------- diag sink (stderr) ---------------- */
 
 static const char* diag_label(KitDiagKind k) {
   switch (k) {
     case KIT_DIAG_NOTE:
       return "note";
     case KIT_DIAG_WARN:
       return "warning";
     case KIT_DIAG_ERROR:
       return "error";
     case KIT_DIAG_FATAL:
       return "fatal";
   }
   return "diag";
 }
 
 /* The compiler currently driving libkit calls is stashed in the stderr sink's
  * `user` field so the sink can resolve loc.file_id to the source's spelling
  * (path or memory-input label). NULL falls back to the numeric `<file:%u>`
  * form. Held on the sink rather than in process-global state so the pointer
  * travels with the sink the emit callback is invoked on. */
 void driver_diag_set_compiler(KitCompiler* c) { g_diag_stderr.user = c; }
 
 KitStatus driver_compiler_new(const KitTarget* t, const KitContext* ctx,
                               KitCompiler** out) {
   KitCompiler* c = NULL;
   KitStatus st = kit_compiler_new(t, ctx, &c);
   if (st != KIT_OK) {
     if (out) *out = NULL;
     return st;
   }
   driver_diag_set_compiler(c);
   if (out) *out = c;
   return KIT_OK;
 }
 
 void driver_compiler_free(KitCompiler* c) {
   if (!c) return;
   if (g_diag_stderr.user == c) driver_diag_set_compiler(NULL);
   kit_compiler_free(c);
 }
 
 static void diag_stderr_emit(KitDiagSink* s, KitDiagKind k, KitSrcLoc loc,
                              const char* fmt, va_list ap) {
   KitCompiler* compiler = s ? (KitCompiler*)s->user : NULL;
   if (loc.file_id || loc.line) {
     KitSlice name = kit_compiler_file_name(compiler, loc.file_id);
     if (name.len) {
       fprintf(stderr, "%.*s:%u:%u: %.*s: ", KIT_SLICE_ARG(name), loc.line,
               loc.col, KIT_SLICE_ARG(kit_slice_cstr(diag_label(k))));
     } else {
       fprintf(stderr, "<file:%u>:%u:%u: %.*s: ", loc.file_id, loc.line, loc.col,
               KIT_SLICE_ARG(kit_slice_cstr(diag_label(k))));
     }
   } else {
     fprintf(stderr, "%.*s: ", KIT_SLICE_ARG(kit_slice_cstr(diag_label(k))));
   }
   vfprintf(stderr, fmt, ap);
   fputc('\n', stderr);
 }
 
 KitDiagSink g_diag_stderr = {
     diag_stderr_emit,
     NULL,
     0,
     0,
 };
 
 /* Driver-level post-compile diagnostic gate. The C frontend currently ignores
  * KitDiagnosticOptions, so the two warning policies are enforced here, over the
  * counts libkit maintains on the diag sink:
  *   -Werror      : a successful compile with any emitted warning becomes a
  *                  failure (the frontend kept compiling; we fail the tool).
  *   -fmax-errors : not yet honored mid-compile by the frontend, so rather than
  *                  silently accept it we emit a single explanatory note.
  * Returns nonzero when the run should be treated as failed. */
 int driver_diag_finish(DriverEnv* env, const char* tool,
                        int warnings_are_errors, uint32_t max_errors) {
   KitDiagSink* sink = env ? env->diag : NULL;
   uint32_t warnings = sink ? sink->warnings : 0u;
   if (max_errors) {
     driver_errf(tool,
                 "note: -fmax-errors is unimplemented; it does not bound the "
                 "error count");
   }
   if (warnings_are_errors && warnings) {
     driver_errf(tool, "%u warning%s treated as error%s (-Werror)", warnings,
                 warnings == 1u ? "" : "s", warnings == 1u ? "" : "s");
     return 1;
   }
   return 0;
 }
 
 /* ---------------- alloc helpers ---------------- */
 
 void* driver_alloc(DriverEnv* e, size_t n) {
   return e->heap->alloc(e->heap, n, _Alignof(max_align_t));
 }
 
 void* driver_alloc_zeroed(DriverEnv* e, size_t n) {
   void* p = driver_alloc(e, n);
   if (p) memset(p, 0, n);
   return p;
 }
 
 void driver_free(DriverEnv* e, void* p, size_t n) {
   if (p) e->heap->free(e->heap, p, n);
 }
 
 void driver_memcpy(void* dst, const void* src, size_t n) {
   memcpy(dst, src, n);
 }
 
 /* ---------------- file load/release (OS-neutral) ---------------- */
 
 /* Pure file_io vtable bookkeeping: no per-host behavior, so it lives here
  * rather than being duplicated in each env/<host>.c. */
 
 int driver_load_bytes(const KitFileIO* io, const char* tool, const char* path,
                       DriverLoad* out, KitSlice* in) {
   out->loaded = 0;
   out->fd.data = NULL;
   out->fd.size = 0;
   out->fd.token = NULL;
   if (!io || !io->read_all) {
     driver_errf(tool, "host file I/O unavailable");
     return 1;
   }
   if (io->read_all(io->user, path, &out->fd) != KIT_OK) {
     driver_errf(tool, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     return 1;
   }
   out->loaded = 1;
   in->data = out->fd.data;
   in->len = out->fd.size;
   return 0;
 }
 
 void driver_release_bytes(const KitFileIO* io, DriverLoad* lf) {
   if (!lf || !lf->loaded) return;
   if (io && io->release) io->release(io->user, &lf->fd);
   lf->loaded = 0;
 }
 
 /* ---------------- hosted dir lists ---------------- */
 
 int driver_hosted_dirs_add_inc(DriverHostedDirs* d, const char* dir) {
   return kit_os_hosted_dirs_add_inc(d, dir);
 }
 
 int driver_hosted_dirs_add_lib(DriverHostedDirs* d, const char* dir) {
   return kit_os_hosted_dirs_add_lib(d, dir);
 }
 
 int driver_hosted_dirs_add_inc_join(DriverHostedDirs* d, const char* base,
                                     const char* sub) {
   return kit_os_hosted_dirs_add_inc_join(d, base, sub);
 }
 
 int driver_hosted_dirs_add_lib_join(DriverHostedDirs* d, const char* base,
                                     const char* sub) {
   return kit_os_hosted_dirs_add_lib_join(d, base, sub);
 }
 
 void driver_hosted_dirs_fini(DriverHostedDirs* d) {
   kit_os_hosted_dirs_fini(d);
 }
 
 /* ---------------- string predicates ---------------- */
 
 /* The driver's only NUL-terminated-string handling: thin boundary shims
  * that route every length scan through kit_slice_cstr and otherwise use
  * the length-based mem* primitives. No libc str* is used. */
 
 int driver_streq(const char* a, const char* b) {
   return kit_slice_eq(kit_slice_cstr(a), kit_slice_cstr(b));
 }
 
 int driver_strneq(const char* a, const char* b, size_t n) {
   size_t i;
   for (i = 0; i < n; ++i) {
     unsigned char ca = (unsigned char)a[i], cb = (unsigned char)b[i];
     if (ca != cb) return 0;
     if (ca == '\0') return 1;
   }
   return 1;
 }
 
 size_t driver_strlen(const char* s) { return kit_slice_cstr(s).len; }
 
 const char* driver_strchr(const char* s, int c) {
   /* search includes the terminator so driver_strchr(s, 0) works like strchr */
   return (const char*)memchr(s, c, kit_slice_cstr(s).len + 1u);
 }
 
 const char* driver_basename(const char* path) {
   size_t i = kit_slice_cstr(path).len;
   while (i > 0) {
     /* Accept both separators so a Windows argv[0] like "C:\\bin\\kit.exe"
      * strips to its basename rather than returning the full path. */
     if (path[i - 1] == '/' || path[i - 1] == '\\') return path + i;
     --i;
   }
   return path;
 }
 
 int driver_has_suffix(const char* s, const char* suffix) {
   size_t ls = kit_slice_cstr(s).len;
   size_t lf = kit_slice_cstr(suffix).len;
   return ls >= lf && memcmp(s + ls - lf, suffix, lf) == 0;
 }
 
 /* ---------------- scalar parsing helpers ---------------- */
 
 int driver_hex_nibble(char c) {
   if (c >= '0' && c <= '9') return c - '0';
   if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
   if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
   return -1;
 }
 
 uint64_t driver_epoch_from_env(void) {
   const char* s = driver_getenv("SOURCE_DATE_EPOCH");
   uint64_t v = 0;
   if (!s || !*s) return 0;
   for (; *s; ++s) {
     if (*s < '0' || *s > '9') return 0;
     v = v * 10 + (uint64_t)(*s - '0');
   }
   return v;
 }
 
 int driver_parse_u64(const char* s, uint64_t* out) {
   uint64_t v = 0;
   int base = 10;
   if (!s || !*s) return 1;
   if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
     base = 16;
     s += 2;
     if (!*s) return 1;
   }
   for (; *s; ++s) {
     int d = driver_hex_nibble(*s);
     if (d < 0 || d >= base) return 1;
     if (v > (UINT64_MAX - (uint64_t)d) / (uint64_t)base) return 1;
     v = v * (uint64_t)base + (uint64_t)d;
   }
   *out = v;
   return 0;
 }
 
 static uint16_t driver_edit_distance(const char* a, size_t an, const char* b,
                                      size_t bn) {
   uint16_t prev[65];
   uint16_t curr[65];
   size_t i, j;
   for (j = 0; j <= bn; ++j) prev[j] = (uint16_t)j;
   for (i = 1; i <= an; ++i) {
     curr[0] = (uint16_t)i;
     for (j = 1; j <= bn; ++j) {
       uint16_t del = (uint16_t)(prev[j] + 1u);
       uint16_t ins = (uint16_t)(curr[j - 1u] + 1u);
       uint16_t sub = (uint16_t)(prev[j - 1u] + (a[i - 1u] != b[j - 1u]));
       uint16_t best = del < ins ? del : ins;
       if (sub < best) best = sub;
       curr[j] = best;
     }
     for (j = 0; j <= bn; ++j) prev[j] = curr[j];
   }
   return prev[bn];
 }
 
 size_t driver_suggest_values(const char* input, const char* const* candidates,
                              size_t candidate_count, DriverSuggestion* out,
                              size_t out_cap) {
   size_t input_len, i, count = 0;
   if (!input || !candidates || !out || out_cap == 0) return 0;
   input_len = driver_strlen(input);
   if (input_len == 0 || input_len > 64) return 0;
   for (i = 0; i < candidate_count; ++i) {
     const char* candidate = candidates[i];
     size_t candidate_len, max_len, pos;
     uint16_t distance, threshold;
     if (!candidate) continue;
     candidate_len = driver_strlen(candidate);
     if (candidate_len == 0 || candidate_len > 64) continue;
     distance = driver_edit_distance(input, input_len, candidate, candidate_len);
     if (distance == 0) continue;
     max_len = input_len > candidate_len ? input_len : candidate_len;
     threshold = (uint16_t)(max_len <= 2 ? 1 : (max_len <= 8 ? 2 : 3));
     if (distance > threshold) continue;
 
     pos = 0;
     while (pos < count && out[pos].distance <= distance) ++pos;
     if (pos >= out_cap) continue;
     if (count < out_cap) ++count;
     for (size_t move = count - 1u; move > pos; --move) out[move] = out[move - 1u];
     out[pos].value = candidate;
     out[pos].distance = distance;
   }
   return count;
 }
 
 char* driver_path_join(DriverEnv* env, const char* a, const char* b,
                        size_t* out_size) {
   size_t al = a ? driver_strlen(a) : 0u;
   size_t bl = b ? driver_strlen(b) : 0u;
   /* Insert a '/' only when there is a `b` to separate from `a` and `a` does
    * not already end in a separator -- a NULL/empty `b` yields a plain copy of
    * `a` with no trailing slash. */
   size_t slash =
       (bl && al > 0 && a[al - 1u] != '/' && a[al - 1u] != '\\') ? 1u : 0u;
   size_t bytes = al + slash + bl + 1u;
   char* out = (char*)driver_alloc(env, bytes);
   size_t off = 0;
   if (!out) return NULL;
   if (al) {
     driver_memcpy(out, a, al);
     off = al;
   }
   if (slash) out[off++] = '/';
   if (bl) {
     driver_memcpy(out + off, b, bl);
     off += bl;
   }
   out[off] = '\0';
   if (out_size) *out_size = bytes;
   return out;
 }
 
 /* ---------------- printf/errf/logf ---------------- */
 
 void driver_errf(const char* tool, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   driver_verrf(tool, fmt, ap);
   va_end(ap);
 }
 
 void driver_verrf(const char* tool, const char* fmt, va_list ap) {
   fprintf(stderr, "%.*s: ", KIT_SLICE_ARG(kit_slice_cstr(tool)));
   vfprintf(stderr, fmt, ap);
   fputc('\n', stderr);
 }
 
 void driver_logf(const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   va_end(ap);
   fputc('\n', stderr);
 }
 
 void kit_debug_printf(const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   va_end(ap);
 }
 
 const char* kit_debug_getenv(const char* name) { return getenv(name); }
 
 /* ---------------- tracing (KIT_TRACE) ---------------- */
 
 /* Hosted side of the kit/trace.h seam: parse KIT_TRACE once, cache it, and
  * answer kit_trace_enabled / format kit_trace_emit. The config is immutable
  * after the first read, so the lazy init is intentionally lock-free --
  * concurrent first-callers re-parse identical data into the same cache, which
  * is idempotent. Tracing is diagnostic-only and never affects compiler
  * output, so this process-scoped state is the one place trace state lives. */
 
 #define TRACE_MAX_SPECS 32
 #define TRACE_BUF_CAP 512
 
 typedef struct TraceSpec {
   const char* module; /* substring matched against the trace point's module */
   int level;          /* threshold 1..5 (KitTraceLevel) */
 } TraceSpec;
 
 static struct {
   int parsed;
   int global_level; /* threshold for modules with no matching spec; 0 = off */
   int nspecs;
   TraceSpec specs[TRACE_MAX_SPECS];
   char buf[TRACE_BUF_CAP]; /* owns the tokenized copy the specs point into */
 } g_trace;
 
 static int trace_level_from_name(const char* s, size_t n) {
   if (n == 5 && memcmp(s, "error", 5) == 0) return KIT_TRACE_ERROR;
   if (n == 4 && memcmp(s, "warn", 4) == 0) return KIT_TRACE_WARN;
   if (n == 7 && memcmp(s, "warning", 7) == 0) return KIT_TRACE_WARN;
   if (n == 4 && memcmp(s, "info", 4) == 0) return KIT_TRACE_INFO;
   if (n == 5 && memcmp(s, "debug", 5) == 0) return KIT_TRACE_DEBUG;
   if (n == 5 && memcmp(s, "trace", 5) == 0) return KIT_TRACE_TRACE;
   return 0;
 }
 
 /* "1" / "*" / "all" are spellings of "everything, max verbosity". */
 static int trace_is_all(const char* s, size_t n) {
   return (n == 1 && (s[0] == '1' || s[0] == '*')) ||
          (n == 3 && memcmp(s, "all", 3) == 0);
 }
 
 static void trace_raise_global(int lvl) {
   if (lvl > g_trace.global_level) g_trace.global_level = lvl;
 }
 
 static void trace_add_module(const char* module, int lvl) {
   if (g_trace.nspecs >= TRACE_MAX_SPECS) return;
   g_trace.specs[g_trace.nspecs].module = module;
   g_trace.specs[g_trace.nspecs].level = lvl;
   g_trace.nspecs++;
 }
 
 static void trace_parse(void) {
   const char* env = getenv("KIT_TRACE");
   size_t len, i, start;
 
   g_trace.parsed = 1;
   g_trace.global_level = 0;
   g_trace.nspecs = 0;
   if (!env || !env[0]) return;
 
   len = strlen(env);
   if (len >= TRACE_BUF_CAP) len = TRACE_BUF_CAP - 1;
   memcpy(g_trace.buf, env, len);
   g_trace.buf[len] = '\0';
 
   /* Split on ',' in place; each token is "[module=]level" or a bare token. */
   start = 0;
   for (i = 0; i <= len; ++i) {
     char* tok;
     size_t tlen;
     char* eq;
     if (i != len && g_trace.buf[i] != ',') continue;
     g_trace.buf[i] = '\0';
     tok = &g_trace.buf[start];
     tlen = i - start;
     start = i + 1;
     if (tlen == 0) continue;
 
     eq = memchr(tok, '=', tlen);
     if (eq) {
       size_t mlen = (size_t)(eq - tok);
       const char* lvls = eq + 1;
       size_t llen = tlen - mlen - 1;
       int lvl = trace_level_from_name(lvls, llen);
       if (lvl == 0 && trace_is_all(lvls, llen)) lvl = KIT_TRACE_TRACE;
       if (lvl == 0) continue; /* unknown level name: ignore the spec */
       *eq = '\0';             /* terminate the module substring in place */
       if (mlen == 0)
         trace_raise_global(lvl);
       else
         trace_add_module(tok, lvl);
     } else {
       int lvl = trace_level_from_name(tok, tlen);
       if (trace_is_all(tok, tlen)) lvl = KIT_TRACE_TRACE;
       if (lvl != 0)
         trace_raise_global(lvl); /* bare level => default for all modules */
       else
         trace_add_module(tok, KIT_TRACE_TRACE); /* bare module => at TRACE */
     }
   }
 }
 
 int kit_trace_enabled(const char* module, int level) {
   int threshold, i;
   if (!g_trace.parsed) trace_parse();
   threshold = g_trace.global_level;
   if (module) {
     /* Most-verbose matching module spec wins, falling back to the global. */
     for (i = 0; i < g_trace.nspecs; ++i)
       if (g_trace.specs[i].level > threshold &&
           strstr(module, g_trace.specs[i].module) != NULL)
         threshold = g_trace.specs[i].level;
   }
   return threshold > 0 && level <= threshold;
 }
 
 static char trace_level_char(int level) {
   switch (level) {
     case KIT_TRACE_ERROR:
       return 'E';
     case KIT_TRACE_WARN:
       return 'W';
     case KIT_TRACE_INFO:
       return 'I';
     case KIT_TRACE_DEBUG:
       return 'D';
     case KIT_TRACE_TRACE:
       return 'T';
     default:
       return '?';
   }
 }
 
 void kit_trace_emit(const char* module, int level, const char* file, int line,
                     const char* fmt, ...) {
   va_list ap;
   char lc = trace_level_char(level);
   if (!file) file = "?";
   /* Show the module tag unless it is just the source path (the default). */
   if (module && strcmp(module, file) != 0)
     fprintf(stderr, "[%c][%s] %s:%d: ", lc, module, file, line);
   else
     fprintf(stderr, "[%c] %s:%d: ", lc, file, line);
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   va_end(ap);
   fputc('\n', stderr);
 }
 
 void driver_printf(const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   vprintf(fmt, ap);
   va_end(ap);
 }
 
 void driver_flush_stdout(void) { fflush(stdout); }
 
 const char* driver_getenv(const char* name) { return getenv(name); }
 
 int driver_line_completion_add(DriverLineCompletionList* l, const char* text,
                                size_t len) {
   DriverLineCompletion* ni;
   char* copy;
   uint32_t nc;
   size_t old_size;
   size_t new_size;
   if (!l || !l->env || !text) return 1;
   if (l->count == l->cap) {
     nc = l->cap ? l->cap * 2u : 16u;
     old_size = (size_t)l->cap * sizeof(*l->items);
     new_size = (size_t)nc * sizeof(*l->items);
     ni = (DriverLineCompletion*)l->env->heap->realloc(
         l->env->heap, l->items, old_size, new_size,
         _Alignof(DriverLineCompletion));
     if (!ni) return 1;
     l->items = ni;
     l->cap = nc;
   }
   copy = (char*)driver_alloc(l->env, len + 1u);
   if (!copy) return 1;
   driver_memcpy(copy, text, len);
   copy[len] = '\0';
   l->items[l->count].text = copy;
   l->items[l->count].size = len + 1u;
   l->count++;
   return 0;
 }
 
 void driver_line_history_fini(DriverEnv* env, DriverLineHistory* h) {
   uint32_t i;
   if (!env || !h) return;
   for (i = 0; i < h->count; ++i) {
     if (h->items && h->items[i]) driver_free(env, h->items[i], h->sizes[i]);
   }
   if (h->items) driver_free(env, h->items, (size_t)h->cap * sizeof(*h->items));
   if (h->sizes) driver_free(env, h->sizes, (size_t)h->cap * sizeof(*h->sizes));
   {
     DriverLineHistory z = {0};
     *h = z;
   }
 }