Merge pull request #197 from mozbeel/android-fix

isARM -> isArm

build.zig

@@ -7,19 +7,15 @@ pub fn build(b: *std.Build) void {
     const maybe_video = b.option(std.Build.LazyPath, "video", "Set the path to the Vulkan Video registry (video.xml)");
     const test_step = b.step("test", "Run all the tests");
 
-    const root_module = b.createModule(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
     // Using the package manager, this artifact can be obtained by the user
     // through `b.dependency(<name in build.zig.zon>, .{}).artifact("vulkan-zig-generator")`.
     // with that, the user need only `.addArg("path/to/vk.xml")`, and then obtain
     // a file source to the generated code with `.addOutputArg("vk.zig")`
     const generator_exe = b.addExecutable(.{
         .name = "vulkan-zig-generator",
-        .root_module = root_module,
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
     });
     b.installArtifact(generator_exe);
 
@@ -51,16 +47,16 @@ pub fn build(b: *std.Build) void {
         // It does not need to run anyway.
         const ref_all_decls_test = b.addObject(.{
             .name = "ref-all-decls-test",
-            .root_module = b.createModule(.{
+            .root_source_file = b.path("test/ref_all_decls.zig"),
-                .root_source_file = b.path("test/ref_all_decls.zig"),
+            .target = target,
-                .target = target,
+            .optimize = optimize,
-                .optimize = optimize,
-            }),
         });
         ref_all_decls_test.root_module.addImport("vulkan", vk_zig_module);
         test_step.dependOn(&ref_all_decls_test.step);
     }
 
-    const test_target = b.addTest(.{ .root_module = root_module });
+    const test_target = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+    });
     test_step.dependOn(&b.addRunArtifact(test_target).step);
 }

build.zig.zon

@@ -2,7 +2,7 @@
     .name = .vulkan,
     .fingerprint = 0xbe155a03c72db6af,
     .version = "0.0.0",
-    .minimum_zig_version = "0.15.0-dev.1518+749f10af4",
+    .minimum_zig_version = "0.14.0-dev.1359+e9a00ba7f",
     .paths = .{
         "build.zig",
         "LICENSE",

examples/build.zig

@@ -12,14 +12,10 @@ pub fn build(b: *std.Build) void {
 
     const triangle_exe = b.addExecutable(.{
         .name = "triangle",
-        .root_module = b.createModule(.{
+        .root_source_file = b.path("triangle.zig"),
-            .root_source_file = b.path("triangle.zig"),
+        .target = target,
-            .target = target,
+        .link_libc = true,
-            .link_libc = true,
+        .optimize = optimize,
-            .optimize = optimize,
-        }),
-        // TODO: Remove this once x86_64 is stable
-        .use_llvm = true,
     });
     b.installArtifact(triangle_exe);
     triangle_exe.linkSystemLibrary("glfw");
@@ -37,18 +33,17 @@ pub fn build(b: *std.Build) void {
 
     if (use_zig_shaders) {
         const spirv_target = b.resolveTargetQuery(.{
-            .cpu_arch = .spirv32,
+            .cpu_arch = .spirv64,
             .os_tag = .vulkan,
             .cpu_model = .{ .explicit = &std.Target.spirv.cpu.vulkan_v1_2 },
+            .cpu_features_add = std.Target.spirv.featureSet(&.{.int64}),
             .ofmt = .spirv,
         });
 
         const vert_spv = b.addObject(.{
             .name = "vertex_shader",
-            .root_module = b.createModule(.{
+            .root_source_file = b.path("shaders/vertex.zig"),
-                .root_source_file = b.path("shaders/vertex.zig"),
+            .target = spirv_target,
-                .target = spirv_target,
-            }),
             .use_llvm = false,
         });
         triangle_exe.root_module.addAnonymousImport(
@@ -58,10 +53,8 @@ pub fn build(b: *std.Build) void {
 
         const frag_spv = b.addObject(.{
             .name = "fragment_shader",
-            .root_module = b.createModule(.{
+            .root_source_file = b.path("shaders/fragment.zig"),
-                .root_source_file = b.path("shaders/fragment.zig"),
+            .target = spirv_target,
-                .target = spirv_target,
-            }),
             .use_llvm = false,
         });
         triangle_exe.root_module.addAnonymousImport(

examples/graphics_context.zig

@@ -49,16 +49,16 @@ pub const GraphicsContext = struct {
         self.allocator = allocator;
         self.vkb = BaseWrapper.load(c.glfwGetInstanceProcAddress);
 
-        var extension_names: std.ArrayList([*:0]const u8) = .empty;
+        var extension_names = std.ArrayList([*:0]const u8).init(allocator);
-        defer extension_names.deinit(allocator);
+        defer extension_names.deinit();
         // these extensions are to support vulkan in mac os
         // see https://github.com/glfw/glfw/issues/2335
-        try extension_names.append(allocator, "VK_KHR_portability_enumeration");
+        try extension_names.append("VK_KHR_portability_enumeration");
-        try extension_names.append(allocator, "VK_KHR_get_physical_device_properties2");
+        try extension_names.append("VK_KHR_get_physical_device_properties2");
 
         var glfw_exts_count: u32 = 0;
         const glfw_exts = c.glfwGetRequiredInstanceExtensions(&glfw_exts_count);
-        try extension_names.appendSlice(allocator, @ptrCast(glfw_exts[0..glfw_exts_count]));
+        try extension_names.appendSlice(@ptrCast(glfw_exts[0..glfw_exts_count]));
 
         const instance = try self.vkb.createInstance(&.{
             .p_application_info = &.{
@@ -253,7 +253,7 @@ fn allocateQueues(instance: Instance, pdev: vk.PhysicalDevice, allocator: Alloca
             graphics_family = family;
         }
 
-        if (present_family == null and (try instance.getPhysicalDeviceSurfaceSupportKHR(pdev, family, surface)) == .true) {
+        if (present_family == null and (try instance.getPhysicalDeviceSurfaceSupportKHR(pdev, family, surface)) == vk.TRUE) {
             present_family = family;
         }
     }

examples/shaders/fragment.zig

@@ -8,5 +8,6 @@ export fn main() callconv(.spirv_fragment) void {
     gpu.location(&v_color, 0);
     gpu.location(&f_color, 0);
 
-    f_color = .{ v_color[0], v_color[1], v_color[2], 1.0 };
+    const temp: @Vector(4, f32) = .{ v_color[0], v_color[1], v_color[2], 1.0 };
+    f_color = temp;
 }

examples/swapchain.zig

@@ -60,7 +60,7 @@ pub const Swapchain = struct {
             .pre_transform = caps.current_transform,
             .composite_alpha = .{ .opaque_bit_khr = true },
             .present_mode = present_mode,
-            .clipped = .true,
+            .clipped = vk.TRUE,
             .old_swapchain = old_handle,
         }, null) catch {
             return error.SwapchainCreationFailed;
@@ -261,7 +261,7 @@ const SwapImage = struct {
     }
 
     fn waitForFence(self: SwapImage, gc: *const GraphicsContext) !void {
-        _ = try gc.dev.waitForFences(1, @ptrCast(&self.frame_fence), .true, std.math.maxInt(u64));
+        _ = try gc.dev.waitForFences(1, @ptrCast(&self.frame_fence), vk.TRUE, std.math.maxInt(u64));
     }
 };
 

examples/triangle.zig

@@ -63,23 +63,6 @@ pub fn main() !void {
     ) orelse return error.WindowInitFailed;
     defer c.glfwDestroyWindow(window);
 
-    // According to the GLFW docs:
-    //
-    // > Window systems put limits on window sizes. Very large or very small window dimensions
-    // > may be overridden by the window system on creation. Check the actual size after creation.
-    // -- https://www.glfw.org/docs/3.3/group__window.html#ga3555a418df92ad53f917597fe2f64aeb
-    //
-    // This happens in practice, for example, when using Wayland with a scaling factor that is not a
-    // divisor of the initial window size (see https://github.com/Snektron/vulkan-zig/pull/192).
-    // To fix it, just fetch the actual size here, after the windowing system has had the time to
-    // update the window.
-    extent.width, extent.height = blk: {
-        var w: c_int = undefined;
-        var h: c_int = undefined;
-        c.glfwGetFramebufferSize(window, &w, &h);
-        break :blk .{ @intCast(w), @intCast(h) };
-    };
-
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
@@ -140,7 +123,6 @@ pub fn main() !void {
     );
     defer destroyCommandBuffers(&gc, pool, allocator, cmdbufs);
 
-    var state: Swapchain.PresentState = .optimal;
     while (c.glfwWindowShouldClose(window) == c.GLFW_FALSE) {
         var w: c_int = undefined;
         var h: c_int = undefined;
@@ -154,6 +136,11 @@ pub fn main() !void {
 
         const cmdbuf = cmdbufs[swapchain.image_index];
 
+        const state = swapchain.present(cmdbuf) catch |err| switch (err) {
+            error.OutOfDateKHR => Swapchain.PresentState.suboptimal,
+            else => |narrow| return narrow,
+        };
+
         if (state == .suboptimal or extent.width != @as(u32, @intCast(w)) or extent.height != @as(u32, @intCast(h))) {
             extent.width = @intCast(w);
             extent.height = @intCast(h);
@@ -174,10 +161,6 @@ pub fn main() !void {
                 framebuffers,
             );
         }
-        state = swapchain.present(cmdbuf) catch |err| switch (err) {
-            error.OutOfDateKHR => Swapchain.PresentState.suboptimal,
-            else => |narrow| return narrow,
-        };
 
         c.glfwPollEvents();
     }
@@ -414,7 +397,7 @@ fn createPipeline(
 
     const piasci = vk.PipelineInputAssemblyStateCreateInfo{
         .topology = .triangle_list,
-        .primitive_restart_enable = .false,
+        .primitive_restart_enable = vk.FALSE,
     };
 
     const pvsci = vk.PipelineViewportStateCreateInfo{
@@ -425,12 +408,12 @@ fn createPipeline(
     };
 
     const prsci = vk.PipelineRasterizationStateCreateInfo{
-        .depth_clamp_enable = .false,
+        .depth_clamp_enable = vk.FALSE,
-        .rasterizer_discard_enable = .false,
+        .rasterizer_discard_enable = vk.FALSE,
         .polygon_mode = .fill,
         .cull_mode = .{ .back_bit = true },
         .front_face = .clockwise,
-        .depth_bias_enable = .false,
+        .depth_bias_enable = vk.FALSE,
         .depth_bias_constant_factor = 0,
         .depth_bias_clamp = 0,
         .depth_bias_slope_factor = 0,
@@ -439,14 +422,14 @@ fn createPipeline(
 
     const pmsci = vk.PipelineMultisampleStateCreateInfo{
         .rasterization_samples = .{ .@"1_bit" = true },
-        .sample_shading_enable = .false,
+        .sample_shading_enable = vk.FALSE,
         .min_sample_shading = 1,
-        .alpha_to_coverage_enable = .false,
+        .alpha_to_coverage_enable = vk.FALSE,
-        .alpha_to_one_enable = .false,
+        .alpha_to_one_enable = vk.FALSE,
     };
 
     const pcbas = vk.PipelineColorBlendAttachmentState{
-        .blend_enable = .false,
+        .blend_enable = vk.FALSE,
         .src_color_blend_factor = .one,
         .dst_color_blend_factor = .zero,
         .color_blend_op = .add,
@@ -457,7 +440,7 @@ fn createPipeline(
     };
 
     const pcbsci = vk.PipelineColorBlendStateCreateInfo{
-        .logic_op_enable = .false,
+        .logic_op_enable = vk.FALSE,
         .logic_op = .copy,
         .attachment_count = 1,
         .p_attachments = @ptrCast(&pcbas),

src/id_render.zig

@@ -52,8 +52,13 @@ pub fn isZigPrimitiveType(name: []const u8) bool {
     return false;
 }
 
-pub fn writeIdentifier(w: *std.io.Writer, id: []const u8) !void {
+pub fn writeIdentifier(writer: anytype, id: []const u8) !void {
-    try w.print("{f}", .{std.zig.fmtId(id)});
+    // https://github.com/ziglang/zig/issues/2897
+    if (isZigPrimitiveType(id)) {
+        try writer.print("@\"{}\"", .{std.zig.fmtEscapes(id)});
+    } else {
+        try writer.print("{}", .{std.zig.fmtId(id)});
+    }
 }
 
 pub const CaseStyle = enum {
@@ -121,12 +126,12 @@ pub const SegmentIterator = struct {
 
 pub const IdRenderer = struct {
     tags: []const []const u8,
-    text_cache: std.io.Writer.Allocating,
+    text_cache: std.ArrayList(u8),
 
     pub fn init(allocator: Allocator, tags: []const []const u8) IdRenderer {
         return .{
             .tags = tags,
-            .text_cache = .init(allocator),
+            .text_cache = std.ArrayList(u8).init(allocator),
         };
     }
 
@@ -142,19 +147,19 @@ pub const IdRenderer = struct {
             if (first) {
                 first = false;
             } else {
-                try self.text_cache.writer.writeByte('_');
+                try self.text_cache.append('_');
             }
 
             for (segment) |c| {
-                try self.text_cache.writer.writeByte(if (screaming) std.ascii.toUpper(c) else std.ascii.toLower(c));
+                try self.text_cache.append(if (screaming) std.ascii.toUpper(c) else std.ascii.toLower(c));
             }
         }
 
         if (tag) |name| {
-            try self.text_cache.writer.writeByte('_');
+            try self.text_cache.append('_');
 
             for (name) |c| {
-                try self.text_cache.writer.writeByte(if (screaming) std.ascii.toUpper(c) else std.ascii.toLower(c));
+                try self.text_cache.append(if (screaming) std.ascii.toUpper(c) else std.ascii.toLower(c));
             }
         }
     }
@@ -166,7 +171,7 @@ pub const IdRenderer = struct {
         while (it.next()) |segment| {
             var i: usize = 0;
             while (i < segment.len and std.ascii.isDigit(segment[i])) {
-                try self.text_cache.writer.writeByte(segment[i]);
+                try self.text_cache.append(segment[i]);
                 i += 1;
             }
 
@@ -175,34 +180,34 @@ pub const IdRenderer = struct {
             }
 
             if (i == 0 and lower_first) {
-                try self.text_cache.writer.writeByte(std.ascii.toLower(segment[i]));
+                try self.text_cache.append(std.ascii.toLower(segment[i]));
             } else {
-                try self.text_cache.writer.writeByte(std.ascii.toUpper(segment[i]));
+                try self.text_cache.append(std.ascii.toUpper(segment[i]));
             }
             lower_first = false;
 
             for (segment[i + 1 ..]) |c| {
-                try self.text_cache.writer.writeByte(std.ascii.toLower(c));
+                try self.text_cache.append(std.ascii.toLower(c));
             }
         }
 
         if (tag) |name| {
-            try self.text_cache.writer.writeAll(name);
+            try self.text_cache.appendSlice(name);
         }
     }
 
-    pub fn renderFmt(self: *IdRenderer, out: *std.Io.Writer, comptime fmt: []const u8, args: anytype) !void {
+    pub fn renderFmt(self: *IdRenderer, out: anytype, comptime fmt: []const u8, args: anytype) !void {
-        _ = self.text_cache.writer.consumeAll();
+        self.text_cache.items.len = 0;
-        try self.text_cache.writer.print(fmt, args);
+        try std.fmt.format(self.text_cache.writer(), fmt, args);
-        try writeIdentifier(out, self.text_cache.writer.buffered());
+        try writeIdentifier(out, self.text_cache.items);
     }
 
-    pub fn renderWithCase(self: *IdRenderer, out: *std.Io.Writer, case_style: CaseStyle, id: []const u8) !void {
+    pub fn renderWithCase(self: *IdRenderer, out: anytype, case_style: CaseStyle, id: []const u8) !void {
         const tag = self.getAuthorTag(id);
         // The trailing underscore doesn't need to be removed here as its removed by the SegmentIterator.
         const adjusted_id = if (tag) |name| id[0 .. id.len - name.len] else id;
 
-        _ = self.text_cache.writer.consumeAll();
+        self.text_cache.items.len = 0;
 
         switch (case_style) {
             .snake => try self.renderSnake(false, adjusted_id, tag),
@@ -211,7 +216,7 @@ pub const IdRenderer = struct {
             .camel => try self.renderCamel(false, adjusted_id, tag),
         }
 
-        try writeIdentifier(out, self.text_cache.writer.buffered());
+        try writeIdentifier(out, self.text_cache.items);
     }
 
     pub fn getAuthorTag(self: IdRenderer, id: []const u8) ?[]const u8 {

src/main.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-
 const generator = @import("vulkan/generator.zig");
 
 fn invalidUsage(prog_name: []const u8, comptime fmt: []const u8, args: anytype) noreturn {
@@ -9,32 +8,27 @@ fn invalidUsage(prog_name: []const u8, comptime fmt: []const u8, args: anytype)
 }
 
 fn reportParseErrors(tree: std.zig.Ast) !void {
-    var buf: [1024]u8 = undefined;
+    const stderr = std.io.getStdErr().writer();
-    var stderr = std.fs.File.stderr().writer(&buf);
+
-    const w = &stderr.interface;
     for (tree.errors) |err| {
         const loc = tree.tokenLocation(0, err.token);
-        try w.print("(vulkan-zig error):{}:{}: error: ", .{ loc.line + 1, loc.column + 1 });
+        try stderr.print("(vulkan-zig error):{}:{}: error: ", .{ loc.line + 1, loc.column + 1 });
-        try tree.renderError(err, w);
+        try tree.renderError(err, stderr);
-        try w.print("\n{s}\n", .{tree.source[loc.line_start..loc.line_end]});
+        try stderr.print("\n{s}\n", .{tree.source[loc.line_start..loc.line_end]});
         for (0..loc.column) |_| {
-            try w.writeAll(" ");
+            try stderr.writeAll(" ");
         }
-        try w.writeAll("^\n");
+        try stderr.writeAll("^\n");
     }
 }
 
-fn oomPanic() noreturn {
-    @panic("Out of memory");
-}
-
 pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const allocator = arena.allocator();
 
     var args = std.process.argsWithAllocator(allocator) catch |err| switch (err) {
-        error.OutOfMemory => oomPanic(),
+        error.OutOfMemory => @panic("OOM"),
     };
     const prog_name = args.next() orelse "vulkan-zig-generator";
 
@@ -47,9 +41,7 @@ pub fn main() !void {
     while (args.next()) |arg| {
         if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
             @setEvalBranchQuota(2000);
-            var buf: [1024]u8 = undefined;
+            std.io.getStdOut().writer().print(
-            var w = std.fs.File.stdout().writer(&buf);
-            w.interface.print(
                 \\Utility to generate a Zig binding from the Vulkan XML API registry.
                 \\
                 \\The most recent Vulkan XML API registry can be obtained from
@@ -68,7 +60,8 @@ pub fn main() !void {
             ,
                 .{prog_name},
             ) catch |err| {
-                std.process.fatal("failed to write to stdout: {s}", .{@errorName(err)});
+                std.log.err("failed to write to stdout: {s}", .{@errorName(err)});
+                std.process.exit(1);
             };
             return;
         } else if (std.mem.eql(u8, arg, "-a") or std.mem.eql(u8, arg, "--api")) {
@@ -103,49 +96,44 @@ pub fn main() !void {
 
     const cwd = std.fs.cwd();
     const xml_src = cwd.readFileAlloc(allocator, xml_path, std.math.maxInt(usize)) catch |err| {
-        std.process.fatal("failed to open input file '{s}' ({s})", .{ xml_path, @errorName(err) });
+        std.log.err("failed to open input file '{s}' ({s})", .{ xml_path, @errorName(err) });
+        std.process.exit(1);
     };
 
     const maybe_video_xml_src = if (maybe_video_xml_path) |video_xml_path|
         cwd.readFileAlloc(allocator, video_xml_path, std.math.maxInt(usize)) catch |err| {
-            std.process.fatal("failed to open input file '{s}' ({s})", .{ video_xml_path, @errorName(err) });
+            std.log.err("failed to open input file '{s}' ({s})", .{ video_xml_path, @errorName(err) });
+            std.process.exit(1);
         }
     else
         null;
 
-    var aw: std.io.Writer.Allocating = .init(allocator);
+    var out_buffer = std.ArrayList(u8).init(allocator);
-    generator.generate(allocator, api, xml_src, maybe_video_xml_src, &aw.writer) catch |err| {
+    generator.generate(allocator, api, xml_src, maybe_video_xml_src, out_buffer.writer()) catch |err| switch (err) {
-        if (debug) {
+        error.InvalidXml => {
-            return err;
+            std.log.err("invalid vulkan registry - invalid xml", .{});
-        }
+            std.log.err("please check that the correct vk.xml file is passed", .{});
-
+            std.process.exit(1);
-        switch (err) {
+        },
-            error.InvalidXml => {
+        error.InvalidRegistry => {
-                std.log.err("invalid vulkan registry - invalid xml", .{});
+            std.log.err("invalid vulkan registry - registry is valid xml but contents are invalid", .{});
-                std.log.err("please check that the correct vk.xml file is passed", .{});
+            std.log.err("please check that the correct vk.xml file is passed", .{});
-                std.process.exit(1);
+            std.process.exit(1);
-            },
+        },
-            error.InvalidRegistry => {
+        error.UnhandledBitfieldStruct => {
-                std.log.err("invalid vulkan registry - registry is valid xml but contents are invalid", .{});
+            std.log.err("unhandled struct with bit fields detected in vk.xml", .{});
-                std.log.err("please check that the correct vk.xml file is passed", .{});
+            std.log.err("this is a bug in vulkan-zig", .{});
-                std.process.exit(1);
+            std.log.err("please make a bug report at https://github.com/Snektron/vulkan-zig/issues/", .{});
-            },
+            std.process.exit(1);
-            error.UnhandledBitfieldStruct => {
+        },
-                std.log.err("unhandled struct with bit fields detected in vk.xml", .{});
+        error.OutOfMemory => @panic("oom"),
-                std.log.err("this is a bug in vulkan-zig", .{});
-                std.log.err("please make a bug report at https://github.com/Snektron/vulkan-zig/issues/", .{});
-                std.process.exit(1);
-            },
-            error.OutOfMemory, error.WriteFailed => oomPanic(),
-        }
     };
 
-    aw.writer.writeByte(0) catch oomPanic();
+    out_buffer.append(0) catch @panic("oom");
 
-    const buffered = aw.writer.buffered();
+    const src = out_buffer.items[0 .. out_buffer.items.len - 1 :0];
-    const src = buffered[0 .. buffered.len - 1 :0];
     const tree = std.zig.Ast.parse(allocator, src, .zig) catch |err| switch (err) {
-        error.OutOfMemory => oomPanic(),
+        error.OutOfMemory => @panic("oom"),
     };
 
     const formatted = if (tree.errors.len > 0) blk: {
@@ -155,20 +143,22 @@ pub fn main() !void {
         std.log.err("or run with --debug to write out unformatted source", .{});
 
         reportParseErrors(tree) catch |err| {
-            std.process.fatal("failed to dump ast errors: {s}", .{@errorName(err)});
+            std.log.err("failed to dump ast errors: {s}", .{@errorName(err)});
+            std.process.exit(1);
         };
 
         if (debug) {
             break :blk src;
         }
         std.process.exit(1);
-    } else tree.renderAlloc(allocator) catch |err| switch (err) {
+    } else tree.render(allocator) catch |err| switch (err) {
-        error.OutOfMemory => oomPanic(),
+        error.OutOfMemory => @panic("oom"),
     };
 
     if (std.fs.path.dirname(out_path)) |dir| {
         cwd.makePath(dir) catch |err| {
-            std.process.fatal("failed to create output directory '{s}' ({s})", .{ dir, @errorName(err) });
+            std.log.err("failed to create output directory '{s}' ({s})", .{ dir, @errorName(err) });
+            std.process.exit(1);
         };
     }
 
@@ -176,7 +166,8 @@ pub fn main() !void {
         .sub_path = out_path,
         .data = formatted,
     }) catch |err| {
-        std.process.fatal("failed to write to output file '{s}' ({s})", .{ out_path, @errorName(err) });
+        std.log.err("failed to write to output file '{s}' ({s})", .{ out_path, @errorName(err) });
+        std.process.exit(1);
     };
 }
 

src/vulkan/c_parse.zig

@@ -457,8 +457,8 @@ fn parseFnPtrSuffix(allocator: Allocator, xctok: *XmlCTokenizer, return_type: Ty
     // There is no good way to estimate the number of parameters beforehand.
     // Fortunately, there are usually a relatively low number of parameters to a function pointer,
     // so an ArrayList backed by an arena allocator is good enough.
-    var params: std.ArrayList(registry.Command.Param) = .empty;
+    var params = std.ArrayList(registry.Command.Param).init(allocator);
-    try params.append(allocator, .{
+    try params.append(.{
         .name = first_param.name.?,
         .param_type = first_param.decl_type,
         .is_buffer_len = false,
@@ -473,7 +473,7 @@ fn parseFnPtrSuffix(allocator: Allocator, xctok: *XmlCTokenizer, return_type: Ty
         }
 
         const decl = try parseDeclaration(allocator, xctok, ptrs_optional);
-        try params.append(allocator, .{
+        try params.append(.{
             .name = decl.name orelse return error.MissingTypeIdentifier,
             .param_type = decl.decl_type,
             .is_buffer_len = false,
@@ -482,7 +482,7 @@ fn parseFnPtrSuffix(allocator: Allocator, xctok: *XmlCTokenizer, return_type: Ty
     }
 
     _ = try xctok.nextNoEof();
-    command_ptr.decl_type.command_ptr.params = try params.toOwnedSlice(allocator);
+    command_ptr.decl_type.command_ptr.params = try params.toOwnedSlice();
     return command_ptr;
 }
 

src/vulkan/generator.zig

@@ -32,7 +32,7 @@ const EnumFieldMerger = struct {
     fn putEnumExtension(self: *EnumFieldMerger, enum_name: []const u8, field: reg.Enum.Field) !void {
         const res = try self.enum_extensions.getOrPut(self.arena, enum_name);
         if (!res.found_existing) {
-            res.value_ptr.* = .empty;
+            res.value_ptr.* = std.ArrayListUnmanaged(reg.Enum.Field){};
         }
 
         try res.value_ptr.append(self.arena, field);
@@ -186,7 +186,7 @@ pub const Generator = struct {
         self.registry.decls.len = i;
     }
 
-    fn render(self: *Generator, writer: *std.Io.Writer) !void {
+    fn render(self: *Generator, writer: anytype) !void {
         try renderRegistry(writer, self.arena.allocator(), &self.registry, &self.id_renderer, self.have_video);
     }
 };
@@ -204,7 +204,7 @@ pub fn generate(
     api: Api,
     spec_xml: []const u8,
     maybe_video_spec_xml: ?[]const u8,
-    writer: *std.Io.Writer,
+    writer: anytype,
 ) !void {
     const spec = xml.parse(allocator, spec_xml) catch |err| switch (err) {
         error.InvalidDocument,

src/vulkan/parse.zig

@@ -28,11 +28,11 @@ pub fn parseXml(
 
     const allocator = arena.allocator();
 
-    var decls: std.ArrayList(registry.Declaration) = .empty;
+    var decls: std.ArrayListUnmanaged(registry.Declaration) = .{};
-    var api_constants: std.ArrayList(registry.ApiConstant) = .empty;
+    var api_constants: std.ArrayListUnmanaged(registry.ApiConstant) = .{};
-    var tags: std.ArrayList(registry.Tag) = .empty;
+    var tags: std.ArrayListUnmanaged(registry.Tag) = .{};
-    var features: std.ArrayList(registry.Feature) = .empty;
+    var features: std.ArrayListUnmanaged(registry.Feature) = .{};
-    var extensions: std.ArrayList(registry.Extension) = .empty;
+    var extensions: std.ArrayListUnmanaged(registry.Extension) = .{};
 
     try parseDeclarations(allocator, root, api, &decls);
     try parseApiConstants(allocator, root, api, &api_constants);
@@ -66,7 +66,7 @@ fn parseDeclarations(
     allocator: Allocator,
     root: *xml.Element,
     api: registry.Api,
-    decls: *std.ArrayList(registry.Declaration),
+    decls: *std.ArrayListUnmanaged(registry.Declaration),
 ) !void {
     const types_elem = root.findChildByTag("types") orelse return error.InvalidRegistry;
     try decls.ensureUnusedCapacity(allocator, types_elem.children.len);
@@ -84,7 +84,7 @@ fn parseTypes(
     allocator: Allocator,
     types_elem: *xml.Element,
     api: registry.Api,
-    decls: *std.ArrayList(registry.Declaration),
+    decls: *std.ArrayListUnmanaged(registry.Declaration),
 ) !void {
     var it = types_elem.findChildrenByTag("type");
     while (it.next()) |ty| {
@@ -429,7 +429,7 @@ fn parseEnums(
     allocator: Allocator,
     root: *xml.Element,
     api: registry.Api,
-    decls: *std.ArrayList(registry.Declaration),
+    decls: *std.ArrayListUnmanaged(registry.Declaration),
 ) !void {
     var it = root.findChildrenByTag("enums");
     while (it.next()) |enums| {
@@ -519,7 +519,7 @@ fn parseCommands(
     allocator: Allocator,
     commands_elem: *xml.Element,
     api: registry.Api,
-    decls: *std.ArrayList(registry.Declaration),
+    decls: *std.ArrayListUnmanaged(registry.Declaration),
 ) !void {
     var it = commands_elem.findChildrenByTag("command");
     while (it.next()) |elem| {
@@ -630,7 +630,7 @@ fn parseApiConstants(
     allocator: Allocator,
     root: *xml.Element,
     api: registry.Api,
-    api_constants: *std.ArrayList(registry.ApiConstant),
+    api_constants: *std.ArrayListUnmanaged(registry.ApiConstant),
 ) !void {
     const maybe_enums = blk: {
         var it = root.findChildrenByTag("enums");
@@ -672,7 +672,7 @@ fn parseDefines(
     allocator: Allocator,
     types: *xml.Element,
     api: registry.Api,
-    api_constants: *std.ArrayList(registry.ApiConstant),
+    api_constants: *std.ArrayListUnmanaged(registry.ApiConstant),
 ) !void {
     var it = types.findChildrenByTag("type");
     while (it.next()) |ty| {
@@ -703,7 +703,7 @@ fn parseDefines(
 fn parseTags(
     allocator: Allocator,
     root: *xml.Element,
-    tags: *std.ArrayList(registry.Tag),
+    tags: *std.ArrayListUnmanaged(registry.Tag),
 ) !void {
     var tags_elem = root.findChildByTag("tags") orelse return;
     try tags.ensureUnusedCapacity(allocator, tags_elem.children.len);
@@ -717,7 +717,7 @@ fn parseTags(
     }
 }
 
-fn parseFeatures(allocator: Allocator, root: *xml.Element, api: registry.Api, features: *std.ArrayList(registry.Feature)) !void {
+fn parseFeatures(allocator: Allocator, root: *xml.Element, api: registry.Api, features: *std.ArrayListUnmanaged(registry.Feature)) !void {
     var it = root.findChildrenByTag("feature");
     while (it.next()) |feature| {
         if (!requiredByApi(feature, api))
@@ -881,7 +881,7 @@ fn parseExtensions(
     allocator: Allocator,
     root: *xml.Element,
     api: registry.Api,
-    extensions: *std.ArrayList(registry.Extension),
+    extensions: *std.ArrayListUnmanaged(registry.Extension),
 ) !void {
     const extensions_elem = root.findChildByTag("extensions") orelse return error.InvalidRegistry;
     try extensions.ensureUnusedCapacity(allocator, extensions_elem.children.len);

src/xml.zig

@@ -439,15 +439,15 @@ fn parseElement(parser: *Parser, alloc: Allocator, comptime kind: ElementKind) !
         },
     };
 
-    var attributes: std.ArrayList(Attribute) = .empty;
+    var attributes = std.ArrayList(Attribute).init(alloc);
-    defer attributes.deinit(alloc);
+    defer attributes.deinit();
 
-    var children: std.ArrayList(Content) = .empty;
+    var children = std.ArrayList(Content).init(alloc);
-    defer children.deinit(alloc);
+    defer children.deinit();
 
     while (parser.eatWs()) {
         const attr = (try parseAttr(parser, alloc)) orelse break;
-        try attributes.append(alloc, attr);
+        try attributes.append(attr);
     }
 
     switch (kind) {
@@ -464,7 +464,7 @@ fn parseElement(parser: *Parser, alloc: Allocator, comptime kind: ElementKind) !
                     }
 
                     const content = try parseContent(parser, alloc);
-                    try children.append(alloc, content);
+                    try children.append(content);
                 }
 
                 const closing_tag = try parseNameNoDupe(parser);
@@ -481,8 +481,8 @@ fn parseElement(parser: *Parser, alloc: Allocator, comptime kind: ElementKind) !
     const element = try alloc.create(Element);
     element.* = .{
         .tag = try alloc.dupe(u8, tag),
-        .attributes = try attributes.toOwnedSlice(alloc),
+        .attributes = try attributes.toOwnedSlice(),
-        .children = try children.toOwnedSlice(alloc),
+        .children = try children.toOwnedSlice(),
     };
     return element;
 }

test/ref_all_decls.zig

@@ -21,76 +21,80 @@ pub const MTLTexture_id = u32;
 pub const MTLSharedEvent_id = u32;
 pub const IOSurfaceRef = u32;
 
-pub const StdVideoH264ProfileIdc = u32;
+// For some reason these types are exported in a different header, and not described in vk.xml.
-pub const StdVideoH264LevelIdc = u32;
+// If we are not also generating these, the user will have to manually specify them.
-pub const StdVideoH264ChromaFormatIdc = u32;
+pub usingnamespace if (!vk.have_vulkan_video) struct {
-pub const StdVideoH264PocType = u32;
+    pub const StdVideoH264ProfileIdc = u32;
-pub const StdVideoH264SpsFlags = u32;
+    pub const StdVideoH264LevelIdc = u32;
-pub const StdVideoH264ScalingLists = u32;
+    pub const StdVideoH264ChromaFormatIdc = u32;
-pub const StdVideoH264SequenceParameterSetVui = u32;
+    pub const StdVideoH264PocType = u32;
-pub const StdVideoH264AspectRatioIdc = u32;
+    pub const StdVideoH264SpsFlags = u32;
-pub const StdVideoH264HrdParameters = u32;
+    pub const StdVideoH264ScalingLists = u32;
-pub const StdVideoH264SpsVuiFlags = u32;
+    pub const StdVideoH264SequenceParameterSetVui = u32;
-pub const StdVideoH264WeightedBipredIdc = u32;
+    pub const StdVideoH264AspectRatioIdc = u32;
-pub const StdVideoH264PpsFlags = u32;
+    pub const StdVideoH264HrdParameters = u32;
-pub const StdVideoH264SliceType = u32;
+    pub const StdVideoH264SpsVuiFlags = u32;
-pub const StdVideoH264CabacInitIdc = u32;
+    pub const StdVideoH264WeightedBipredIdc = u32;
-pub const StdVideoH264DisableDeblockingFilterIdc = u32;
+    pub const StdVideoH264PpsFlags = u32;
-pub const StdVideoH264PictureType = u32;
+    pub const StdVideoH264SliceType = u32;
-pub const StdVideoH264ModificationOfPicNumsIdc = u32;
+    pub const StdVideoH264CabacInitIdc = u32;
-pub const StdVideoH264MemMgmtControlOp = u32;
+    pub const StdVideoH264DisableDeblockingFilterIdc = u32;
-pub const StdVideoDecodeH264PictureInfo = u32;
+    pub const StdVideoH264PictureType = u32;
-pub const StdVideoDecodeH264ReferenceInfo = u32;
+    pub const StdVideoH264ModificationOfPicNumsIdc = u32;
-pub const StdVideoDecodeH264PictureInfoFlags = u32;
+    pub const StdVideoH264MemMgmtControlOp = u32;
-pub const StdVideoDecodeH264ReferenceInfoFlags = u32;
+    pub const StdVideoDecodeH264PictureInfo = u32;
-pub const StdVideoH264SequenceParameterSet = u32;
+    pub const StdVideoDecodeH264ReferenceInfo = u32;
-pub const StdVideoH264PictureParameterSet = u32;
+    pub const StdVideoDecodeH264PictureInfoFlags = u32;
-pub const StdVideoH265ProfileIdc = u32;
+    pub const StdVideoDecodeH264ReferenceInfoFlags = u32;
-pub const StdVideoH265VideoParameterSet = u32;
+    pub const StdVideoH264SequenceParameterSet = u32;
-pub const StdVideoH265SequenceParameterSet = u32;
+    pub const StdVideoH264PictureParameterSet = u32;
-pub const StdVideoH265PictureParameterSet = u32;
+    pub const StdVideoH265ProfileIdc = u32;
-pub const StdVideoH265DecPicBufMgr = u32;
+    pub const StdVideoH265VideoParameterSet = u32;
-pub const StdVideoH265HrdParameters = u32;
+    pub const StdVideoH265SequenceParameterSet = u32;
-pub const StdVideoH265VpsFlags = u32;
+    pub const StdVideoH265PictureParameterSet = u32;
-pub const StdVideoH265LevelIdc = u32;
+    pub const StdVideoH265DecPicBufMgr = u32;
-pub const StdVideoH265SpsFlags = u32;
+    pub const StdVideoH265HrdParameters = u32;
-pub const StdVideoH265ScalingLists = u32;
+    pub const StdVideoH265VpsFlags = u32;
-pub const StdVideoH265SequenceParameterSetVui = u32;
+    pub const StdVideoH265LevelIdc = u32;
-pub const StdVideoH265PredictorPaletteEntries = u32;
+    pub const StdVideoH265SpsFlags = u32;
-pub const StdVideoH265PpsFlags = u32;
+    pub const StdVideoH265ScalingLists = u32;
-pub const StdVideoH265SubLayerHrdParameters = u32;
+    pub const StdVideoH265SequenceParameterSetVui = u32;
-pub const StdVideoH265HrdFlags = u32;
+    pub const StdVideoH265PredictorPaletteEntries = u32;
-pub const StdVideoH265SpsVuiFlags = u32;
+    pub const StdVideoH265PpsFlags = u32;
-pub const StdVideoH265SliceType = u32;
+    pub const StdVideoH265SubLayerHrdParameters = u32;
-pub const StdVideoH265PictureType = u32;
+    pub const StdVideoH265HrdFlags = u32;
-pub const StdVideoDecodeH265PictureInfo = u32;
+    pub const StdVideoH265SpsVuiFlags = u32;
-pub const StdVideoDecodeH265ReferenceInfo = u32;
+    pub const StdVideoH265SliceType = u32;
-pub const StdVideoDecodeH265PictureInfoFlags = u32;
+    pub const StdVideoH265PictureType = u32;
-pub const StdVideoDecodeH265ReferenceInfoFlags = u32;
+    pub const StdVideoDecodeH265PictureInfo = u32;
-pub const StdVideoAV1Profile = u32;
+    pub const StdVideoDecodeH265ReferenceInfo = u32;
-pub const StdVideoAV1Level = u32;
+    pub const StdVideoDecodeH265PictureInfoFlags = u32;
-pub const StdVideoAV1SequenceHeader = u32;
+    pub const StdVideoDecodeH265ReferenceInfoFlags = u32;
-pub const StdVideoDecodeAV1PictureInfo = u32;
+    pub const StdVideoAV1Profile = u32;
-pub const StdVideoDecodeAV1ReferenceInfo = u32;
+    pub const StdVideoAV1Level = u32;
-pub const StdVideoEncodeH264SliceHeader = u32;
+    pub const StdVideoAV1SequenceHeader = u32;
-pub const StdVideoEncodeH264PictureInfo = u32;
+    pub const StdVideoDecodeAV1PictureInfo = u32;
-pub const StdVideoEncodeH264ReferenceInfo = u32;
+    pub const StdVideoDecodeAV1ReferenceInfo = u32;
-pub const StdVideoEncodeH264SliceHeaderFlags = u32;
+    pub const StdVideoEncodeH264SliceHeader = u32;
-pub const StdVideoEncodeH264ReferenceListsInfo = u32;
+    pub const StdVideoEncodeH264PictureInfo = u32;
-pub const StdVideoEncodeH264PictureInfoFlags = u32;
+    pub const StdVideoEncodeH264ReferenceInfo = u32;
-pub const StdVideoEncodeH264ReferenceInfoFlags = u32;
+    pub const StdVideoEncodeH264SliceHeaderFlags = u32;
-pub const StdVideoEncodeH264RefMgmtFlags = u32;
+    pub const StdVideoEncodeH264ReferenceListsInfo = u32;
-pub const StdVideoEncodeH264RefListModEntry = u32;
+    pub const StdVideoEncodeH264PictureInfoFlags = u32;
-pub const StdVideoEncodeH264RefPicMarkingEntry = u32;
+    pub const StdVideoEncodeH264ReferenceInfoFlags = u32;
-pub const StdVideoEncodeH265PictureInfoFlags = u32;
+    pub const StdVideoEncodeH264RefMgmtFlags = u32;
-pub const StdVideoEncodeH265PictureInfo = u32;
+    pub const StdVideoEncodeH264RefListModEntry = u32;
-pub const StdVideoEncodeH265SliceSegmentHeader = u32;
+    pub const StdVideoEncodeH264RefPicMarkingEntry = u32;
-pub const StdVideoEncodeH265ReferenceInfo = u32;
+    pub const StdVideoEncodeH265PictureInfoFlags = u32;
-pub const StdVideoEncodeH265ReferenceListsInfo = u32;
+    pub const StdVideoEncodeH265PictureInfo = u32;
-pub const StdVideoEncodeH265SliceSegmentHeaderFlags = u32;
+    pub const StdVideoEncodeH265SliceSegmentHeader = u32;
-pub const StdVideoEncodeH265ReferenceInfoFlags = u32;
+    pub const StdVideoEncodeH265ReferenceInfo = u32;
-pub const StdVideoEncodeH265ReferenceModificationFlags = u32;
+    pub const StdVideoEncodeH265ReferenceListsInfo = u32;
-pub const StdVideoEncodeAV1OperatingPointInfo = u32;
+    pub const StdVideoEncodeH265SliceSegmentHeaderFlags = u32;
+    pub const StdVideoEncodeH265ReferenceInfoFlags = u32;
+    pub const StdVideoEncodeH265ReferenceModificationFlags = u32;
+    pub const StdVideoEncodeAV1OperatingPointInfo = u32;
+} else struct {};
 
 comptime {
     @setEvalBranchQuota(1000000);