84 lines
2.6 KiB
Plaintext
84 lines
2.6 KiB
Plaintext
const std = #import("std");
|
|
const linux = std.os.linux;
|
|
const macos = std.os.macos;
|
|
const builtin = #import("builtin");
|
|
const os = builtin.os;
|
|
|
|
const Error = switch (os) {
|
|
.linux => linux.Error,
|
|
.macos => macos.Error,
|
|
else => #error("OS not supported"),
|
|
};
|
|
|
|
const unwrap_syscall = fn(syscall_result: ssize) Error!usize {
|
|
if (syscall_result == -1) {
|
|
const absolute_error: u64 = #cast(-syscall_result);
|
|
const error_int: u32 = #cast(absolute_error);
|
|
const err: Error = #cast(error_int);
|
|
return err;
|
|
} else {
|
|
const result: usize = #cast(syscall_result);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
const MapFlags = switch (os) {
|
|
.macos => bitfield(u32){
|
|
shared: bool,
|
|
private: bool,
|
|
reserved: u2 = 0,
|
|
fixed: bool,
|
|
reserved0: bool = 0,
|
|
noreserve: bool,
|
|
reserved1: u2 = 0,
|
|
has_semaphore: bool,
|
|
no_cache: bool,
|
|
reserved2: u1 = 0,
|
|
anonymous: bool,
|
|
reserved3: u19 = 0,
|
|
},
|
|
.linux => linux.MapFlags,
|
|
else => #error("OS not supported"),
|
|
};
|
|
|
|
const FileDescriptor = s32;
|
|
const ProcessId = s32;
|
|
const MAP_FAILED = 0xffffffffffffffff;
|
|
|
|
const ProtectionFlags = bitfield(u32) {
|
|
read: bool,
|
|
write: bool,
|
|
execute: bool,
|
|
};
|
|
|
|
const get_protection_flags = fn(flags: std.os.ProtectionFlags) ProtectionFlags {
|
|
return ProtectionFlags{
|
|
.read = flags.read,
|
|
.write = flags.write,
|
|
.execute = flags.execute,
|
|
};
|
|
}
|
|
|
|
const get_map_flags = fn(flags: std.os.MapFlags) MapFlags{
|
|
return MapFlags{
|
|
.shared = false,
|
|
.private = true,
|
|
.fixed = false,
|
|
.noreserve = false,
|
|
.has_semaphore = false,
|
|
.no_cache = false,
|
|
.anonymous = true,
|
|
};
|
|
}
|
|
|
|
const write :: extern = fn cc(.c) (file_descriptor: FileDescriptor, bytes_ptr: [&]const u8, bytes_len: usize) ssize;
|
|
const exit :: extern = fn cc(.c) (exit_code: s32) noreturn;
|
|
const fork :: extern = fn cc(.c) () ProcessId;
|
|
const mmap :: extern = fn cc(.c) (address: ?[&]const u8, length: usize, protection_flags: ProtectionFlags, map_flags: MapFlags, file_descriptor: FileDescriptor, offset: u64) usize;
|
|
const munmap :: extern = fn cc(.c) (address: [&]const u8, length: usize) s32;
|
|
const execve :: extern = fn cc(.c) (path: [&:0]const u8, argv: [&:null]const ?[&:0]const u8, env: [&:null]const ?[&:null]const u8) s32;
|
|
const realpath :: extern = fn cc(.c) (path: [&:0]const u8, resolved_path: [&:0]u8) ?[&:0]u8;
|
|
const waitpid :: extern = fn cc(.c) (pid: ProcessId, status: &s32, flags: s32) s32;
|
|
|
|
const _NSGetExecutablePath :: extern = fn cc(.c) (buffer: [&:0]u8, buffer_size: &u32) s32;
|