Merge pull request #226 from ziglang/macro

Check that struct_identifier in macro is defined

Author: Vexu

build/Translator.zig

@@ -200,14 +200,23 @@ pub fn addSystemFrameworkPath(t: *const Translator, path: Build.LazyPath) void {
 /// Exposes the embed path `path` to both translate-c and to `t.mod`.
 pub fn addEmbedPath(t: *const Translator, path: Build.LazyPath) void {
     t.mod.addEmbedPath(path);
-    t.run.appendPrefixedFileArg("--embed-dir=", path);
+    t.run.addPrefixedDirectoryArg("--embed-dir=", path);
 }
 /// Exposes the config header generaeted by `ch` to both translate-c and to `t.mod`.
 pub fn addConfigHeader(t: *const Translator, ch: *Build.Step.ConfigHeader) void {
     t.mod.addConfigHeader(ch);
     appendIncludeArg(t.run, "-I", ch.getOutputDir());
 }
 
+/// If the value is omitted, it is set to 1.
+/// `name` and `value` need not live longer than the function call.
+pub fn defineCMacro(t: *const Translator, name: []const u8, value: ?[]const u8) void {
+    const b = t.mod.owner;
+    const macro = b.fmt("-D{s}={s}", .{ name, value orelse "1" });
+    t.mod.c_macros.append(b.allocator, macro) catch @panic("OOM");
+    t.run.addArg(macro);
+}
+
 /// Helper function for adding things like `-I /path/to/include/dir` to arg vectors.
 fn appendIncludeArg(run: *Build.Step.Run, arg: []const u8, path: Build.LazyPath) void {
     run.addArg(arg);

examples/compile_c/build.zig

@@ -16,7 +16,7 @@ pub fn build(b: *std.Build) !void {
         .target = target,
         .optimize = optimize,
     });
-    trans.run.addArg("-D__TRANSLATE_C__");
+    trans.defineCMacro("__TRANSLATE_C__", null);
     // Build an executable from `trans.mod` (the Zig module containing the translated code).
     const translated_exe = b.addExecutable(.{
         .name = "translated-exe",

src/MacroTranslator.zig

@@ -79,6 +79,20 @@ pub fn transFnMacro(mt: *MacroTranslator) ParseError!void {
         try block_scope.discardVariable(mangled_name);
     }
 
+    // #define FOO(x)
+    if (mt.peek() == .eof) {
+        try block_scope.statements.append(mt.t.gpa, ZigTag.return_void.init());
+
+        const fn_decl = try ZigTag.pub_inline_fn.create(mt.t.arena, .{
+            .name = mt.name,
+            .params = fn_params,
+            .return_type = ZigTag.void_type.init(),
+            .body = try block_scope.complete(),
+        });
+        try mt.t.addTopLevelDecl(mt.name, fn_decl);
+        return;
+    }
+
     const expr = try mt.parseCExpr(scope);
     const last = mt.peek();
     if (last != .eof)
@@ -252,7 +266,7 @@ fn parseCNumLit(mt: *MacroTranslator) ParseError!ZigNode {
     const lit_bytes = mt.tokSlice();
     mt.i += 1;
 
-    var bytes = try std.ArrayListUnmanaged(u8).initCapacity(arena, lit_bytes.len + 3);
+    var bytes = try std.ArrayList(u8).initCapacity(arena, lit_bytes.len + 3);
 
     const prefix = aro.Tree.Token.NumberPrefix.fromString(lit_bytes);
     switch (prefix) {
@@ -974,7 +988,12 @@ fn parseCSpecifierQualifierList(mt: *MacroTranslator, scope: *Scope) ParseError!
             try mt.expect(.identifier);
 
             const name = try std.fmt.allocPrint(mt.t.arena, "{s}_{s}", .{ tag_name, identifier });
-            return try ZigTag.identifier.create(mt.t.arena, name);
+            if (!mt.t.global_scope.contains(name)) {
+                try mt.fail("unable to translate C expr: '{s}' not found", .{name});
+                return error.ParseError;
+            }
+
+            return try ZigTag.identifier.create(mt.t.arena, try mt.t.arena.dupe(u8, name));
         },
         else => {},
     }

src/Scope.zig

@@ -8,15 +8,15 @@ const Translator = @import("Translator.zig");
 const Scope = @This();
 
 pub const SymbolTable = std.StringArrayHashMapUnmanaged(ast.Node);
-pub const AliasList = std.ArrayListUnmanaged(struct {
+pub const AliasList = std.ArrayList(struct {
     alias: []const u8,
     name: []const u8,
 });
 
 /// Associates a container (structure or union) with its relevant member functions.
 pub const ContainerMemberFns = struct {
     container_decl_ptr: *ast.Node,
-    member_fns: std.ArrayListUnmanaged(*ast.Payload.Func) = .empty,
+    member_fns: std.ArrayList(*ast.Payload.Func) = .empty,
 };
 pub const ContainerMemberFnsHashMap = std.AutoArrayHashMapUnmanaged(aro.QualType, ContainerMemberFns);
 
@@ -55,7 +55,7 @@ pub const Condition = struct {
 pub const Block = struct {
     base: Scope,
     translator: *Translator,
-    statements: std.ArrayListUnmanaged(ast.Node),
+    statements: std.ArrayList(ast.Node),
     variables: AliasList,
     mangle_count: u32 = 0,
     label: ?[]const u8 = null,
@@ -195,7 +195,7 @@ pub const Root = struct {
     translator: *Translator,
     sym_table: SymbolTable,
     blank_macros: std.StringArrayHashMapUnmanaged(void),
-    nodes: std.ArrayListUnmanaged(ast.Node),
+    nodes: std.ArrayList(ast.Node),
     container_member_fns_map: ContainerMemberFnsHashMap,
 
     pub fn init(t: *Translator) Root {
@@ -300,7 +300,7 @@ pub const Root = struct {
             for (members.member_fns.items) |func| {
                 const func_name = func.data.name.?;
                 const func_name_trimmed = std.mem.trimEnd(u8, func_name, "_");
-                const last_idx = std.mem.lastIndexOf(u8, func_name_trimmed, "_") orelse continue;
+                const last_idx = std.mem.findLast(u8, func_name_trimmed, "_") orelse continue;
                 const func_name_alias = func_name[last_idx + 1 ..];
                 const member_name_slot = try member_names.getOrPutValue(gpa, func_name_alias, {});
                 if (member_name_slot.found_existing) continue;

src/Translator.zig

@@ -3583,7 +3583,7 @@ fn transArrayInit(
     const array_item_qt = array_init.container_qt.childType(t.comp);
     const array_item_type = try t.transType(scope, array_item_qt, array_init.l_brace_tok);
     var maybe_lhs: ?ZigNode = null;
-    var val_list: std.ArrayListUnmanaged(ZigNode) = .empty;
+    var val_list: std.ArrayList(ZigNode) = .empty;
     defer val_list.deinit(t.gpa);
     var i: usize = 0;
     while (i < array_init.items.len) {

src/ast.zig

@@ -879,7 +879,7 @@ const Context = struct {
     gpa: Allocator,
     buf: std.ArrayList(u8) = .empty,
     nodes: std.zig.Ast.NodeList = .empty,
-    extra_data: std.ArrayListUnmanaged(u32) = .empty,
+    extra_data: std.ArrayList(u32) = .empty,
     tokens: std.zig.Ast.TokenList = .empty,
 
     fn addTokenFmt(c: *Context, tag: TokenTag, comptime format: []const u8, args: anytype) Allocator.Error!TokenIndex {

src/main.zig

@@ -123,7 +123,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
         break :args args[0..i];
     };
     const user_macros = macros: {
-        var macro_buf: std.ArrayListUnmanaged(u8) = .empty;
+        var macro_buf: std.ArrayList(u8) = .empty;
         defer macro_buf.deinit(gpa);
 
         var discard_buf: [256]u8 = undefined;

test/cases/translate/Macro_without_a_value.c

@@ -1,5 +1,11 @@
 #define FOO
+#define BAR(x)
 
 // translate
 //
 // pub const FOO = "";
+//
+// pub inline fn BAR(x: anytype) void {
+//     _ = &x;
+//     return;
+// }

test/cases/translate/struct_in_macro_not_defined.c

@@ -0,0 +1,6 @@
+#define FOO(x) x
+#define BAR(x) struct FOO(x)
+
+// translate
+//
+// pub const BAR = @compileError("unable to translate C expr: 'struct_FOO' not found");