Pragma, Preprocessor: add "beforeInclude" hook, extend "once"

src/aro/Pragma.zig

@@ -4,10 +4,13 @@ const Compilation = @import("Compilation.zig");
 const Diagnostics = @import("Diagnostics.zig");
 const Parser = @import("Parser.zig");
 const Preprocessor = @import("Preprocessor.zig");
+const Source = @import("Source.zig");
 const TokenIndex = @import("Tree.zig").TokenIndex;
 
 pub const Error = Compilation.Error || error{ UnknownPragma, StopPreprocessing };
 
+pub const BeforeIncludeError = Compilation.Error || error{SkipInclude};
+
 const Pragma = @This();
 
 /// A do-nothing pragma; useful for unwrapping an optional pragma into a pragma that does nothing in the null case.
@@ -29,6 +32,10 @@ afterParse: ?*const fn (*Pragma, *Compilation) void = null,
 /// Called during Compilation.deinit
 deinit: *const fn (*Pragma, *Compilation) void,
 
+/// Called during Preprocessor.include. Return SkipInclude to skip the include
+/// altogether (see once.zig).
+beforeInclude: ?*const fn (*Pragma, *Preprocessor, Source) BeforeIncludeError!void = null,
+
 /// Called whenever the preprocessor encounters this pragma. `start_idx` is the index
 /// within `pp.tokens` of the pragma name token. The pragma end is indicated by a
 /// .nl token (which may be generated if the source ends with a pragma with no newline)

src/aro/Preprocessor.zig

@@ -829,6 +829,9 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         }
 
                         _ = pp.defines.orderedRemove(macro_name);
+                        if (pp.verbose) {
+                            pp.verboseLog(directive, "macro {s} undefined", .{macro_name});
+                        }
                         try pp.expectNl(&tokenizer);
                     },
                     .keyword_include => {
@@ -3550,6 +3553,34 @@ fn include(pp: *Preprocessor, tokenizer: *Tokenizer, which: Compilation.WhichInc
         if (pp.defines.contains(guard)) return;
     }
 
+    // Run any beforeInclude pragma hooks.
+    //
+    // NOTE: This is currently the only deep-preprocessor hook other than the
+    // actual token handler itself. If more are added, an event hook system
+    // similar to the compilation-scoped one should be considered with a
+    // payload structure that can handle context-relevant event data (e.g.,
+    // here, the source file data is needed).
+    for (pp.comp.pragma_handlers.keys(), pp.comp.pragma_handlers.values()) |handler_pragma_name, handler_pragma| {
+        if (handler_pragma.beforeInclude) |func| {
+            func(handler_pragma, pp, new_source) catch |handler_err| {
+                switch (handler_err) {
+                    error.SkipInclude => {
+                        if (pp.verbose) {
+                            pp.verboseLog(
+                                first,
+                                "skipping include file {s} under direction of \"{s}\" pragma",
+                                .{ new_source.path, handler_pragma_name },
+                            );
+                        }
+
+                        return;
+                    },
+                    else => |e| return e,
+                }
+            };
+        }
+    }
+
     if (pp.dep_file) |dep| try dep.addDependency(gpa, new_source.path);
     if (pp.verbose) {
         pp.verboseLog(first, "include file {s}", .{new_source.path});

src/aro/pragmas/once.zig

@@ -14,6 +14,7 @@ const Once = @This();
 pragma: Pragma = .{
     .afterParse = afterParse,
     .deinit = deinit,
+    .beforeInclude = beforeInclude,
     .preprocessorHandler = preprocessorHandler,
     .preserveTokens = preserveTokens,
 },
@@ -37,6 +38,11 @@ fn deinit(pragma: *Pragma, comp: *Compilation) void {
     comp.gpa.destroy(self);
 }
 
+fn beforeInclude(pragma: *Pragma, _: *Preprocessor, source: Source) Pragma.BeforeIncludeError!void {
+    var self: *Once = @fieldParentPtr("pragma", pragma);
+    if (self.pragma_once.contains(source.id)) return error.SkipInclude;
+}
+
 fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {
     var self: *Once = @fieldParentPtr("pragma", pragma);
     const name_tok = pp.tokens.get(start_idx);

test/cases/include/pragma_once_not_at_start/a.h

@@ -0,0 +1,2 @@
+#include <b.h>
+#include <c.h>

test/cases/include/pragma_once_not_at_start/b.h

@@ -0,0 +1,5 @@
+#define __B_INSIDE__
+
+#include <c.h>
+
+#undef __B_INSIDE__

test/cases/include/pragma_once_not_at_start/c.h

@@ -0,0 +1,5 @@
+#if !defined(__B_INSIDE__)
+#error "expected test macros to be present"
+#endif
+
+#pragma once

test/cases/pragma once not at start of file.c

@@ -0,0 +1,6 @@
+#include <a.h> // include/pragma_once_not_at_start/a.h
+
+/** manifest:
+syntax
+args = -I include/pragma_once_not_at_start
+*/