std.os.uefi: ziggify function signatures

Author: dotcarmen

lib/std/os/uefi.zig

@@ -247,3 +247,7 @@ test {
     _ = tables;
     _ = protocol;
 }
+
+pub fn unexpectedError(err: Status.Error) noreturn {
+    std.debug.panic("unexpected error: {any}", .{err});
+}

lib/std/os/uefi/protocol/absolute_pointer.zig

@@ -4,22 +4,33 @@ const Event = uefi.Event;
 const Guid = uefi.Guid;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 /// Protocol for touchscreens.
 pub const AbsolutePointer = extern struct {
-    _reset: *const fn (*const AbsolutePointer, bool) callconv(cc) Status,
+    _reset: *const fn (*AbsolutePointer, bool) callconv(cc) Status,
     _get_state: *const fn (*const AbsolutePointer, *State) callconv(cc) Status,
     wait_for_input: Event,
     mode: *Mode,
 
     /// Resets the pointer device hardware.
-    pub fn reset(self: *const AbsolutePointer, verify: bool) Status {
-        return self._reset(self, verify);
+    pub fn reset(self: *AbsolutePointer, verify: bool) !void {
+        switch (self._reset(self, verify)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     /// Retrieves the current state of a pointer device.
-    pub fn getState(self: *const AbsolutePointer, state: *State) Status {
-        return self._get_state(self, state);
+    pub fn getState(self: *const AbsolutePointer) !State {
+        var state: State = undefined;
+        switch (self._get_state(self, &state)) {
+            .success => return state,
+            .not_ready => return Error.NotReady,
+            .device_error => return Error.DeviceError,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     pub const guid align(8) = Guid{

lib/std/os/uefi/protocol/block_io.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const uefi = std.os.uefi;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 pub const BlockIo = extern struct {
     const Self = @This();
@@ -15,23 +16,48 @@ pub const BlockIo = extern struct {
     _flush_blocks: *const fn (*BlockIo) callconv(cc) Status,
 
     /// Resets the block device hardware.
-    pub fn reset(self: *Self, extended_verification: bool) Status {
-        return self._reset(self, extended_verification);
+    pub fn reset(self: *Self, extended_verification: bool) !void {
+        switch (self._reset(self, extended_verification)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     /// Reads the number of requested blocks from the device.
-    pub fn readBlocks(self: *Self, media_id: u32, lba: u64, buffer_size: usize, buf: [*]u8) Status {
-        return self._read_blocks(self, media_id, lba, buffer_size, buf);
+    pub fn readBlocks(self: *Self, media_id: u32, lba: u64, buf: []u8) !void {
+        switch (self._read_blocks(self, media_id, lba, buf.len, buf.ptr)) {
+            .success => {},
+            .device_error => Error.DeviceError,
+            .no_media => Error.NoMedia,
+            .bad_buffer_size => Error.BadBufferSize,
+            .invalid_parameter => Error.InvalidParameter,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     /// Writes a specified number of blocks to the device.
-    pub fn writeBlocks(self: *Self, media_id: u32, lba: u64, buffer_size: usize, buf: [*]u8) Status {
-        return self._write_blocks(self, media_id, lba, buffer_size, buf);
+    pub fn writeBlocks(self: *Self, media_id: u32, lba: u64, buf: []const u8) !void {
+        switch (self._write_blocks(self, media_id, lba, buf.len, buf.ptr)) {
+            .success => {},
+            .write_protected => Error.WriteProtected,
+            .no_media => Error.NoMedia,
+            .media_changed => Error.MediaChanged,
+            .device_error => Error.DeviceError,
+            .bad_buffer_size => Error.BadBufferSize,
+            .invalid_parameter => Error.InvalidParameter,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     /// Flushes all modified data to a physical block device.
-    pub fn flushBlocks(self: *Self) Status {
-        return self._flush_blocks(self);
+    pub fn flushBlocks(self: *Self) !void {
+        switch (self._flush_blocks(self)) {
+            .success => {},
+            .device_error => Error.DeviceError,
+            .no_media => Error.NoMedia,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
     }
 
     pub const guid align(8) = uefi.Guid{

lib/std/os/uefi/protocol/device_path.zig

@@ -23,15 +23,15 @@ pub const DevicePath = extern struct {
     };
 
     /// Returns the next DevicePath node in the sequence, if any.
-    pub fn next(self: *DevicePath) ?*DevicePath {
+    pub fn next(self: *const DevicePath) ?*DevicePath {
         if (self.type == .end and @as(uefi.DevicePath.End.Subtype, @enumFromInt(self.subtype)) == .end_entire)
             return null;
 
         return @as(*DevicePath, @ptrCast(@as([*]u8, @ptrCast(self)) + self.length));
     }
 
     /// Calculates the total length of the device path structure in bytes, including the end of device path node.
-    pub fn size(self: *DevicePath) usize {
+    pub fn size(self: *const DevicePath) usize {
         var node = self;
 
         while (node.next()) |next_node| {
@@ -42,7 +42,7 @@ pub const DevicePath = extern struct {
     }
 
     /// Creates a file device path from the existing device path and a file path.
-    pub fn create_file_device_path(self: *DevicePath, allocator: Allocator, path: [:0]align(1) const u16) !*DevicePath {
+    pub fn create_file_device_path(self: *const DevicePath, allocator: Allocator, path: []const u16) !*DevicePath {
         const path_size = self.size();
 
         // 2 * (path.len + 1) for the path and its null terminator, which are u16s

lib/std/os/uefi/protocol/edid.zig

@@ -4,6 +4,7 @@ const Guid = uefi.Guid;
 const Handle = uefi.Handle;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 /// EDID information for an active video output device
 pub const Active = extern struct {
@@ -44,10 +45,19 @@ pub const Override = extern struct {
         self: *const Override,
         handle: Handle,
         attributes: *Attributes,
-        edid_size: *usize,
-        edid: *?[*]u8,
-    ) Status {
-        return self._get_edid(self, handle, attributes, edid_size, edid);
+    ) !?[]u8 {
+        var size: usize = 0;
+        var ptr: ?[*]u8 = null;
+        switch (self._get_edid(self, handle, attributes, &size, &ptr)) {
+            .success => {},
+            .unsupported => return Error.Unsupported,
+            else => |err| uefi.unexpectedError(err.err()),
+        }
+
+        if (size == 0 or ptr == null)
+            return null;
+
+        return ptr[0..size];
     }
 
     pub const guid align(8) = Guid{