kit

pp_directive.c (41401B)

---

 /* pp_directive.c — if-stack, PP expression evaluator, #include search/open,
  * #line, #pragma, #error, #embed, and directive dispatch. */
 
 #include "pp/pp_priv.h"
 
 static void destringize(Pp* pp, const Tok* str_tok, char* out, size_t cap,
                         size_t* out_len);
 
 /* ============================================================
  * If-stack
  * ============================================================ */
 
 static void if_push(Pp* pp, IfFrame f) {
   if (pp->ifstk_n == pp->ifstk_cap) {
     u32 nc = pp->ifstk_cap ? pp->ifstk_cap * 2 : 4;
     pp->ifstk = pp_xrealloc(pp, pp->ifstk, sizeof(IfFrame) * pp->ifstk_cap,
                             sizeof(IfFrame) * nc, _Alignof(IfFrame));
     pp->ifstk_cap = nc;
   }
   pp->ifstk[pp->ifstk_n++] = f;
 }
 
 static IfFrame* if_top(Pp* pp) {
   return pp->ifstk_n ? &pp->ifstk[pp->ifstk_n - 1] : NULL;
 }
 
 static void if_pop(Pp* pp) {
   if (pp->ifstk_n) --pp->ifstk_n;
 }
 
 /* ============================================================
  * Directive line reader
  * ============================================================ */
 
 /* Read tokens up through (and including) the next TOK_NEWLINE / TOK_EOF.
  * Drops the newline; collected tokens are arena-allocated and returned via
  * *out_toks/out_n. */
 void read_directive_line(Pp* pp, Tok** out_toks, u32* out_n) {
   Tok* buf = NULL;
   u32 cap = 0, n = 0;
   Tok t;
   HidesetId hs;
   for (;;) {
     t = src_next_raw(pp, &hs, NULL);
     if (t.kind == TOK_NEWLINE || t.kind == TOK_EOF) break;
     if (n == cap) {
       u32 nc = cap ? cap * 2 : 8;
       Tok* nb = (Tok*)arena_alloc(pp->arena, sizeof(Tok) * nc, _Alignof(Tok));
       if (cap) memcpy(nb, buf, sizeof(Tok) * cap);
       buf = nb;
       cap = nc;
     }
     buf[n++] = t;
   }
   *out_toks = buf;
   *out_n = n;
 }
 
 /* ============================================================
  * PP expression evaluator (§6.10.1)
  * ============================================================ */
 
 /* Parse a C integer constant from a pp-number's spelling. Suffixes (u, l,
  * etc.) are ignored. Recognizes decimal, hex (0x...), and octal (0...). */
 static i64 parse_pp_int(const char* s, size_t n) {
   int base = 10;
   size_t i = 0;
   u64 val = 0; /* unsigned: #if arithmetic wraps on overflow, signed would be UB */
   if (n >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
     base = 16;
     i = 2;
   } else if (n >= 1 && s[0] == '0') {
     base = 8;
     i = 1;
   }
   for (; i < n; ++i) {
     char c = s[i];
     int d;
     if (c >= '0' && c <= '9')
       d = c - '0';
     else if (base == 16 && c >= 'a' && c <= 'f')
       d = c - 'a' + 10;
     else if (base == 16 && c >= 'A' && c <= 'F')
       d = c - 'A' + 10;
     else
       break;
     if (d >= base) break;
     val = val * (u64)base + (u64)d;
   }
   return (i64)val;
 }
 
 /* Pre-pass: replace `defined X` / `defined ( X )` with a 0/1 pp-number,
  * preserving the rest of the token sequence. The operand of `defined` is
  * NOT macro-expanded. Output is a fresh TokVec. */
 static void prepass_defined(Pp* pp, const Tok* in, u32 nin, TokVec* out) {
   u32 i;
   for (i = 0; i < nin; ++i) {
     if (in[i].kind == TOK_IDENT && in[i].v.ident == pp->sym_defined) {
       int has_paren = 0;
       Sym ident = 0;
       u32 j = i + 1;
       if (j < nin && in[j].kind == TOK_PUNCT && in[j].v.punct == '(') {
         has_paren = 1;
         ++j;
       }
       if (j >= nin || in[j].kind != TOK_IDENT) {
         compiler_panic(pp->c, in[i].loc,
                        "operand of 'defined' must be an identifier");
       }
       ident = in[j].v.ident;
       ++j;
       if (has_paren) {
         if (j >= nin || in[j].kind != TOK_PUNCT || in[j].v.punct != ')') {
           compiler_panic(pp->c, in[i].loc,
                          "expected ')' after 'defined' operand");
         }
         ++j;
       }
       {
         Tok t;
         memset(&t, 0, sizeof(t));
         t.kind = TOK_NUM;
         t.flags = in[i].flags & (TF_AT_BOL | TF_HAS_SPACE);
         t.loc = in[i].loc;
         t.spelling =
             kit_sym_intern(pp->pool->c, mt_get(pp, ident) ? KIT_SLICE_LIT("1")
                                                           : KIT_SLICE_LIT("0"));
         tv_push(pp, out, t);
       }
       i = j - 1;
     } else {
       tv_push(pp, out, in[i]);
     }
   }
 }
 
 /* Macro-expand a sequence of pre-#if tokens to completion.
  *
  * Sets pp->in_if_expansion for the duration so pp_next_raw can keep
  * `defined`-operator operands raw even when they ride out of a macro
  * body via the ## operator. Without this flag a macro body like
  *   #define G(x) (!defined(__G_DEFINED_ ## x))
  * would have the pasted operand expanded if it happens to name an
  * already-defined macro, leaving the second prepass to choke on
  * `defined()`. */
 static void expand_for_if(Pp* pp, const Tok* in, u32 nin, TokVec* out) {
   Tok* slice;
   u8 saved;
   if (nin == 0) return;
   slice = arena_array(pp->arena, Tok, nin);
   memcpy(slice, in, sizeof(Tok) * nin);
   saved = pp->in_if_expansion;
   pp->in_if_expansion = 1;
   pp->defined_skip = 0;
   expand_arg_to_eof(pp, slice, NULL, nin, out);
   pp->in_if_expansion = saved;
   pp->defined_skip = 0;
 }
 
 /* Replace remaining identifiers with `0` per §6.10.1 ¶4, after `defined`
  * has been handled. */
 static void replace_remaining_if_identifiers(Pp* pp, TokVec* toks) {
   u32 i;
   Sym zero = kit_sym_intern(pp->pool->c, KIT_SLICE_LIT("0"));
   for (i = 0; i < toks->n; ++i) {
     if (toks->data[i].kind == TOK_IDENT) {
       toks->data[i].kind = TOK_NUM;
       toks->data[i].spelling = zero;
     }
   }
 }
 
 /* Recursive-descent expression evaluator over an expanded token list. */
 typedef struct EE {
   Pp* pp;
   const Tok* toks;
   u32 n;
   u32 pos;
   SrcLoc loc;
   SrcLoc op_loc; /* loc of the binary operator being applied (for panics) */
 } EE;
 
 static i64 ee_ternary(EE* e);
 
 static const Tok* ee_peek(EE* e) {
   return e->pos < e->n ? &e->toks[e->pos] : NULL;
 }
 
 static int ee_match_punct(EE* e, u32 p) {
   const Tok* t = ee_peek(e);
   if (t && t->kind == TOK_PUNCT && t->v.punct == p) {
     ++e->pos;
     return 1;
   }
   return 0;
 }
 
 static i64 ee_primary(EE* e) {
   const Tok* t = ee_peek(e);
   if (!t) compiler_panic(e->pp->c, e->loc, "#if: missing operand");
   if (t->kind == TOK_NUM) {
     KitSlice s = kit_sym_str(e->pp->pool->c, t->spelling);
     ++e->pos;
     return parse_pp_int(s.s, s.len);
   }
   if (t->kind == TOK_CHR) {
     /* Treat as the codepoint of the first character (post-decoding
      * not implemented; cover the common case of a single ASCII
      * char). */
     KitSlice s = kit_sym_str(e->pp->pool->c, t->spelling);
     ++e->pos;
     if (s.len >= 3 && s.s[0] == '\'') return (unsigned char)s.s[1];
     return 0;
   }
   if (t->kind == TOK_PUNCT && t->v.punct == '(') {
     i64 v;
     ++e->pos;
     v = ee_ternary(e);
     if (!ee_match_punct(e, ')')) {
       compiler_panic(e->pp->c, t->loc, "#if: expected ')'");
     }
     return v;
   }
   compiler_panic(e->pp->c, t->loc, "#if: unexpected token in expression");
   return 0;
 }
 
 static i64 ee_unary(EE* e) {
   const Tok* t = ee_peek(e);
   if (t && t->kind == TOK_PUNCT) {
     u32 p = t->v.punct;
     if (p == '!' || p == '-' || p == '+' || p == '~') {
       i64 v;
       ++e->pos;
       v = ee_unary(e);
       switch (p) {
         case '!':
           return v ? 0 : 1;
         case '-':
           return -v;
         case '+':
           return v;
         case '~':
           return ~v;
       }
     }
   }
   return ee_primary(e);
 }
 
 /* One row per binary operator, highest `prec` binds tightest. All listed
  * operators are left-associative; ternary (right-assoc) stays special-cased
  * in ee_ternary. `apply` folds (lhs OP rhs) and owns the div/mod-by-zero
  * panic (it needs the operator loc, threaded via EE::op_loc). */
 typedef i64 (*EeApply)(EE* e, i64 a, i64 b);
 
 static i64 eb_mul(EE* e, i64 a, i64 b) {
   (void)e;
   return a * b;
 }
 static i64 eb_div(EE* e, i64 a, i64 b) {
   if (b == 0) compiler_panic(e->pp->c, e->op_loc, "#if: division by zero");
   return a / b;
 }
 static i64 eb_mod(EE* e, i64 a, i64 b) {
   if (b == 0) compiler_panic(e->pp->c, e->op_loc, "#if: modulo by zero");
   return a % b;
 }
 static i64 eb_add(EE* e, i64 a, i64 b) {
   (void)e;
   return a + b;
 }
 static i64 eb_sub(EE* e, i64 a, i64 b) {
   (void)e;
   return a - b;
 }
 static i64 eb_shl(EE* e, i64 a, i64 b) {
   (void)e;
   return a << b;
 }
 static i64 eb_shr(EE* e, i64 a, i64 b) {
   (void)e;
   return a >> b;
 }
 static i64 eb_lt(EE* e, i64 a, i64 b) {
   (void)e;
   return a < b;
 }
 static i64 eb_gt(EE* e, i64 a, i64 b) {
   (void)e;
   return a > b;
 }
 static i64 eb_le(EE* e, i64 a, i64 b) {
   (void)e;
   return a <= b;
 }
 static i64 eb_ge(EE* e, i64 a, i64 b) {
   (void)e;
   return a >= b;
 }
 static i64 eb_eq(EE* e, i64 a, i64 b) {
   (void)e;
   return a == b;
 }
 static i64 eb_ne(EE* e, i64 a, i64 b) {
   (void)e;
   return a != b;
 }
 static i64 eb_band(EE* e, i64 a, i64 b) {
   (void)e;
   return a & b;
 }
 static i64 eb_bxor(EE* e, i64 a, i64 b) {
   (void)e;
   return a ^ b;
 }
 static i64 eb_bor(EE* e, i64 a, i64 b) {
   (void)e;
   return a | b;
 }
 static i64 eb_logand(EE* e, i64 a, i64 b) {
   (void)e;
   return a && b;
 }
 static i64 eb_logor(EE* e, i64 a, i64 b) {
   (void)e;
   return a || b;
 }
 
 typedef struct EeOp {
   u32 punct; /* P_* / ASCII codepoint of the operator token */
   u8 prec;   /* higher binds tighter */
   EeApply apply;
 } EeOp;
 
 static const EeOp ee_ops[] = {
     {'*', 10, eb_mul},   {'/', 10, eb_div},     {'%', 10, eb_mod},
     {'+', 9, eb_add},    {'-', 9, eb_sub},      {P_SHL, 8, eb_shl},
     {P_SHR, 8, eb_shr},  {'<', 7, eb_lt},       {'>', 7, eb_gt},
     {P_LE, 7, eb_le},    {P_GE, 7, eb_ge},      {P_EQ, 6, eb_eq},
     {P_NE, 6, eb_ne},    {'&', 5, eb_band},     {'^', 4, eb_bxor},
     {'|', 3, eb_bor},    {P_AND, 2, eb_logand}, {P_OR, 1, eb_logor},
 };
 
 static const EeOp* ee_lookup_op(const Tok* t) {
   size_t i;
   if (!t || t->kind != TOK_PUNCT) return NULL;
   for (i = 0; i < sizeof(ee_ops) / sizeof(ee_ops[0]); ++i) {
     if (ee_ops[i].punct == t->v.punct) return &ee_ops[i];
   }
   return NULL;
 }
 
 /* Precedence-climbing fold of all left-associative binary operators. */
 static i64 ee_binary(EE* e, int min_prec) {
   i64 v = ee_unary(e);
   for (;;) {
     const Tok* t = ee_peek(e);
     const EeOp* op = ee_lookup_op(t);
     SrcLoc op_loc;
     i64 rhs;
     if (!op || op->prec < min_prec) break;
     op_loc = t->loc;
     ++e->pos;
     /* Left-associative: parse the RHS with strictly higher precedence so
      * same-prec operators fold left-to-right. */
     rhs = ee_binary(e, op->prec + 1);
     e->op_loc = op_loc;
     v = op->apply(e, v, rhs);
   }
   return v;
 }
 
 static i64 ee_ternary(EE* e) {
   i64 c = ee_binary(e, 1);
   if (ee_match_punct(e, '?')) {
     i64 a = ee_ternary(e);
     i64 b;
     if (!ee_match_punct(e, ':')) {
       compiler_panic(e->pp->c, e->loc, "#if: ':' expected in ternary");
     }
     b = ee_ternary(e);
     return c ? a : b;
   }
   return c;
 }
 
 i64 eval_if_expr(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   TokVec defs = {0};
   TokVec exp = {0};
   TokVec defs2 = {0};
   EE e;
   i64 v;
 
   prepass_defined(pp, line, n, &defs);
   expand_for_if(pp, defs.data, defs.n, &exp);
   prepass_defined(pp, exp.data, exp.n, &defs2);
   replace_remaining_if_identifiers(pp, &defs2);
 
   e.pp = pp;
   e.toks = defs2.data;
   e.n = defs2.n;
   e.pos = 0;
   e.loc = loc;
   v = ee_ternary(&e);
   if (e.pos != e.n) {
     compiler_panic(pp->c, e.loc,
                    "#if: unexpected trailing tokens in expression");
   }
   return v;
 }
 
 /* ============================================================
  * Conditional inclusion helpers
  * ============================================================ */
 
 static void consume_to_newline(Pp* pp) {
   Tok t;
   do {
     t = src_next_raw(pp, NULL, NULL);
   } while (t.kind != TOK_NEWLINE && t.kind != TOK_EOF);
 }
 
 /* Drive the source forward consuming tokens until we either:
  *   - reach a balancing #endif (pops the frame, returns), or
  *   - reach a #elif / #else that flips the top frame to IF_INCLUDE
  *     (returns with that frame active).
  * Nested #if directives inside the skipped group are tracked via
  * `local_depth`. Unrecognised directives in skipped groups are tolerated
  * (§6.10 ¶4, covered by `8c_skipped_relaxed_syntax`). */
 static void skip_until_active(Pp* pp) {
   int local_depth = 0;
   while (pp->ifstk_n > 0) {
     IfFrame* top = if_top(pp);
     Tok t;
     if (top->state == IF_INCLUDE && local_depth == 0) return;
     t = src_next_raw(pp, NULL, NULL);
     if (t.kind == TOK_EOF) {
       compiler_panic(pp->c, top->loc, "unterminated #if / #ifdef");
     }
     if (t.kind != TOK_PP_HASH || (t.flags & TF_AT_BOL) == 0) continue;
 
     /* Read directive name (or null directive). */
     {
       Tok nt = src_next_raw(pp, NULL, NULL);
       Sym name;
       if (nt.kind == TOK_NEWLINE || nt.kind == TOK_EOF) continue;
       if (nt.kind != TOK_IDENT) {
         consume_to_newline(pp);
         continue;
       }
       name = nt.v.ident;
       if (name == pp->sym_if || name == pp->sym_ifdef ||
           name == pp->sym_ifndef) {
         ++local_depth;
         consume_to_newline(pp);
         continue;
       }
       if (name == pp->sym_endif) {
         consume_to_newline(pp);
         if (local_depth > 0) {
           --local_depth;
           continue;
         }
         if_pop(pp);
         return;
       }
       if (name == pp->sym_else) {
         consume_to_newline(pp);
         if (local_depth > 0) continue;
         if (top->has_else) {
           compiler_panic(pp->c, t.loc, "duplicate #else");
         }
         top->has_else = 1;
         if (top->state == IF_SEEK_TRUE) {
           top->state = IF_INCLUDE;
           return;
         }
         top->state = IF_DONE;
         continue;
       }
       if (name == pp->sym_elif) {
         if (local_depth > 0 || top->has_else || top->state == IF_DONE) {
           consume_to_newline(pp);
           continue;
         }
         if (top->state == IF_SEEK_TRUE) {
           Tok* line;
           u32 ln;
           i64 v;
           read_directive_line(pp, &line, &ln);
           v = eval_if_expr(pp, line, ln, t.loc);
           if (v != 0) {
             top->state = IF_INCLUDE;
             return;
           }
           continue;
         }
         /* Was IF_INCLUDE; #elif means we're done. (Should already
          * have been transitioned to DONE before entering this
          * skip — defensive.) */
         top->state = IF_DONE;
         consume_to_newline(pp);
         continue;
       }
       /* Other directive — relaxed: skip silently. */
       consume_to_newline(pp);
       continue;
     }
   }
 }
 
 /* ============================================================
  * Predefined macro name guard
  * ============================================================ */
 
 static int is_predefined_macro_name(Pp* pp, Sym name) {
   return name == pp->sym_va_args || name == pp->sym_line__ ||
          name == pp->sym_file__ || name == pp->sym_date__ ||
          name == pp->sym_time__;
   /* __STDC__/__STDC_HOSTED__/__STDC_VERSION__ are registered as real
    * macros, so the macro-table lookup catches them. */
 }
 
 /* ============================================================
  * #ifdef / #if / #elif / #else / #endif
  * ============================================================ */
 
 static void do_ifdef(Pp* pp, const Tok* line, u32 n, int negate, SrcLoc loc) {
   int defined;
   IfFrame f;
   if (n < 1 || line[0].kind != TOK_IDENT) {
     compiler_panic(pp->c, loc,
                    negate ? "#ifndef: expected identifier"
                           : "#ifdef: expected identifier");
   }
   defined = (mt_get(pp, line[0].v.ident) != NULL) ||
             is_predefined_macro_name(pp, line[0].v.ident);
   if (negate) defined = !defined;
   memset(&f, 0, sizeof(f));
   f.state = defined ? IF_INCLUDE : IF_SEEK_TRUE;
   f.loc = loc;
   if_push(pp, f);
   if (!defined) skip_until_active(pp);
 }
 
 static void do_if_directive(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   i64 v = eval_if_expr(pp, line, n, loc);
   IfFrame f;
   memset(&f, 0, sizeof(f));
   f.state = v ? IF_INCLUDE : IF_SEEK_TRUE;
   f.loc = loc;
   if_push(pp, f);
   if (!v) skip_until_active(pp);
 }
 
 static void do_elif(Pp* pp, SrcLoc loc) {
   /* We only reach do_elif from the active branch — meaning the
    * preceding group emitted code. So we must skip the rest. */
   IfFrame* top = if_top(pp);
   if (!top) compiler_panic(pp->c, loc, "stray #elif");
   if (top->has_else) compiler_panic(pp->c, loc, "#elif after #else");
   top->state = IF_DONE;
   skip_until_active(pp);
 }
 
 static void do_else(Pp* pp, SrcLoc loc) {
   IfFrame* top = if_top(pp);
   if (!top) compiler_panic(pp->c, loc, "stray #else");
   if (top->has_else) compiler_panic(pp->c, loc, "duplicate #else");
   top->has_else = 1;
   top->state = IF_DONE;
   skip_until_active(pp);
 }
 
 static void do_endif(Pp* pp, SrcLoc loc) {
   if (!if_top(pp)) compiler_panic(pp->c, loc, "stray #endif");
   if_pop(pp);
 }
 
 /* ============================================================
  * #include (§6.10.2)
  * ============================================================ */
 
 /* Read `path` via the host's file_io and copy its bytes into the pp
  * arena so they outlive io->release. Returns 1 on success. */
 static int try_open_include(Pp* pp, const char* path, const u8** data_out,
                             size_t* size_out) {
   KitFileData fd;
   const KitFileIO* io;
   u8* buf;
 
   memset(&fd, 0, sizeof(fd));
   io = kit_compiler_context(pp->c)->file_io;
   if (!io || !io->read_all) {
     compiler_panic(pp->c, (SrcLoc){0, 0, 0},
                    "#include: env.file_io is not configured");
   }
   if (io->read_all(io->user, path, &fd) != KIT_OK) return 0;
   {
     size_t sz = fd.size;
     buf = (u8*)arena_alloc(pp->arena, sz ? sz : 1, 1);
     if (sz && fd.data) memcpy(buf, fd.data, sz);
     if (io->release) io->release(io->user, &fd); /* zeros fd */
     *data_out = buf;
     *size_out = sz;
   }
   return 1;
 }
 
 /* Return the includer's directory for resolving a quoted include, or "."
  * for in-memory/builtin sources (where CWD is the natural fallback, like
  * gcc treats stdin). `dir_out` must point to a buffer of size >= cap. */
 static int includer_dir(Pp* pp, SrcLoc loc, char* dir_out, size_t cap) {
   KitSourceFile sf;
   const char* p = NULL;
   size_t plen = 0;
   const char* slash;
   size_t dlen;
   memset(&sf, 0, sizeof(sf));
   if (kit_source_file(pp->c, loc.file_id, &sf) == 0 && sf.name) {
     KitSlice s = kit_sym_str(pp->pool->c, sf.name);
     p = s.s;
     plen = s.len;
   }
   if (!p || plen == 0 || p[0] == '<') {
     if (cap < 2) return 0;
     dir_out[0] = '.';
     dir_out[1] = 0;
     return 1;
   }
   slash = NULL;
   {
     size_t i;
     for (i = plen; i > 0; --i) {
       if (p[i - 1] == '/') {
         slash = p + i - 1;
         break;
       }
     }
   }
   if (!slash) {
     if (cap < 2) return 0;
     dir_out[0] = '.';
     dir_out[1] = 0;
     return 1;
   }
   dlen = (size_t)(slash - p);
   if (dlen == 0) dlen = 1; /* path was "/x" — dir is "/" */
   if (dlen + 1 > cap) return 0;
   memcpy(dir_out, p, dlen);
   dir_out[dlen] = 0;
   return 1;
 }
 
 /* Search for a header. Absolute paths are opened verbatim. Quoted form
  * ("...") additionally searches the directory of the file containing the
  * #include first (per C §6.10.2); bracket form (<...>) skips that step.
  * Both forms then walk the configured -I / -isystem dirs in order. */
 static int find_and_open_include(Pp* pp, const char* path, int system,
                                  SrcLoc loc, const u8** data, size_t* size,
                                  char* resolved, size_t resolved_cap) {
   char buf[4096];
   u32 i;
   size_t plen = kit_slice_cstr(path).len;
 
   if (plen > 0 && path[0] == '/') {
     if (try_open_include(pp, path, data, size)) {
       if (plen + 1 > resolved_cap) return 0;
       memcpy(resolved, path, plen + 1);
       return 1;
     }
     return 0;
   }
 
   if (!system) {
     char dir[4096];
     if (includer_dir(pp, loc, dir, sizeof(dir))) {
       size_t dlen = kit_slice_cstr(dir).len;
       if (dlen + 1 + plen + 1 <= sizeof(buf)) {
         memcpy(buf, dir, dlen);
         buf[dlen] = '/';
         memcpy(buf + dlen + 1, path, plen);
         buf[dlen + 1 + plen] = 0;
         if (try_open_include(pp, buf, data, size)) {
           if (dlen + 1 + plen + 1 > resolved_cap) return 0;
           memcpy(resolved, buf, dlen + 1 + plen + 1);
           return 1;
         }
       }
     }
   }
   for (i = 0; i < pp->ninc_dirs; ++i) {
     const char* d = pp->inc_dirs[i].path;
     size_t dlen = kit_slice_cstr(d).len;
     if (dlen + 1 + plen + 1 > sizeof(buf)) continue;
     memcpy(buf, d, dlen);
     buf[dlen] = '/';
     memcpy(buf + dlen + 1, path, plen);
     buf[dlen + 1 + plen] = 0;
     if (try_open_include(pp, buf, data, size)) {
       if (dlen + 1 + plen + 1 > resolved_cap) return 0;
       memcpy(resolved, buf, dlen + 1 + plen + 1);
       return 1;
     }
   }
   return 0;
 }
 
 /* Parse the directive arguments into (path, system_flag). Handles:
  *   - directly-lexed TOK_HEADER: < ... > or " ... "
  *   - macro-replaced form: line is macro-expanded, then expected to
  *     produce either a TOK_STR ("...") or a < ... > sequence. */
 static void parse_include_path(Pp* pp, const Tok* line, u32 n, SrcLoc loc,
                                char* path_out, size_t cap, int* system_out) {
   if (n == 0) compiler_panic(pp->c, loc, "#include: missing path");
 
   if (line[0].kind == TOK_HEADER) {
     KitSlice sl = kit_sym_str(pp->pool->c, line[0].spelling);
     const char* s = sl.s;
     size_t slen = sl.len;
     if (slen < 2) compiler_panic(pp->c, loc, "#include: malformed header name");
     if (s[0] == '<' && s[slen - 1] == '>')
       *system_out = 1;
     else if (s[0] == '"' && s[slen - 1] == '"')
       *system_out = 0;
     else
       compiler_panic(pp->c, loc, "#include: malformed header name");
     if (slen - 2 + 1 > cap)
       compiler_panic(pp->c, loc, "#include: path too long");
     memcpy(path_out, s + 1, slen - 2);
     path_out[slen - 2] = 0;
     return;
   }
 
   /* Macro-replaced form. */
   {
     TokVec exp = {0};
     Tok* slice = arena_array(pp->arena, Tok, n);
     memcpy(slice, line, sizeof(Tok) * n);
     expand_arg_to_eof(pp, slice, NULL, n, &exp);
 
     if (exp.n == 0) {
       compiler_panic(pp->c, loc, "#include: empty after macro replacement");
     }
     if (exp.data[0].kind == TOK_STR) {
       KitSlice sl = kit_sym_str(pp->pool->c, exp.data[0].spelling);
       const char* s = sl.s;
       size_t slen = sl.len;
       if (slen < 2 || s[0] != '"' || s[slen - 1] != '"') {
         compiler_panic(pp->c, loc, "#include: malformed string");
       }
       if (slen - 2 + 1 > cap) {
         compiler_panic(pp->c, loc, "#include: path too long");
       }
       memcpy(path_out, s + 1, slen - 2);
       path_out[slen - 2] = 0;
       *system_out = 0;
       return;
     }
     if (exp.data[0].kind == TOK_PUNCT && exp.data[0].v.punct == '<') {
       size_t pos = 0;
       u32 i;
       for (i = 1; i < exp.n; ++i) {
         size_t slen = 0;
         const char* s = NULL;
         if (exp.data[i].kind == TOK_PUNCT && exp.data[i].v.punct == '>') {
           break;
         }
         if (exp.data[i].spelling) {
           KitSlice sl = kit_sym_str(pp->pool->c, exp.data[i].spelling);
           s = sl.s;
           slen = sl.len;
         }
         if (s && pos + slen + 1 <= cap) {
           memcpy(path_out + pos, s, slen);
           pos += slen;
         }
       }
       path_out[pos] = 0;
       *system_out = 1;
       return;
     }
     compiler_panic(pp->c, loc,
                    "#include: expected \"...\" or <...> after expansion");
   }
 }
 
 static void do_include(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   char path[4096];
   char resolved[4096];
   int system_form = 0;
   const u8* data;
   size_t size;
   Lexer* lex;
   u32 includer_id = 0;
   u32 included_id;
   u32 i;
   TokSrc s;
 
   parse_include_path(pp, line, n, loc, path, sizeof(path), &system_form);
 
   if (!find_and_open_include(pp, path, system_form, loc, &data, &size, resolved,
                              sizeof(resolved))) {
     compiler_panic(pp->c, loc, "#include: file not found: %.*s",
                    KIT_SLICE_ARG(kit_slice_cstr(path)));
   }
 
   /* Walk the source stack to find the current includer's file_id. */
   for (i = pp->nsources; i > 0; --i) {
     TokSrc* tp = &pp->sources[i - 1];
     if (tp->kind == SRC_LEX && tp->lex) {
       includer_id = lex_file_id(tp->lex);
       break;
     }
   }
 
   lex = lex_open_mem(pp->c, resolved, (const char*)data, size);
   included_id = lex_file_id(lex);
 
   memset(&s, 0, sizeof(s));
   s.kind = SRC_LEX;
   s.lex = lex;
   src_push(pp, s);
 
   kit_source_add_include(pp->c, includer_id, included_id, loc, system_form);
 }
 
 /* ============================================================
  * #line (§6.10.4)
  * ============================================================ */
 
 /* Find the topmost SRC_LEX source on the stack — that's the "current
  * file" whose line/file should track #line directives. */
 TokSrc* current_lex_src(Pp* pp) {
   u32 i;
   for (i = pp->nsources; i > 0; --i) {
     TokSrc* s = &pp->sources[i - 1];
     if (s->kind == SRC_LEX) return s;
   }
   return NULL;
 }
 
 static void do_line(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   /* Macro-replace arguments first (a2). */
   TokVec exp = {0};
   Tok* slice;
   TokSrc* lex_src;
   i64 target_line;
   Sym target_file = 0;
 
   if (n == 0) compiler_panic(pp->c, loc, "#line: missing arguments");
   slice = arena_array(pp->arena, Tok, n);
   memcpy(slice, line, sizeof(Tok) * n);
   expand_arg_to_eof(pp, slice, NULL, n, &exp);
 
   if (exp.n == 0 || exp.data[0].kind != TOK_NUM) {
     compiler_panic(pp->c, loc, "#line: expected line number");
   }
   {
     KitSlice s = kit_sym_str(pp->pool->c, exp.data[0].spelling);
     target_line = parse_pp_int(s.s, s.len);
   }
   if (exp.n >= 2) {
     if (exp.data[1].kind != TOK_STR) {
       compiler_panic(pp->c, loc, "#line: file argument must be a string");
     }
     {
       KitSlice s = kit_sym_str(pp->pool->c, exp.data[1].spelling);
       if (s.len >= 2 && s.s[0] == '"' && s.s[s.len - 1] == '"') {
         /* Destringize to logical bytes (undo \" and \\): file_override is
          * stored unescaped, like a real source path, and __FILE__ re-escapes
          * it uniformly when expanded. */
         char* fbuf = (char*)arena_alloc(pp->arena, s.len, 1);
         size_t flen = 0;
         destringize(pp, &exp.data[1], fbuf, s.len, &flen);
         target_file =
             kit_sym_intern(pp->pool->c, (KitSlice){.s = fbuf, .len = flen});
       }
     }
   }
 
   lex_src = current_lex_src(pp);
   if (!lex_src) compiler_panic(pp->c, loc, "#line outside any file");
   {
     /* The next token (post-directive-NL) currently has lex.line ==
      * <lex's line counter>. Set delta so its user-visible line ==
      * target_line. */
     SrcLoc here = lex_loc(lex_src->lex);
     lex_src->line_delta = (i32)target_line - (i32)here.line;
     if (target_file) lex_src->file_override = target_file;
   }
 }
 
 /* ============================================================
  * #pragma + _Pragma (§6.10.6, §6.10.9)
  * ============================================================ */
 
 /* Push the unmodified directive line back onto the source stack as a
  * buffer, so pp_emit_text writes it as-is. SRC_BUF gates directive
  * recognition off, so this won't recurse. */
 void emit_pragma_line(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   TokVec out = {0};
   HidesetId* hids;
   u32 i;
   Tok hash, ident, nl;
 
   memset(&hash, 0, sizeof(hash));
   hash.kind = TOK_PP_HASH;
   hash.flags = TF_AT_BOL;
   hash.loc = loc;
   hash.spelling = kit_sym_intern(pp->pool->c, KIT_SLICE_LIT("#"));
   tv_push(pp, &out, hash);
 
   memset(&ident, 0, sizeof(ident));
   ident.kind = TOK_IDENT;
   ident.flags = 0;
   ident.loc = loc;
   ident.spelling = pp->sym_pragma_kw;
   ident.v.ident = pp->sym_pragma_kw;
   tv_push(pp, &out, ident);
 
   for (i = 0; i < n; ++i) {
     Tok t = line[i];
     /* Force a leading space between tokens. */
     t.flags |= TF_HAS_SPACE;
     if (i == 0) {
       /* Space between "pragma" and the first arg. */
     }
     tv_push(pp, &out, t);
   }
 
   memset(&nl, 0, sizeof(nl));
   nl.kind = TOK_NEWLINE;
   nl.loc = loc;
   tv_push(pp, &out, nl);
 
   hids = arena_array(pp->arena, HidesetId, out.n ? out.n : 1);
   for (i = 0; i < out.n; ++i) hids[i] = HS_EMPTY;
   push_buf(pp, out.data, hids, out.n);
 }
 
 static int pragma_num_u32(Pp* pp, const Tok* t, u32* out) {
   const char* s;
   size_t len;
   u32 v = 0;
   KitSlice sl;
   if (!t || t->kind != TOK_NUM || !out) return 0;
   sl = kit_sym_str(pp->pool->c, t->spelling);
   s = sl.s;
   len = sl.len;
   if (!s || len == 0) return 0;
   for (size_t i = 0; i < len; ++i) {
     if (s[i] < '0' || s[i] > '9') break;
     v = v * 10u + (u32)(s[i] - '0');
   }
   *out = v;
   return 1;
 }
 
 static void handle_pragma_pack(Pp* pp, const Tok* line, u32 n) {
   u32 i = 0;
   if (n < 3 || line[0].kind != TOK_IDENT) return;
   {
     KitSlice sl = kit_sym_str(pp->pool->c, line[0].v.ident);
     const char* s = sl.s;
     size_t len = sl.len;
     if (!s || len != 4 || memcmp(s, "pack", 4) != 0) return;
   }
   if (line[1].kind != TOK_PUNCT || line[1].v.punct != '(') return;
   i = 2;
   if (i < n && line[i].kind == TOK_PUNCT && line[i].v.punct == ')') {
     pp->pack_align = 0;
     return;
   }
   if (i < n && line[i].kind == TOK_IDENT) {
     KitSlice sl = kit_sym_str(pp->pool->c, line[i].v.ident);
     const char* s = sl.s;
     size_t len = sl.len;
     if (s && len == 4 && memcmp(s, "push", 4) == 0) {
       if (pp->pack_stack_n <
           (u32)(sizeof pp->pack_stack / sizeof pp->pack_stack[0])) {
         pp->pack_stack[pp->pack_stack_n++] = pp->pack_align;
       }
       ++i;
       if (i < n && line[i].kind == TOK_PUNCT && line[i].v.punct == ',') {
         u32 v = 0;
         ++i;
         if (i < n && pragma_num_u32(pp, &line[i], &v)) pp->pack_align = v;
       }
       return;
     }
     if (s && len == 3 && memcmp(s, "pop", 3) == 0) {
       if (pp->pack_stack_n) pp->pack_align = pp->pack_stack[--pp->pack_stack_n];
       return;
     }
   }
   {
     u32 v = 0;
     if (pragma_num_u32(pp, &line[i], &v)) pp->pack_align = v;
   }
 }
 
 static void do_pragma(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   /* Forward unrecognised pragmas to the output. STDC pragmas pass
    * through too; we don't act on them yet. */
   handle_pragma_pack(pp, line, n);
   emit_pragma_line(pp, line, n, loc);
 }
 
 /* Destringize a string literal token's content: strip surrounding quotes
  * and undo the `\"` and `\\` escapes. Other escape sequences pass
  * through verbatim — the result is fed back through the lexer, which
  * does its own escape handling for any string literals nested inside. */
 static void destringize(Pp* pp, const Tok* str_tok, char* out, size_t cap,
                         size_t* out_len) {
   KitSlice sl = kit_sym_str(pp->pool->c, str_tok->spelling);
   const char* s = sl.s;
   size_t slen = sl.len;
   size_t i, w = 0;
   if (slen < 2 || s[0] != '"' || s[slen - 1] != '"') {
     compiler_panic(pp->c, str_tok->loc,
                    "_Pragma: argument must be a string literal");
   }
   for (i = 1; i + 1 < slen; ++i) {
     char c = s[i];
     if (c == '\\' && i + 2 < slen && (s[i + 1] == '\\' || s[i + 1] == '"')) {
       ++i;
       c = s[i];
     }
     if (w + 1 >= cap)
       compiler_panic(pp->c, str_tok->loc, "_Pragma: payload too long");
     out[w++] = c;
   }
   out[w] = 0;
   *out_len = w;
 }
 
 /* Handle a `_Pragma("...")` invocation. Caller has consumed the
  * `_Pragma` identifier. Reads `(` STR `)`, destringizes, re-lexes the
  * payload, and emits a #pragma directive line. */
 int try_expand_pragma_op(Pp* pp, const Tok* invoke) {
   Tok lp, str, rp;
   char buf[1024];
   size_t buf_n = 0;
   Lexer* lex;
   TokVec args = {0};
 
   /* Peek '(' (skipping NL). Use peek_for_invoke_paren for consistency,
    * but we need the saved-back behavior for a non-match. */
   {
     int saw_ws;
     if (!peek_for_invoke_paren(pp, &saw_ws)) {
       return 0; /* not an invocation; emit _Pragma as ident */
     }
     (void)saw_ws;
   }
   /* Read the string literal arg. */
   {
     HidesetId hs;
     str = src_next_raw(pp, &hs, NULL);
   }
   if (str.kind != TOK_STR) {
     compiler_panic(pp->c, invoke->loc, "_Pragma: expected string literal");
   }
   {
     HidesetId hs;
     rp = src_next_raw(pp, &hs, NULL);
   }
   if (rp.kind != TOK_PUNCT || rp.v.punct != ')') {
     compiler_panic(pp->c, invoke->loc, "_Pragma: expected ')'");
   }
   (void)lp;
 
   destringize(pp, &str, buf, sizeof(buf) - 2, &buf_n);
   /* Append a NL so the lexer terminates cleanly. */
   buf[buf_n++] = '\n';
   buf[buf_n] = 0;
 
   /* Re-lex into args. Bytes need to live until lex_close; copy into
    * arena. */
   {
     char* arena_buf = (char*)arena_alloc(pp->arena, buf_n + 1, 1);
     memcpy(arena_buf, buf, buf_n + 1);
     lex = lex_open_mem(pp->c, "<_Pragma>", arena_buf, buf_n);
   }
   for (;;) {
     Tok t = lex_next(lex);
     if (t.kind == TOK_EOF || t.kind == TOK_NEWLINE) break;
     tv_push(pp, &args, t);
   }
   lex_close(lex);
 
   emit_pragma_line(pp, args.data, args.n, invoke->loc);
   return 1;
 }
 
 /* ============================================================
  * #error / #warning
  * ============================================================ */
 
 static void directive_message(Pp* pp, const Tok* line, u32 n, CharBuf* cb) {
   u32 i;
   for (i = 0; i < n; ++i) {
     KitSlice slc = line[i].spelling ? kit_sym_str(pp->pool->c, line[i].spelling)
                                     : KIT_SLICE_NULL;
     const char* s = slc.s;
     size_t sl = slc.len;
     if (i > 0) cb_putc(pp, cb, ' ');
     if (s && sl) cb_append(pp, cb, s, (u32)sl);
   }
   cb_putc(pp, cb, 0);
 }
 
 static void pp_warn(Pp* pp, SrcLoc loc, const char* fmt, ...) {
   KitDiagSink* sink = kit_compiler_context(pp->c)->diag;
   va_list ap;
   if (sink && sink->emit) {
     va_start(ap, fmt);
     sink->emit(sink, KIT_DIAG_WARN, loc, fmt, ap);
     va_end(ap);
   }
   if (sink) sink->warnings++;
 }
 
 static void do_error(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   CharBuf cb = {0};
   directive_message(pp, line, n, &cb);
   compiler_panic(pp->c, loc, "#error: %.*s",
                  KIT_SLICE_ARG(kit_slice_cstr(cb.data ? cb.data : "")));
 }
 
 static void do_warning(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   CharBuf cb = {0};
   directive_message(pp, line, n, &cb);
   pp_warn(pp, loc, "#warning: %.*s",
           KIT_SLICE_ARG(kit_slice_cstr(cb.data ? cb.data : "")));
 }
 
 /* ============================================================
  * #embed (C23, §6.10.* per N3033)
  * ============================================================ */
 
 static void do_embed(Pp* pp, const Tok* line, u32 n, SrcLoc loc) {
   char path[4096];
   char resolved[4096];
   int system_form = 0;
   const u8* data;
   size_t size;
   u32 j;
   /* Optional embed parameters parsed below. */
   i64 limit_n = -1;
   Tok* if_empty_toks = NULL;
   u32 if_empty_n = 0;
   /* Header-name path: first token. */
   u32 arg_start = 0;
 
   if (n == 0) compiler_panic(pp->c, loc, "#embed: missing path");
 
   if (line[0].kind == TOK_HEADER) {
     KitSlice slc = kit_sym_str(pp->pool->c, line[0].spelling);
     const char* s = slc.s;
     size_t sl = slc.len;
     if (sl < 2) compiler_panic(pp->c, loc, "#embed: malformed header name");
     if (s[0] == '<' && s[sl - 1] == '>')
       system_form = 1;
     else if (s[0] == '"' && s[sl - 1] == '"')
       system_form = 0;
     else
       compiler_panic(pp->c, loc, "#embed: malformed header name");
     memcpy(path, s + 1, sl - 2);
     path[sl - 2] = 0;
     arg_start = 1;
   } else {
     compiler_panic(pp->c, loc, "#embed: header-name argument required");
   }
 
   /* Parse trailing parameters: limit(N), if_empty(...). */
   j = arg_start;
   while (j < n) {
     if (line[j].kind == TOK_IDENT) {
       KitSlice slc = kit_sym_str(pp->pool->c, line[j].v.ident);
       const char* s = slc.s;
       size_t sl = slc.len;
       if (sl == 5 && memcmp(s, "limit", 5) == 0) {
         if (j + 1 >= n || line[j + 1].kind != TOK_PUNCT ||
             line[j + 1].v.punct != '(') {
           compiler_panic(pp->c, loc, "#embed: expected '(' after limit");
         }
         j += 2;
         if (j >= n || line[j].kind != TOK_NUM) {
           compiler_panic(pp->c, loc, "#embed: limit() expects an integer");
         }
         {
           KitSlice s2 = kit_sym_str(pp->pool->c, line[j].spelling);
           limit_n = parse_pp_int(s2.s, s2.len);
         }
         ++j;
         if (j >= n || line[j].kind != TOK_PUNCT || line[j].v.punct != ')') {
           compiler_panic(pp->c, loc, "#embed: expected ')' to close limit");
         }
         ++j;
         continue;
       }
       if (sl == 8 && memcmp(s, "if_empty", 8) == 0) {
         u32 depth = 0;
         u32 start;
         if (j + 1 >= n || line[j + 1].kind != TOK_PUNCT ||
             line[j + 1].v.punct != '(') {
           compiler_panic(pp->c, loc, "#embed: expected '(' after if_empty");
         }
         j += 2;
         start = j;
         while (j < n) {
           if (line[j].kind == TOK_PUNCT) {
             if (line[j].v.punct == '(')
               ++depth;
             else if (line[j].v.punct == ')') {
               if (depth == 0) break;
               --depth;
             }
           }
           ++j;
         }
         if (j >= n) {
           compiler_panic(pp->c, loc, "#embed: unterminated if_empty");
         }
         if_empty_toks = arena_array(pp->arena, Tok, j - start ? j - start : 1);
         if_empty_n = j - start;
         memcpy(if_empty_toks, line + start, sizeof(Tok) * if_empty_n);
         ++j; /* skip ')' */
         continue;
       }
     }
     compiler_panic(pp->c, loc, "#embed: unexpected token in parameter list");
   }
 
   if (!find_and_open_include(pp, path, system_form, loc, &data, &size, resolved,
                              sizeof(resolved))) {
     compiler_panic(pp->c, loc, "#embed: file not found: %.*s",
                    KIT_SLICE_ARG(kit_slice_cstr(path)));
   }
 
   /* Apply limit(). */
   {
     size_t emit_n = size;
     if (limit_n >= 0 && (u64)limit_n < emit_n) emit_n = (size_t)limit_n;
     if (emit_n == 0) {
       /* Empty: emit if_empty payload (or nothing). */
       if (if_empty_toks && if_empty_n) {
         HidesetId* hids = arena_array(pp->arena, HidesetId, if_empty_n);
         u32 i;
         for (i = 0; i < if_empty_n; ++i) hids[i] = HS_EMPTY;
         push_buf(pp, if_empty_toks, hids, if_empty_n);
       }
       return;
     }
     /* Build a buffer of pp-numbers separated by ',' punctuators. */
     {
       TokVec out = {0};
       HidesetId* hids;
       size_t i;
       for (i = 0; i < emit_n; ++i) {
         char numbuf[8];
         int nl = 0;
         u8 v = data[i];
         /* "u8 -> decimal" without sprintf. */
         if (v == 0) {
           numbuf[nl++] = '0';
         } else {
           char tmp[4];
           int k = 0;
           while (v) {
             tmp[k++] = (char)('0' + (v % 10));
             v /= 10;
           }
           while (k > 0) numbuf[nl++] = tmp[--k];
         }
         {
           Tok t;
           memset(&t, 0, sizeof(t));
           t.kind = TOK_NUM;
           t.loc = loc;
           t.spelling = kit_sym_intern(
               pp->pool->c, (KitSlice){.s = numbuf, .len = (size_t)nl});
           if (i == 0) t.flags = TF_AT_BOL;
           /* Bytes after a comma get a leading space to match
            * clang's `, ` separator format. */
           else
             t.flags = TF_HAS_SPACE;
           tv_push(pp, &out, t);
         }
         if (i + 1 < emit_n) {
           Tok comma;
           memset(&comma, 0, sizeof(comma));
           comma.kind = TOK_PUNCT;
           comma.v.punct = ',';
           comma.loc = loc;
           comma.spelling = kit_sym_intern(pp->pool->c, KIT_SLICE_LIT(","));
           tv_push(pp, &out, comma);
         }
       }
       hids = arena_array(pp->arena, HidesetId, out.n ? out.n : 1);
       {
         u32 k;
         for (k = 0; k < out.n; ++k) hids[k] = HS_EMPTY;
       }
       push_buf(pp, out.data, hids, out.n);
     }
   }
 }
 
 /* ============================================================
  * Directive dispatch
  * ============================================================ */
 
 void process_directive(Pp* pp, SrcLoc hash_loc) {
   Tok* line;
   u32 n;
   Sym name;
 
   read_directive_line(pp, &line, &n);
   if (n == 0) {
     /* Null directive: '#' newline. Nothing to do. */
     return;
   }
   if (line[0].kind != TOK_IDENT) {
     compiler_panic(pp->c, line[0].loc, "expected directive name after '#'");
   }
   name = line[0].v.ident;
   if (name == pp->sym_define)
     do_define(pp, line + 1, n - 1);
   else if (name == pp->sym_undef)
     do_undef(pp, line + 1, n - 1);
   else if (name == pp->sym_if)
     do_if_directive(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_ifdef)
     do_ifdef(pp, line + 1, n - 1, 0, hash_loc);
   else if (name == pp->sym_ifndef)
     do_ifdef(pp, line + 1, n - 1, 1, hash_loc);
   else if (name == pp->sym_elif)
     do_elif(pp, hash_loc);
   else if (name == pp->sym_else)
     do_else(pp, hash_loc);
   else if (name == pp->sym_endif)
     do_endif(pp, hash_loc);
   else if (name == pp->sym_include)
     do_include(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_line)
     do_line(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_pragma)
     do_pragma(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_error)
     do_error(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_warning)
     do_warning(pp, line + 1, n - 1, hash_loc);
   else if (name == pp->sym_embed)
     do_embed(pp, line + 1, n - 1, hash_loc);
   else {
     compiler_panic(pp->c, line[0].loc, "unsupported directive");
   }
 }