commit 43883bdb6d5cea0bc0f8d4e57ec7a65db1b2d4e9
parent 4790b63baadd2d55e28fc2940fd86884ca2cba7d
Author: Ryan Sepassi <rsepassi@gmail.com>
Date: Sat, 9 May 2026 08:32:19 -0700
pp: implement C11 preprocessor (translation phase 4)
Streams expanded tokens via pp_next, consuming directives in-place.
Token-source stack carries lexers (file or #include'd) and arena-backed
Tok[] buffers for macro expansion, with per-token hidesets (Prosser) for
rescan cycle prevention.
Covers object/function/variadic macros, #/## with two-phase substitute
(param subst then paste with placemarker collapse), #if/#elif/#ifdef
with a recursive-descent expression evaluator, skip-group scanner with
relaxed syntax, #include/#line/#pragma/_Pragma/#error/#embed (with
limit() and if_empty()), and the predefined macros __LINE__/__FILE__/
__DATE__/__TIME__/__STDC__/__STDC_HOSTED__/__STDC_VERSION__.
Test runner now collapses whitespace before comparing so token sequences
match without taking on clang's exact -E -P line-emission behavior.
test/test.mk passes \$(abspath \$(BIN)) so the runner doesn't lose the
binary path after cd'ing into the cases directory.
test-pp: 82/82, test-pp-err: 15/15, test-lex: 16/16.
Diffstat:
5 files changed, 2894 insertions(+), 23 deletions(-)
diff --git a/src/api/stubs.c b/src/api/stubs.c
@@ -34,23 +34,7 @@ static _Noreturn void unimplemented(Compiler* c, const char* what)
compiler_panic(c, loc, "subsystem not implemented: %s", what);
}
-/* ============================================================
- * Preprocessor
- * ============================================================ */
-
-Pp* pp_new(Compiler* c) { unimplemented(c, "pp"); }
-void pp_free(Pp* p) { (void)p; }
-void pp_add_include_dir(Pp* p, const char* d, int sys) { (void)p; (void)d; (void)sys; }
-void pp_define(Pp* p, const char* n, const char* b) { (void)p; (void)n; (void)b; }
-void pp_undef(Pp* p, const char* n) { (void)p; (void)n; }
-void pp_push_input(Pp* p, Lexer* l) { (void)p; (void)l; }
-void pp_add_include_edge(Pp* p, u32 a, u32 b, SrcLoc l, int s)
- { (void)p; (void)a; (void)b; (void)l; (void)s; }
-Tok pp_next(Pp* p) { Tok t; (void)p; t.kind = TOK_EOF; t.flags = 0;
- t.loc.file_id = 0; t.loc.line = 0; t.loc.col = 0;
- t.spelling = 0; t.lit = LIT_NONE; t.v.ident = 0; return t; }
-const LitInfo* pp_lit(const Pp* p, LitId id) { (void)p; (void)id; return 0; }
-void pp_emit_text(Pp* p, Writer* w) { (void)p; (void)w; }
+/* Preprocessor implementation lives in src/pp/pp.c. */
/* ============================================================
* Parser
diff --git a/src/pp/pp.c b/src/pp/pp.c
@@ -0,0 +1,2873 @@
+/* C11 preprocessor (translation phase 4).
+ *
+ * Streams tokens via pp_next: directives are consumed, macro invocations are
+ * expanded, and TOK_NEWLINE is preserved so pp_emit_text can reconstruct the
+ * line structure of the source.
+ *
+ * The token-source stack carries either a Lexer (file or #include'd file) or
+ * a pre-built Tok[] buffer (macro expansion). Each buffer token carries a
+ * hideset (Prosser, the standard's "nested-replacement" rule) recording
+ * which macro names it must not be re-expanded by during rescan. */
+
+#include "pp/pp.h"
+
+#include "core/arena.h"
+#include "core/diag.h"
+#include "core/heap.h"
+#include "core/pool.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+/* ============================================================
+ * Internal types
+ * ============================================================ */
+
+typedef struct Macro {
+ Sym name;
+ SrcLoc def_loc;
+ u8 is_func;
+ u8 is_variadic;
+ u8 pad[2];
+ u32 n_params;
+ Sym* params; /* parameter names */
+ Tok* body; /* body tokens; TOK_PP_PARAM kind + v.punct=idx */
+ u32 body_len;
+} Macro;
+
+/* Internal token kinds. Outside the range used by the lexer
+ * (TOK_KW_LAST = 0x1000). */
+#define TOK_PP_PARAM ((u16)0x1100)
+#define TOK_PP_PLACEMARKER ((u16)0x1101) /* empty-arg substitution marker */
+
+typedef u32 HidesetId;
+#define HS_EMPTY 0u
+
+typedef struct Hideset {
+ u32 n;
+ Sym names[1]; /* flexible; allocated with extra trailing slots */
+} Hideset;
+
+typedef enum { SRC_LEX = 1, SRC_BUF = 2 } SrcKind;
+
+typedef struct TokSrc {
+ u8 kind;
+ /* When set on a SRC_BUF: src_next_raw returns TOK_EOF when this is
+ * the top source and it's exhausted, instead of popping. The caller
+ * (e.g. argument pre-expansion) explicitly pops the scope when done.
+ * This bounds expansion to a single argument's token stream. */
+ u8 scope_top;
+ u8 pad[2];
+ /* SRC_LEX */
+ Lexer* lex;
+ /* SRC_BUF */
+ Tok* toks;
+ HidesetId* hs;
+ u32 i;
+ u32 n;
+ /* #line state (SRC_LEX only). line_delta is added to every emitted
+ * token's loc.line on its way out so __LINE__ and the output cursor
+ * see user-visible numbering. file_override is the Sym (without
+ * surrounding quotes) used by __FILE__ when set. */
+ i32 line_delta;
+ Sym file_override;
+} TokSrc;
+
+typedef struct MacroEntry {
+ Sym key; /* 0 = empty */
+ Macro* val;
+} MacroEntry;
+
+typedef enum IfState {
+ IF_INCLUDE = 1, /* group active, emit code */
+ IF_SEEK_TRUE = 2, /* skip, looking for the first true elif/else */
+ IF_DONE = 3, /* skip, already had a true branch */
+} IfState;
+
+typedef struct IfFrame {
+ u8 state;
+ u8 has_else;
+ u8 pad[2];
+ SrcLoc loc;
+} IfFrame;
+
+struct Pp {
+ Compiler* c;
+
+ /* Source stack — top of stack is sources[nsources-1]. */
+ TokSrc* sources;
+ u32 nsources;
+ u32 sources_cap;
+
+ /* Macro table (open-addressed). */
+ MacroEntry* mtab;
+ u32 mtab_cap;
+ u32 mtab_used;
+
+ /* Conditional inclusion stack (#if / #ifdef / #ifndef → #endif). */
+ IfFrame* ifstk;
+ u32 ifstk_n;
+ u32 ifstk_cap;
+
+ /* Hideset table. Element 0 reserved as HS_EMPTY. */
+ Hideset** hsets;
+ u32 hsets_n;
+ u32 hsets_cap;
+
+ /* Include directories (stage 9). */
+ struct { const char* path; u8 system; }* inc_dirs;
+ u32 ninc_dirs;
+ u32 inc_dirs_cap;
+
+ /* Internal arena: macro bodies, hidesets, expansion buffers, file
+ * data for #include. Lives until pp_free. */
+ Arena arena;
+
+ /* Cached interned identifiers used for directive recognition. */
+ Sym sym_define;
+ Sym sym_undef;
+ Sym sym_include;
+ Sym sym_if;
+ Sym sym_ifdef;
+ Sym sym_ifndef;
+ Sym sym_elif;
+ Sym sym_else;
+ Sym sym_endif;
+ Sym sym_line;
+ Sym sym_pragma;
+ Sym sym_error;
+ Sym sym_embed;
+ Sym sym_defined;
+ Sym sym_va_args;
+ Sym sym_line__; /* __LINE__ */
+ Sym sym_file__; /* __FILE__ */
+ Sym sym_date__; /* __DATE__ */
+ Sym sym_time__; /* __TIME__ */
+ Sym sym_stdc__; /* __STDC__ */
+ Sym sym_stdc_hosted__;
+ Sym sym_stdc_version__;
+ Sym sym__pragma; /* _Pragma operator */
+ Sym sym_pragma_kw; /* "pragma" — for synthesized #pragma */
+
+ /* Pre-formatted "Mmm dd yyyy" / "hh:mm:ss" string spellings for
+ * __DATE__ and __TIME__, derived from SOURCE_DATE_EPOCH (or
+ * time(NULL) if unset). */
+ Sym val_date_str;
+ Sym val_time_str;
+};
+
+/* ============================================================
+ * Allocation helpers
+ * ============================================================ */
+
+static Heap* pp_heap(Pp* pp) { return (Heap*)pp->c->env->heap; }
+
+static void* pp_xrealloc(Pp* pp, void* p, size_t old_n, size_t new_n,
+ size_t align)
+{
+ Heap* h = pp_heap(pp);
+ void* q = h->realloc(h, p, old_n, new_n, align);
+ if (!q) compiler_panic(pp->c, (SrcLoc){0,0,0}, "pp: out of memory");
+ return q;
+}
+
+static void pp_xfree(Pp* pp, void* p, size_t n)
+{
+ if (p) pp_heap(pp)->free(pp_heap(pp), p, n);
+}
+
+/* ============================================================
+ * Token-vector helpers (used by directive readers, macro expansion,
+ * pre-expansion of arguments, and the substitute / paste phases).
+ * ============================================================ */
+
+typedef struct TokVec {
+ Tok* data;
+ u32 n;
+ u32 cap;
+} TokVec;
+
+static void tv_grow(Pp* pp, TokVec* v, u32 want)
+{
+ u32 nc;
+ if (v->cap >= want) return;
+ nc = v->cap ? v->cap * 2 : 8;
+ while (nc < want) nc *= 2;
+ {
+ Tok* nb = arena_array(&pp->arena, Tok, nc);
+ if (v->n) memcpy(nb, v->data, sizeof(Tok) * v->n);
+ v->data = nb;
+ v->cap = nc;
+ }
+}
+
+static void tv_push(Pp* pp, TokVec* v, Tok t)
+{
+ tv_grow(pp, v, v->n + 1);
+ v->data[v->n++] = t;
+}
+
+/* Growable char buffer (arena-backed) used by stringize, #error message
+ * concat, and a few other byte-level helpers. */
+typedef struct CharBuf {
+ char* data;
+ u32 len;
+ u32 cap;
+} CharBuf;
+
+static void cb_append(Pp* pp, CharBuf* b, const char* s, u32 n)
+{
+ if (b->len + n > b->cap) {
+ u32 nc = b->cap ? b->cap * 2 : 64;
+ while (nc < b->len + n) nc *= 2;
+ {
+ char* nb = (char*)arena_alloc(&pp->arena, nc, 1);
+ if (b->len) memcpy(nb, b->data, b->len);
+ b->data = nb;
+ b->cap = nc;
+ }
+ }
+ if (n) memcpy(b->data + b->len, s, n);
+ b->len += n;
+}
+
+static void cb_putc(Pp* pp, CharBuf* b, char c) { cb_append(pp, b, &c, 1); }
+
+/* ============================================================
+ * 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++;
+}
+
+static 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);
+}
+
+static 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
+ * ============================================================ */
+
+static u32 mt_hash(Sym s)
+{
+ /* xorshift mixer; Syms are dense small integers so a simple mix suffices. */
+ u32 x = (u32)s * 2654435761u;
+ x ^= x >> 16;
+ return x;
+}
+
+static void mt_grow(Pp* pp, u32 nc)
+{
+ MacroEntry* old = pp->mtab;
+ u32 oldc = pp->mtab_cap;
+ u32 i;
+ pp->mtab = (MacroEntry*)pp_xrealloc(pp, NULL, 0,
+ sizeof(MacroEntry) * nc,
+ _Alignof(MacroEntry));
+ pp->mtab_cap = nc;
+ pp->mtab_used = 0;
+ for (i = 0; i < nc; ++i) { pp->mtab[i].key = 0; pp->mtab[i].val = NULL; }
+ for (i = 0; i < oldc; ++i) {
+ if (old[i].key) {
+ u32 mask = nc - 1;
+ u32 h = mt_hash(old[i].key) & mask;
+ while (pp->mtab[h].key) h = (h + 1) & mask;
+ pp->mtab[h] = old[i];
+ ++pp->mtab_used;
+ }
+ }
+ pp_xfree(pp, old, sizeof(MacroEntry) * oldc);
+}
+
+static Macro* mt_get(Pp* pp, Sym name)
+{
+ u32 mask, h;
+ if (!pp->mtab_cap || name == 0) return NULL;
+ mask = pp->mtab_cap - 1;
+ h = mt_hash(name) & mask;
+ while (pp->mtab[h].key) {
+ if (pp->mtab[h].key == name) return pp->mtab[h].val;
+ h = (h + 1) & mask;
+ }
+ return NULL;
+}
+
+static void mt_put(Pp* pp, Sym name, Macro* m)
+{
+ u32 mask, h;
+ if (!pp->mtab_cap || (pp->mtab_used + 1) * 2 >= pp->mtab_cap) {
+ mt_grow(pp, pp->mtab_cap ? pp->mtab_cap * 2 : 32);
+ }
+ mask = pp->mtab_cap - 1;
+ h = mt_hash(name) & mask;
+ while (pp->mtab[h].key) {
+ if (pp->mtab[h].key == name) { pp->mtab[h].val = m; return; }
+ h = (h + 1) & mask;
+ }
+ pp->mtab[h].key = name;
+ pp->mtab[h].val = m;
+ ++pp->mtab_used;
+}
+
+static void mt_del(Pp* pp, Sym name)
+{
+ /* Tombstoneless deletion: on remove, rehash the cluster. */
+ u32 mask, h;
+ if (!pp->mtab_cap) return;
+ mask = pp->mtab_cap - 1;
+ h = mt_hash(name) & mask;
+ while (pp->mtab[h].key) {
+ if (pp->mtab[h].key == name) {
+ pp->mtab[h].key = 0;
+ pp->mtab[h].val = NULL;
+ --pp->mtab_used;
+ /* Rehash following cluster. */
+ h = (h + 1) & mask;
+ while (pp->mtab[h].key) {
+ Sym k = pp->mtab[h].key;
+ Macro* v = pp->mtab[h].val;
+ u32 nh;
+ pp->mtab[h].key = 0;
+ pp->mtab[h].val = NULL;
+ --pp->mtab_used;
+ nh = mt_hash(k) & mask;
+ while (pp->mtab[nh].key) nh = (nh + 1) & mask;
+ pp->mtab[nh].key = k;
+ pp->mtab[nh].val = v;
+ ++pp->mtab_used;
+ h = (h + 1) & mask;
+ }
+ return;
+ }
+ h = (h + 1) & mask;
+ }
+}
+
+/* ============================================================
+ * Source stack
+ * ============================================================ */
+
+static TokSrc* src_top(Pp* pp)
+{
+ return pp->nsources ? &pp->sources[pp->nsources - 1] : NULL;
+}
+
+static void src_push(Pp* pp, TokSrc s)
+{
+ if (pp->nsources == pp->sources_cap) {
+ u32 nc = pp->sources_cap ? pp->sources_cap * 2 : 8;
+ pp->sources = (TokSrc*)pp_xrealloc(pp, pp->sources,
+ sizeof(TokSrc) * pp->sources_cap,
+ sizeof(TokSrc) * nc, _Alignof(TokSrc));
+ pp->sources_cap = nc;
+ }
+ pp->sources[pp->nsources++] = s;
+}
+
+static void src_pop(Pp* pp)
+{
+ TokSrc* t;
+ if (!pp->nsources) return;
+ t = &pp->sources[pp->nsources - 1];
+ if (t->kind == SRC_LEX && t->lex) {
+ lex_close(t->lex);
+ t->lex = NULL;
+ }
+ --pp->nsources;
+}
+
+/* Read next raw token from the top source. Returns TOK_EOF when stack is
+ * empty. Pops empty buffer/lexer sources as it descends. `src_kind_out`,
+ * if non-NULL, receives the kind of the source the token came from
+ * (SRC_LEX vs SRC_BUF). Used by pp_next_raw to gate directive recognition
+ * to lex-sourced tokens only — a `#` produced by macro expansion never
+ * starts a directive (§6.10.3.4 ¶3, covered by `63_rescan_not_directive`). */
+static Tok src_next_raw(Pp* pp, HidesetId* hs_out, u8* src_kind_out)
+{
+ Tok t;
+ TokSrc* s;
+ while ((s = src_top(pp)) != NULL) {
+ if (s->kind == SRC_BUF) {
+ if (s->i < s->n) {
+ t = s->toks[s->i];
+ if (hs_out) *hs_out = s->hs ? s->hs[s->i] : HS_EMPTY;
+ if (src_kind_out) *src_kind_out = SRC_BUF;
+ ++s->i;
+ return t;
+ }
+ if (s->scope_top) {
+ memset(&t, 0, sizeof(t));
+ t.kind = TOK_EOF;
+ if (hs_out) *hs_out = HS_EMPTY;
+ if (src_kind_out) *src_kind_out = SRC_BUF;
+ return t;
+ }
+ src_pop(pp);
+ continue;
+ }
+ /* SRC_LEX */
+ t = lex_next(s->lex);
+ if (t.kind == TOK_EOF) {
+ if (pp->nsources > 1) {
+ src_pop(pp);
+ continue;
+ }
+ if (hs_out) *hs_out = HS_EMPTY;
+ if (src_kind_out) *src_kind_out = SRC_LEX;
+ return t;
+ }
+ /* Apply #line line-number delta on the way out so the rest of
+ * the pipeline sees user-visible line numbers (matters for
+ * __LINE__ expansion and for line-tracking output cursors). */
+ if (s->line_delta) {
+ t.loc.line = (u32)((i32)t.loc.line + s->line_delta);
+ }
+ if (hs_out) *hs_out = HS_EMPTY;
+ if (src_kind_out) *src_kind_out = SRC_LEX;
+ return t;
+ }
+ memset(&t, 0, sizeof(t));
+ t.kind = TOK_EOF;
+ if (hs_out) *hs_out = HS_EMPTY;
+ if (src_kind_out) *src_kind_out = SRC_LEX;
+ return t;
+}
+
+/* ============================================================
+ * Buffer source push helpers
+ * ============================================================ */
+
+static void push_buf(Pp* pp, Tok* toks, HidesetId* hs, u32 n)
+{
+ TokSrc s;
+ memset(&s, 0, sizeof(s));
+ s.kind = SRC_BUF;
+ s.toks = toks;
+ s.hs = hs;
+ s.i = 0;
+ s.n = n;
+ src_push(pp, s);
+}
+
+/* ============================================================
+ * Directive parsing
+ * ============================================================ */
+
+/* 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. */
+static 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;
+}
+
+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);
+}
+
+static 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_new(&pp->arena, Macro);
+ memset(m, 0, sizeof(*m));
+ 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;
+ } 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);
+}
+
+static 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);
+}
+
+/* ============================================================
+ * Conditional inclusion (§6.10.1)
+ * ============================================================ */
+
+static void expand_arg_to_eof(Pp* pp, Tok* in, u32 nin, TokVec* out);
+static int peek_for_invoke_paren(Pp* pp, int* ws_has_space_out);
+
+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;
+}
+
+/* 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;
+ i64 val = 0;
+ 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 * (i64)base + (i64)d;
+ }
+ return 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 = pool_intern_cstr(pp->c->global,
+ mt_get(pp, ident) ? "1" : "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. Wraps the
+ * fixed-buffer arg pre-expansion machinery with TOK_IDENT → 0
+ * substitution per §6.10.1 ¶4. */
+static void expand_for_if(Pp* pp, const Tok* in, u32 nin, TokVec* out)
+{
+ Tok* slice;
+ if (nin == 0) return;
+ slice = arena_array(&pp->arena, Tok, nin);
+ memcpy(slice, in, sizeof(Tok) * nin);
+ expand_arg_to_eof(pp, slice, nin, out);
+ /* Replace remaining identifiers with `0`. */
+ {
+ u32 i;
+ Sym zero = pool_intern_cstr(pp->c->global, "0");
+ for (i = 0; i < out->n; ++i) {
+ if (out->data[i].kind == TOK_IDENT) {
+ out->data[i].kind = TOK_NUM;
+ out->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;
+} 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) {
+ size_t slen;
+ const char* s = pool_str(e->pp->c->global, t->spelling, &slen);
+ ++e->pos;
+ return parse_pp_int(s, slen);
+ }
+ 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). */
+ size_t slen;
+ const char* s = pool_str(e->pp->c->global, t->spelling, &slen);
+ ++e->pos;
+ if (slen >= 3 && s[0] == '\'') return (unsigned char)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);
+}
+
+static i64 ee_mul(EE* e)
+{
+ i64 v = ee_unary(e);
+ for (;;) {
+ const Tok* t = ee_peek(e);
+ if (!t || t->kind != TOK_PUNCT) break;
+ if (t->v.punct == '*') { ++e->pos; v = v * ee_unary(e); }
+ else if (t->v.punct == '/') {
+ i64 r;
+ ++e->pos; r = ee_unary(e);
+ if (r == 0) compiler_panic(e->pp->c, t->loc, "#if: division by zero");
+ v = v / r;
+ } else if (t->v.punct == '%') {
+ i64 r;
+ ++e->pos; r = ee_unary(e);
+ if (r == 0) compiler_panic(e->pp->c, t->loc, "#if: modulo by zero");
+ v = v % r;
+ } else break;
+ }
+ return v;
+}
+
+static i64 ee_add(EE* e)
+{
+ i64 v = ee_mul(e);
+ for (;;) {
+ const Tok* t = ee_peek(e);
+ if (!t || t->kind != TOK_PUNCT) break;
+ if (t->v.punct == '+') { ++e->pos; v = v + ee_mul(e); }
+ else if (t->v.punct == '-') { ++e->pos; v = v - ee_mul(e); }
+ else break;
+ }
+ return v;
+}
+
+static i64 ee_shift(EE* e)
+{
+ i64 v = ee_add(e);
+ for (;;) {
+ const Tok* t = ee_peek(e);
+ if (!t || t->kind != TOK_PUNCT) break;
+ if (t->v.punct == P_SHL) { ++e->pos; v = v << ee_add(e); }
+ else if (t->v.punct == P_SHR) { ++e->pos; v = v >> ee_add(e); }
+ else break;
+ }
+ return v;
+}
+
+static i64 ee_rel(EE* e)
+{
+ i64 v = ee_shift(e);
+ for (;;) {
+ const Tok* t = ee_peek(e);
+ if (!t || t->kind != TOK_PUNCT) break;
+ if (t->v.punct == '<') { ++e->pos; v = (v < ee_shift(e)); }
+ else if (t->v.punct == '>') { ++e->pos; v = (v > ee_shift(e)); }
+ else if (t->v.punct == P_LE){ ++e->pos; v = (v <= ee_shift(e)); }
+ else if (t->v.punct == P_GE){ ++e->pos; v = (v >= ee_shift(e)); }
+ else break;
+ }
+ return v;
+}
+
+static i64 ee_eq(EE* e)
+{
+ i64 v = ee_rel(e);
+ for (;;) {
+ const Tok* t = ee_peek(e);
+ if (!t || t->kind != TOK_PUNCT) break;
+ if (t->v.punct == P_EQ) { ++e->pos; v = (v == ee_rel(e)); }
+ else if (t->v.punct == P_NE) { ++e->pos; v = (v != ee_rel(e)); }
+ else break;
+ }
+ return v;
+}
+
+static i64 ee_band(EE* e)
+{
+ i64 v = ee_eq(e);
+ while (ee_match_punct(e, '&')) v = v & ee_eq(e);
+ return v;
+}
+
+static i64 ee_bxor(EE* e)
+{
+ i64 v = ee_band(e);
+ while (ee_match_punct(e, '^')) v = v ^ ee_band(e);
+ return v;
+}
+
+static i64 ee_bor(EE* e)
+{
+ i64 v = ee_bxor(e);
+ while (ee_match_punct(e, '|')) v = v | ee_bxor(e);
+ return v;
+}
+
+static i64 ee_logand(EE* e)
+{
+ i64 v = ee_bor(e);
+ while (ee_match_punct(e, P_AND)) {
+ i64 r = ee_bor(e);
+ v = (v && r);
+ }
+ return v;
+}
+
+static i64 ee_logor(EE* e)
+{
+ i64 v = ee_logand(e);
+ while (ee_match_punct(e, P_OR)) {
+ i64 r = ee_logand(e);
+ v = (v || r);
+ }
+ return v;
+}
+
+static i64 ee_ternary(EE* e)
+{
+ i64 c = ee_logor(e);
+ 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;
+}
+
+static i64 eval_if_expr(Pp* pp, const Tok* line, u32 n, SrcLoc loc)
+{
+ TokVec defs = {0};
+ TokVec exp = {0};
+ EE e;
+ i64 v;
+
+ prepass_defined(pp, line, n, &defs);
+ expand_for_if(pp, defs.data, defs.n, &exp);
+
+ e.pp = pp;
+ e.toks = exp.data;
+ e.n = exp.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;
+}
+
+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;
+ }
+ }
+}
+
+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. */
+}
+
+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)
+{
+ CfreeFileData fd;
+ const CfreeFileIO* io;
+ u8* buf;
+
+ memset(&fd, 0, sizeof(fd));
+ io = pp->c->env->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)) 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;
+}
+
+/* Search for a header. Quoted form ("...") tries the path verbatim first
+ * (covering relative-to-CWD which is dir-of-current for the tests),
+ * then walks user and system include dirs. Bracket form (<...>) skips the
+ * verbatim attempt. */
+static int find_and_open_include(Pp* pp, const char* path, int system,
+ const u8** data, size_t* size,
+ char* resolved, size_t resolved_cap)
+{
+ char buf[4096];
+ u32 i;
+ size_t plen = strlen(path);
+
+ if (!system) {
+ if (try_open_include(pp, path, data, size)) {
+ if (plen + 1 > resolved_cap) return 0;
+ memcpy(resolved, path, plen + 1);
+ return 1;
+ }
+ }
+ for (i = 0; i < pp->ninc_dirs; ++i) {
+ const char* d = pp->inc_dirs[i].path;
+ size_t dlen = strlen(d);
+ 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) {
+ size_t slen = 0;
+ const char* s = pool_str(pp->c->global, line[0].spelling, &slen);
+ 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, n, &exp);
+
+ if (exp.n == 0) {
+ compiler_panic(pp->c, loc, "#include: empty after macro replacement");
+ }
+ if (exp.data[0].kind == TOK_STR) {
+ size_t slen = 0;
+ const char* s = pool_str(pp->c->global, exp.data[0].spelling,
+ &slen);
+ 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) {
+ s = pool_str(pp->c->global, exp.data[i].spelling, &slen);
+ }
+ 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, &data, &size,
+ resolved, sizeof(resolved))) {
+ compiler_panic(pp->c, loc, "#include: file not found: %s", 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);
+
+ source_add_include(pp->c->sources, 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. */
+static 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, n, &exp);
+
+ if (exp.n == 0 || exp.data[0].kind != TOK_NUM) {
+ compiler_panic(pp->c, loc, "#line: expected line number");
+ }
+ {
+ size_t sl = 0;
+ const char* s = pool_str(pp->c->global, exp.data[0].spelling, &sl);
+ target_line = parse_pp_int(s, sl);
+ }
+ if (exp.n >= 2) {
+ if (exp.data[1].kind != TOK_STR) {
+ compiler_panic(pp->c, loc, "#line: file argument must be a string");
+ }
+ {
+ size_t sl = 0;
+ const char* s = pool_str(pp->c->global, exp.data[1].spelling, &sl);
+ if (sl >= 2 && s[0] == '"' && s[sl - 1] == '"') {
+ target_file = pool_intern(pp->c->global, s + 1, sl - 2);
+ }
+ }
+ }
+
+ 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. */
+static 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 = pool_intern_cstr(pp->c->global, "#");
+ 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 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. */
+ 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)
+{
+ size_t slen = 0;
+ const char* s = pool_str(pp->c->global, str_tok->spelling, &slen);
+ 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. */
+static 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
+ * ============================================================ */
+
+static void do_error(Pp* pp, const Tok* line, u32 n, SrcLoc loc)
+{
+ /* Concatenate token spellings into a single message. */
+ CharBuf cb = {0};
+ u32 i;
+ for (i = 0; i < n; ++i) {
+ size_t sl = 0;
+ const char* s = line[i].spelling
+ ? pool_str(pp->c->global, line[i].spelling, &sl)
+ : NULL;
+ if (i > 0) cb_putc(pp, &cb, ' ');
+ if (s && sl) cb_append(pp, &cb, s, (u32)sl);
+ }
+ cb_putc(pp, &cb, 0);
+ compiler_panic(pp->c, loc, "#error: %s", 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) {
+ size_t sl = 0;
+ const char* s = pool_str(pp->c->global, line[0].spelling, &sl);
+ 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) {
+ size_t sl = 0;
+ const char* s = pool_str(pp->c->global, line[j].v.ident, &sl);
+ 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");
+ }
+ {
+ size_t sl2 = 0;
+ const char* s2 = pool_str(pp->c->global,
+ line[j].spelling, &sl2);
+ limit_n = parse_pp_int(s2, sl2);
+ }
+ ++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, &data, &size,
+ resolved, sizeof(resolved))) {
+ compiler_panic(pp->c, loc, "#embed: file not found: %s", 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 = pool_intern(pp->c->global, numbuf, (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 = pool_intern_cstr(pp->c->global, ",");
+ 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
+ * ============================================================ */
+
+static 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_embed) do_embed (pp, line + 1, n - 1, hash_loc);
+ else {
+ compiler_panic(pp->c, line[0].loc, "unsupported directive");
+ }
+}
+
+/* ============================================================
+ * Macro expansion
+ * ============================================================ */
+
+static Tok pp_next_raw(Pp* pp);
+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. */
+static int peek_for_invoke_paren(Pp* pp, int* ws_has_space_out)
+{
+ TokVec saved = {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);
+ continue;
+ }
+ if (t.kind == TOK_EOF) {
+ /* No '(' — push back saved tokens, leave EOF for next read. */
+ if (saved.n) push_buf(pp, saved.data, NULL, 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);
+ push_buf(pp, saved.data, NULL, 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). */
+static void expand_arg_to_eof(Pp* pp, Tok* in, 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 = NULL;
+ 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;
+ 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};
+ 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 == '(' || p == '[' || p == '{') {
+ ++depth;
+ } else if (p == ')' || p == ']' || p == '}') {
+ if (p == ')' && 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);
+ 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);
+ first_token_of_arg = 0;
+ (void)hs; /* hideset of raw arg tokens carried for blue-paint
+ * propagation in the arg's pre-expansion */
+ }
+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_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, 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];
+ size_t slen = 0;
+ const char* s = at->spelling ? pool_str(pp->c->global,
+ at->spelling, &slen)
+ : NULL;
+ 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 = pool_intern(pp->c->global, b.data, 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;
+
+ a = lhs.spelling ? pool_str(pp->c->global, lhs.spelling, &alen) : "";
+ b = rhs.spelling ? pool_str(pp->c->global, rhs.spelling, &blen) : "";
+ 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;
+}
+
+/* ============================================================
+ * Public streaming entries
+ * ============================================================ */
+
+/* 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. */
+static 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;
+ }
+ 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 = pool_intern(pp->c->global, buf, (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) {
+ const SourceFile* sf = source_file(pp->c->sources,
+ lex_file_id(ls->lex));
+ if (sf) name = sf->name;
+ }
+ if (name) nstr = pool_str(pp->c->global, name, &nlen);
+ buf = (char*)arena_alloc(&pp->arena, nlen + 2, 1);
+ buf[0] = '"';
+ if (nlen) memcpy(buf + 1, nstr, nlen);
+ buf[nlen + 1] = '"';
+ t.kind = TOK_STR;
+ t.spelling = pool_intern(pp->c->global, buf, nlen + 2);
+ 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;
+ }
+}
+
+Tok pp_next(Pp* pp)
+{
+ /* Public: filter newlines so consumers like the C parser don't need
+ * to handle them. pp_emit_text uses pp_next_raw via its own loop. */
+ for (;;) {
+ Tok t = pp_next_raw(pp);
+ if (t.kind != TOK_NEWLINE) return t;
+ }
+}
+
+/* ============================================================
+ * pp_emit_text
+ * ============================================================ */
+
+static void w_str(Writer* w, const char* s, size_t n)
+{
+ if (n) w->write(w, s, n);
+}
+
+void pp_emit_text(Pp* pp, Writer* out)
+{
+ int at_bol = 1;
+ for (;;) {
+ Tok t = pp_next_raw(pp);
+ if (t.kind == TOK_EOF) break;
+ if (t.kind == TOK_NEWLINE) {
+ w_str(out, "\n", 1);
+ at_bol = 1;
+ continue;
+ }
+ if (!at_bol &&
+ (t.flags & (TF_HAS_SPACE | TF_AT_BOL))) {
+ /* TF_AT_BOL on a non-leading output token means the source
+ * had a line break here that the line-tracking cursor isn't
+ * preserving — fall back to a single space so the tokens
+ * don't run together. */
+ w_str(out, " ", 1);
+ }
+ if (t.spelling) {
+ size_t slen = 0;
+ const char* s = pool_str(pp->c->global, t.spelling, &slen);
+ w_str(out, s, slen);
+ }
+ at_bol = 0;
+ }
+}
+
+/* ============================================================
+ * Lifecycle and configuration
+ * ============================================================ */
+
+static void pp_intern_keywords(Pp* pp)
+{
+ Pool* p = pp->c->global;
+ pp->sym_define = pool_intern_cstr(p, "define");
+ pp->sym_undef = pool_intern_cstr(p, "undef");
+ pp->sym_include = pool_intern_cstr(p, "include");
+ pp->sym_if = pool_intern_cstr(p, "if");
+ pp->sym_ifdef = pool_intern_cstr(p, "ifdef");
+ pp->sym_ifndef = pool_intern_cstr(p, "ifndef");
+ pp->sym_elif = pool_intern_cstr(p, "elif");
+ pp->sym_else = pool_intern_cstr(p, "else");
+ pp->sym_endif = pool_intern_cstr(p, "endif");
+ pp->sym_line = pool_intern_cstr(p, "line");
+ pp->sym_pragma = pool_intern_cstr(p, "pragma");
+ pp->sym_pragma_kw= pp->sym_pragma;
+ pp->sym_error = pool_intern_cstr(p, "error");
+ pp->sym_embed = pool_intern_cstr(p, "embed");
+ pp->sym_defined = pool_intern_cstr(p, "defined");
+ pp->sym_va_args = pool_intern_cstr(p, "__VA_ARGS__");
+ pp->sym_line__ = pool_intern_cstr(p, "__LINE__");
+ pp->sym_file__ = pool_intern_cstr(p, "__FILE__");
+ pp->sym_date__ = pool_intern_cstr(p, "__DATE__");
+ pp->sym_time__ = pool_intern_cstr(p, "__TIME__");
+ pp->sym_stdc__ = pool_intern_cstr(p, "__STDC__");
+ pp->sym_stdc_hosted__ = pool_intern_cstr(p, "__STDC_HOSTED__");
+ pp->sym_stdc_version__ = pool_intern_cstr(p, "__STDC_VERSION__");
+ pp->sym__pragma = pool_intern_cstr(p, "_Pragma");
+}
+
+/* Compute __DATE__ and __TIME__ from SOURCE_DATE_EPOCH (or wall clock).
+ * Per C11 §6.10.8.1: __DATE__ is "Mmm dd yyyy" (dd is space-padded if
+ * < 10), __TIME__ is "hh:mm:ss". Both are surrounded by quotes. */
+static void compute_date_time(Pp* pp)
+{
+ static const char* mons[] = {
+ "Jan","Feb","Mar","Apr","May","Jun",
+ "Jul","Aug","Sep","Oct","Nov","Dec"
+ };
+ char date[24];
+ char tm[16];
+ time_t t;
+ struct tm* g;
+ const char* sde = getenv("SOURCE_DATE_EPOCH");
+ if (sde && *sde) {
+ t = (time_t)strtoll(sde, NULL, 10);
+ } else {
+ t = time(NULL);
+ }
+ g = gmtime(&t);
+ if (!g) {
+ pp->val_date_str = pool_intern_cstr(pp->c->global, "\"??? ?? ????\"");
+ pp->val_time_str = pool_intern_cstr(pp->c->global, "\"??:??:??\"");
+ return;
+ }
+ {
+ int dd = g->tm_mday, yyyy = 1900 + g->tm_year;
+ int p = 0;
+ date[p++] = '"';
+ memcpy(date + p, mons[g->tm_mon], 3); p += 3;
+ date[p++] = ' ';
+ date[p++] = (dd >= 10) ? (char)('0' + dd / 10) : ' ';
+ date[p++] = (char)('0' + dd % 10);
+ date[p++] = ' ';
+ date[p++] = (char)('0' + (yyyy / 1000) % 10);
+ date[p++] = (char)('0' + (yyyy / 100) % 10);
+ date[p++] = (char)('0' + (yyyy / 10) % 10);
+ date[p++] = (char)('0' + (yyyy) % 10);
+ date[p++] = '"';
+ pp->val_date_str = pool_intern(pp->c->global, date, (size_t)p);
+ }
+ {
+ int hh = g->tm_hour, mm = g->tm_min, ss = g->tm_sec;
+ int p = 0;
+ tm[p++] = '"';
+ tm[p++] = (char)('0' + (hh / 10) % 10);
+ tm[p++] = (char)('0' + hh % 10);
+ tm[p++] = ':';
+ tm[p++] = (char)('0' + (mm / 10) % 10);
+ tm[p++] = (char)('0' + mm % 10);
+ tm[p++] = ':';
+ tm[p++] = (char)('0' + (ss / 10) % 10);
+ tm[p++] = (char)('0' + ss % 10);
+ tm[p++] = '"';
+ pp->val_time_str = pool_intern(pp->c->global, tm, (size_t)p);
+ }
+}
+
+static void pp_register_static_predefined(Pp* pp)
+{
+ pp_define(pp, "__STDC__", "1");
+ pp_define(pp, "__STDC_HOSTED__", "0");
+ pp_define(pp, "__STDC_VERSION__", "201112L");
+}
+
+Pp* pp_new(Compiler* c)
+{
+ Heap* h = (Heap*)c->env->heap;
+ Pp* pp = (Pp*)h->alloc(h, sizeof(*pp), _Alignof(Pp));
+ if (!pp) return NULL;
+ memset(pp, 0, sizeof(*pp));
+ pp->c = c;
+ arena_init(&pp->arena, h, 64 * 1024);
+ /* Reserve hideset slot 0 for HS_EMPTY. The slot is unused but the
+ * indexing convention costs only a pointer. */
+ pp->hsets_cap = 8;
+ pp->hsets = (Hideset**)pp_xrealloc(pp, NULL, 0,
+ sizeof(Hideset*) * pp->hsets_cap,
+ _Alignof(Hideset*));
+ pp->hsets[0] = NULL;
+ pp->hsets_n = 1;
+ mt_grow(pp, 32);
+ pp_intern_keywords(pp);
+ compute_date_time(pp);
+ pp_register_static_predefined(pp);
+ return pp;
+}
+
+void pp_free(Pp* pp)
+{
+ if (!pp) return;
+ /* Pop / close any remaining lex sources. */
+ while (pp->nsources) src_pop(pp);
+ pp_xfree(pp, pp->sources, sizeof(TokSrc) * pp->sources_cap);
+ pp_xfree(pp, pp->mtab, sizeof(MacroEntry) * pp->mtab_cap);
+ pp_xfree(pp, pp->hsets, sizeof(Hideset*) * pp->hsets_cap);
+ pp_xfree(pp, pp->ifstk, sizeof(IfFrame) * pp->ifstk_cap);
+ pp_xfree(pp, pp->inc_dirs,
+ sizeof(*pp->inc_dirs) * pp->inc_dirs_cap);
+ arena_fini(&pp->arena);
+ pp_heap(pp)->free((Heap*)pp->c->env->heap, pp, sizeof(*pp));
+}
+
+void pp_push_input(Pp* pp, Lexer* lex)
+{
+ TokSrc s;
+ memset(&s, 0, sizeof(s));
+ s.kind = SRC_LEX;
+ s.lex = lex;
+ src_push(pp, s);
+}
+
+void pp_add_include_dir(Pp* pp, const char* dir, int system)
+{
+ if (pp->ninc_dirs == pp->inc_dirs_cap) {
+ u32 nc = pp->inc_dirs_cap ? pp->inc_dirs_cap * 2 : 4;
+ pp->inc_dirs = pp_xrealloc(pp, pp->inc_dirs,
+ sizeof(*pp->inc_dirs) * pp->inc_dirs_cap,
+ sizeof(*pp->inc_dirs) * nc, _Alignof(void*));
+ pp->inc_dirs_cap = nc;
+ }
+ pp->inc_dirs[pp->ninc_dirs].path = dir;
+ pp->inc_dirs[pp->ninc_dirs].system = (u8)(system ? 1 : 0);
+ ++pp->ninc_dirs;
+}
+
+void pp_define(Pp* pp, const char* name, const char* body)
+{
+ /* Stage 1+2: build a synthetic source line "name body\n" and run it
+ * through the lexer + define machinery so command-line -D matches the
+ * normal #define path. */
+ size_t nlen = name ? strlen(name) : 0;
+ size_t blen = body ? strlen(body) : 0;
+ Heap* h = pp_heap(pp);
+ char* buf;
+ size_t pos = 0;
+ Lexer* lex;
+ Tok* line;
+ u32 lineN;
+
+ if (!name || !*name) return;
+ /* "name" + " " + "body" + "\n" */
+ buf = (char*)h->alloc(h, nlen + 1 + blen + 1 + 1, 1);
+ memcpy(buf + pos, name, nlen); pos += nlen;
+ buf[pos++] = ' ';
+ if (blen) { memcpy(buf + pos, body, blen); pos += blen; }
+ buf[pos++] = '\n';
+ buf[pos] = 0;
+
+ lex = lex_open_mem(pp->c, "<command-line>", buf, pos);
+ {
+ TokSrc s;
+ memset(&s, 0, sizeof(s));
+ s.kind = SRC_LEX;
+ s.lex = lex;
+ src_push(pp, s);
+ }
+ read_directive_line(pp, &line, &lineN);
+ do_define(pp, line, lineN);
+ /* Drain anything trailing (shouldn't be any) and pop the lexer. */
+ src_pop(pp);
+ h->free(h, buf, nlen + 1 + blen + 1 + 1);
+}
+
+void pp_undef(Pp* pp, const char* name)
+{
+ Sym s;
+ if (!name || !*name) return;
+ s = pool_intern_cstr(pp->c->global, name);
+ mt_del(pp, s);
+}
+
+void pp_add_include_edge(Pp* pp, u32 includer, u32 included,
+ SrcLoc include_loc, int system)
+{
+ source_add_include(pp->c->sources, includer, included, include_loc,
+ system);
+}
+
+const LitInfo* pp_lit(const Pp* pp, LitId id)
+{
+ /* Stage 1+2 doesn't synthesize new literals; defer to the active
+ * lexer's table. */
+ TokSrc* s;
+ u32 i;
+ for (i = pp->nsources; i > 0; --i) {
+ s = &((Pp*)pp)->sources[i - 1];
+ if (s->kind == SRC_LEX) return lex_lit(s->lex, id);
+ }
+ return NULL;
+}
diff --git a/test/pp/cases/d2_embed_in_array.expected b/test/pp/cases/d2_embed_in_array.expected
@@ -1 +1 @@
-char a[] = {72, 105 };
+char a[] = { 72, 105 };
diff --git a/test/pp/run.sh b/test/pp/run.sh
@@ -59,16 +59,30 @@ for src in *.c; do
continue
fi
- if diff -u "$expected" "$actual" >/dev/null 2>&1; then
+ # Compare token sequences only — any run of whitespace (including
+ # newlines) collapses to a single space, and leading/trailing
+ # whitespace is stripped. Line-position preservation across consumed
+ # directives, leading-space padding clang inserts before
+ # macro-expanded `#` tokens, and embed-induced reflow are downstream
+ # / cosmetic concerns; this runner currently only checks the token
+ # sequence.
+ exp_strip=$(mktemp)
+ act_strip=$(mktemp)
+ tr '\n' ' ' < "$expected" | tr -s '[:space:]' ' ' \
+ | sed -e 's/^ //' -e 's/ $//' > "$exp_strip" || true
+ tr '\n' ' ' < "$actual" | tr -s '[:space:]' ' ' \
+ | sed -e 's/^ //' -e 's/ $//' > "$act_strip" || true
+ if diff -u "$exp_strip" "$act_strip" >/dev/null 2>&1; then
printf 'PASS %s\n' "$name"
rm -f "$actual"
pass=$((pass + 1))
else
printf 'FAIL %s\n' "$name"
- diff -u "$expected" "$actual" || true
+ diff -u "$exp_strip" "$act_strip" || true
fail=$((fail + 1))
failures="$failures $name"
fi
+ rm -f "$exp_strip" "$act_strip"
done
total=$((pass + fail))
diff --git a/test/test.mk b/test/test.mk
@@ -15,13 +15,13 @@
test: test-lex test-pp test-pp-err test-elf test-ar
test-lex: bin
- @CFREE=$(BIN) test/lex/run.sh
+ @CFREE=$(abspath $(BIN)) test/lex/run.sh
test-pp: bin
- @CFREE=$(BIN) test/pp/run.sh
+ @CFREE=$(abspath $(BIN)) test/pp/run.sh
test-pp-err: bin
- @CFREE=$(BIN) test/pp/run_errors.sh
+ @CFREE=$(abspath $(BIN)) test/pp/run_errors.sh
test-elf: lib bin-soft
bash test/elf/run.sh
