Make MbrPartitionTable compile

Author: der-teufel-programming

src/components/part/MbrPartitionTable.zig

@@ -50,7 +50,7 @@ pub fn parse(ctx: dim.Context) !dim.Content {
         }
     }
 
-    return .create_handle(pf, .create(@This(), .{
+    return .create_handle(pf, .create(PartTable, .{
         .guess_size_fn = guess_size,
         .render_fn = render,
     }));
@@ -74,19 +74,20 @@ fn parse_partition(ctx: dim.Context) !Partition {
     parse_loop: while (true) {
         const kw = try ctx.parse_enum(enum {
             type,
-            size,
             bootable,
+            size,
+            offset,
             contents,
             endpart,
         });
-        switch (kw) {
+        try switch (kw) {
             .type => updater.set(.type, try ctx.parse_enum(PartitionType)),
             .bootable => updater.set(.bootable, true),
             .size => updater.set(.size, try ctx.parse_mem_size()),
             .offset => updater.set(.offset, try ctx.parse_mem_size()),
-            .contents => updater.set(.contents, try ctx.parse_content()),
+            .contents => updater.set(.data, try ctx.parse_content()),
             .endpart => break :parse_loop,
-        }
+        };
     }
 
     try updater.validate();

src/dim.zig

@@ -255,7 +255,7 @@ pub fn FieldUpdater(comptime Obj: type, comptime optional_fields: []const std.me
 
         pub fn set(fup: *FUP, comptime field: FieldName, value: @FieldType(Obj, @tagName(field))) !void {
             if (fup.updated_fields.contains(field)) {
-                fup.ctx.report_nonfatal_error("duplicate assignment of {s}.{s}", .{
+                try fup.ctx.report_nonfatal_error("duplicate assignment of {s}.{s}", .{
                     @typeName(Obj),
                     @tagName(field),
                 });
@@ -273,7 +273,7 @@ pub fn FieldUpdater(comptime Obj: type, comptime optional_fields: []const std.me
             missing_fields = missing_fields.complement();
             var iter = missing_fields.iterator();
             while (iter.next()) |fld| {
-                fup.ctx.report_nonfatal_error("missing assignment of {s}.{s}", .{
+                try fup.ctx.report_nonfatal_error("missing assignment of {s}.{s}", .{
                     @typeName(Obj),
                     @tagName(fld),
                 });
@@ -290,6 +290,8 @@ const Environment = struct {
         UnknownContentType,
         FatalConfigError,
         InvalidEnumTag,
+        Overflow,
+        InvalidSize,
     };
 
     arena: std.mem.Allocator,
@@ -341,6 +343,24 @@ pub const Content = struct {
     obj: *anyopaque,
     vtable: *const VTable,
 
+    pub const empty: Content = .{
+        .obj = undefined,
+        .vtable = &emptyVTable,
+    };
+
+    const emptyVTable: VTable = blk: {
+        const Wrap = struct {
+            fn render(_: *anyopaque, _: *BinaryStream) RenderError!void {}
+            fn guess_size_fn(_: *anyopaque) GuessError!SizeGuess {
+                return .{ .exact = 0 };
+            }
+        };
+        break :blk .{
+            .render_fn = Wrap.render,
+            .guess_size_fn = Wrap.guess_size_fn,
+        };
+    };
+
     pub fn create_handle(obj: *anyopaque, vtable: *const VTable) Content {
         return .{ .obj = obj, .vtable = vtable };
     }
@@ -361,10 +381,13 @@ pub const Content = struct {
         render_fn: *const fn (*anyopaque, *BinaryStream) RenderError!void,
         guess_size_fn: *const fn (*anyopaque) GuessError!SizeGuess,
 
-        pub fn create(comptime Container: type, comptime funcs: struct {
-            render_fn: *const fn (*Container, *BinaryStream) RenderError!void,
-            guess_size_fn: *const fn (*Container) GuessError!SizeGuess,
-        }) *const VTable {
+        pub fn create(
+            comptime Container: type,
+            comptime funcs: struct {
+                render_fn: *const fn (*Container, *BinaryStream) RenderError!void,
+                guess_size_fn: *const fn (*Container) GuessError!SizeGuess,
+            },
+        ) *const VTable {
             const Wrap = struct {
                 fn render(self: *anyopaque, stream: *BinaryStream) RenderError!void {
                     return funcs.render_fn(