//! Every `std.Io.VTable` entry this port does not implement, as a function that panics with its //! own name. //! //! `std.Io.VTable` has 109 entries (`/usr/lib/zig/std/Io.zig:51-255`). A port of it to a chip with //! no filesystem, no sockets and no processes implements sixteen of them, and the honest way to //! express the other 93 is not a partial struct - the struct has no optional fields - but a complete //! one whose unimplemented entries announce themselves the moment they are reached. So this file is //! the floor: `p4.zig` starts from `unimplemented.vtable` and overwrites the entries it really has, //! and anything it forgot fails with the name of the entry rather than a jump to address zero. //! //! A stub for an entry `p4.zig` does implement is dead the moment the assignment overwrites the //! field, so it costs nothing: a riscv32 `-OReleaseSmall` build emits exactly the 93 that survive. //! //! The signatures are transcribed from that VTable declaration verbatim, which is why they carry //! precision about types nothing here will ever construct: the compiler checks each one against //! std, so a Zig release that changes a signature - or adds an entry - is a build error in this //! file instead of a silent gap. The parameter names are dropped to `_` because a stub that reads //! its arguments would be a lie. //! //! Note the five `fileMemoryMap*` entries. Their signatures name `Io.File.MemoryMap`, and merely //! *defining* a function with that in its type forces the struct to be laid out, which on //! riscv32-freestanding needs `std.options.page_size_min` - see `p4.zig`'s "Integrating this". const std = @import("std"); const Io = std.Io; const Alignment = std.mem.Alignment; const AnyFuture = Io.AnyFuture; const Batch = Io.Batch; const CancelProtection = Io.CancelProtection; const Cancelable = Io.Cancelable; const Clock = Io.Clock; const ConcurrentError = Io.ConcurrentError; const Dir = Io.Dir; const Duration = Io.Duration; const File = Io.File; const Group = Io.Group; const LockedStderr = Io.LockedStderr; const Operation = Io.Operation; const Queue = Io.Queue; const RandomSecureError = Io.RandomSecureError; const Terminal = Io.Terminal; const Timeout = Io.Timeout; const Timestamp = Io.Timestamp; const net = Io.net; /// A `std.Io.VTable` in which nothing is implemented. Every entry panics with its own name. pub const vtable: Io.VTable = .{ .crashHandler = panics.crashHandler, .async = panics.async, .concurrent = panics.concurrent, .await = panics.await, .cancel = panics.cancel, .groupAsync = panics.groupAsync, .groupConcurrent = panics.groupConcurrent, .groupAwait = panics.groupAwait, .groupCancel = panics.groupCancel, .recancel = panics.recancel, .swapCancelProtection = panics.swapCancelProtection, .checkCancel = panics.checkCancel, .futexWait = panics.futexWait, .futexWaitUncancelable = panics.futexWaitUncancelable, .futexWake = panics.futexWake, .operate = panics.operate, .batchAwaitAsync = panics.batchAwaitAsync, .batchAwaitConcurrent = panics.batchAwaitConcurrent, .batchCancel = panics.batchCancel, .dirCreateDir = panics.dirCreateDir, .dirCreateDirPath = panics.dirCreateDirPath, .dirCreateDirPathOpen = panics.dirCreateDirPathOpen, .dirOpenDir = panics.dirOpenDir, .dirStat = panics.dirStat, .dirStatFile = panics.dirStatFile, .dirAccess = panics.dirAccess, .dirCreateFile = panics.dirCreateFile, .dirCreateFileAtomic = panics.dirCreateFileAtomic, .dirOpenFile = panics.dirOpenFile, .dirClose = panics.dirClose, .dirRead = panics.dirRead, .dirRealPath = panics.dirRealPath, .dirRealPathFile = panics.dirRealPathFile, .dirDeleteFile = panics.dirDeleteFile, .dirDeleteDir = panics.dirDeleteDir, .dirRename = panics.dirRename, .dirRenamePreserve = panics.dirRenamePreserve, .dirSymLink = panics.dirSymLink, .dirReadLink = panics.dirReadLink, .dirSetOwner = panics.dirSetOwner, .dirSetFileOwner = panics.dirSetFileOwner, .dirSetPermissions = panics.dirSetPermissions, .dirSetFilePermissions = panics.dirSetFilePermissions, .dirSetTimestamps = panics.dirSetTimestamps, .dirHardLink = panics.dirHardLink, .fileStat = panics.fileStat, .fileLength = panics.fileLength, .fileClose = panics.fileClose, .fileWritePositional = panics.fileWritePositional, .fileWriteFileStreaming = panics.fileWriteFileStreaming, .fileWriteFilePositional = panics.fileWriteFilePositional, .fileReadPositional = panics.fileReadPositional, .fileSeekBy = panics.fileSeekBy, .fileSeekTo = panics.fileSeekTo, .fileSync = panics.fileSync, .fileIsTty = panics.fileIsTty, .fileEnableAnsiEscapeCodes = panics.fileEnableAnsiEscapeCodes, .fileSupportsAnsiEscapeCodes = panics.fileSupportsAnsiEscapeCodes, .fileSetLength = panics.fileSetLength, .fileSetOwner = panics.fileSetOwner, .fileSetPermissions = panics.fileSetPermissions, .fileSetTimestamps = panics.fileSetTimestamps, .fileLock = panics.fileLock, .fileTryLock = panics.fileTryLock, .fileUnlock = panics.fileUnlock, .fileDowngradeLock = panics.fileDowngradeLock, .fileRealPath = panics.fileRealPath, .fileHardLink = panics.fileHardLink, .fileMemoryMapCreate = panics.fileMemoryMapCreate, .fileMemoryMapDestroy = panics.fileMemoryMapDestroy, .fileMemoryMapSetLength = panics.fileMemoryMapSetLength, .fileMemoryMapRead = panics.fileMemoryMapRead, .fileMemoryMapWrite = panics.fileMemoryMapWrite, .processExecutableOpen = panics.processExecutableOpen, .processExecutablePath = panics.processExecutablePath, .lockStderr = panics.lockStderr, .tryLockStderr = panics.tryLockStderr, .unlockStderr = panics.unlockStderr, .processCurrentPath = panics.processCurrentPath, .processSetCurrentDir = panics.processSetCurrentDir, .processSetCurrentPath = panics.processSetCurrentPath, .processReplace = panics.processReplace, .processReplacePath = panics.processReplacePath, .processSpawn = panics.processSpawn, .processSpawnPath = panics.processSpawnPath, .childWait = panics.childWait, .childKill = panics.childKill, .progressParentFile = panics.progressParentFile, .now = panics.now, .clockResolution = panics.clockResolution, .sleep = panics.sleep, .random = panics.random, .randomSecure = panics.randomSecure, .netListenIp = panics.netListenIp, .netAccept = panics.netAccept, .netBindIp = panics.netBindIp, .netConnectIp = panics.netConnectIp, .netListenUnix = panics.netListenUnix, .netConnectUnix = panics.netConnectUnix, .netSocketCreatePair = panics.netSocketCreatePair, .netSend = panics.netSend, .netRead = panics.netRead, .netWrite = panics.netWrite, .netWriteFile = panics.netWriteFile, .netClose = panics.netClose, .netShutdown = panics.netShutdown, .netInterfaceNameResolve = panics.netInterfaceNameResolve, .netInterfaceName = panics.netInterfaceName, .netLookup = panics.netLookup, }; /// One function per entry. Grouped in a namespace so the panic message and the vtable field /// cannot drift apart: `panics.dirOpenFile` is the entry named `dirOpenFile`. const panics = struct { fn crashHandler(_: ?*anyopaque) void { @panic("io.p4 unimplemented: crashHandler"); } fn async(_: ?*anyopaque, _: []u8, _: std.mem.Alignment, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque, result: *anyopaque) void) ?*AnyFuture { @panic("io.p4 unimplemented: async"); } fn concurrent(_: ?*anyopaque, _: usize, _: std.mem.Alignment, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque, result: *anyopaque) void) ConcurrentError!*AnyFuture { @panic("io.p4 unimplemented: concurrent"); } fn await(_: ?*anyopaque, _: *AnyFuture, _: []u8, _: std.mem.Alignment) void { @panic("io.p4 unimplemented: await"); } fn cancel(_: ?*anyopaque, _: *AnyFuture, _: []u8, _: std.mem.Alignment) void { @panic("io.p4 unimplemented: cancel"); } fn groupAsync(_: ?*anyopaque, _: *Group, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque) void) void { @panic("io.p4 unimplemented: groupAsync"); } fn groupConcurrent(_: ?*anyopaque, _: *Group, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque) void) ConcurrentError!void { @panic("io.p4 unimplemented: groupConcurrent"); } fn groupAwait(_: ?*anyopaque, _: *Group, _: *anyopaque) Cancelable!void { @panic("io.p4 unimplemented: groupAwait"); } fn groupCancel(_: ?*anyopaque, _: *Group, _: *anyopaque) void { @panic("io.p4 unimplemented: groupCancel"); } fn recancel(_: ?*anyopaque) void { @panic("io.p4 unimplemented: recancel"); } fn swapCancelProtection(_: ?*anyopaque, _: CancelProtection) CancelProtection { @panic("io.p4 unimplemented: swapCancelProtection"); } fn checkCancel(_: ?*anyopaque) Cancelable!void { @panic("io.p4 unimplemented: checkCancel"); } fn futexWait(_: ?*anyopaque, _: *const u32, _: u32, _: Timeout) Cancelable!void { @panic("io.p4 unimplemented: futexWait"); } fn futexWaitUncancelable(_: ?*anyopaque, _: *const u32, _: u32) void { @panic("io.p4 unimplemented: futexWaitUncancelable"); } fn futexWake(_: ?*anyopaque, _: *const u32, _: u32) void { @panic("io.p4 unimplemented: futexWake"); } fn operate(_: ?*anyopaque, _: Operation) Cancelable!Operation.Result { @panic("io.p4 unimplemented: operate"); } fn batchAwaitAsync(_: ?*anyopaque, _: *Batch) Cancelable!void { @panic("io.p4 unimplemented: batchAwaitAsync"); } fn batchAwaitConcurrent(_: ?*anyopaque, _: *Batch, _: Timeout) Batch.AwaitConcurrentError!void { @panic("io.p4 unimplemented: batchAwaitConcurrent"); } fn batchCancel(_: ?*anyopaque, _: *Batch) void { @panic("io.p4 unimplemented: batchCancel"); } fn dirCreateDir(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions) Dir.CreateDirError!void { @panic("io.p4 unimplemented: dirCreateDir"); } fn dirCreateDirPath(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus { @panic("io.p4 unimplemented: dirCreateDirPath"); } fn dirCreateDirPathOpen(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions, _: Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir { @panic("io.p4 unimplemented: dirCreateDirPathOpen"); } fn dirOpenDir(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.OpenOptions) Dir.OpenError!Dir { @panic("io.p4 unimplemented: dirOpenDir"); } fn dirStat(_: ?*anyopaque, _: Dir) Dir.StatError!Dir.Stat { @panic("io.p4 unimplemented: dirStat"); } fn dirStatFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.StatFileOptions) Dir.StatFileError!File.Stat { @panic("io.p4 unimplemented: dirStatFile"); } fn dirAccess(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.AccessOptions) Dir.AccessError!void { @panic("io.p4 unimplemented: dirAccess"); } fn dirCreateFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.CreateFileOptions) File.OpenError!File { @panic("io.p4 unimplemented: dirCreateFile"); } fn dirCreateFileAtomic(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic { @panic("io.p4 unimplemented: dirCreateFileAtomic"); } fn dirOpenFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.OpenFileOptions) File.OpenError!File { @panic("io.p4 unimplemented: dirOpenFile"); } fn dirClose(_: ?*anyopaque, _: []const Dir) void { @panic("io.p4 unimplemented: dirClose"); } fn dirRead(_: ?*anyopaque, _: *Dir.Reader, _: []Dir.Entry) Dir.Reader.Error!usize { @panic("io.p4 unimplemented: dirRead"); } fn dirRealPath(_: ?*anyopaque, _: Dir, _: []u8) Dir.RealPathError!usize { @panic("io.p4 unimplemented: dirRealPath"); } fn dirRealPathFile(_: ?*anyopaque, _: Dir, _: []const u8, _: []u8) Dir.RealPathFileError!usize { @panic("io.p4 unimplemented: dirRealPathFile"); } fn dirDeleteFile(_: ?*anyopaque, _: Dir, _: []const u8) Dir.DeleteFileError!void { @panic("io.p4 unimplemented: dirDeleteFile"); } fn dirDeleteDir(_: ?*anyopaque, _: Dir, _: []const u8) Dir.DeleteDirError!void { @panic("io.p4 unimplemented: dirDeleteDir"); } fn dirRename(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8) Dir.RenameError!void { @panic("io.p4 unimplemented: dirRename"); } fn dirRenamePreserve(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8) Dir.RenamePreserveError!void { @panic("io.p4 unimplemented: dirRenamePreserve"); } fn dirSymLink(_: ?*anyopaque, _: Dir, _: []const u8, _: []const u8, _: Dir.SymLinkFlags) Dir.SymLinkError!void { @panic("io.p4 unimplemented: dirSymLink"); } fn dirReadLink(_: ?*anyopaque, _: Dir, _: []const u8, _: []u8) Dir.ReadLinkError!usize { @panic("io.p4 unimplemented: dirReadLink"); } fn dirSetOwner(_: ?*anyopaque, _: Dir, _: ?File.Uid, _: ?File.Gid) Dir.SetOwnerError!void { @panic("io.p4 unimplemented: dirSetOwner"); } fn dirSetFileOwner(_: ?*anyopaque, _: Dir, _: []const u8, _: ?File.Uid, _: ?File.Gid, _: Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void { @panic("io.p4 unimplemented: dirSetFileOwner"); } fn dirSetPermissions(_: ?*anyopaque, _: Dir, _: Dir.Permissions) Dir.SetPermissionsError!void { @panic("io.p4 unimplemented: dirSetPermissions"); } fn dirSetFilePermissions(_: ?*anyopaque, _: Dir, _: []const u8, _: File.Permissions, _: Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void { @panic("io.p4 unimplemented: dirSetFilePermissions"); } fn dirSetTimestamps(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.SetTimestampsOptions) Dir.SetTimestampsError!void { @panic("io.p4 unimplemented: dirSetTimestamps"); } fn dirHardLink(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8, _: Dir.HardLinkOptions) Dir.HardLinkError!void { @panic("io.p4 unimplemented: dirHardLink"); } fn fileStat(_: ?*anyopaque, _: File) File.StatError!File.Stat { @panic("io.p4 unimplemented: fileStat"); } fn fileLength(_: ?*anyopaque, _: File) File.LengthError!u64 { @panic("io.p4 unimplemented: fileLength"); } fn fileClose(_: ?*anyopaque, _: []const File) void { @panic("io.p4 unimplemented: fileClose"); } fn fileWritePositional(_: ?*anyopaque, _: File, _: []const u8, _: []const []const u8, _: usize, _: u64) File.WritePositionalError!usize { @panic("io.p4 unimplemented: fileWritePositional"); } fn fileWriteFileStreaming(_: ?*anyopaque, _: File, _: []const u8, _: *Io.File.Reader, _: Io.Limit) File.Writer.WriteFileError!usize { @panic("io.p4 unimplemented: fileWriteFileStreaming"); } fn fileWriteFilePositional(_: ?*anyopaque, _: File, _: []const u8, _: *Io.File.Reader, _: Io.Limit, _: u64) File.WriteFilePositionalError!usize { @panic("io.p4 unimplemented: fileWriteFilePositional"); } fn fileReadPositional(_: ?*anyopaque, _: File, _: []const []u8, _: u64) File.ReadPositionalError!usize { @panic("io.p4 unimplemented: fileReadPositional"); } fn fileSeekBy(_: ?*anyopaque, _: File, _: i64) File.SeekError!void { @panic("io.p4 unimplemented: fileSeekBy"); } fn fileSeekTo(_: ?*anyopaque, _: File, _: u64) File.SeekError!void { @panic("io.p4 unimplemented: fileSeekTo"); } fn fileSync(_: ?*anyopaque, _: File) File.SyncError!void { @panic("io.p4 unimplemented: fileSync"); } fn fileIsTty(_: ?*anyopaque, _: File) Cancelable!bool { @panic("io.p4 unimplemented: fileIsTty"); } fn fileEnableAnsiEscapeCodes(_: ?*anyopaque, _: File) File.EnableAnsiEscapeCodesError!void { @panic("io.p4 unimplemented: fileEnableAnsiEscapeCodes"); } fn fileSupportsAnsiEscapeCodes(_: ?*anyopaque, _: File) Cancelable!bool { @panic("io.p4 unimplemented: fileSupportsAnsiEscapeCodes"); } fn fileSetLength(_: ?*anyopaque, _: File, _: u64) File.SetLengthError!void { @panic("io.p4 unimplemented: fileSetLength"); } fn fileSetOwner(_: ?*anyopaque, _: File, _: ?File.Uid, _: ?File.Gid) File.SetOwnerError!void { @panic("io.p4 unimplemented: fileSetOwner"); } fn fileSetPermissions(_: ?*anyopaque, _: File, _: File.Permissions) File.SetPermissionsError!void { @panic("io.p4 unimplemented: fileSetPermissions"); } fn fileSetTimestamps(_: ?*anyopaque, _: File, _: File.SetTimestampsOptions) File.SetTimestampsError!void { @panic("io.p4 unimplemented: fileSetTimestamps"); } fn fileLock(_: ?*anyopaque, _: File, _: File.Lock) File.LockError!void { @panic("io.p4 unimplemented: fileLock"); } fn fileTryLock(_: ?*anyopaque, _: File, _: File.Lock) File.LockError!bool { @panic("io.p4 unimplemented: fileTryLock"); } fn fileUnlock(_: ?*anyopaque, _: File) void { @panic("io.p4 unimplemented: fileUnlock"); } fn fileDowngradeLock(_: ?*anyopaque, _: File) File.DowngradeLockError!void { @panic("io.p4 unimplemented: fileDowngradeLock"); } fn fileRealPath(_: ?*anyopaque, _: File, _: []u8) File.RealPathError!usize { @panic("io.p4 unimplemented: fileRealPath"); } fn fileHardLink(_: ?*anyopaque, _: File, _: Dir, _: []const u8, _: File.HardLinkOptions) File.HardLinkError!void { @panic("io.p4 unimplemented: fileHardLink"); } fn fileMemoryMapCreate(_: ?*anyopaque, _: File, _: File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap { @panic("io.p4 unimplemented: fileMemoryMapCreate"); } fn fileMemoryMapDestroy(_: ?*anyopaque, _: *File.MemoryMap) void { @panic("io.p4 unimplemented: fileMemoryMapDestroy"); } fn fileMemoryMapSetLength(_: ?*anyopaque, _: *File.MemoryMap, _: usize) File.MemoryMap.SetLengthError!void { @panic("io.p4 unimplemented: fileMemoryMapSetLength"); } fn fileMemoryMapRead(_: ?*anyopaque, _: *File.MemoryMap) File.ReadPositionalError!void { @panic("io.p4 unimplemented: fileMemoryMapRead"); } fn fileMemoryMapWrite(_: ?*anyopaque, _: *File.MemoryMap) File.WritePositionalError!void { @panic("io.p4 unimplemented: fileMemoryMapWrite"); } fn processExecutableOpen(_: ?*anyopaque, _: Dir.OpenFileOptions) std.process.OpenExecutableError!File { @panic("io.p4 unimplemented: processExecutableOpen"); } fn processExecutablePath(_: ?*anyopaque, _: []u8) std.process.ExecutablePathError!usize { @panic("io.p4 unimplemented: processExecutablePath"); } fn lockStderr(_: ?*anyopaque, _: ?Terminal.Mode) Cancelable!LockedStderr { @panic("io.p4 unimplemented: lockStderr"); } fn tryLockStderr(_: ?*anyopaque, _: ?Terminal.Mode) Cancelable!?LockedStderr { @panic("io.p4 unimplemented: tryLockStderr"); } fn unlockStderr(_: ?*anyopaque) void { @panic("io.p4 unimplemented: unlockStderr"); } fn processCurrentPath(_: ?*anyopaque, _: []u8) std.process.CurrentPathError!usize { @panic("io.p4 unimplemented: processCurrentPath"); } fn processSetCurrentDir(_: ?*anyopaque, _: Dir) std.process.SetCurrentDirError!void { @panic("io.p4 unimplemented: processSetCurrentDir"); } fn processSetCurrentPath(_: ?*anyopaque, _: []const u8) std.process.SetCurrentPathError!void { @panic("io.p4 unimplemented: processSetCurrentPath"); } fn processReplace(_: ?*anyopaque, _: std.process.ReplaceOptions) std.process.ReplaceError { @panic("io.p4 unimplemented: processReplace"); } fn processReplacePath(_: ?*anyopaque, _: Dir, _: std.process.ReplaceOptions) std.process.ReplaceError { @panic("io.p4 unimplemented: processReplacePath"); } fn processSpawn(_: ?*anyopaque, _: std.process.SpawnOptions) std.process.SpawnError!std.process.Child { @panic("io.p4 unimplemented: processSpawn"); } fn processSpawnPath(_: ?*anyopaque, _: Dir, _: std.process.SpawnOptions) std.process.SpawnError!std.process.Child { @panic("io.p4 unimplemented: processSpawnPath"); } fn childWait(_: ?*anyopaque, _: *std.process.Child) std.process.Child.WaitError!std.process.Child.Term { @panic("io.p4 unimplemented: childWait"); } fn childKill(_: ?*anyopaque, _: *std.process.Child) void { @panic("io.p4 unimplemented: childKill"); } fn progressParentFile(_: ?*anyopaque) std.Progress.ParentFileError!File { @panic("io.p4 unimplemented: progressParentFile"); } fn now(_: ?*anyopaque, _: Clock) Timestamp { @panic("io.p4 unimplemented: now"); } fn clockResolution(_: ?*anyopaque, _: Clock) Clock.ResolutionError!Duration { @panic("io.p4 unimplemented: clockResolution"); } fn sleep(_: ?*anyopaque, _: Timeout) Cancelable!void { @panic("io.p4 unimplemented: sleep"); } fn random(_: ?*anyopaque, _: []u8) void { @panic("io.p4 unimplemented: random"); } fn randomSecure(_: ?*anyopaque, _: []u8) RandomSecureError!void { @panic("io.p4 unimplemented: randomSecure"); } fn netListenIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.ListenOptions) net.IpAddress.ListenError!net.Socket { @panic("io.p4 unimplemented: netListenIp"); } fn netAccept(_: ?*anyopaque, _: net.Socket.Handle, _: net.Server.AcceptOptions) net.Server.AcceptError!net.Socket { @panic("io.p4 unimplemented: netAccept"); } fn netBindIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.BindOptions) net.IpAddress.BindError!net.Socket { @panic("io.p4 unimplemented: netBindIp"); } fn netConnectIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Socket { @panic("io.p4 unimplemented: netConnectIp"); } fn netListenUnix(_: ?*anyopaque, _: *const net.UnixAddress, _: net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle { @panic("io.p4 unimplemented: netListenUnix"); } fn netConnectUnix(_: ?*anyopaque, _: *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle { @panic("io.p4 unimplemented: netConnectUnix"); } fn netSocketCreatePair(_: ?*anyopaque, _: net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket { @panic("io.p4 unimplemented: netSocketCreatePair"); } fn netSend(_: ?*anyopaque, _: net.Socket.Handle, _: []net.OutgoingMessage, _: net.SendFlags) struct { ?net.Socket.SendError, usize } { @panic("io.p4 unimplemented: netSend"); } fn netRead(_: ?*anyopaque, _: net.Socket.Handle, _: [][]u8) net.Stream.Reader.Error!usize { @panic("io.p4 unimplemented: netRead"); } fn netWrite(_: ?*anyopaque, _: net.Socket.Handle, _: []const u8, _: []const []const u8, _: usize) net.Stream.Writer.Error!usize { @panic("io.p4 unimplemented: netWrite"); } fn netWriteFile(_: ?*anyopaque, _: net.Socket.Handle, _: []const u8, _: *Io.File.Reader, _: Io.Limit) net.Stream.Writer.WriteFileError!usize { @panic("io.p4 unimplemented: netWriteFile"); } fn netClose(_: ?*anyopaque, _: []const net.Socket.Handle) void { @panic("io.p4 unimplemented: netClose"); } fn netShutdown(_: ?*anyopaque, _: net.Socket.Handle, _: net.ShutdownHow) net.ShutdownError!void { @panic("io.p4 unimplemented: netShutdown"); } fn netInterfaceNameResolve(_: ?*anyopaque, _: *const net.Interface.Name) net.Interface.Name.ResolveError!net.Interface { @panic("io.p4 unimplemented: netInterfaceNameResolve"); } fn netInterfaceName(_: ?*anyopaque, _: net.Interface) net.Interface.NameError!net.Interface.Name { @panic("io.p4 unimplemented: netInterfaceName"); } fn netLookup(_: ?*anyopaque, _: net.HostName, _: *Queue(net.HostName.LookupResult), _: net.HostName.LookupOptions) net.HostName.LookupError!void { @panic("io.p4 unimplemented: netLookup"); } };