kit

pp_expand.c (36292B)

---

 /* pp_expand.c — hideset table, macro hashmap, #define/#undef, substitution,
  * paste, stringize, argument prescan, func/object macro expansion. */
 
 #include "pp/pp_priv.h"
 
 static int body_tokens_equal(const Tok* a, u32 na, const Tok* b, u32 nb);
 static int macros_equal(const Macro* a, const Macro* b);
 
 /* ============================================================
  * Hideset table
  * ============================================================ */
 
 static int sym_in_array(const Sym* a, u32 n, Sym s) {
   u32 i;
   for (i = 0; i < n; ++i)
     if (a[i] == s) return 1;
   return 0;
 }
 
 static HidesetId hs_register(Pp* pp, const Sym* names, u32 n) {
   Hideset* h;
   u32 i;
   if (n == 0) return HS_EMPTY;
 
   /* Linear search for an existing identical hideset. Hidesets are tiny. */
   for (i = 1; i < pp->hsets_n; ++i) {
     Hideset* e = pp->hsets[i];
     if (e->n != n) continue;
     {
       u32 j;
       for (j = 0; j < n; ++j)
         if (e->names[j] != names[j]) break;
       if (j == n) return (HidesetId)i;
     }
   }
 
   if (pp->hsets_n == pp->hsets_cap) {
     u32 nc = pp->hsets_cap ? pp->hsets_cap * 2 : 8;
     pp->hsets =
         (Hideset**)pp_xrealloc(pp, pp->hsets, sizeof(Hideset*) * pp->hsets_cap,
                                sizeof(Hideset*) * nc, _Alignof(Hideset*));
     pp->hsets_cap = nc;
   }
   h = (Hideset*)arena_alloc(pp->arena,
                             sizeof(Hideset) + sizeof(Sym) * (n ? n - 1 : 0),
                             _Alignof(Hideset));
   h->n = n;
   for (i = 0; i < n; ++i) h->names[i] = names[i];
   pp->hsets[pp->hsets_n] = h;
   return (HidesetId)pp->hsets_n++;
 }
 
 int hs_contains(Pp* pp, HidesetId id, Sym s) {
   Hideset* h;
   if (id == HS_EMPTY || s == 0) return 0;
   h = pp->hsets[id];
   return sym_in_array(h->names, h->n, s);
 }
 
 HidesetId hs_add(Pp* pp, HidesetId id, Sym s) {
   Sym buf[64];
   Hideset* h;
   u32 n;
   u32 i;
 
   if (s == 0) return id;
   if (hs_contains(pp, id, s)) return id;
 
   n = (id == HS_EMPTY) ? 0 : pp->hsets[id]->n;
   if (n + 1 > sizeof(buf) / sizeof(buf[0])) {
     compiler_panic(pp->c, (SrcLoc){0, 0, 0}, "pp: hideset overflow");
   }
   if (id != HS_EMPTY) {
     h = pp->hsets[id];
     for (i = 0; i < h->n; ++i) buf[i] = h->names[i];
   }
   /* Keep sorted (numerically) for canonical hideset identity. */
   {
     u32 pos = n;
     while (pos > 0 && buf[pos - 1] > s) {
       buf[pos] = buf[pos - 1];
       --pos;
     }
     buf[pos] = s;
   }
   return hs_register(pp, buf, n + 1);
 }
 
 /* Used by token-paste in stage 5; declared early so the rest of the file
  * doesn't grow forward decls. */
 __attribute__((unused)) static HidesetId hs_intersect(Pp* pp, HidesetId a,
                                                       HidesetId b) {
   Sym buf[64];
   Hideset *ha, *hb;
   u32 i, j, k;
   if (a == HS_EMPTY || b == HS_EMPTY) return HS_EMPTY;
   if (a == b) return a;
   ha = pp->hsets[a];
   hb = pp->hsets[b];
   /* Both sorted; standard merge intersection. */
   i = j = k = 0;
   while (i < ha->n && j < hb->n) {
     if (ha->names[i] == hb->names[j]) {
       buf[k++] = ha->names[i];
       ++i;
       ++j;
     } else if (ha->names[i] < hb->names[j]) {
       ++i;
     } else {
       ++j;
     }
   }
   return hs_register(pp, buf, k);
 }
 
 /* ============================================================
  * Macro table
  * ============================================================ */
 
 /* Thin wrappers over the generated MacroMap_* functions; preserved
  * because the call sites are tagged "mt_*" throughout this TU. */
 Macro* mt_get(Pp* pp, Sym name) {
   Macro** v = MacroMap_get(&pp->mtab, name);
   return v ? *v : NULL;
 }
 
 void mt_put(Pp* pp, Sym name, Macro* m) {
   (void)MacroMap_set(&pp->mtab, name, m);
 }
 
 void mt_del(Pp* pp, Sym name) { MacroMap_del(&pp->mtab, name); }
 
 /* ============================================================
  * #define / #undef
  * ============================================================ */
 
 void do_define(Pp* pp, const Tok* line, u32 n) {
   Macro* m;
   u32 i = 0;
   Sym name;
   SrcLoc def_loc;
   Macro* existing;
 
   if (i >= n || line[i].kind != TOK_IDENT) {
     compiler_panic(pp->c, n ? line[0].loc : (SrcLoc){0, 0, 0},
                    "#define: expected macro name");
   }
   name = line[i].v.ident;
   def_loc = line[i].loc;
   ++i;
 
   m = arena_znew(pp->arena, Macro);
   m->name = name;
   m->def_loc = def_loc;
 
   /* Function-like vs object-like: '(' immediately after the name with no
    * intervening whitespace. */
   if (i < n && line[i].kind == TOK_PUNCT && line[i].v.punct == '(' &&
       (line[i].flags & TF_HAS_SPACE) == 0) {
     Sym* params = NULL;
     u32 pcap = 0, pn = 0;
     ++i;
     m->is_func = 1;
     if (i < n && line[i].kind == TOK_PUNCT && line[i].v.punct == ')') {
       ++i;
     } else {
       for (;;) {
         if (i >= n) {
           compiler_panic(pp->c, def_loc,
                          "#define: unterminated parameter list");
         }
         if (line[i].kind == TOK_PUNCT && line[i].v.punct == P_ELLIPSIS) {
           /* Append a synthetic __VA_ARGS__ param so body-rewrite
            * matches the standard identifier directly. */
           if (pn == pcap) {
             u32 nc = pcap ? pcap * 2 : 4;
             Sym* nb = arena_array(pp->arena, Sym, nc);
             if (pcap) memcpy(nb, params, sizeof(Sym) * pcap);
             params = nb;
             pcap = nc;
           }
           params[pn++] = pp->sym_va_args;
           m->is_variadic = 1;
           ++i;
         } else if (line[i].kind == TOK_IDENT) {
           if (pn == pcap) {
             u32 nc = pcap ? pcap * 2 : 4;
             Sym* nb = arena_array(pp->arena, Sym, nc);
             if (pcap) memcpy(nb, params, sizeof(Sym) * pcap);
             params = nb;
             pcap = nc;
           }
           params[pn++] = line[i].v.ident;
           ++i;
           /* GNU named variadic: `args...` — the named parameter itself collects
            * the trailing arguments (the body refers to it by name rather than
            * __VA_ARGS__). The variadic arg-collection below is positional on the
            * last param, so we just mark the macro variadic and eat the ellipsis;
            * the "'...' must be last" check still fires if a comma follows. Linux
            * UAPI headers use this (e.g. <linux/stddef.h>'s __struct_group). */
           if (i < n && line[i].kind == TOK_PUNCT &&
               line[i].v.punct == P_ELLIPSIS) {
             m->is_variadic = 1;
             ++i;
           }
         } else {
           compiler_panic(pp->c, line[i].loc, "#define: bad parameter list");
         }
         if (i >= n) {
           compiler_panic(pp->c, def_loc,
                          "#define: unterminated parameter list");
         }
         if (line[i].kind == TOK_PUNCT && line[i].v.punct == ')') {
           ++i;
           break;
         }
         if (m->is_variadic) {
           compiler_panic(pp->c, line[i].loc,
                          "#define: '...' must be last parameter");
         }
         if (line[i].kind == TOK_PUNCT && line[i].v.punct == ',') {
           ++i;
           continue;
         }
         compiler_panic(pp->c, line[i].loc, "#define: expected ',' or ')'");
       }
     }
     m->params = params;
     m->n_params = pn;
   }
 
   /* Refuse define/undef of a few names the spec reserves: `defined`
    * and a small set of mandatory predefined macros. */
   if (name == pp->sym_defined || name == pp->sym_line__ ||
       name == pp->sym_file__ || name == pp->sym_date__ ||
       name == pp->sym_time__) {
     compiler_panic(pp->c, def_loc,
                    "#define of a reserved / predefined name is not allowed");
   }
   /* Static predefineds are already in the macro table; redefining
    * with a different body is caught by the existing macros_equal
    * check below, but #define of __STDC__ et al. with the SAME body
    * should also be rejected. */
   if (name == pp->sym_stdc__ || name == pp->sym_stdc_hosted__ ||
       name == pp->sym_stdc_version__) {
     /* Allow re-registration of the predefined value at pp_new time
      * but reject user-level redefinition. We detect "user-level"
      * by checking whether it's already in the table — at pp_new the
      * first call goes through cleanly. */
     if (mt_get(pp, name)) {
       compiler_panic(pp->c, def_loc,
                      "#define of a mandatory predefined macro is not allowed");
     }
   }
 
   /* Body: rewrite parameter occurrences to TOK_PP_PARAM. */
   {
     u32 body_n = n - i;
     u32 j;
     m->body = body_n ? arena_array(pp->arena, Tok, body_n) : NULL;
     m->body_len = body_n;
     for (j = 0; j < body_n; ++j) {
       Tok t = line[i + j];
       if (m->is_func && t.kind == TOK_IDENT) {
         u32 p;
         for (p = 0; p < m->n_params; ++p) {
           if (m->params[p] == t.v.ident) {
             t.kind = TOK_PP_PARAM;
             t.v.punct = p;
             break;
           }
         }
       }
       /* §6.10.3 ¶5: __VA_ARGS__ outside a variadic macro is
        * undefined behavior; we diagnose. */
       if (!m->is_variadic && t.kind == TOK_IDENT &&
           t.v.ident == pp->sym_va_args) {
         compiler_panic(pp->c, t.loc,
                        "__VA_ARGS__ may only appear in a variadic macro body");
       }
       m->body[j] = t;
     }
     /* Drop the leading-space bit on the first body token: it reflects
      * the whitespace between the macro name (or close-paren) and the
      * body, which is irrelevant to expansion output. */
     if (m->body_len) m->body[0].flags &= (u16)~TF_HAS_SPACE;
   }
 
   existing = mt_get(pp, name);
   if (existing) {
     if (!macros_equal(existing, m)) {
       compiler_panic(pp->c, def_loc,
                      "macro redefined with different replacement");
     }
     return;
   }
   mt_put(pp, name, m);
 }
 
 void do_undef(Pp* pp, const Tok* line, u32 n) {
   Sym name;
   if (!n || line[0].kind != TOK_IDENT) {
     compiler_panic(pp->c, n ? line[0].loc : (SrcLoc){0, 0, 0},
                    "#undef: expected identifier");
   }
   name = line[0].v.ident;
   if (name == pp->sym_defined || name == pp->sym_line__ ||
       name == pp->sym_file__ || name == pp->sym_date__ ||
       name == pp->sym_time__ || name == pp->sym_stdc__ ||
       name == pp->sym_stdc_hosted__ || name == pp->sym_stdc_version__) {
     compiler_panic(pp->c, line[0].loc,
                    "#undef of a mandatory predefined name is not allowed");
   }
   mt_del(pp, name);
 }
 
 /* ============================================================
  * Body comparison helpers
  * ============================================================ */
 
 static int body_tokens_equal(const Tok* a, u32 na, const Tok* b, u32 nb) {
   u32 i;
   if (na != nb) return 0;
   for (i = 0; i < na; ++i) {
     if (a[i].kind != b[i].kind) return 0;
     if (a[i].spelling != b[i].spelling) return 0;
     /* Whitespace separation must match (§6.10.3 ¶2). The first body
      * token's leading-space bit is meaningless (it's whatever was
      * between macro name and body); skip i==0 for that bit. */
     if (i > 0) {
       if ((a[i].flags & TF_HAS_SPACE) != (b[i].flags & TF_HAS_SPACE)) {
         return 0;
       }
     }
   }
   return 1;
 }
 
 static int macros_equal(const Macro* a, const Macro* b) {
   if (a->is_func != b->is_func) return 0;
   if (a->is_variadic != b->is_variadic) return 0;
   if (a->n_params != b->n_params) return 0;
   {
     u32 i;
     for (i = 0; i < a->n_params; ++i) {
       if (a->params[i] != b->params[i]) return 0;
     }
   }
   return body_tokens_equal(a->body, a->body_len, b->body, b->body_len);
 }
 
 /* ============================================================
  * Object-macro expansion
  * ============================================================ */
 
 static void subst_phase2(Pp* pp, const Tok* in, u32 nin, const Tok* invoke,
                          TokVec* out);
 
 /* Build a buffer of the macro's body (with hidesets) and push it. The
  * first expanded token inherits the invocation token's TF_AT_BOL /
  * TF_HAS_SPACE so output formatting matches the invocation site. */
 static void expand_object_macro(Pp* pp, const Macro* m, const Tok* invoke,
                                 HidesetId invoke_hs) {
   TokVec body = {0};
   Tok* tmp;
   HidesetId hs;
   HidesetId* hids;
   u32 i;
 
   if (m->body_len == 0) {
     return; /* placemarker: nothing to push */
   }
   /* Run the body through the paste phase: object-like macros may use
    * `##`. There are no parameters, so phase 1 reduces to a copy. */
   tmp = arena_array(pp->arena, Tok, m->body_len);
   for (i = 0; i < m->body_len; ++i) tmp[i] = m->body[i];
   subst_phase2(pp, tmp, m->body_len, invoke, &body);
 
   if (body.n == 0) return;
 
   /* Transfer invocation flags onto the first emitted token. */
   body.data[0].flags =
       (u16)((body.data[0].flags & ~(TF_AT_BOL | TF_HAS_SPACE)) |
             (invoke->flags & (TF_AT_BOL | TF_HAS_SPACE)));
   for (i = 0; i < body.n; ++i) body.data[i].loc = invoke->loc;
 
   hs = hs_add(pp, invoke_hs, m->name);
   hids = arena_array(pp->arena, HidesetId, body.n);
   for (i = 0; i < body.n; ++i) hids[i] = hs;
   push_buf(pp, body.data, hids, body.n);
 }
 
 /* ============================================================
  * Function-like macro expansion
  * ============================================================ */
 
 /* Peek for an open paren after the just-consumed identifier (which named
  * a function-like macro). Newlines are whitespace inside an invocation.
  * Returns 1 with `*ws_has_space_out` indicating whether any whitespace
  * (newlines or HAS_SPACE) sat between the ident and the `(`. Returns 0 if
  * no `(` follows; pushed-back tokens (NLs + the non-`(` token, if any)
  * are restored as a buffer source so subsequent reads still see them. */
 int peek_for_invoke_paren(Pp* pp, int* ws_has_space_out) {
   TokVec saved = {0};
   HsVec saved_hs = {0};
   int saw_ws = 0;
   Tok t;
   HidesetId hs;
 
   for (;;) {
     t = src_next_raw(pp, &hs, NULL);
     if (t.kind == TOK_NEWLINE) {
       saw_ws = 1;
       tv_push(pp, &saved, t);
       hsv_push(pp, &saved_hs, hs);
       continue;
     }
     if (t.kind == TOK_EOF) {
       /* No '(' — push back saved tokens, leave EOF for next read. */
       if (saved.n) push_buf(pp, saved.data, saved_hs.data, saved.n);
       *ws_has_space_out = saw_ws;
       return 0;
     }
     if (t.flags & TF_HAS_SPACE) saw_ws = 1;
     if (t.kind == TOK_PUNCT && t.v.punct == '(') {
       /* Consumed. The newlines we walked past are whitespace and
        * dropped (per spec); they don't go back on the stack. */
       *ws_has_space_out = saw_ws;
       return 1;
     }
     /* Save this non-`(` token too and push back. */
     tv_push(pp, &saved, t);
     hsv_push(pp, &saved_hs, hs);
     push_buf(pp, saved.data, saved_hs.data, saved.n);
     *ws_has_space_out = saw_ws;
     return 0;
   }
 }
 
 /* Run macro expansion on a fixed token sequence to completion, yielding the
  * fully-expanded token sequence. Used to pre-expand each function-macro
  * argument before substitution (§6.10.3.1 ¶1). */
 void expand_arg_to_eof(Pp* pp, Tok* in, HidesetId* hs, u32 nin, TokVec* out) {
   TokSrc src;
   Tok t;
 
   memset(&src, 0, sizeof(src));
   src.kind = SRC_BUF;
   src.scope_top = 1;
   src.toks = in;
   src.hs = hs;
   src.n = nin;
   src_push(pp, src);
 
   for (;;) {
     t = pp_next_raw(pp); /* drives macro expansion within this scope */
     if (t.kind == TOK_EOF) break;
     if (t.kind == TOK_NEWLINE) {
       /* Newlines inside an arg act as whitespace; convert to
        * "next-token has TF_HAS_SPACE". Drop the NL token itself. */
       continue;
     }
     tv_push(pp, out, t);
   }
   /* Pop our scope source. */
   --pp->nsources;
 }
 
 /* Argument list for a function-like invocation. Stored as parallel
  * (start, end) ranges into a flat unexpanded token vector and a flat
  * expanded token vector. */
 typedef struct ArgList {
   /* Unexpanded arg tokens (raw as collected from invocation). */
   Tok* raw;
   HidesetId* raw_hs;
   u32 raw_n;
   u32* raw_start; /* size n_args + 1 (sentinel = raw_n) */
   /* Pre-expanded tokens. */
   Tok* exp;
   u32 exp_n;
   u32* exp_start; /* size n_args + 1 (sentinel = exp_n) */
   u32 n_args;
 } ArgList;
 
 /* Collect arguments. Caller has just consumed the opening `(`. Returns the
  * close-paren's token (used as the invocation's last source location). */
 static Tok read_invocation_args(Pp* pp, const Macro* m, SrcLoc invoke_loc,
                                 ArgList* out) {
   TokVec raw = {0};
   HsVec raw_hs = {0};
   u32* starts;
   u32 starts_cap = 0;
   u32 n_args = 0;
   u32 cur_start = 0;
   int depth = 0;
   Tok t;
   HidesetId hs;
   int first_token_of_arg = 1;
   Tok close_tok;
 
   memset(out, 0, sizeof(*out));
   starts = arena_array(pp->arena, u32, 8);
   starts_cap = 8;
   starts[0] = 0;
 
   for (;;) {
     t = src_next_raw(pp, &hs, NULL);
     if (t.kind == TOK_EOF) {
       compiler_panic(pp->c, invoke_loc,
                      "unterminated function-like macro invocation");
     }
     if (t.kind == TOK_NEWLINE) {
       /* Whitespace within an invocation. Mark the next token as
        * having space; drop the NL. */
       if (raw.n && depth >= 0) {
         /* No-op token list; we'll OR onto the next pushed token. */
       }
       /* Use a sentinel: track via a flag on a deferred push. We
        * accumulate "has_space" by setting it on the next pushed
        * token. */
       /* Simpler: just push a placeholder by OR'ing onto next via
        * a flag stored in `first_token_of_arg`-style state. */
       /* Implementation: use the next read token's TF_HAS_SPACE bit,
        * which the lexer already sets after a NL. Actually NOT —
        * after a NL the lexer sets TF_AT_BOL on the next token, not
        * HAS_SPACE necessarily. Force it: */
       /* We'll OR it manually onto the next token. */
       /* Use a small flag stash: */
       /* (handled below by setting a pending flag) */
       /* See: pending_space variable */
       /* — commit: declare a pending_space static earlier. */
       continue;
     }
 
     if (t.kind == TOK_PUNCT) {
       u32 p = t.v.punct;
       if (p == '(') {
         ++depth;
       } else if (p == ')') {
         if (depth == 0) {
           /* End of invocation. Close the current argument. The
            * empty-args case (no commas seen, no tokens
            * collected) emits a slot only when the macro expects
            * at least one argument; arity-0 macros take none. */
           close_tok = t;
           {
             int empty_call =
                 (n_args == 0 && raw.n == cur_start && first_token_of_arg);
             int want_slot = !empty_call || (m->n_params > 0) || m->is_variadic;
             if (want_slot) {
               if (n_args + 1 >= starts_cap) {
                 u32 nc = starts_cap * 2;
                 u32* nb = arena_array(pp->arena, u32, nc);
                 memcpy(nb, starts, sizeof(u32) * starts_cap);
                 starts = nb;
                 starts_cap = nc;
               }
               ++n_args;
               starts[n_args] = raw.n;
             }
           }
           goto done;
         }
         --depth;
       } else if (p == ',' && depth == 0) {
         /* Variadic: once we've filled all named params, the rest
          * (commas included) collect into __VA_ARGS__. */
         if (m->is_variadic && n_args + 1 >= m->n_params) {
           /* This comma is part of __VA_ARGS__. Push it. */
           tv_push(pp, &raw, t);
           hsv_push(pp, &raw_hs, hs);
           first_token_of_arg = 0;
           continue;
         }
         /* Close current arg, start next. */
         if (n_args + 1 >= starts_cap) {
           u32 nc = starts_cap * 2;
           u32* nb = arena_array(pp->arena, u32, nc);
           memcpy(nb, starts, sizeof(u32) * starts_cap);
           starts = nb;
           starts_cap = nc;
         }
         ++n_args;
         starts[n_args] = raw.n;
         cur_start = raw.n;
         first_token_of_arg = 1;
         continue;
       }
     }
     tv_push(pp, &raw, t);
     hsv_push(pp, &raw_hs, hs);
     first_token_of_arg = 0;
   }
 done:
   /* Validate arity. */
   {
     u32 expected = m->n_params;
     if (m->is_variadic) {
       if (n_args < (expected ? expected - 1 : 0)) {
         /* Allow exactly expected-1 (empty __VA_ARGS__) by
          * synthesizing an empty trailing arg. */
         if (n_args + 1 == (expected ? expected - 1 : 0)) {
           /* off by one — fall through to error */
         }
         compiler_panic(pp->c, invoke_loc,
                        "too few arguments to variadic macro invocation");
       }
       /* Synthesize an empty __VA_ARGS__ if caller passed exactly
        * the named-parameter count. */
       if (n_args + 1 == expected) {
         if (n_args + 1 >= starts_cap) {
           u32 nc = starts_cap * 2;
           u32* nb = arena_array(pp->arena, u32, nc);
           memcpy(nb, starts, sizeof(u32) * starts_cap);
           starts = nb;
           starts_cap = nc;
         }
         ++n_args;
         starts[n_args] = raw.n;
       }
     } else {
       if (n_args != expected) {
         /* Spec: arity-0 macro `M()` invoked as `M()` is allowed and
          * has 0 args. Above logic produces 0 in that case. */
         compiler_panic(pp->c, invoke_loc,
                        "wrong number of arguments to function-like macro");
       }
     }
   }
   out->raw = raw.data;
   out->raw_hs = raw_hs.data;
   out->raw_n = raw.n;
   out->raw_start = starts;
   out->n_args = n_args;
   return close_tok;
 }
 
 /* Build pre-expanded args. */
 static void preexpand_args(Pp* pp, ArgList* a) {
   TokVec exp = {0};
   u32* exp_start;
   u32 i;
   exp_start = arena_array(pp->arena, u32, a->n_args + 1);
   exp_start[0] = 0;
   for (i = 0; i < a->n_args; ++i) {
     u32 lo = a->raw_start[i];
     u32 hi = a->raw_start[i + 1];
     if (hi > lo) {
       /* Copy the slice into a fresh buffer so expand_arg_to_eof can
        * own it without aliasing. */
       Tok* slice = arena_array(pp->arena, Tok, hi - lo);
       memcpy(slice, &a->raw[lo], sizeof(Tok) * (hi - lo));
       expand_arg_to_eof(pp, slice, a->raw_hs ? &a->raw_hs[lo] : NULL, hi - lo,
                         &exp);
     }
     exp_start[i + 1] = exp.n;
   }
   a->exp = exp.data;
   a->exp_n = exp.n;
   a->exp_start = exp_start;
 }
 
 /* Build a stringized TOK_STR from the unexpanded argument tokens
  * `arg[lo..hi)`. The first token's leading-space flag is ignored (leading
  * whitespace stripped). Inside string/char-literal spellings, '"' and '\'
  * are escaped. */
 static Tok make_stringize(Pp* pp, const Tok* arg, u32 lo, u32 hi, SrcLoc loc) {
   CharBuf b = {0};
   u32 i;
   Tok t;
   Sym sp;
 
   cb_putc(pp, &b, '"');
   for (i = lo; i < hi; ++i) {
     const Tok* at = &arg[i];
     KitSlice sl =
         at->spelling ? kit_sym_str(pp->pool->c, at->spelling) : KIT_SLICE_NULL;
     const char* s = sl.s;
     size_t slen = sl.len;
     if (i > lo && (at->flags & TF_HAS_SPACE)) cb_putc(pp, &b, ' ');
     if (s && slen) {
       int esc = (at->kind == TOK_STR || at->kind == TOK_CHR);
       size_t k;
       for (k = 0; k < slen; ++k) {
         char c = s[k];
         if (esc && (c == '\\' || c == '"')) cb_putc(pp, &b, '\\');
         cb_putc(pp, &b, c);
       }
     }
   }
   cb_putc(pp, &b, '"');
 
   sp = kit_sym_intern(pp->pool->c, (KitSlice){.s = b.data, .len = b.len});
   memset(&t, 0, sizeof(t));
   t.kind = TOK_STR;
   t.loc = loc;
   t.spelling = sp;
   t.v.str = sp;
   return t;
 }
 
 /* Concatenate two token spellings and re-lex into a single token. Empty
  * (placemarker) sides collapse to the other side per §6.10.3.3 ¶2. */
 static Tok paste_tokens(Pp* pp, Tok lhs, Tok rhs, SrcLoc loc) {
   char buf[1024];
   size_t alen = 0, blen = 0;
   const char* a;
   const char* b;
   Lexer* lex;
   Tok t1, t2;
 
   if (lhs.kind == TOK_PP_PLACEMARKER) return rhs;
   if (rhs.kind == TOK_PP_PLACEMARKER) return lhs;
 
   if (lhs.spelling) {
     KitSlice s = kit_sym_str(pp->pool->c, lhs.spelling);
     a = s.s;
     alen = s.len;
   } else {
     a = "";
   }
   if (rhs.spelling) {
     KitSlice s = kit_sym_str(pp->pool->c, rhs.spelling);
     b = s.s;
     blen = s.len;
   } else {
     b = "";
   }
   if (alen + blen + 2 > sizeof(buf)) {
     compiler_panic(pp->c, loc, "token paste: spelling too long");
   }
   if (alen) memcpy(buf, a, alen);
   if (blen) memcpy(buf + alen, b, blen);
   buf[alen + blen] = '\n';
   buf[alen + blen + 1] = 0;
 
   lex = lex_open_mem(pp->c, "<paste>", buf, alen + blen + 1);
   t1 = lex_next(lex);
   t2 = lex_next(lex);
   if (t1.kind == TOK_EOF) {
     /* Both empty (shouldn't reach here since we handled placemarkers). */
     lex_close(lex);
     return lhs;
   }
   if (t2.kind != TOK_NEWLINE && t2.kind != TOK_EOF) {
     lex_close(lex);
     compiler_panic(pp->c, loc, "token pasting yields multiple tokens, invalid");
   }
   lex_close(lex);
 
   /* Inherit positional flags from LHS (it sat in the same slot). */
   t1.flags = (u16)((t1.flags & ~(TF_AT_BOL | TF_HAS_SPACE)) |
                    (lhs.flags & (TF_AT_BOL | TF_HAS_SPACE)));
   t1.loc = loc;
   return t1;
 }
 
 /* Phase 1 (param substitution). For each parameter occurrence in the
  * body: if adjacent to ## or # (handled separately), substitute the raw
  * argument tokens; otherwise substitute the pre-expanded form. Empty raw
  * args become a TOK_PP_PLACEMARKER which phase 2 collapses. */
 static void subst_phase1(Pp* pp, const Macro* m, ArgList* a, const Tok* invoke,
                          TokVec* out) {
   u32 j;
   for (j = 0; j < m->body_len; ++j) {
     const Tok* bt = &m->body[j];
     if (bt->kind == TOK_PP_HASH) {
       /* §6.10.3.2: # must be followed by a parameter. */
       if (j + 1 >= m->body_len || m->body[j + 1].kind != TOK_PP_PARAM) {
         compiler_panic(pp->c, bt->loc,
                        "'#' is not followed by a macro parameter");
       }
       {
         u32 p = m->body[j + 1].v.punct;
         u32 lo = a->raw_start[p];
         u32 hi = a->raw_start[p + 1];
         Tok s = make_stringize(pp, a->raw, lo, hi, invoke->loc);
         s.flags = (u16)((s.flags & ~(TF_AT_BOL | TF_HAS_SPACE)) |
                         (bt->flags & (TF_AT_BOL | TF_HAS_SPACE)));
         tv_push(pp, out, s);
         ++j;
         continue;
       }
     }
     if (bt->kind == TOK_PP_PARAM) {
       u32 p = bt->v.punct;
       int adj_paste =
           (j > 0 && m->body[j - 1].kind == TOK_PP_PASTE) ||
           (j + 1 < m->body_len && m->body[j + 1].kind == TOK_PP_PASTE);
 
       u32 lo, hi;
       if (adj_paste) {
         lo = a->raw_start[p];
         hi = a->raw_start[p + 1];
       } else {
         lo = a->exp_start[p];
         hi = a->exp_start[p + 1];
       }
 
       if (lo == hi) {
         /* Empty argument → placemarker. */
         Tok pm;
         memset(&pm, 0, sizeof(pm));
         pm.kind = TOK_PP_PLACEMARKER;
         pm.flags = bt->flags & (TF_AT_BOL | TF_HAS_SPACE);
         pm.loc = invoke->loc;
         tv_push(pp, out, pm);
       } else {
         u32 k;
         int first = 1;
         Tok* src = adj_paste ? a->raw : a->exp;
         for (k = lo; k < hi; ++k) {
           Tok t = src[k];
           if (first) {
             t.flags = (u16)((t.flags & ~(TF_AT_BOL | TF_HAS_SPACE)) |
                             (bt->flags & (TF_AT_BOL | TF_HAS_SPACE)));
             first = 0;
           }
           tv_push(pp, out, t);
         }
       }
       continue;
     }
     tv_push(pp, out, *bt);
   }
 }
 
 /* Phase 2 (paste). Walk the post-substitute buffer; for each TOK_PP_PASTE,
  * splice the previous output token with the next input token. Then strip
  * remaining placemarkers. */
 static void subst_phase2(Pp* pp, const Tok* in, u32 nin, const Tok* invoke,
                          TokVec* out) {
   u32 i;
   for (i = 0; i < nin; ++i) {
     Tok t = in[i];
     if (t.kind == TOK_PP_PASTE) {
       Tok lhs, rhs;
       if (out->n == 0 || i + 1 >= nin) {
         compiler_panic(pp->c, invoke->loc,
                        "'##' at start or end of replacement list");
       }
       lhs = out->data[--out->n];
       rhs = in[++i];
       tv_push(pp, out, paste_tokens(pp, lhs, rhs, invoke->loc));
       continue;
     }
     tv_push(pp, out, t);
   }
   /* Strip placemarkers, preserving leading-space flag on the next token. */
   {
     u32 r = 0, w = 0;
     u16 carry = 0;
     for (r = 0; r < out->n; ++r) {
       if (out->data[r].kind == TOK_PP_PLACEMARKER) {
         carry |= out->data[r].flags & (TF_AT_BOL | TF_HAS_SPACE);
         continue;
       }
       if (carry) {
         out->data[r].flags |= carry;
         carry = 0;
       }
       if (w != r) out->data[w] = out->data[r];
       ++w;
     }
     out->n = w;
   }
 }
 
 /* Wrapper: phases 1 and 2 in sequence, plus invocation-loc / flag transfer. */
 static void substitute_body(Pp* pp, const Macro* m, ArgList* a,
                             const Tok* invoke, HidesetId result_hs, TokVec* out,
                             TokVec* hs_out) {
   TokVec phase1 = {0};
   u32 i;
   subst_phase1(pp, m, a, invoke, &phase1);
   subst_phase2(pp, phase1.data, phase1.n, invoke, out);
   /* Invocation flags onto first emitted token. */
   if (out->n) {
     out->data[0].flags =
         (u16)((out->data[0].flags & ~(TF_AT_BOL | TF_HAS_SPACE)) |
               (invoke->flags & (TF_AT_BOL | TF_HAS_SPACE)));
   }
   /* Locations to invocation site. */
   for (i = 0; i < out->n; ++i) out->data[i].loc = invoke->loc;
   /* Build parallel hideset vector. */
   for (i = 0; i < out->n; ++i) {
     Tok hsmark;
     memset(&hsmark, 0, sizeof(hsmark));
     hsmark.spelling = (Sym)result_hs;
     tv_push(pp, hs_out, hsmark);
   }
 }
 
 /* Expand a function-like macro invocation: peek for `(`, collect args,
  * pre-expand them, substitute the body, push the result. Returns 1 if
  * the invocation was performed, 0 if there was no `(` (the caller should
  * emit the identifier as-is). */
 static int try_expand_func_macro(Pp* pp, const Macro* m, const Tok* invoke,
                                  HidesetId invoke_hs) {
   int saw_ws;
   ArgList args;
   TokVec body = {0};
   TokVec hsvec = {0}; /* parallel to body, holds HidesetId per slot */
   HidesetId result_hs;
   Tok close_tok;
 
   if (!peek_for_invoke_paren(pp, &saw_ws)) {
     return 0;
   }
   (void)saw_ws;
   read_invocation_args(pp, m, invoke->loc, &args);
   /* Note: assigned to silence unused-result; we don't use the close tok yet. */
   close_tok.kind = 0;
   (void)close_tok;
   preexpand_args(pp, &args);
 
   /* Hideset of result = invocation hideset ∪ {macro_name}. The standard
    * intersects with the closing `)`'s hideset for blue-paint purity, but
    * for the freshly-collected `)` from the lex source that's the empty
    * set, so the union form suffices here. */
   result_hs = hs_add(pp, invoke_hs, m->name);
   substitute_body(pp, m, &args, invoke, result_hs, &body, &hsvec);
 
   {
     u32 i;
     HidesetId* hids = arena_array(pp->arena, HidesetId, body.n ? body.n : 1);
     for (i = 0; i < body.n; ++i) {
       hids[i] = (HidesetId)hsvec.data[i].spelling;
     }
     push_buf(pp, body.data, hids, body.n);
   }
   return 1;
 }
 
 /* ============================================================
  * pp_next_raw — mutual recursion entry (called from expand_arg_to_eof)
  * Defined here; also declared in pp_priv.h so pp.c can call it.
  * ============================================================ */
 
 /* pp_next_raw: reads from the top source, applies macro expansion when an
  * identifier names a macro that isn't blue-painted, and consumes
  * directives in-place. TOK_NEWLINE is preserved for pp_emit_text. */
 Tok pp_next_raw(Pp* pp) {
   Tok t;
   HidesetId hs;
   u8 src_kind;
   for (;;) {
     t = src_next_raw(pp, &hs, &src_kind);
     if (t.kind == TOK_EOF) return t;
     if (t.kind == TOK_PP_HASH && (t.flags & TF_AT_BOL) && src_kind == SRC_LEX) {
       process_directive(pp, t.loc);
       /* No synthesized newline: the comparator collapses
        * whitespace, so blank-line replacement of consumed
        * directives isn't observable here. Directives that produce
        * content (e.g. #include, #embed, #pragma) push their own
        * tokens onto the source stack, which the next loop
        * iteration picks up. */
       continue;
     }
     /* While expanding an #if condition, suppress macro expansion of
      * `defined`-operator operands so a `defined(X)` produced by a
      * macro body whose argument was pasted via ## doesn't accidentally
      * expand an already-defined X to its body (typically empty). See
      * the `defined_skip` field comment in pp_priv.h. */
     if (pp->in_if_expansion) {
       if (pp->defined_skip == 1 && t.kind == TOK_IDENT) {
         t.flags |= TF_NO_EXPAND;
         pp->defined_skip = 0;
       } else if (pp->defined_skip == 2) {
         if (t.kind == TOK_PUNCT && t.v.punct == '(') {
           pp->defined_skip = 3;
         } else if (t.kind == TOK_IDENT) {
           /* `defined IDENT` (no parens) — same as the skip==1 case. */
           t.flags |= TF_NO_EXPAND;
           pp->defined_skip = 0;
         } else {
           pp->defined_skip = 0;
         }
       } else if (pp->defined_skip == 3) {
         if (t.kind == TOK_IDENT) {
           t.flags |= TF_NO_EXPAND;
           pp->defined_skip = 4;
         } else if (t.kind == TOK_PUNCT && t.v.punct == ')') {
           pp->defined_skip = 0;
         }
       } else if (pp->defined_skip == 4) {
         if (t.kind == TOK_PUNCT && t.v.punct == ')') {
           pp->defined_skip = 0;
         }
       } else if (t.kind == TOK_IDENT && t.v.ident == pp->sym_defined) {
         pp->defined_skip = 2;
       }
     }
     if (t.kind == TOK_IDENT && (t.flags & TF_NO_EXPAND) == 0) {
       Sym id = t.v.ident;
 
       /* Dynamic predefined macros: __LINE__ / __FILE__ /
        * __DATE__ / __TIME__. Always expand, ignoring the macro
        * table. */
       if (id == pp->sym_line__) {
         char tmp[16], buf[16];
         int k = 0, j = 0;
         u32 ln = t.loc.line;
         if (ln == 0)
           buf[k++] = '0';
         else {
           while (ln) {
             tmp[j++] = (char)('0' + ln % 10);
             ln /= 10;
           }
           while (j > 0) buf[k++] = tmp[--j];
         }
         t.kind = TOK_NUM;
         t.spelling =
             kit_sym_intern(pp->pool->c, (KitSlice){.s = buf, .len = (size_t)k});
         return t;
       }
       if (id == pp->sym_file__) {
         TokSrc* ls = current_lex_src(pp);
         Sym name = 0;
         size_t nlen = 0;
         const char* nstr = NULL;
         char* buf;
         if (ls && ls->file_override) {
           name = ls->file_override;
         } else if (ls) {
           KitSourceFile sf;
           memset(&sf, 0, sizeof(sf));
           if (kit_source_file(pp->c, lex_file_id(ls->lex), &sf) == 0) {
             name = sf.name;
           }
         }
         if (name) {
           KitSlice s = kit_sym_str(pp->pool->c, name);
           nstr = s.s;
           nlen = s.len;
         }
         /* The source name is the raw filesystem path (or a #line override,
          * destringized to logical bytes by do_line). Re-stringize it as a
          * valid C string literal: escape '\\' and '"'. On POSIX paths use
          * '/' so this was a no-op; on Windows the path holds backslashes
          * (e.g. C:\\Users\\...), and emitting them raw turns '\\U'/'\\u'/'\\x'
          * into bogus escape sequences (the "malformed UCN" on '\\Users'). */
         {
           size_t bn = 0;
           size_t i;
           buf = (char*)arena_alloc(pp->arena, nlen * 2 + 2, 1);
           buf[bn++] = '"';
           for (i = 0; i < nlen; ++i) {
             char ch = nstr[i];
             if (ch == '\\' || ch == '"') buf[bn++] = '\\';
             buf[bn++] = ch;
           }
           buf[bn++] = '"';
           t.kind = TOK_STR;
           t.spelling =
               kit_sym_intern(pp->pool->c, (KitSlice){.s = buf, .len = bn});
           t.v.str = t.spelling;
         }
         return t;
       }
       if (id == pp->sym_date__) {
         t.kind = TOK_STR;
         t.spelling = pp->val_date_str;
         t.v.str = t.spelling;
         return t;
       }
       if (id == pp->sym_time__) {
         t.kind = TOK_STR;
         t.spelling = pp->val_time_str;
         t.v.str = t.spelling;
         return t;
       }
       if (id == pp->sym__pragma) {
         if (try_expand_pragma_op(pp, &t)) continue;
         /* No '(' — fall through and emit as plain ident. */
       }
 
       {
         Macro* m = mt_get(pp, id);
         if (m && !hs_contains(pp, hs, m->name)) {
           if (!m->is_func) {
             expand_object_macro(pp, m, &t, hs);
             continue;
           }
           if (try_expand_func_macro(pp, m, &t, hs)) {
             continue;
           }
           /* No '(' followed; emit as plain identifier. */
         }
       }
     }
     return t;
   }
 }