Implements basic writing to files

Author: Felix "xq" Queißner

.gitignore

@@ -1,3 +1,4 @@
 .zig-cache/
 zig-out/
-.vscode/
+.vscode/
+.dim-out/

justfile

@@ -1,6 +1,8 @@
 
 zig:="zig-0.14.0"
 
+out:=".dim-out"
+
 default: install test
 
 install:
@@ -23,8 +25,8 @@ behaviour-tests: \
     (behaviour-test "tests/part/mbr/basic-single-part-unsized.dis")
 
 behaviour-test script: install
-    ./zig-out/bin/dim --output .zig-cache/disk.img --script "{{script}}" --size 30M
-
+    @mkdir -p {{ join(out, parent_directory(script)) }}
+    ./zig-out/bin/dim --output {{ join(out, without_extension(script) + ".img") }} --script "{{script}}" --size 30M
 
 fuzz:
     {{zig}} build install test --fuzz --port 35991

src/components/FillData.zig

@@ -22,6 +22,6 @@ pub fn parse(ctx: dim.Context) !dim.Content {
 fn render(self: *FillData, stream: *dim.BinaryStream) dim.Content.RenderError!void {
     try stream.writer().writeByteNTimes(
         self.fill_value,
-        stream.capacity,
+        stream.length,
     );
 }

src/dim.zig

@@ -133,9 +133,7 @@ pub fn main() !u8 {
 
         try output_file.file.setEndPos(size_limit);
 
-        var stream = BinaryStream{
-            .capacity = size_limit,
-        };
+        var stream: BinaryStream = .init_file(output_file.file, size_limit);
 
         try root_content.render(&stream);
 
@@ -338,7 +336,7 @@ const Environment = struct {
 ///
 ///
 pub const Content = struct {
-    pub const RenderError = FileName.OpenError || FileHandle.ReadError || error{WriteError};
+    pub const RenderError = FileName.OpenError || FileHandle.ReadError || BinaryStream.WriteError;
     pub const GuessError = FileName.GetSizeError;
 
     obj: *anyopaque,
@@ -509,26 +507,117 @@ pub const FileHandle = struct {
 };
 
 pub const BinaryStream = struct {
-    pub const WriteError = error{IoError};
+    pub const WriteError = error{ Overflow, IoError };
     pub const Writer = std.io.Writer(*BinaryStream, WriteError, write_some);
 
+    backing: Backing,
+
+    virtual_offset: u64 = 0,
+
     /// Max number of bytes that can be written
-    capacity: u64,
+    length: u64,
+
+    /// Constructs a BinaryStream from a slice.
+    pub fn init_buffer(data: []u8) BinaryStream {
+        return .{
+            .backing = .{ .buffer = data.ptr },
+            .length = data.len,
+        };
+    }
+
+    /// Constructs a BinaryStream from a file.
+    pub fn init_file(file: std.fs.File, max_len: u64) BinaryStream {
+        return .{
+            .backing = .{
+                .file = .{
+                    .file = file,
+                    .base = 0,
+                },
+            },
+            .length = max_len,
+        };
+    }
+
+    /// Returns a view into the stream.
+    pub fn slice(bs: BinaryStream, offset: u64, length: ?u64) error{OutOfBounds}!BinaryStream {
+        if (offset > bs.length)
+            return error.OutOfBounds;
+        const true_length = length or bs.length - offset;
+        if (true_length > bs.length)
+            return error.OutOfBounds;
+
+        return .{
+            .length = true_length,
+            .backing = switch (bs.backing) {
+                .buffer => |old| .{ .buffer = old + offset },
+                .file => |old| .{
+                    .file = old.file,
+                    .base = old.base + offset,
+                },
+            },
+        };
+    }
+
+    pub fn write(bs: *BinaryStream, offset: u64, data: []const u8) WriteError!void {
+        const end_pos = offset + data.len;
+        if (end_pos > bs.length)
+            return error.Overflow;
+
+        switch (bs.backing) {
+            .buffer => |ptr| @memcpy(ptr[@intCast(offset)..][0..data.len], data),
+            .file => |state| {
+                state.file.seekTo(state.base + offset) catch return error.IoError;
+                state.file.writeAll(data) catch |err| switch (err) {
+                    error.DiskQuota, error.NoSpaceLeft, error.FileTooBig => return error.Overflow,
+
+                    error.InputOutput,
+                    error.DeviceBusy,
+                    error.InvalidArgument,
+                    error.AccessDenied,
+                    error.BrokenPipe,
+                    error.SystemResources,
+                    error.OperationAborted,
+                    error.NotOpenForWriting,
+                    error.LockViolation,
+                    error.WouldBlock,
+                    error.ConnectionResetByPeer,
+                    error.ProcessNotFound,
+                    error.NoDevice,
+                    error.Unexpected,
+                    => return error.IoError,
+                };
+            },
+        }
+    }
+
+    pub fn seek_to(bs: *BinaryStream, offset: u64) error{OutOfBounds}!void {
+        if (offset > bs.length)
+            return error.OutOfBounds;
+        bs.virtual_offset = offset;
+    }
 
     pub fn writer(bs: *BinaryStream) Writer {
         return .{ .context = bs };
     }
 
     fn write_some(stream: *BinaryStream, data: []const u8) WriteError!usize {
-        _ = stream;
-        // TODO: Implement write_some!
+        const remaining_len = stream.length - stream.virtual_offset;
+
+        const written_len: usize = @intCast(@min(remaining_len, data.len));
 
-        // std.debug.print("dummy write of '{}'\n", .{
-        //     std.fmt.fmtSliceHexUpper(data),
-        // });
+        try stream.write(stream.virtual_offset, data[0..written_len]);
+        stream.virtual_offset += written_len;
 
-        return data.len;
+        return written_len;
     }
+
+    pub const Backing = union(enum) {
+        file: struct {
+            file: std.fs.File,
+            base: u64,
+        },
+        buffer: [*]u8,
+    };
 };
 
 test {