From ca33cb990b5a05829067e18ea24bcb36a75aba67 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 8 Sep 2021 13:12:38 +0100 Subject: [PATCH] Strip semicolons in core which were missing --- core/dynlib/lib_unix.odin | 16 +- core/math/big/helpers.odin | 12 +- core/math/big/internal.odin | 2 +- core/mem/mem.odin | 5 +- core/odin/tokenizer/token.odin | 2 +- core/os/dir_darwin.odin | 62 +- core/os/dir_linux.odin | 62 +- core/os/os_darwin.odin | 660 ++++++++--------- core/os/os_linux.odin | 716 +++++++++---------- core/os/stat_unix.odin | 86 +-- core/path/filepath/path_unix.odin | 34 +- core/runtime/default_allocators_general.odin | 8 +- core/runtime/internal_linux.odin | 70 +- core/runtime/os_specific_any.odin | 6 +- core/runtime/procs_unix.odin | 12 +- core/sync/sync2/primitives_darwin.odin | 38 +- core/sync/sync2/primitives_linux.odin | 4 +- core/sync/sync2/primitives_pthreads.odin | 150 ++-- core/sync/sync_darwin.odin | 30 +- core/sync/sync_linux.odin | 14 +- core/sync/sync_unix.odin | 144 ++-- core/sys/darwin/mach_darwin.odin | 24 +- core/sys/unix/pthread_darwin.odin | 66 +- core/sys/unix/pthread_linux.odin | 90 +-- core/sys/unix/pthread_unix.odin | 78 +- core/thread/thread_unix.odin | 110 +-- core/time/time_unix.odin | 82 +-- 27 files changed, 1296 insertions(+), 1287 deletions(-) diff --git a/core/dynlib/lib_unix.odin b/core/dynlib/lib_unix.odin index 42eb96c31..bb8affb79 100644 --- a/core/dynlib/lib_unix.odin +++ b/core/dynlib/lib_unix.odin @@ -4,20 +4,20 @@ package dynlib import "core:os" load_library :: proc(path: string, global_symbols := false) -> (Library, bool) { - flags := os.RTLD_NOW; + flags := os.RTLD_NOW if global_symbols { - flags |= os.RTLD_GLOBAL; + flags |= os.RTLD_GLOBAL } - lib := os.dlopen(path, flags); - return Library(lib), lib != nil; + lib := os.dlopen(path, flags) + return Library(lib), lib != nil } unload_library :: proc(library: Library) { - os.dlclose(rawptr(library)); + os.dlclose(rawptr(library)) } symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) { - ptr = os.dlsym(rawptr(library), symbol); - found = ptr != nil; - return; + ptr = os.dlsym(rawptr(library), symbol) + found = ptr != nil + return } diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin index 10c9f9e13..ae94946e1 100644 --- a/core/math/big/helpers.odin +++ b/core/math/big/helpers.odin @@ -788,10 +788,16 @@ destroy_constants :: proc() { } -assert_if_nil :: #force_inline proc(integers: ..^Int, loc := #caller_location) { - integers := integers +assert_if_nil :: proc{assert_if_nil_int, assert_if_nil_rat} - for i in &integers { +assert_if_nil_int :: #force_inline proc(integers: ..^Int, loc := #caller_location) { + for i in integers { assert(i != nil, "(nil)", loc) } } + +assert_if_nil_rat :: #force_inline proc(rationals: ..^Rat, loc := #caller_location) { + for r in rationals { + assert(r != nil, "(nil)", loc) + } +} diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin index 97630a340..f84d034bf 100644 --- a/core/math/big/internal.odin +++ b/core/math/big/internal.odin @@ -1042,7 +1042,7 @@ internal_is_initialized :: proc { internal_int_is_initialized, } internal_int_is_zero :: #force_inline proc(a: ^Int) -> (zero: bool) { return a.used == 0 } -internal_is_zero :: proc { internal_int_is_zero, } +internal_is_zero :: proc { internal_int_is_zero, internal_rat_is_zero } /* This procedure will return `true` if the `Int` is positive, `false` if not. diff --git a/core/mem/mem.odin b/core/mem/mem.odin index 544036c40..f63a15e23 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -168,7 +168,10 @@ buffer_from_slice :: proc "contextless" (backing: $T/[]$E) -> [dynamic]E { data = raw_data(backing), len = 0, cap = len(backing), - allocator = nil_allocator(), + allocator = Allocator{ + procedure = nil_allocator_proc, + data = nil, + }, } } diff --git a/core/odin/tokenizer/token.odin b/core/odin/tokenizer/token.odin index 13ac0e177..43a8552fa 100644 --- a/core/odin/tokenizer/token.odin +++ b/core/odin/tokenizer/token.odin @@ -317,7 +317,7 @@ is_literal :: proc(kind: Token_Kind) -> bool { } is_operator :: proc(kind: Token_Kind) -> bool { #partial switch kind { - case .B_Operator_Begin .. .B_Operator_End: + case .B_Operator_Begin ..= .B_Operator_End: return true case .In, .Not_In: return true diff --git a/core/os/dir_darwin.odin b/core/os/dir_darwin.odin index 851bd1635..74c410a51 100644 --- a/core/os/dir_darwin.odin +++ b/core/os/dir_darwin.odin @@ -4,67 +4,67 @@ import "core:strings" import "core:mem" read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { - dirp: Dir; - dirp, err = _fdopendir(fd); + dirp: Dir + dirp, err = _fdopendir(fd) if err != ERROR_NONE { - return; + return } - defer _closedir(dirp); + defer _closedir(dirp) - dirpath: string; - dirpath, err = absolute_path_from_handle(fd); + dirpath: string + dirpath, err = absolute_path_from_handle(fd) if err != ERROR_NONE { - return; + return } - defer delete(dirpath); + defer delete(dirpath) - n := n; - size := n; + n := n + size := n if n <= 0 { - n = -1; - size = 100; + n = -1 + size = 100 } - dfi := make([dynamic]File_Info, 0, size, allocator); + dfi := make([dynamic]File_Info, 0, size, allocator) for { - entry: Dirent; - end_of_stream: bool; - entry, err, end_of_stream = _readdir(dirp); + entry: Dirent + end_of_stream: bool + entry, err, end_of_stream = _readdir(dirp) if err != ERROR_NONE { for fi_ in dfi { - file_info_delete(fi_, allocator); + file_info_delete(fi_, allocator) } - delete(dfi); - return; + delete(dfi) + return } else if end_of_stream { - break; + break } - fi_: File_Info; - filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] }); + fi_: File_Info + filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] }) if filename == "." || filename == ".." { - continue; + continue } - fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator); - defer delete(fullpath, context.temp_allocator); + fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator) + defer delete(fullpath, context.temp_allocator) - fi_, err = stat(fullpath, allocator); + fi_, err = stat(fullpath, allocator) if err != ERROR_NONE { for fi__ in dfi { - file_info_delete(fi__, allocator); + file_info_delete(fi__, allocator) } - delete(dfi); - return; + delete(dfi) + return } - append(&dfi, fi_); + append(&dfi, fi_) } - return dfi[:], ERROR_NONE; + return dfi[:], ERROR_NONE } diff --git a/core/os/dir_linux.odin b/core/os/dir_linux.odin index 851bd1635..74c410a51 100644 --- a/core/os/dir_linux.odin +++ b/core/os/dir_linux.odin @@ -4,67 +4,67 @@ import "core:strings" import "core:mem" read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { - dirp: Dir; - dirp, err = _fdopendir(fd); + dirp: Dir + dirp, err = _fdopendir(fd) if err != ERROR_NONE { - return; + return } - defer _closedir(dirp); + defer _closedir(dirp) - dirpath: string; - dirpath, err = absolute_path_from_handle(fd); + dirpath: string + dirpath, err = absolute_path_from_handle(fd) if err != ERROR_NONE { - return; + return } - defer delete(dirpath); + defer delete(dirpath) - n := n; - size := n; + n := n + size := n if n <= 0 { - n = -1; - size = 100; + n = -1 + size = 100 } - dfi := make([dynamic]File_Info, 0, size, allocator); + dfi := make([dynamic]File_Info, 0, size, allocator) for { - entry: Dirent; - end_of_stream: bool; - entry, err, end_of_stream = _readdir(dirp); + entry: Dirent + end_of_stream: bool + entry, err, end_of_stream = _readdir(dirp) if err != ERROR_NONE { for fi_ in dfi { - file_info_delete(fi_, allocator); + file_info_delete(fi_, allocator) } - delete(dfi); - return; + delete(dfi) + return } else if end_of_stream { - break; + break } - fi_: File_Info; - filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] }); + fi_: File_Info + filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] }) if filename == "." || filename == ".." { - continue; + continue } - fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator); - defer delete(fullpath, context.temp_allocator); + fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator) + defer delete(fullpath, context.temp_allocator) - fi_, err = stat(fullpath, allocator); + fi_, err = stat(fullpath, allocator) if err != ERROR_NONE { for fi__ in dfi { - file_info_delete(fi__, allocator); + file_info_delete(fi__, allocator) } - delete(dfi); - return; + delete(dfi) + return } - append(&dfi, fi_); + append(&dfi, fi_) } - return dfi[:], ERROR_NONE; + return dfi[:], ERROR_NONE } diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin index 47e3e51d3..ce6da85a1 100644 --- a/core/os/os_darwin.odin +++ b/core/os/os_darwin.odin @@ -9,183 +9,183 @@ import "core:strings" import "core:strconv" import "core:c" -Handle :: distinct i32; -File_Time :: distinct u64; -Errno :: distinct int; +Handle :: distinct i32 +File_Time :: distinct u64 +Errno :: distinct int -INVALID_HANDLE :: ~Handle(0); +INVALID_HANDLE :: ~Handle(0) -ERROR_NONE: Errno : 0; -EPERM: Errno : 1; /* Operation not permitted */ -ENOENT: Errno : 2; /* No such file or directory */ -ESRCH: Errno : 3; /* No such process */ -EINTR: Errno : 4; /* Interrupted system call */ -EIO: Errno : 5; /* Input/output error */ -ENXIO: Errno : 6; /* Device not configured */ -E2BIG: Errno : 7; /* Argument list too long */ -ENOEXEC: Errno : 8; /* Exec format error */ -EBADF: Errno : 9; /* Bad file descriptor */ -ECHILD: Errno : 10; /* No child processes */ -EDEADLK: Errno : 11; /* Resource deadlock avoided */ -ENOMEM: Errno : 12; /* Cannot allocate memory */ -EACCES: Errno : 13; /* Permission denied */ -EFAULT: Errno : 14; /* Bad address */ -ENOTBLK: Errno : 15; /* Block device required */ -EBUSY: Errno : 16; /* Device / Resource busy */ -EEXIST: Errno : 17; /* File exists */ -EXDEV: Errno : 18; /* Cross-device link */ -ENODEV: Errno : 19; /* Operation not supported by device */ -ENOTDIR: Errno : 20; /* Not a directory */ -EISDIR: Errno : 21; /* Is a directory */ -EINVAL: Errno : 22; /* Invalid argument */ -ENFILE: Errno : 23; /* Too many open files in system */ -EMFILE: Errno : 24; /* Too many open files */ -ENOTTY: Errno : 25; /* Inappropriate ioctl for device */ -ETXTBSY: Errno : 26; /* Text file busy */ -EFBIG: Errno : 27; /* File too large */ -ENOSPC: Errno : 28; /* No space left on device */ -ESPIPE: Errno : 29; /* Illegal seek */ -EROFS: Errno : 30; /* Read-only file system */ -EMLINK: Errno : 31; /* Too many links */ -EPIPE: Errno : 32; /* Broken pipe */ +ERROR_NONE: Errno : 0 +EPERM: Errno : 1 /* Operation not permitted */ +ENOENT: Errno : 2 /* No such file or directory */ +ESRCH: Errno : 3 /* No such process */ +EINTR: Errno : 4 /* Interrupted system call */ +EIO: Errno : 5 /* Input/output error */ +ENXIO: Errno : 6 /* Device not configured */ +E2BIG: Errno : 7 /* Argument list too long */ +ENOEXEC: Errno : 8 /* Exec format error */ +EBADF: Errno : 9 /* Bad file descriptor */ +ECHILD: Errno : 10 /* No child processes */ +EDEADLK: Errno : 11 /* Resource deadlock avoided */ +ENOMEM: Errno : 12 /* Cannot allocate memory */ +EACCES: Errno : 13 /* Permission denied */ +EFAULT: Errno : 14 /* Bad address */ +ENOTBLK: Errno : 15 /* Block device required */ +EBUSY: Errno : 16 /* Device / Resource busy */ +EEXIST: Errno : 17 /* File exists */ +EXDEV: Errno : 18 /* Cross-device link */ +ENODEV: Errno : 19 /* Operation not supported by device */ +ENOTDIR: Errno : 20 /* Not a directory */ +EISDIR: Errno : 21 /* Is a directory */ +EINVAL: Errno : 22 /* Invalid argument */ +ENFILE: Errno : 23 /* Too many open files in system */ +EMFILE: Errno : 24 /* Too many open files */ +ENOTTY: Errno : 25 /* Inappropriate ioctl for device */ +ETXTBSY: Errno : 26 /* Text file busy */ +EFBIG: Errno : 27 /* File too large */ +ENOSPC: Errno : 28 /* No space left on device */ +ESPIPE: Errno : 29 /* Illegal seek */ +EROFS: Errno : 30 /* Read-only file system */ +EMLINK: Errno : 31 /* Too many links */ +EPIPE: Errno : 32 /* Broken pipe */ /* math software */ -EDOM: Errno : 33; /* Numerical argument out of domain */ -ERANGE: Errno : 34; /* Result too large */ +EDOM: Errno : 33 /* Numerical argument out of domain */ +ERANGE: Errno : 34 /* Result too large */ /* non-blocking and interrupt i/o */ -EAGAIN: Errno : 35; /* Resource temporarily unavailable */ -EWOULDBLOCK: Errno : EAGAIN; /* Operation would block */ -EINPROGRESS: Errno : 36; /* Operation now in progress */ -EALREADY: Errno : 37; /* Operation already in progress */ +EAGAIN: Errno : 35 /* Resource temporarily unavailable */ +EWOULDBLOCK: Errno : EAGAIN /* Operation would block */ +EINPROGRESS: Errno : 36 /* Operation now in progress */ +EALREADY: Errno : 37 /* Operation already in progress */ /* ipc/network software -- argument errors */ -ENOTSOCK: Errno : 38; /* Socket operation on non-socket */ -EDESTADDRREQ: Errno : 39; /* Destination address required */ -EMSGSIZE: Errno : 40; /* Message too long */ -EPROTOTYPE: Errno : 41; /* Protocol wrong type for socket */ -ENOPROTOOPT: Errno : 42; /* Protocol not available */ -EPROTONOSUPPORT: Errno : 43; /* Protocol not supported */ -ESOCKTNOSUPPORT: Errno : 44; /* Socket type not supported */ -ENOTSUP: Errno : 45; /* Operation not supported */ -EPFNOSUPPORT: Errno : 46; /* Protocol family not supported */ -EAFNOSUPPORT: Errno : 47; /* Address family not supported by protocol family */ -EADDRINUSE: Errno : 48; /* Address already in use */ -EADDRNOTAVAIL: Errno : 49; /* Can't assign requested address */ +ENOTSOCK: Errno : 38 /* Socket operation on non-socket */ +EDESTADDRREQ: Errno : 39 /* Destination address required */ +EMSGSIZE: Errno : 40 /* Message too long */ +EPROTOTYPE: Errno : 41 /* Protocol wrong type for socket */ +ENOPROTOOPT: Errno : 42 /* Protocol not available */ +EPROTONOSUPPORT: Errno : 43 /* Protocol not supported */ +ESOCKTNOSUPPORT: Errno : 44 /* Socket type not supported */ +ENOTSUP: Errno : 45 /* Operation not supported */ +EPFNOSUPPORT: Errno : 46 /* Protocol family not supported */ +EAFNOSUPPORT: Errno : 47 /* Address family not supported by protocol family */ +EADDRINUSE: Errno : 48 /* Address already in use */ +EADDRNOTAVAIL: Errno : 49 /* Can't assign requested address */ /* ipc/network software -- operational errors */ -ENETDOWN: Errno : 50; /* Network is down */ -ENETUNREACH: Errno : 51; /* Network is unreachable */ -ENETRESET: Errno : 52; /* Network dropped connection on reset */ -ECONNABORTED: Errno : 53; /* Software caused connection abort */ -ECONNRESET: Errno : 54; /* Connection reset by peer */ -ENOBUFS: Errno : 55; /* No buffer space available */ -EISCONN: Errno : 56; /* Socket is already connected */ -ENOTCONN: Errno : 57; /* Socket is not connected */ -ESHUTDOWN: Errno : 58; /* Can't send after socket shutdown */ -ETOOMANYREFS: Errno : 59; /* Too many references: can't splice */ -ETIMEDOUT: Errno : 60; /* Operation timed out */ -ECONNREFUSED: Errno : 61; /* Connection refused */ +ENETDOWN: Errno : 50 /* Network is down */ +ENETUNREACH: Errno : 51 /* Network is unreachable */ +ENETRESET: Errno : 52 /* Network dropped connection on reset */ +ECONNABORTED: Errno : 53 /* Software caused connection abort */ +ECONNRESET: Errno : 54 /* Connection reset by peer */ +ENOBUFS: Errno : 55 /* No buffer space available */ +EISCONN: Errno : 56 /* Socket is already connected */ +ENOTCONN: Errno : 57 /* Socket is not connected */ +ESHUTDOWN: Errno : 58 /* Can't send after socket shutdown */ +ETOOMANYREFS: Errno : 59 /* Too many references: can't splice */ +ETIMEDOUT: Errno : 60 /* Operation timed out */ +ECONNREFUSED: Errno : 61 /* Connection refused */ -ELOOP: Errno : 62; /* Too many levels of symbolic links */ -ENAMETOOLONG: Errno : 63; /* File name too long */ +ELOOP: Errno : 62 /* Too many levels of symbolic links */ +ENAMETOOLONG: Errno : 63 /* File name too long */ /* should be rearranged */ -EHOSTDOWN: Errno : 64; /* Host is down */ -EHOSTUNREACH: Errno : 65; /* No route to host */ -ENOTEMPTY: Errno : 66; /* Directory not empty */ +EHOSTDOWN: Errno : 64 /* Host is down */ +EHOSTUNREACH: Errno : 65 /* No route to host */ +ENOTEMPTY: Errno : 66 /* Directory not empty */ /* quotas & mush */ -EPROCLIM: Errno : 67; /* Too many processes */ -EUSERS: Errno : 68; /* Too many users */ -EDQUOT: Errno : 69; /* Disc quota exceeded */ +EPROCLIM: Errno : 67 /* Too many processes */ +EUSERS: Errno : 68 /* Too many users */ +EDQUOT: Errno : 69 /* Disc quota exceeded */ /* Network File System */ -ESTALE: Errno : 70; /* Stale NFS file handle */ -EREMOTE: Errno : 71; /* Too many levels of remote in path */ -EBADRPC: Errno : 72; /* RPC struct is bad */ -ERPCMISMATCH: Errno : 73; /* RPC version wrong */ -EPROGUNAVAIL: Errno : 74; /* RPC prog. not avail */ -EPROGMISMATCH: Errno : 75; /* Program version wrong */ -EPROCUNAVAIL: Errno : 76; /* Bad procedure for program */ +ESTALE: Errno : 70 /* Stale NFS file handle */ +EREMOTE: Errno : 71 /* Too many levels of remote in path */ +EBADRPC: Errno : 72 /* RPC struct is bad */ +ERPCMISMATCH: Errno : 73 /* RPC version wrong */ +EPROGUNAVAIL: Errno : 74 /* RPC prog. not avail */ +EPROGMISMATCH: Errno : 75 /* Program version wrong */ +EPROCUNAVAIL: Errno : 76 /* Bad procedure for program */ -ENOLCK: Errno : 77; /* No locks available */ -ENOSYS: Errno : 78; /* Function not implemented */ +ENOLCK: Errno : 77 /* No locks available */ +ENOSYS: Errno : 78 /* Function not implemented */ -EFTYPE: Errno : 79; /* Inappropriate file type or format */ -EAUTH: Errno : 80; /* Authentication error */ -ENEEDAUTH: Errno : 81; /* Need authenticator */ +EFTYPE: Errno : 79 /* Inappropriate file type or format */ +EAUTH: Errno : 80 /* Authentication error */ +ENEEDAUTH: Errno : 81 /* Need authenticator */ /* Intelligent device errors */ -EPWROFF: Errno : 82; /* Device power is off */ -EDEVERR: Errno : 83; /* Device error, e.g. paper out */ -EOVERFLOW: Errno : 84; /* Value too large to be stored in data type */ +EPWROFF: Errno : 82 /* Device power is off */ +EDEVERR: Errno : 83 /* Device error, e.g. paper out */ +EOVERFLOW: Errno : 84 /* Value too large to be stored in data type */ /* Program loading errors */ -EBADEXEC: Errno : 85; /* Bad executable */ -EBADARCH: Errno : 86; /* Bad CPU type in executable */ -ESHLIBVERS: Errno : 87; /* Shared library version mismatch */ -EBADMACHO: Errno : 88; /* Malformed Macho file */ +EBADEXEC: Errno : 85 /* Bad executable */ +EBADARCH: Errno : 86 /* Bad CPU type in executable */ +ESHLIBVERS: Errno : 87 /* Shared library version mismatch */ +EBADMACHO: Errno : 88 /* Malformed Macho file */ -ECANCELED: Errno : 89; /* Operation canceled */ +ECANCELED: Errno : 89 /* Operation canceled */ -EIDRM: Errno : 90; /* Identifier removed */ -ENOMSG: Errno : 91; /* No message of desired type */ -EILSEQ: Errno : 92; /* Illegal byte sequence */ -ENOATTR: Errno : 93; /* Attribute not found */ +EIDRM: Errno : 90 /* Identifier removed */ +ENOMSG: Errno : 91 /* No message of desired type */ +EILSEQ: Errno : 92 /* Illegal byte sequence */ +ENOATTR: Errno : 93 /* Attribute not found */ -EBADMSG: Errno : 94; /* Bad message */ -EMULTIHOP: Errno : 95; /* Reserved */ -ENODATA: Errno : 96; /* No message available on STREAM */ -ENOLINK: Errno : 97; /* Reserved */ -ENOSR: Errno : 98; /* No STREAM resources */ -ENOSTR: Errno : 99; /* Not a STREAM */ -EPROTO: Errno : 100; /* Protocol error */ -ETIME: Errno : 101; /* STREAM ioctl timeout */ +EBADMSG: Errno : 94 /* Bad message */ +EMULTIHOP: Errno : 95 /* Reserved */ +ENODATA: Errno : 96 /* No message available on STREAM */ +ENOLINK: Errno : 97 /* Reserved */ +ENOSR: Errno : 98 /* No STREAM resources */ +ENOSTR: Errno : 99 /* Not a STREAM */ +EPROTO: Errno : 100 /* Protocol error */ +ETIME: Errno : 101 /* STREAM ioctl timeout */ -ENOPOLICY: Errno : 103; /* No such policy registered */ +ENOPOLICY: Errno : 103 /* No such policy registered */ -ENOTRECOVERABLE: Errno : 104; /* State not recoverable */ -EOWNERDEAD: Errno : 105; /* Previous owner died */ +ENOTRECOVERABLE: Errno : 104 /* State not recoverable */ +EOWNERDEAD: Errno : 105 /* Previous owner died */ -EQFULL: Errno : 106; /* Interface output queue is full */ -ELAST: Errno : 106; /* Must be equal largest errno */ +EQFULL: Errno : 106 /* Interface output queue is full */ +ELAST: Errno : 106 /* Must be equal largest errno */ -O_RDONLY :: 0x0000; -O_WRONLY :: 0x0001; -O_RDWR :: 0x0002; -O_CREATE :: 0x0200; -O_EXCL :: 0x0800; -O_NOCTTY :: 0; -O_TRUNC :: 0x0400; -O_NONBLOCK :: 0x0004; -O_APPEND :: 0x0008; -O_SYNC :: 0x0080; -O_ASYNC :: 0x0040; -O_CLOEXEC :: 0x1000000; +O_RDONLY :: 0x0000 +O_WRONLY :: 0x0001 +O_RDWR :: 0x0002 +O_CREATE :: 0x0200 +O_EXCL :: 0x0800 +O_NOCTTY :: 0 +O_TRUNC :: 0x0400 +O_NONBLOCK :: 0x0004 +O_APPEND :: 0x0008 +O_SYNC :: 0x0080 +O_ASYNC :: 0x0040 +O_CLOEXEC :: 0x1000000 -SEEK_SET :: 0; -SEEK_CUR :: 1; -SEEK_END :: 2; -SEEK_DATA :: 3; -SEEK_HOLE :: 4; -SEEK_MAX :: SEEK_HOLE; +SEEK_SET :: 0 +SEEK_CUR :: 1 +SEEK_END :: 2 +SEEK_DATA :: 3 +SEEK_HOLE :: 4 +SEEK_MAX :: SEEK_HOLE // NOTE(zangent): These are OS specific! // Do not mix these up! -RTLD_LAZY :: 0x1; -RTLD_NOW :: 0x2; -RTLD_LOCAL :: 0x4; -RTLD_GLOBAL :: 0x8; -RTLD_NODELETE :: 0x80; -RTLD_NOLOAD :: 0x10; -RTLD_FIRST :: 0x100; +RTLD_LAZY :: 0x1 +RTLD_NOW :: 0x2 +RTLD_LOCAL :: 0x4 +RTLD_GLOBAL :: 0x8 +RTLD_NODELETE :: 0x80 +RTLD_NOLOAD :: 0x10 +RTLD_FIRST :: 0x100 // "Argv" arguments converted to Odin strings -args := _alloc_command_line_arguments(); +args := _alloc_command_line_arguments() Unix_File_Time :: struct { seconds: i64, @@ -214,7 +214,7 @@ OS_Stat :: struct { _spare: i32, // RESERVED _reserve1, _reserve2: i64, // RESERVED -}; +} // NOTE(laleksic, 2021-01-21): Comment and rename these to match OS_Stat above Dirent :: struct { @@ -223,159 +223,159 @@ Dirent :: struct { reclen: u16, type: u8, name: [256]byte, -}; +} -Dir :: distinct rawptr; // DIR* +Dir :: distinct rawptr // DIR* // File type -S_IFMT :: 0o170000; // Type of file mask -S_IFIFO :: 0o010000; // Named pipe (fifo) -S_IFCHR :: 0o020000; // Character special -S_IFDIR :: 0o040000; // Directory -S_IFBLK :: 0o060000; // Block special -S_IFREG :: 0o100000; // Regular -S_IFLNK :: 0o120000; // Symbolic link -S_IFSOCK :: 0o140000; // Socket +S_IFMT :: 0o170000 // Type of file mask +S_IFIFO :: 0o010000 // Named pipe (fifo) +S_IFCHR :: 0o020000 // Character special +S_IFDIR :: 0o040000 // Directory +S_IFBLK :: 0o060000 // Block special +S_IFREG :: 0o100000 // Regular +S_IFLNK :: 0o120000 // Symbolic link +S_IFSOCK :: 0o140000 // Socket // File mode // Read, write, execute/search by owner -S_IRWXU :: 0o0700; // RWX mask for owner -S_IRUSR :: 0o0400; // R for owner -S_IWUSR :: 0o0200; // W for owner -S_IXUSR :: 0o0100; // X for owner +S_IRWXU :: 0o0700 // RWX mask for owner +S_IRUSR :: 0o0400 // R for owner +S_IWUSR :: 0o0200 // W for owner +S_IXUSR :: 0o0100 // X for owner // Read, write, execute/search by group -S_IRWXG :: 0o0070; // RWX mask for group -S_IRGRP :: 0o0040; // R for group -S_IWGRP :: 0o0020; // W for group -S_IXGRP :: 0o0010; // X for group +S_IRWXG :: 0o0070 // RWX mask for group +S_IRGRP :: 0o0040 // R for group +S_IWGRP :: 0o0020 // W for group +S_IXGRP :: 0o0010 // X for group // Read, write, execute/search by others -S_IRWXO :: 0o0007; // RWX mask for other -S_IROTH :: 0o0004; // R for other -S_IWOTH :: 0o0002; // W for other -S_IXOTH :: 0o0001; // X for other +S_IRWXO :: 0o0007 // RWX mask for other +S_IROTH :: 0o0004 // R for other +S_IWOTH :: 0o0002 // W for other +S_IXOTH :: 0o0001 // X for other -S_ISUID :: 0o4000; // Set user id on execution -S_ISGID :: 0o2000; // Set group id on execution -S_ISVTX :: 0o1000; // Directory restrcted delete +S_ISUID :: 0o4000 // Set user id on execution +S_ISGID :: 0o2000 // Set group id on execution +S_ISVTX :: 0o1000 // Directory restrcted delete -S_ISLNK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFLNK; } -S_ISREG :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFREG; } -S_ISDIR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFDIR; } -S_ISCHR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFCHR; } -S_ISBLK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFBLK; } -S_ISFIFO :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFIFO; } -S_ISSOCK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFSOCK; } +S_ISLNK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFLNK } +S_ISREG :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFREG } +S_ISDIR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFDIR } +S_ISCHR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFCHR } +S_ISBLK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFBLK } +S_ISFIFO :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFIFO } +S_ISSOCK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFSOCK } -R_OK :: 4; // Test for read permission -W_OK :: 2; // Test for write permission -X_OK :: 1; // Test for execute permission -F_OK :: 0; // Test for file existance +R_OK :: 4 // Test for read permission +W_OK :: 2 // Test for write permission +X_OK :: 1 // Test for execute permission +F_OK :: 0 // Test for file existance foreign libc { - @(link_name="__error") __error :: proc() -> ^int ---; + @(link_name="__error") __error :: proc() -> ^int --- - @(link_name="open") _unix_open :: proc(path: cstring, flags: i32, mode: u16) -> Handle ---; - @(link_name="close") _unix_close :: proc(handle: Handle) ---; - @(link_name="read") _unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---; - @(link_name="write") _unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---; - @(link_name="lseek") _unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int ---; - @(link_name="gettid") _unix_gettid :: proc() -> u64 ---; - @(link_name="getpagesize") _unix_getpagesize :: proc() -> i32 ---; - @(link_name="stat64") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---; - @(link_name="lstat") _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---; - @(link_name="fstat") _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> c.int ---; - @(link_name="readlink") _unix_readlink :: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t ---; - @(link_name="access") _unix_access :: proc(path: cstring, mask: int) -> int ---; - @(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir ---; - @(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int ---; - @(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) ---; - @(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int ---; + @(link_name="open") _unix_open :: proc(path: cstring, flags: i32, mode: u16) -> Handle --- + @(link_name="close") _unix_close :: proc(handle: Handle) --- + @(link_name="read") _unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int --- + @(link_name="write") _unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int --- + @(link_name="lseek") _unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int --- + @(link_name="gettid") _unix_gettid :: proc() -> u64 --- + @(link_name="getpagesize") _unix_getpagesize :: proc() -> i32 --- + @(link_name="stat64") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int --- + @(link_name="lstat") _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> c.int --- + @(link_name="fstat") _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> c.int --- + @(link_name="readlink") _unix_readlink :: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t --- + @(link_name="access") _unix_access :: proc(path: cstring, mask: int) -> int --- + @(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir --- + @(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int --- + @(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) --- + @(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int --- - @(link_name="malloc") _unix_malloc :: proc(size: int) -> rawptr ---; - @(link_name="calloc") _unix_calloc :: proc(num, size: int) -> rawptr ---; - @(link_name="free") _unix_free :: proc(ptr: rawptr) ---; - @(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr ---; - @(link_name="getenv") _unix_getenv :: proc(cstring) -> cstring ---; - @(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring ---; - @(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int ---; - @(link_name="realpath") _unix_realpath :: proc(path: cstring, resolved_path: rawptr) -> rawptr ---; + @(link_name="malloc") _unix_malloc :: proc(size: int) -> rawptr --- + @(link_name="calloc") _unix_calloc :: proc(num, size: int) -> rawptr --- + @(link_name="free") _unix_free :: proc(ptr: rawptr) --- + @(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr --- + @(link_name="getenv") _unix_getenv :: proc(cstring) -> cstring --- + @(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring --- + @(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int --- + @(link_name="realpath") _unix_realpath :: proc(path: cstring, resolved_path: rawptr) -> rawptr --- - @(link_name="exit") _unix_exit :: proc(status: int) -> ! ---; + @(link_name="exit") _unix_exit :: proc(status: int) -> ! --- } foreign dl { - @(link_name="dlopen") _unix_dlopen :: proc(filename: cstring, flags: int) -> rawptr ---; - @(link_name="dlsym") _unix_dlsym :: proc(handle: rawptr, symbol: cstring) -> rawptr ---; - @(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int ---; - @(link_name="dlerror") _unix_dlerror :: proc() -> cstring ---; + @(link_name="dlopen") _unix_dlopen :: proc(filename: cstring, flags: int) -> rawptr --- + @(link_name="dlsym") _unix_dlsym :: proc(handle: rawptr, symbol: cstring) -> rawptr --- + @(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int --- + @(link_name="dlerror") _unix_dlerror :: proc() -> cstring --- } get_last_error :: proc() -> int { - return __error()^; + return __error()^ } open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) { - cstr := strings.clone_to_cstring(path); - handle := _unix_open(cstr, i32(flags), u16(mode)); - delete(cstr); + cstr := strings.clone_to_cstring(path) + handle := _unix_open(cstr, i32(flags), u16(mode)) + delete(cstr) if handle == -1 { - return INVALID_HANDLE, 1; + return INVALID_HANDLE, 1 } - return handle, 0; + return handle, 0 } close :: proc(fd: Handle) { - _unix_close(fd); + _unix_close(fd) } write :: proc(fd: Handle, data: []u8) -> (int, Errno) { - assert(fd != -1); + assert(fd != -1) if len(data) == 0 { - return 0, 0; + return 0, 0 } - bytes_written := _unix_write(fd, raw_data(data), len(data)); + bytes_written := _unix_write(fd, raw_data(data), len(data)) if bytes_written == -1 { - return 0, 1; + return 0, 1 } - return bytes_written, 0; + return bytes_written, 0 } read :: proc(fd: Handle, data: []u8) -> (int, Errno) { - assert(fd != -1); + assert(fd != -1) - bytes_read := _unix_read(fd, raw_data(data), len(data)); + bytes_read := _unix_read(fd, raw_data(data), len(data)) if bytes_read == -1 { - return 0, 1; + return 0, 1 } - return bytes_read, 0; + return bytes_read, 0 } seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { - assert(fd != -1); + assert(fd != -1) - final_offset := i64(_unix_lseek(fd, int(offset), whence)); + final_offset := i64(_unix_lseek(fd, int(offset), whence)) if final_offset == -1 { - return 0, 1; + return 0, 1 } - return final_offset, 0; + return final_offset, 0 } file_size :: proc(fd: Handle) -> (i64, Errno) { - prev, _ := seek(fd, 0, SEEK_CUR); - size, err := seek(fd, 0, SEEK_END); - seek(fd, prev, SEEK_SET); - return i64(size), err; + prev, _ := seek(fd, 0, SEEK_CUR) + size, err := seek(fd, 0, SEEK_END) + seek(fd, prev, SEEK_SET) + return i64(size), err } // NOTE(bill): Uses startup to initialize it -stdin: Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE); -stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE); -stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE); +stdin: Handle = 0 // get_std_handle(win32.STD_INPUT_HANDLE); +stdout: Handle = 1 // get_std_handle(win32.STD_OUTPUT_HANDLE); +stderr: Handle = 2 // get_std_handle(win32.STD_ERROR_HANDLE); /* TODO(zangent): Implement these! last_write_time :: proc(fd: Handle) -> File_Time {} @@ -383,239 +383,239 @@ last_write_time_by_name :: proc(name: string) -> File_Time {} */ is_path_separator :: proc(r: rune) -> bool { - return r == '/'; + return r == '/' } @private _stat :: proc(path: string) -> (OS_Stat, Errno) { - cstr := strings.clone_to_cstring(path, context.temp_allocator); + cstr := strings.clone_to_cstring(path, context.temp_allocator) - s: OS_Stat; - result := _unix_stat(cstr, &s); + s: OS_Stat + result := _unix_stat(cstr, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _lstat :: proc(path: string) -> (OS_Stat, Errno) { - cstr := strings.clone_to_cstring(path, context.temp_allocator); + cstr := strings.clone_to_cstring(path, context.temp_allocator) - s: OS_Stat; - result := _unix_lstat(cstr, &s); + s: OS_Stat + result := _unix_lstat(cstr, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _fstat :: proc(fd: Handle) -> (OS_Stat, Errno) { - s: OS_Stat; - result := _unix_fstat(fd, &s); + s: OS_Stat + result := _unix_fstat(fd, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _fdopendir :: proc(fd: Handle) -> (Dir, Errno) { - dirp := _unix_fdopendir(fd); + dirp := _unix_fdopendir(fd) if dirp == cast(Dir)nil { - return nil, Errno(get_last_error()); + return nil, Errno(get_last_error()) } - return dirp, ERROR_NONE; + return dirp, ERROR_NONE } @private _closedir :: proc(dirp: Dir) -> Errno { - rc := _unix_closedir(dirp); + rc := _unix_closedir(dirp) if rc != 0 { - return Errno(get_last_error()); + return Errno(get_last_error()) } - return ERROR_NONE; + return ERROR_NONE } @private _rewinddir :: proc(dirp: Dir) { - _unix_rewinddir(dirp); + _unix_rewinddir(dirp) } @private _readdir :: proc(dirp: Dir) -> (entry: Dirent, err: Errno, end_of_stream: bool) { - result: ^Dirent; - rc := _unix_readdir_r(dirp, &entry, &result); + result: ^Dirent + rc := _unix_readdir_r(dirp, &entry, &result) if rc != 0 { - err = Errno(get_last_error()); - return; + err = Errno(get_last_error()) + return } - err = ERROR_NONE; + err = ERROR_NONE if result == nil { - end_of_stream = true; - return; + end_of_stream = true + return } - end_of_stream = false; + end_of_stream = false - return; + return } @private _readlink :: proc(path: string) -> (string, Errno) { - path_cstr := strings.clone_to_cstring(path, context.temp_allocator); + path_cstr := strings.clone_to_cstring(path, context.temp_allocator) - bufsz : uint = 256; - buf := make([]byte, bufsz); + bufsz : uint = 256 + buf := make([]byte, bufsz) for { - rc := _unix_readlink(path_cstr, &(buf[0]), bufsz); + rc := _unix_readlink(path_cstr, &(buf[0]), bufsz) if rc == -1 { - delete(buf); - return "", Errno(get_last_error()); + delete(buf) + return "", Errno(get_last_error()) } else if rc == int(bufsz) { // NOTE(laleksic, 2021-01-21): Any cleaner way to resize the slice? - bufsz *= 2; - delete(buf); - buf = make([]byte, bufsz); + bufsz *= 2 + delete(buf) + buf = make([]byte, bufsz) } else { - return strings.string_from_ptr(&buf[0], rc), ERROR_NONE; + return strings.string_from_ptr(&buf[0], rc), ERROR_NONE } } } absolute_path_from_handle :: proc(fd: Handle) -> (string, Errno) { - buf : [256]byte; - fd_str := strconv.itoa( buf[:], cast(int)fd ); + buf : [256]byte + fd_str := strconv.itoa( buf[:], cast(int)fd ) - procfs_path := strings.concatenate( []string{ "/proc/self/fd/", fd_str } ); - defer delete(procfs_path); + procfs_path := strings.concatenate( []string{ "/proc/self/fd/", fd_str } ) + defer delete(procfs_path) - return _readlink(procfs_path); + return _readlink(procfs_path) } absolute_path_from_relative :: proc(rel: string) -> (path: string, err: Errno) { - rel := rel; + rel := rel if rel == "" { - rel = "."; + rel = "." } - rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator); + rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator) - path_ptr := _unix_realpath(rel_cstr, nil); + path_ptr := _unix_realpath(rel_cstr, nil) if path_ptr == nil { - return "", Errno(get_last_error()); + return "", Errno(get_last_error()) } - defer _unix_free(path_ptr); + defer _unix_free(path_ptr) - path_cstr := transmute(cstring)path_ptr; - path = strings.clone( string(path_cstr) ); + path_cstr := transmute(cstring)path_ptr + path = strings.clone( string(path_cstr) ) - return path, ERROR_NONE; + return path, ERROR_NONE } access :: proc(path: string, mask: int) -> bool { - cstr := strings.clone_to_cstring(path, context.temp_allocator); - return _unix_access(cstr, mask) == 0; + cstr := strings.clone_to_cstring(path, context.temp_allocator) + return _unix_access(cstr, mask) == 0 } heap_alloc :: proc(size: int) -> rawptr { - assert(size > 0); - return _unix_calloc(1, size); + assert(size > 0) + return _unix_calloc(1, size) } heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - return _unix_realloc(ptr, new_size); + return _unix_realloc(ptr, new_size) } heap_free :: proc(ptr: rawptr) { - _unix_free(ptr); + _unix_free(ptr) } getenv :: proc(name: string) -> (string, bool) { - path_str := strings.clone_to_cstring(name, context.temp_allocator); - cstr := _unix_getenv(path_str); + path_str := strings.clone_to_cstring(name, context.temp_allocator) + cstr := _unix_getenv(path_str) if cstr == nil { - return "", false; + return "", false } - return string(cstr), true; + return string(cstr), true } get_current_directory :: proc() -> string { - page_size := get_page_size(); // NOTE(tetra): See note in os_linux.odin/get_current_directory. - buf := make([dynamic]u8, page_size); + page_size := get_page_size() // NOTE(tetra): See note in os_linux.odin/get_current_directory. + buf := make([dynamic]u8, page_size) for { - cwd := _unix_getcwd(cstring(raw_data(buf)), c.size_t(len(buf))); + cwd := _unix_getcwd(cstring(raw_data(buf)), c.size_t(len(buf))) if cwd != nil { - return string(cwd); + return string(cwd) } if Errno(get_last_error()) != ERANGE { - return ""; + return "" } - resize(&buf, len(buf)+page_size); + resize(&buf, len(buf)+page_size) } - unreachable(); + unreachable() } set_current_directory :: proc(path: string) -> (err: Errno) { - cstr := strings.clone_to_cstring(path, context.temp_allocator); - res := _unix_chdir(cstr); + cstr := strings.clone_to_cstring(path, context.temp_allocator) + res := _unix_chdir(cstr) if res == -1 { - return Errno(get_last_error()); + return Errno(get_last_error()) } - return ERROR_NONE; + return ERROR_NONE } exit :: proc "contextless" (code: int) -> ! { - _unix_exit(code); + _unix_exit(code) } current_thread_id :: proc "contextless" () -> int { - tid: u64; + tid: u64 // NOTE(Oskar): available from OSX 10.6 and iOS 3.2. // For older versions there is `syscall(SYS_thread_selfid)`, but not really // the same thing apparently. - foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int ---; } - pthread_threadid_np(nil, &tid); - return int(tid); + foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int --- } + pthread_threadid_np(nil, &tid) + return int(tid) } dlopen :: proc(filename: string, flags: int) -> rawptr { - cstr := strings.clone_to_cstring(filename, context.temp_allocator); - handle := _unix_dlopen(cstr, flags); - return handle; + cstr := strings.clone_to_cstring(filename, context.temp_allocator) + handle := _unix_dlopen(cstr, flags) + return handle } dlsym :: proc(handle: rawptr, symbol: string) -> rawptr { - assert(handle != nil); - cstr := strings.clone_to_cstring(symbol, context.temp_allocator); - proc_handle := _unix_dlsym(handle, cstr); - return proc_handle; + assert(handle != nil) + cstr := strings.clone_to_cstring(symbol, context.temp_allocator) + proc_handle := _unix_dlsym(handle, cstr) + return proc_handle } dlclose :: proc(handle: rawptr) -> bool { - assert(handle != nil); - return _unix_dlclose(handle) == 0; + assert(handle != nil) + return _unix_dlclose(handle) == 0 } dlerror :: proc() -> string { - return string(_unix_dlerror()); + return string(_unix_dlerror()) } get_page_size :: proc() -> int { // NOTE(tetra): The page size never changes, so why do anything complicated // if we don't have to. - @static page_size := -1; + @static page_size := -1 if page_size != -1 { - return page_size; + return page_size } - page_size = int(_unix_getpagesize()); - return page_size; + page_size = int(_unix_getpagesize()) + return page_size } _alloc_command_line_arguments :: proc() -> []string { - res := make([]string, len(runtime.args__)); + res := make([]string, len(runtime.args__)) for arg, i in runtime.args__ { - res[i] = string(arg); + res[i] = string(arg) } - return res; + return res } diff --git a/core/os/os_linux.odin b/core/os/os_linux.odin index 531a090ef..bc4717b44 100644 --- a/core/os/os_linux.odin +++ b/core/os/os_linux.odin @@ -9,176 +9,176 @@ import "core:c" import "core:strconv" import "core:intrinsics" -Handle :: distinct i32; -File_Time :: distinct u64; -Errno :: distinct i32; +Handle :: distinct i32 +File_Time :: distinct u64 +Errno :: distinct i32 -INVALID_HANDLE :: ~Handle(0); +INVALID_HANDLE :: ~Handle(0) -ERROR_NONE: Errno : 0; -EPERM: Errno : 1; -ENOENT: Errno : 2; -ESRCH: Errno : 3; -EINTR: Errno : 4; -EIO: Errno : 5; -ENXIO: Errno : 6; -EBADF: Errno : 9; -EAGAIN: Errno : 11; -ENOMEM: Errno : 12; -EACCES: Errno : 13; -EFAULT: Errno : 14; -EEXIST: Errno : 17; -ENODEV: Errno : 19; -ENOTDIR: Errno : 20; -EISDIR: Errno : 21; -EINVAL: Errno : 22; -ENFILE: Errno : 23; -EMFILE: Errno : 24; -ETXTBSY: Errno : 26; -EFBIG: Errno : 27; -ENOSPC: Errno : 28; -ESPIPE: Errno : 29; -EROFS: Errno : 30; -EPIPE: Errno : 32; +ERROR_NONE: Errno : 0 +EPERM: Errno : 1 +ENOENT: Errno : 2 +ESRCH: Errno : 3 +EINTR: Errno : 4 +EIO: Errno : 5 +ENXIO: Errno : 6 +EBADF: Errno : 9 +EAGAIN: Errno : 11 +ENOMEM: Errno : 12 +EACCES: Errno : 13 +EFAULT: Errno : 14 +EEXIST: Errno : 17 +ENODEV: Errno : 19 +ENOTDIR: Errno : 20 +EISDIR: Errno : 21 +EINVAL: Errno : 22 +ENFILE: Errno : 23 +EMFILE: Errno : 24 +ETXTBSY: Errno : 26 +EFBIG: Errno : 27 +ENOSPC: Errno : 28 +ESPIPE: Errno : 29 +EROFS: Errno : 30 +EPIPE: Errno : 32 -ERANGE: Errno : 34; /* Result too large */ -EDEADLK: Errno : 35; /* Resource deadlock would occur */ -ENAMETOOLONG: Errno : 36; /* File name too long */ -ENOLCK: Errno : 37; /* No record locks available */ +ERANGE: Errno : 34 /* Result too large */ +EDEADLK: Errno : 35 /* Resource deadlock would occur */ +ENAMETOOLONG: Errno : 36 /* File name too long */ +ENOLCK: Errno : 37 /* No record locks available */ -ENOSYS: Errno : 38; /* Invalid system call number */ +ENOSYS: Errno : 38 /* Invalid system call number */ -ENOTEMPTY: Errno : 39; /* Directory not empty */ -ELOOP: Errno : 40; /* Too many symbolic links encountered */ -EWOULDBLOCK: Errno : EAGAIN; /* Operation would block */ -ENOMSG: Errno : 42; /* No message of desired type */ -EIDRM: Errno : 43; /* Identifier removed */ -ECHRNG: Errno : 44; /* Channel number out of range */ -EL2NSYNC: Errno : 45; /* Level 2 not synchronized */ -EL3HLT: Errno : 46; /* Level 3 halted */ -EL3RST: Errno : 47; /* Level 3 reset */ -ELNRNG: Errno : 48; /* Link number out of range */ -EUNATCH: Errno : 49; /* Protocol driver not attached */ -ENOCSI: Errno : 50; /* No CSI structure available */ -EL2HLT: Errno : 51; /* Level 2 halted */ -EBADE: Errno : 52; /* Invalid exchange */ -EBADR: Errno : 53; /* Invalid request descriptor */ -EXFULL: Errno : 54; /* Exchange full */ -ENOANO: Errno : 55; /* No anode */ -EBADRQC: Errno : 56; /* Invalid request code */ -EBADSLT: Errno : 57; /* Invalid slot */ -EDEADLOCK: Errno : EDEADLK; -EBFONT: Errno : 59; /* Bad font file format */ -ENOSTR: Errno : 60; /* Device not a stream */ -ENODATA: Errno : 61; /* No data available */ -ETIME: Errno : 62; /* Timer expired */ -ENOSR: Errno : 63; /* Out of streams resources */ -ENONET: Errno : 64; /* Machine is not on the network */ -ENOPKG: Errno : 65; /* Package not installed */ -EREMOTE: Errno : 66; /* Object is remote */ -ENOLINK: Errno : 67; /* Link has been severed */ -EADV: Errno : 68; /* Advertise error */ -ESRMNT: Errno : 69; /* Srmount error */ -ECOMM: Errno : 70; /* Communication error on send */ -EPROTO: Errno : 71; /* Protocol error */ -EMULTIHOP: Errno : 72; /* Multihop attempted */ -EDOTDOT: Errno : 73; /* RFS specific error */ -EBADMSG: Errno : 74; /* Not a data message */ -EOVERFLOW: Errno : 75; /* Value too large for defined data type */ -ENOTUNIQ: Errno : 76; /* Name not unique on network */ -EBADFD: Errno : 77; /* File descriptor in bad state */ -EREMCHG: Errno : 78; /* Remote address changed */ -ELIBACC: Errno : 79; /* Can not access a needed shared library */ -ELIBBAD: Errno : 80; /* Accessing a corrupted shared library */ -ELIBSCN: Errno : 81; /* .lib section in a.out corrupted */ -ELIBMAX: Errno : 82; /* Attempting to link in too many shared libraries */ -ELIBEXEC: Errno : 83; /* Cannot exec a shared library directly */ -EILSEQ: Errno : 84; /* Illegal byte sequence */ -ERESTART: Errno : 85; /* Interrupted system call should be restarted */ -ESTRPIPE: Errno : 86; /* Streams pipe error */ -EUSERS: Errno : 87; /* Too many users */ -ENOTSOCK: Errno : 88; /* Socket operation on non-socket */ -EDESTADDRREQ: Errno : 89; /* Destination address required */ -EMSGSIZE: Errno : 90; /* Message too long */ -EPROTOTYPE: Errno : 91; /* Protocol wrong type for socket */ -ENOPROTOOPT: Errno : 92; /* Protocol not available */ -EPROTONOSUPPORT:Errno : 93; /* Protocol not supported */ -ESOCKTNOSUPPORT:Errno : 94; /* Socket type not supported */ -EOPNOTSUPP: Errno : 95; /* Operation not supported on transport endpoint */ -EPFNOSUPPORT: Errno : 96; /* Protocol family not supported */ -EAFNOSUPPORT: Errno : 97; /* Address family not supported by protocol */ -EADDRINUSE: Errno : 98; /* Address already in use */ -EADDRNOTAVAIL: Errno : 99; /* Cannot assign requested address */ -ENETDOWN: Errno : 100; /* Network is down */ -ENETUNREACH: Errno : 101; /* Network is unreachable */ -ENETRESET: Errno : 102; /* Network dropped connection because of reset */ -ECONNABORTED: Errno : 103; /* Software caused connection abort */ -ECONNRESET: Errno : 104; /* Connection reset by peer */ -ENOBUFS: Errno : 105; /* No buffer space available */ -EISCONN: Errno : 106; /* Transport endpoint is already connected */ -ENOTCONN: Errno : 107; /* Transport endpoint is not connected */ -ESHUTDOWN: Errno : 108; /* Cannot send after transport endpoint shutdown */ -ETOOMANYREFS: Errno : 109; /* Too many references: cannot splice */ -ETIMEDOUT: Errno : 110; /* Connection timed out */ -ECONNREFUSED: Errno : 111; /* Connection refused */ -EHOSTDOWN: Errno : 112; /* Host is down */ -EHOSTUNREACH: Errno : 113; /* No route to host */ -EALREADY: Errno : 114; /* Operation already in progress */ -EINPROGRESS: Errno : 115; /* Operation now in progress */ -ESTALE: Errno : 116; /* Stale file handle */ -EUCLEAN: Errno : 117; /* Structure needs cleaning */ -ENOTNAM: Errno : 118; /* Not a XENIX named type file */ -ENAVAIL: Errno : 119; /* No XENIX semaphores available */ -EISNAM: Errno : 120; /* Is a named type file */ -EREMOTEIO: Errno : 121; /* Remote I/O error */ -EDQUOT: Errno : 122; /* Quota exceeded */ +ENOTEMPTY: Errno : 39 /* Directory not empty */ +ELOOP: Errno : 40 /* Too many symbolic links encountered */ +EWOULDBLOCK: Errno : EAGAIN /* Operation would block */ +ENOMSG: Errno : 42 /* No message of desired type */ +EIDRM: Errno : 43 /* Identifier removed */ +ECHRNG: Errno : 44 /* Channel number out of range */ +EL2NSYNC: Errno : 45 /* Level 2 not synchronized */ +EL3HLT: Errno : 46 /* Level 3 halted */ +EL3RST: Errno : 47 /* Level 3 reset */ +ELNRNG: Errno : 48 /* Link number out of range */ +EUNATCH: Errno : 49 /* Protocol driver not attached */ +ENOCSI: Errno : 50 /* No CSI structure available */ +EL2HLT: Errno : 51 /* Level 2 halted */ +EBADE: Errno : 52 /* Invalid exchange */ +EBADR: Errno : 53 /* Invalid request descriptor */ +EXFULL: Errno : 54 /* Exchange full */ +ENOANO: Errno : 55 /* No anode */ +EBADRQC: Errno : 56 /* Invalid request code */ +EBADSLT: Errno : 57 /* Invalid slot */ +EDEADLOCK: Errno : EDEADLK +EBFONT: Errno : 59 /* Bad font file format */ +ENOSTR: Errno : 60 /* Device not a stream */ +ENODATA: Errno : 61 /* No data available */ +ETIME: Errno : 62 /* Timer expired */ +ENOSR: Errno : 63 /* Out of streams resources */ +ENONET: Errno : 64 /* Machine is not on the network */ +ENOPKG: Errno : 65 /* Package not installed */ +EREMOTE: Errno : 66 /* Object is remote */ +ENOLINK: Errno : 67 /* Link has been severed */ +EADV: Errno : 68 /* Advertise error */ +ESRMNT: Errno : 69 /* Srmount error */ +ECOMM: Errno : 70 /* Communication error on send */ +EPROTO: Errno : 71 /* Protocol error */ +EMULTIHOP: Errno : 72 /* Multihop attempted */ +EDOTDOT: Errno : 73 /* RFS specific error */ +EBADMSG: Errno : 74 /* Not a data message */ +EOVERFLOW: Errno : 75 /* Value too large for defined data type */ +ENOTUNIQ: Errno : 76 /* Name not unique on network */ +EBADFD: Errno : 77 /* File descriptor in bad state */ +EREMCHG: Errno : 78 /* Remote address changed */ +ELIBACC: Errno : 79 /* Can not access a needed shared library */ +ELIBBAD: Errno : 80 /* Accessing a corrupted shared library */ +ELIBSCN: Errno : 81 /* .lib section in a.out corrupted */ +ELIBMAX: Errno : 82 /* Attempting to link in too many shared libraries */ +ELIBEXEC: Errno : 83 /* Cannot exec a shared library directly */ +EILSEQ: Errno : 84 /* Illegal byte sequence */ +ERESTART: Errno : 85 /* Interrupted system call should be restarted */ +ESTRPIPE: Errno : 86 /* Streams pipe error */ +EUSERS: Errno : 87 /* Too many users */ +ENOTSOCK: Errno : 88 /* Socket operation on non-socket */ +EDESTADDRREQ: Errno : 89 /* Destination address required */ +EMSGSIZE: Errno : 90 /* Message too long */ +EPROTOTYPE: Errno : 91 /* Protocol wrong type for socket */ +ENOPROTOOPT: Errno : 92 /* Protocol not available */ +EPROTONOSUPPORT:Errno : 93 /* Protocol not supported */ +ESOCKTNOSUPPORT:Errno : 94 /* Socket type not supported */ +EOPNOTSUPP: Errno : 95 /* Operation not supported on transport endpoint */ +EPFNOSUPPORT: Errno : 96 /* Protocol family not supported */ +EAFNOSUPPORT: Errno : 97 /* Address family not supported by protocol */ +EADDRINUSE: Errno : 98 /* Address already in use */ +EADDRNOTAVAIL: Errno : 99 /* Cannot assign requested address */ +ENETDOWN: Errno : 100 /* Network is down */ +ENETUNREACH: Errno : 101 /* Network is unreachable */ +ENETRESET: Errno : 102 /* Network dropped connection because of reset */ +ECONNABORTED: Errno : 103 /* Software caused connection abort */ +ECONNRESET: Errno : 104 /* Connection reset by peer */ +ENOBUFS: Errno : 105 /* No buffer space available */ +EISCONN: Errno : 106 /* Transport endpoint is already connected */ +ENOTCONN: Errno : 107 /* Transport endpoint is not connected */ +ESHUTDOWN: Errno : 108 /* Cannot send after transport endpoint shutdown */ +ETOOMANYREFS: Errno : 109 /* Too many references: cannot splice */ +ETIMEDOUT: Errno : 110 /* Connection timed out */ +ECONNREFUSED: Errno : 111 /* Connection refused */ +EHOSTDOWN: Errno : 112 /* Host is down */ +EHOSTUNREACH: Errno : 113 /* No route to host */ +EALREADY: Errno : 114 /* Operation already in progress */ +EINPROGRESS: Errno : 115 /* Operation now in progress */ +ESTALE: Errno : 116 /* Stale file handle */ +EUCLEAN: Errno : 117 /* Structure needs cleaning */ +ENOTNAM: Errno : 118 /* Not a XENIX named type file */ +ENAVAIL: Errno : 119 /* No XENIX semaphores available */ +EISNAM: Errno : 120 /* Is a named type file */ +EREMOTEIO: Errno : 121 /* Remote I/O error */ +EDQUOT: Errno : 122 /* Quota exceeded */ -ENOMEDIUM: Errno : 123; /* No medium found */ -EMEDIUMTYPE: Errno : 124; /* Wrong medium type */ -ECANCELED: Errno : 125; /* Operation Canceled */ -ENOKEY: Errno : 126; /* Required key not available */ -EKEYEXPIRED: Errno : 127; /* Key has expired */ -EKEYREVOKED: Errno : 128; /* Key has been revoked */ -EKEYREJECTED: Errno : 129; /* Key was rejected by service */ +ENOMEDIUM: Errno : 123 /* No medium found */ +EMEDIUMTYPE: Errno : 124 /* Wrong medium type */ +ECANCELED: Errno : 125 /* Operation Canceled */ +ENOKEY: Errno : 126 /* Required key not available */ +EKEYEXPIRED: Errno : 127 /* Key has expired */ +EKEYREVOKED: Errno : 128 /* Key has been revoked */ +EKEYREJECTED: Errno : 129 /* Key was rejected by service */ /* for robust mutexes */ -EOWNERDEAD: Errno : 130; /* Owner died */ -ENOTRECOVERABLE: Errno : 131; /* State not recoverable */ +EOWNERDEAD: Errno : 130 /* Owner died */ +ENOTRECOVERABLE: Errno : 131 /* State not recoverable */ -ERFKILL: Errno : 132; /* Operation not possible due to RF-kill */ +ERFKILL: Errno : 132 /* Operation not possible due to RF-kill */ -EHWPOISON: Errno : 133; /* Memory page has hardware error */ +EHWPOISON: Errno : 133 /* Memory page has hardware error */ -O_RDONLY :: 0x00000; -O_WRONLY :: 0x00001; -O_RDWR :: 0x00002; -O_CREATE :: 0x00040; -O_EXCL :: 0x00080; -O_NOCTTY :: 0x00100; -O_TRUNC :: 0x00200; -O_NONBLOCK :: 0x00800; -O_APPEND :: 0x00400; -O_SYNC :: 0x01000; -O_ASYNC :: 0x02000; -O_CLOEXEC :: 0x80000; +O_RDONLY :: 0x00000 +O_WRONLY :: 0x00001 +O_RDWR :: 0x00002 +O_CREATE :: 0x00040 +O_EXCL :: 0x00080 +O_NOCTTY :: 0x00100 +O_TRUNC :: 0x00200 +O_NONBLOCK :: 0x00800 +O_APPEND :: 0x00400 +O_SYNC :: 0x01000 +O_ASYNC :: 0x02000 +O_CLOEXEC :: 0x80000 -SEEK_SET :: 0; -SEEK_CUR :: 1; -SEEK_END :: 2; -SEEK_DATA :: 3; -SEEK_HOLE :: 4; -SEEK_MAX :: SEEK_HOLE; +SEEK_SET :: 0 +SEEK_CUR :: 1 +SEEK_END :: 2 +SEEK_DATA :: 3 +SEEK_HOLE :: 4 +SEEK_MAX :: SEEK_HOLE // NOTE(zangent): These are OS specific! // Do not mix these up! -RTLD_LAZY :: 0x001; -RTLD_NOW :: 0x002; -RTLD_BINDING_MASK :: 0x3; -RTLD_GLOBAL :: 0x100; +RTLD_LAZY :: 0x001 +RTLD_NOW :: 0x002 +RTLD_BINDING_MASK :: 0x3 +RTLD_GLOBAL :: 0x100 // "Argv" arguments converted to Odin strings -args := _alloc_command_line_arguments(); +args := _alloc_command_line_arguments() Unix_File_Time :: struct { seconds: i64, @@ -205,7 +205,7 @@ OS_Stat :: struct { _reserve1, _reserve2, _reserve3: i64, -}; +} // NOTE(laleksic, 2021-01-21): Comment and rename these to match OS_Stat above Dirent :: struct { @@ -214,427 +214,427 @@ Dirent :: struct { reclen: u16, type: u8, name: [256]byte, -}; +} -Dir :: distinct rawptr; // DIR* +Dir :: distinct rawptr // DIR* // File type -S_IFMT :: 0o170000; // Type of file mask -S_IFIFO :: 0o010000; // Named pipe (fifo) -S_IFCHR :: 0o020000; // Character special -S_IFDIR :: 0o040000; // Directory -S_IFBLK :: 0o060000; // Block special -S_IFREG :: 0o100000; // Regular -S_IFLNK :: 0o120000; // Symbolic link -S_IFSOCK :: 0o140000; // Socket +S_IFMT :: 0o170000 // Type of file mask +S_IFIFO :: 0o010000 // Named pipe (fifo) +S_IFCHR :: 0o020000 // Character special +S_IFDIR :: 0o040000 // Directory +S_IFBLK :: 0o060000 // Block special +S_IFREG :: 0o100000 // Regular +S_IFLNK :: 0o120000 // Symbolic link +S_IFSOCK :: 0o140000 // Socket // File mode // Read, write, execute/search by owner -S_IRWXU :: 0o0700; // RWX mask for owner -S_IRUSR :: 0o0400; // R for owner -S_IWUSR :: 0o0200; // W for owner -S_IXUSR :: 0o0100; // X for owner +S_IRWXU :: 0o0700 // RWX mask for owner +S_IRUSR :: 0o0400 // R for owner +S_IWUSR :: 0o0200 // W for owner +S_IXUSR :: 0o0100 // X for owner // Read, write, execute/search by group -S_IRWXG :: 0o0070; // RWX mask for group -S_IRGRP :: 0o0040; // R for group -S_IWGRP :: 0o0020; // W for group -S_IXGRP :: 0o0010; // X for group +S_IRWXG :: 0o0070 // RWX mask for group +S_IRGRP :: 0o0040 // R for group +S_IWGRP :: 0o0020 // W for group +S_IXGRP :: 0o0010 // X for group // Read, write, execute/search by others -S_IRWXO :: 0o0007; // RWX mask for other -S_IROTH :: 0o0004; // R for other -S_IWOTH :: 0o0002; // W for other -S_IXOTH :: 0o0001; // X for other +S_IRWXO :: 0o0007 // RWX mask for other +S_IROTH :: 0o0004 // R for other +S_IWOTH :: 0o0002 // W for other +S_IXOTH :: 0o0001 // X for other -S_ISUID :: 0o4000; // Set user id on execution -S_ISGID :: 0o2000; // Set group id on execution -S_ISVTX :: 0o1000; // Directory restrcted delete +S_ISUID :: 0o4000 // Set user id on execution +S_ISGID :: 0o2000 // Set group id on execution +S_ISVTX :: 0o1000 // Directory restrcted delete -S_ISLNK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFLNK; } -S_ISREG :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFREG; } -S_ISDIR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFDIR; } -S_ISCHR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFCHR; } -S_ISBLK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFBLK; } -S_ISFIFO :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFIFO; } -S_ISSOCK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFSOCK; } +S_ISLNK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFLNK } +S_ISREG :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFREG } +S_ISDIR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFDIR } +S_ISCHR :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFCHR } +S_ISBLK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFBLK } +S_ISFIFO :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFIFO } +S_ISSOCK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFSOCK } -F_OK :: 0; // Test for file existance -X_OK :: 1; // Test for execute permission -W_OK :: 2; // Test for write permission -R_OK :: 4; // Test for read permission +F_OK :: 0 // Test for file existance +X_OK :: 1 // Test for execute permission +W_OK :: 2 // Test for write permission +R_OK :: 4 // Test for read permission -SYS_GETTID :: 186; +SYS_GETTID :: 186 foreign libc { - @(link_name="__errno_location") __errno_location :: proc() -> ^int ---; + @(link_name="__errno_location") __errno_location :: proc() -> ^int --- - @(link_name="open") _unix_open :: proc(path: cstring, flags: c.int, mode: c.int) -> Handle ---; - @(link_name="close") _unix_close :: proc(fd: Handle) -> c.int ---; - @(link_name="read") _unix_read :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---; - @(link_name="write") _unix_write :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---; - @(link_name="lseek64") _unix_seek :: proc(fd: Handle, offset: i64, whence: c.int) -> i64 ---; - @(link_name="gettid") _unix_gettid :: proc() -> u64 ---; - @(link_name="getpagesize") _unix_getpagesize :: proc() -> c.int ---; - @(link_name="stat64") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---; - @(link_name="lstat") _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---; - @(link_name="fstat") _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> c.int ---; - @(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir ---; - @(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int ---; - @(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) ---; - @(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int ---; - @(link_name="readlink") _unix_readlink :: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t ---; - @(link_name="access") _unix_access :: proc(path: cstring, mask: c.int) -> c.int ---; + @(link_name="open") _unix_open :: proc(path: cstring, flags: c.int, mode: c.int) -> Handle --- + @(link_name="close") _unix_close :: proc(fd: Handle) -> c.int --- + @(link_name="read") _unix_read :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t --- + @(link_name="write") _unix_write :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t --- + @(link_name="lseek64") _unix_seek :: proc(fd: Handle, offset: i64, whence: c.int) -> i64 --- + @(link_name="gettid") _unix_gettid :: proc() -> u64 --- + @(link_name="getpagesize") _unix_getpagesize :: proc() -> c.int --- + @(link_name="stat64") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int --- + @(link_name="lstat") _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> c.int --- + @(link_name="fstat") _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> c.int --- + @(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir --- + @(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int --- + @(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) --- + @(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int --- + @(link_name="readlink") _unix_readlink :: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t --- + @(link_name="access") _unix_access :: proc(path: cstring, mask: c.int) -> c.int --- - @(link_name="malloc") _unix_malloc :: proc(size: c.size_t) -> rawptr ---; - @(link_name="calloc") _unix_calloc :: proc(num, size: c.size_t) -> rawptr ---; - @(link_name="free") _unix_free :: proc(ptr: rawptr) ---; - @(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: c.size_t) -> rawptr ---; - @(link_name="getenv") _unix_getenv :: proc(cstring) -> cstring ---; - @(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring ---; - @(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int ---; - @(link_name="realpath") _unix_realpath :: proc(path: cstring, resolved_path: rawptr) -> rawptr ---; + @(link_name="malloc") _unix_malloc :: proc(size: c.size_t) -> rawptr --- + @(link_name="calloc") _unix_calloc :: proc(num, size: c.size_t) -> rawptr --- + @(link_name="free") _unix_free :: proc(ptr: rawptr) --- + @(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: c.size_t) -> rawptr --- + @(link_name="getenv") _unix_getenv :: proc(cstring) -> cstring --- + @(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring --- + @(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int --- + @(link_name="realpath") _unix_realpath :: proc(path: cstring, resolved_path: rawptr) -> rawptr --- - @(link_name="exit") _unix_exit :: proc(status: c.int) -> ! ---; + @(link_name="exit") _unix_exit :: proc(status: c.int) -> ! --- } foreign dl { - @(link_name="dlopen") _unix_dlopen :: proc(filename: cstring, flags: c.int) -> rawptr ---; - @(link_name="dlsym") _unix_dlsym :: proc(handle: rawptr, symbol: cstring) -> rawptr ---; - @(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> c.int ---; - @(link_name="dlerror") _unix_dlerror :: proc() -> cstring ---; + @(link_name="dlopen") _unix_dlopen :: proc(filename: cstring, flags: c.int) -> rawptr --- + @(link_name="dlsym") _unix_dlsym :: proc(handle: rawptr, symbol: cstring) -> rawptr --- + @(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> c.int --- + @(link_name="dlerror") _unix_dlerror :: proc() -> cstring --- } is_path_separator :: proc(r: rune) -> bool { - return r == '/'; + return r == '/' } get_last_error :: proc() -> int { - return __errno_location()^; + return __errno_location()^ } open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) { - cstr := strings.clone_to_cstring(path); - handle := _unix_open(cstr, c.int(flags), c.int(mode)); - delete(cstr); + cstr := strings.clone_to_cstring(path) + handle := _unix_open(cstr, c.int(flags), c.int(mode)) + delete(cstr) if handle == -1 { - return INVALID_HANDLE, Errno(get_last_error()); + return INVALID_HANDLE, Errno(get_last_error()) } - return handle, ERROR_NONE; + return handle, ERROR_NONE } close :: proc(fd: Handle) -> Errno { - result := _unix_close(fd); + result := _unix_close(fd) if result == -1 { - return Errno(get_last_error()); + return Errno(get_last_error()) } - return ERROR_NONE; + return ERROR_NONE } read :: proc(fd: Handle, data: []byte) -> (int, Errno) { - bytes_read := _unix_read(fd, &data[0], c.size_t(len(data))); + bytes_read := _unix_read(fd, &data[0], c.size_t(len(data))) if bytes_read == -1 { - return -1, Errno(get_last_error()); + return -1, Errno(get_last_error()) } - return int(bytes_read), ERROR_NONE; + return int(bytes_read), ERROR_NONE } write :: proc(fd: Handle, data: []byte) -> (int, Errno) { if len(data) == 0 { - return 0, ERROR_NONE; + return 0, ERROR_NONE } - bytes_written := _unix_write(fd, &data[0], c.size_t(len(data))); + bytes_written := _unix_write(fd, &data[0], c.size_t(len(data))) if bytes_written == -1 { - return -1, Errno(get_last_error()); + return -1, Errno(get_last_error()) } - return int(bytes_written), ERROR_NONE; + return int(bytes_written), ERROR_NONE } seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { - res := _unix_seek(fd, offset, c.int(whence)); + res := _unix_seek(fd, offset, c.int(whence)) if res == -1 { - return -1, Errno(get_last_error()); + return -1, Errno(get_last_error()) } - return res, ERROR_NONE; + return res, ERROR_NONE } file_size :: proc(fd: Handle) -> (i64, Errno) { - s, err := _fstat(fd); + s, err := _fstat(fd) if err != ERROR_NONE { - return 0, err; + return 0, err } - return max(s.size, 0), ERROR_NONE; + return max(s.size, 0), ERROR_NONE } // NOTE(bill): Uses startup to initialize it -stdin: Handle = 0; -stdout: Handle = 1; -stderr: Handle = 2; +stdin: Handle = 0 +stdout: Handle = 1 +stderr: Handle = 2 /* TODO(zangent): Implement these! last_write_time :: proc(fd: Handle) -> File_Time {} last_write_time_by_name :: proc(name: string) -> File_Time {} */ last_write_time :: proc(fd: Handle) -> (File_Time, Errno) { - s, err := _fstat(fd); + s, err := _fstat(fd) if err != ERROR_NONE { - return 0, err; + return 0, err } - modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds; - return File_Time(modified), ERROR_NONE; + modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds + return File_Time(modified), ERROR_NONE } last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) { - s, err := _stat(name); + s, err := _stat(name) if err != ERROR_NONE { - return 0, err; + return 0, err } - modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds; - return File_Time(modified), ERROR_NONE; + modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds + return File_Time(modified), ERROR_NONE } @private _stat :: proc(path: string) -> (OS_Stat, Errno) { - cstr := strings.clone_to_cstring(path); - defer delete(cstr); + cstr := strings.clone_to_cstring(path) + defer delete(cstr) - s: OS_Stat; - result := _unix_stat(cstr, &s); + s: OS_Stat + result := _unix_stat(cstr, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _lstat :: proc(path: string) -> (OS_Stat, Errno) { - cstr := strings.clone_to_cstring(path); - defer delete(cstr); + cstr := strings.clone_to_cstring(path) + defer delete(cstr) - s: OS_Stat; - result := _unix_lstat(cstr, &s); + s: OS_Stat + result := _unix_lstat(cstr, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _fstat :: proc(fd: Handle) -> (OS_Stat, Errno) { - s: OS_Stat; - result := _unix_fstat(fd, &s); + s: OS_Stat + result := _unix_fstat(fd, &s) if result == -1 { - return s, Errno(get_last_error()); + return s, Errno(get_last_error()) } - return s, ERROR_NONE; + return s, ERROR_NONE } @private _fdopendir :: proc(fd: Handle) -> (Dir, Errno) { - dirp := _unix_fdopendir(fd); + dirp := _unix_fdopendir(fd) if dirp == cast(Dir)nil { - return nil, Errno(get_last_error()); + return nil, Errno(get_last_error()) } - return dirp, ERROR_NONE; + return dirp, ERROR_NONE } @private _closedir :: proc(dirp: Dir) -> Errno { - rc := _unix_closedir(dirp); + rc := _unix_closedir(dirp) if rc != 0 { - return Errno(get_last_error()); + return Errno(get_last_error()) } - return ERROR_NONE; + return ERROR_NONE } @private _rewinddir :: proc(dirp: Dir) { - _unix_rewinddir(dirp); + _unix_rewinddir(dirp) } @private _readdir :: proc(dirp: Dir) -> (entry: Dirent, err: Errno, end_of_stream: bool) { - result: ^Dirent; - rc := _unix_readdir_r(dirp, &entry, &result); + result: ^Dirent + rc := _unix_readdir_r(dirp, &entry, &result) if rc != 0 { - err = Errno(get_last_error()); - return; + err = Errno(get_last_error()) + return } - err = ERROR_NONE; + err = ERROR_NONE if result == nil { - end_of_stream = true; - return; + end_of_stream = true + return } - end_of_stream = false; + end_of_stream = false - return; + return } @private _readlink :: proc(path: string) -> (string, Errno) { - path_cstr := strings.clone_to_cstring(path); - defer delete(path_cstr); + path_cstr := strings.clone_to_cstring(path) + defer delete(path_cstr) - bufsz : uint = 256; - buf := make([]byte, bufsz); + bufsz : uint = 256 + buf := make([]byte, bufsz) for { - rc := _unix_readlink(path_cstr, &(buf[0]), bufsz); + rc := _unix_readlink(path_cstr, &(buf[0]), bufsz) if rc == -1 { - delete(buf); - return "", Errno(get_last_error()); + delete(buf) + return "", Errno(get_last_error()) } else if rc == int(bufsz) { // NOTE(laleksic, 2021-01-21): Any cleaner way to resize the slice? - bufsz *= 2; - delete(buf); - buf = make([]byte, bufsz); + bufsz *= 2 + delete(buf) + buf = make([]byte, bufsz) } else { - return strings.string_from_ptr(&buf[0], rc), ERROR_NONE; + return strings.string_from_ptr(&buf[0], rc), ERROR_NONE } } } absolute_path_from_handle :: proc(fd: Handle) -> (string, Errno) { - buf : [256]byte; - fd_str := strconv.itoa( buf[:], cast(int)fd ); + buf : [256]byte + fd_str := strconv.itoa( buf[:], cast(int)fd ) - procfs_path := strings.concatenate( []string{ "/proc/self/fd/", fd_str } ); - defer delete(procfs_path); + procfs_path := strings.concatenate( []string{ "/proc/self/fd/", fd_str } ) + defer delete(procfs_path) - return _readlink(procfs_path); + return _readlink(procfs_path) } absolute_path_from_relative :: proc(rel: string) -> (path: string, err: Errno) { - rel := rel; + rel := rel if rel == "" { - rel = "."; + rel = "." } - rel_cstr := strings.clone_to_cstring(rel); - defer delete(rel_cstr); + rel_cstr := strings.clone_to_cstring(rel) + defer delete(rel_cstr) - path_ptr := _unix_realpath(rel_cstr, nil); + path_ptr := _unix_realpath(rel_cstr, nil) if path_ptr == nil { - return "", Errno(get_last_error()); + return "", Errno(get_last_error()) } - defer _unix_free(path_ptr); + defer _unix_free(path_ptr) - path_cstr := transmute(cstring)path_ptr; - path = strings.clone( string(path_cstr) ); + path_cstr := transmute(cstring)path_ptr + path = strings.clone( string(path_cstr) ) - return path, ERROR_NONE; + return path, ERROR_NONE } access :: proc(path: string, mask: int) -> (bool, Errno) { - cstr := strings.clone_to_cstring(path); - defer delete(cstr); - result := _unix_access(cstr, c.int(mask)); + cstr := strings.clone_to_cstring(path) + defer delete(cstr) + result := _unix_access(cstr, c.int(mask)) if result == -1 { - return false, Errno(get_last_error()); + return false, Errno(get_last_error()) } - return true, ERROR_NONE; + return true, ERROR_NONE } heap_alloc :: proc(size: int) -> rawptr { - assert(size >= 0); - return _unix_calloc(1, c.size_t(size)); + assert(size >= 0) + return _unix_calloc(1, c.size_t(size)) } heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - return _unix_realloc(ptr, c.size_t(new_size)); + return _unix_realloc(ptr, c.size_t(new_size)) } heap_free :: proc(ptr: rawptr) { - _unix_free(ptr); + _unix_free(ptr) } getenv :: proc(name: string) -> (string, bool) { - path_str := strings.clone_to_cstring(name); - defer delete(path_str); - cstr := _unix_getenv(path_str); + path_str := strings.clone_to_cstring(name) + defer delete(path_str) + cstr := _unix_getenv(path_str) if cstr == nil { - return "", false; + return "", false } - return string(cstr), true; + return string(cstr), true } get_current_directory :: proc() -> string { // NOTE(tetra): I would use PATH_MAX here, but I was not able to find // an authoritative value for it across all systems. // The largest value I could find was 4096, so might as well use the page size. - page_size := get_page_size(); - buf := make([dynamic]u8, page_size); + page_size := get_page_size() + buf := make([dynamic]u8, page_size) for { - #no_bounds_check cwd := _unix_getcwd(cstring(&buf[0]), c.size_t(len(buf))); + #no_bounds_check cwd := _unix_getcwd(cstring(&buf[0]), c.size_t(len(buf))) if cwd != nil { - return string(cwd); + return string(cwd) } if Errno(get_last_error()) != ERANGE { - return ""; + return "" } - resize(&buf, len(buf)+page_size); + resize(&buf, len(buf)+page_size) } - unreachable(); + unreachable() } set_current_directory :: proc(path: string) -> (err: Errno) { - cstr := strings.clone_to_cstring(path, context.temp_allocator); - res := _unix_chdir(cstr); + cstr := strings.clone_to_cstring(path, context.temp_allocator) + res := _unix_chdir(cstr) if res == -1 { - return Errno(get_last_error()); + return Errno(get_last_error()) } - return ERROR_NONE; + return ERROR_NONE } exit :: proc "contextless" (code: int) -> ! { - _unix_exit(c.int(code)); + _unix_exit(c.int(code)) } current_thread_id :: proc "contextless" () -> int { - return cast(int)intrinsics.syscall(SYS_GETTID); + return cast(int)intrinsics.syscall(SYS_GETTID) } dlopen :: proc(filename: string, flags: int) -> rawptr { - cstr := strings.clone_to_cstring(filename); - defer delete(cstr); - handle := _unix_dlopen(cstr, c.int(flags)); - return handle; + cstr := strings.clone_to_cstring(filename) + defer delete(cstr) + handle := _unix_dlopen(cstr, c.int(flags)) + return handle } dlsym :: proc(handle: rawptr, symbol: string) -> rawptr { - assert(handle != nil); - cstr := strings.clone_to_cstring(symbol); - defer delete(cstr); - proc_handle := _unix_dlsym(handle, cstr); - return proc_handle; + assert(handle != nil) + cstr := strings.clone_to_cstring(symbol) + defer delete(cstr) + proc_handle := _unix_dlsym(handle, cstr) + return proc_handle } dlclose :: proc(handle: rawptr) -> bool { - assert(handle != nil); - return _unix_dlclose(handle) == 0; + assert(handle != nil) + return _unix_dlclose(handle) == 0 } dlerror :: proc() -> string { - return string(_unix_dlerror()); + return string(_unix_dlerror()) } get_page_size :: proc() -> int { // NOTE(tetra): The page size never changes, so why do anything complicated // if we don't have to. - @static page_size := -1; + @static page_size := -1 if page_size != -1 { - return page_size; + return page_size } - page_size = int(_unix_getpagesize()); - return page_size; + page_size = int(_unix_getpagesize()) + return page_size } _alloc_command_line_arguments :: proc() -> []string { - res := make([]string, len(runtime.args__)); + res := make([]string, len(runtime.args__)) for arg, i in runtime.args__ { - res[i] = string(arg); + res[i] = string(arg) } - return res; + return res } diff --git a/core/os/stat_unix.odin b/core/os/stat_unix.odin index a3f25b5aa..08c6f53c4 100644 --- a/core/os/stat_unix.odin +++ b/core/os/stat_unix.odin @@ -54,102 +54,102 @@ File_Info :: struct { _make_time_from_unix_file_time :: proc(uft: Unix_File_Time) -> time.Time { return time.Time{ _nsec = uft.nanoseconds + uft.seconds * 1_000_000_000, - }; + } } @private _fill_file_info_from_stat :: proc(fi: ^File_Info, s: OS_Stat) { - fi.size = s.size; - fi.mode = cast(File_Mode)s.mode; - fi.is_dir = S_ISDIR(u32(s.mode)); + fi.size = s.size + fi.mode = cast(File_Mode)s.mode + fi.is_dir = S_ISDIR(u32(s.mode)) // NOTE(laleksic, 2021-01-21): Not really creation time, but closest we can get (maybe better to leave it 0?) - fi.creation_time = _make_time_from_unix_file_time(s.status_change); + fi.creation_time = _make_time_from_unix_file_time(s.status_change) - fi.modification_time = _make_time_from_unix_file_time(s.modified); - fi.access_time = _make_time_from_unix_file_time(s.last_access); + fi.modification_time = _make_time_from_unix_file_time(s.modified) + fi.access_time = _make_time_from_unix_file_time(s.last_access) } @private path_base :: proc(path: string) -> string { is_separator :: proc(c: byte) -> bool { - return c == '/'; + return c == '/' } if path == "" { - return "."; + return "." } - path := path; + path := path for len(path) > 0 && is_separator(path[len(path)-1]) { - path = path[:len(path)-1]; + path = path[:len(path)-1] } - i := len(path)-1; + i := len(path)-1 for i >= 0 && !is_separator(path[i]) { - i -= 1; + i -= 1 } if i >= 0 { - path = path[i+1:]; + path = path[i+1:] } if path == "" { - return "/"; + return "/" } - return path; + return path } lstat :: proc(name: string, allocator := context.allocator) -> (fi: File_Info, err: Errno) { - context.allocator = allocator; + context.allocator = allocator - s: OS_Stat; - s, err = _lstat(name); + s: OS_Stat + s, err = _lstat(name) if err != ERROR_NONE { - return fi, err; + return fi, err } - _fill_file_info_from_stat(&fi, s); - fi.fullpath, err = absolute_path_from_relative(name); + _fill_file_info_from_stat(&fi, s) + fi.fullpath, err = absolute_path_from_relative(name) if err != ERROR_NONE { - return; + return } - fi.name = path_base(fi.fullpath); - return fi, ERROR_NONE; + fi.name = path_base(fi.fullpath) + return fi, ERROR_NONE } stat :: proc(name: string, allocator := context.allocator) -> (fi: File_Info, err: Errno) { - context.allocator = allocator; + context.allocator = allocator - s: OS_Stat; - s, err = _stat(name); + s: OS_Stat + s, err = _stat(name) if err != ERROR_NONE { - return fi, err; + return fi, err } - _fill_file_info_from_stat(&fi, s); - fi.fullpath, err = absolute_path_from_relative(name); + _fill_file_info_from_stat(&fi, s) + fi.fullpath, err = absolute_path_from_relative(name) if err != ERROR_NONE { - return; + return } - fi.name = path_base(fi.fullpath); - return fi, ERROR_NONE; + fi.name = path_base(fi.fullpath) + return fi, ERROR_NONE } fstat :: proc(fd: Handle, allocator := context.allocator) -> (fi: File_Info, err: Errno) { - context.allocator = allocator; + context.allocator = allocator - s: OS_Stat; - s, err = _fstat(fd); + s: OS_Stat + s, err = _fstat(fd) if err != ERROR_NONE { - return fi, err; + return fi, err } - _fill_file_info_from_stat(&fi, s); - fi.fullpath, err = absolute_path_from_handle(fd); + _fill_file_info_from_stat(&fi, s) + fi.fullpath, err = absolute_path_from_handle(fd) if err != ERROR_NONE { - return; + return } - fi.name = path_base(fi.fullpath); - return fi, ERROR_NONE; + fi.name = path_base(fi.fullpath) + return fi, ERROR_NONE } diff --git a/core/path/filepath/path_unix.odin b/core/path/filepath/path_unix.odin index 165d856de..1db528a2f 100644 --- a/core/path/filepath/path_unix.odin +++ b/core/path/filepath/path_unix.odin @@ -9,43 +9,43 @@ when ODIN_OS == "darwin" { import "core:strings" -SEPARATOR :: '/'; -SEPARATOR_STRING :: `/`; -LIST_SEPARATOR :: ':'; +SEPARATOR :: '/' +SEPARATOR_STRING :: `/` +LIST_SEPARATOR :: ':' is_reserved_name :: proc(path: string) -> bool { - return false; + return false } is_abs :: proc(path: string) -> bool { - return strings.has_prefix(path, "/"); + return strings.has_prefix(path, "/") } abs :: proc(path: string, allocator := context.allocator) -> (string, bool) { - rel := path; + rel := path if rel == "" { - rel = "."; + rel = "." } - rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator); - path_ptr := realpath(rel_cstr, nil); + rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator) + path_ptr := realpath(rel_cstr, nil) if path_ptr == nil { - return "", __error()^ == 0; + return "", __error()^ == 0 } - defer _unix_free(path_ptr); + defer _unix_free(path_ptr) - path_cstr := cstring(path_ptr); - path_str := strings.clone(string(path_cstr), allocator); - return path_str, true; + path_cstr := cstring(path_ptr) + path_str := strings.clone(string(path_cstr), allocator) + return path_str, true } join :: proc(elems: ..string, allocator := context.allocator) -> string { for e, i in elems { if e != "" { - p := strings.join(elems[i:], SEPARATOR_STRING, context.temp_allocator); - return clean(p, allocator); + p := strings.join(elems[i:], SEPARATOR_STRING, context.temp_allocator) + return clean(p, allocator) } } - return ""; + return "" } @(private) diff --git a/core/runtime/default_allocators_general.odin b/core/runtime/default_allocators_general.odin index 2414d71d2..f25f8f178 100644 --- a/core/runtime/default_allocators_general.odin +++ b/core/runtime/default_allocators_general.odin @@ -8,22 +8,22 @@ when ODIN_DEFAULT_TO_NIL_ALLOCATOR { default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { - return nil, .None; + return nil, .None } default_allocator :: proc() -> Allocator { return Allocator{ procedure = default_allocator_proc, data = nil, - }; + } } } else { // TODO(bill): reimplement these procedures in the os_specific stuff import "core:os" - default_allocator_proc :: os.heap_allocator_proc; + default_allocator_proc :: os.heap_allocator_proc default_allocator :: proc() -> Allocator { - return os.heap_allocator(); + return os.heap_allocator() } } diff --git a/core/runtime/internal_linux.odin b/core/runtime/internal_linux.odin index a712bb367..359293de3 100644 --- a/core/runtime/internal_linux.odin +++ b/core/runtime/internal_linux.odin @@ -4,86 +4,86 @@ import "core:intrinsics" @(link_name="__umodti3") umodti3 :: proc "c" (a, b: u128) -> u128 { - r: u128 = ---; - _ = udivmod128(a, b, &r); - return r; + r: u128 = --- + _ = udivmod128(a, b, &r) + return r } @(link_name="__udivmodti4") udivmodti4 :: proc "c" (a, b: u128, rem: ^u128) -> u128 { - return udivmod128(a, b, rem); + return udivmod128(a, b, rem) } @(link_name="__udivti3") udivti3 :: proc "c" (a, b: u128) -> u128 { - return udivmodti4(a, b, nil); + return udivmodti4(a, b, nil) } @(link_name="__modti3") modti3 :: proc "c" (a, b: i128) -> i128 { - s_a := a >> (128 - 1); - s_b := b >> (128 - 1); - an := (a ~ s_a) - s_a; - bn := (b ~ s_b) - s_b; + s_a := a >> (128 - 1) + s_b := b >> (128 - 1) + an := (a ~ s_a) - s_a + bn := (b ~ s_b) - s_b - r: u128 = ---; - _ = udivmod128(transmute(u128)an, transmute(u128)bn, &r); - return (transmute(i128)r ~ s_a) - s_a; + r: u128 = --- + _ = udivmod128(transmute(u128)an, transmute(u128)bn, &r) + return (transmute(i128)r ~ s_a) - s_a } @(link_name="__divmodti4") divmodti4 :: proc "c" (a, b: i128, rem: ^i128) -> i128 { - u := udivmod128(transmute(u128)a, transmute(u128)b, cast(^u128)rem); - return transmute(i128)u; + u := udivmod128(transmute(u128)a, transmute(u128)b, cast(^u128)rem) + return transmute(i128)u } @(link_name="__divti3") divti3 :: proc "c" (a, b: i128) -> i128 { - u := udivmodti4(transmute(u128)a, transmute(u128)b, nil); - return transmute(i128)u; + u := udivmodti4(transmute(u128)a, transmute(u128)b, nil) + return transmute(i128)u } @(link_name="__fixdfti") fixdfti :: proc(a: u64) -> i128 { - significandBits :: 52; - typeWidth :: (size_of(u64)*8); - exponentBits :: (typeWidth - significandBits - 1); - maxExponent :: ((1 << exponentBits) - 1); - exponentBias :: (maxExponent >> 1); + significandBits :: 52 + typeWidth :: (size_of(u64)*8) + exponentBits :: (typeWidth - significandBits - 1) + maxExponent :: ((1 << exponentBits) - 1) + exponentBias :: (maxExponent >> 1) - implicitBit :: (u64(1) << significandBits); - significandMask :: (implicitBit - 1); - signBit :: (u64(1) << (significandBits + exponentBits)); - absMask :: (signBit - 1); - exponentMask :: (absMask ~ significandMask); + implicitBit :: (u64(1) << significandBits) + significandMask :: (implicitBit - 1) + signBit :: (u64(1) << (significandBits + exponentBits)) + absMask :: (signBit - 1) + exponentMask :: (absMask ~ significandMask) // Break a into sign, exponent, significand - aRep := a; - aAbs := aRep & absMask; - sign := i128(-1 if aRep & signBit != 0 else 1); - exponent := u64((aAbs >> significandBits) - exponentBias); - significand := u64((aAbs & significandMask) | implicitBit); + aRep := a + aAbs := aRep & absMask + sign := i128(-1 if aRep & signBit != 0 else 1) + exponent := u64((aAbs >> significandBits) - exponentBias) + significand := u64((aAbs & significandMask) | implicitBit) // If exponent is negative, the result is zero. if exponent < 0 { - return 0; + return 0 } // If the value is too large for the integer type, saturate. if exponent >= size_of(i128) * 8 { - return max(i128) if sign == 1 else min(i128); + return max(i128) if sign == 1 else min(i128) } // If 0 <= exponent < significandBits, right shift to get the result. // Otherwise, shift left. if exponent < significandBits { - return sign * i128(significand >> (significandBits - exponent)); + return sign * i128(significand >> (significandBits - exponent)) } else { - return sign * (i128(significand) << (exponent - significandBits)); + return sign * (i128(significand) << (exponent - significandBits)) } } diff --git a/core/runtime/os_specific_any.odin b/core/runtime/os_specific_any.odin index 7d6f05d87..397340798 100644 --- a/core/runtime/os_specific_any.odin +++ b/core/runtime/os_specific_any.odin @@ -7,7 +7,7 @@ import "core:os" // TODO(bill): reimplement `os.write` so that it does not rely on package os // NOTE: Use os_specific_linux.odin, os_specific_darwin.odin, etc _os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { - context = default_context(); - n, err := os.write(os.stderr, data); - return int(n), _OS_Errno(err); + context = default_context() + n, err := os.write(os.stderr, data) + return int(n), _OS_Errno(err) } diff --git a/core/runtime/procs_unix.odin b/core/runtime/procs_unix.odin index 1f7b074b9..3a7fa0798 100644 --- a/core/runtime/procs_unix.odin +++ b/core/runtime/procs_unix.odin @@ -4,15 +4,15 @@ package runtime @(link_name="memset") memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr { if ptr == nil || len == 0 { - return ptr; + return ptr } - b := byte(val); + b := byte(val) - p_start := uintptr(ptr); - p_end := p_start + uintptr(max(len, 0)); + p_start := uintptr(ptr) + p_end := p_start + uintptr(max(len, 0)) for p := p_start; p < p_end; p += 1 { - (^byte)(p)^ = b; + (^byte)(p)^ = b } - return ptr; + return ptr } diff --git a/core/sync/sync2/primitives_darwin.odin b/core/sync/sync2/primitives_darwin.odin index af342abf3..309567f75 100644 --- a/core/sync/sync2/primitives_darwin.odin +++ b/core/sync/sync2/primitives_darwin.odin @@ -9,13 +9,13 @@ import "core:intrinsics" foreign import pthread "System.framework" _current_thread_id :: proc "contextless" () -> int { - tid: u64; + tid: u64 // NOTE(Oskar): available from OSX 10.6 and iOS 3.2. // For older versions there is `syscall(SYS_thread_selfid)`, but not really // the same thing apparently. - foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int ---; } - pthread_threadid_np(nil, &tid); - return int(tid); + foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int --- } + pthread_threadid_np(nil, &tid) + return int(tid) } foreign { @@ -26,38 +26,38 @@ foreign { } _atomic_try_wait_slow :: proc(ptr: ^u32, val: u32) { - history: uint = 10; + history: uint = 10 for { // Exponential wait - _darwin_usleep(history >> 2); - history += history >> 2; + _darwin_usleep(history >> 2) + history += history >> 2 if history > (1 << 10) { - history = 1 << 10; + history = 1 << 10 } if atomic_load(ptr) != val { - break; + break } } } _atomic_wait :: proc(ptr: ^u32, val: u32) { if intrinsics.expect(atomic_load(ptr) != val, true) { - return; + return } for i in 0..<16 { if atomic_load(ptr) != val { - return; + return } if i < 12 { - intrinsics.cpu_relax(); + intrinsics.cpu_relax() } else { - _darwin_sched_yield(); + _darwin_sched_yield() } } for val == atomic_load(ptr) { - _atomic_try_wait_slow(ptr, val); + _atomic_try_wait_slow(ptr, val) } } @@ -73,7 +73,7 @@ _mutex_unlock :: proc(m: ^Mutex) { } _mutex_try_lock :: proc(m: ^Mutex) -> bool { - return false; + return false } _RW_Mutex :: struct { @@ -86,7 +86,7 @@ _rw_mutex_unlock :: proc(rw: ^RW_Mutex) { } _rw_mutex_try_lock :: proc(rw: ^RW_Mutex) -> bool { - return false; + return false } _rw_mutex_shared_lock :: proc(rw: ^RW_Mutex) { @@ -96,7 +96,7 @@ _rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) { } _rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool { - return false; + return false } @@ -110,7 +110,7 @@ _recursive_mutex_unlock :: proc(m: ^Recursive_Mutex) { } _recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool { - return false; + return false } @@ -123,7 +123,7 @@ _cond_wait :: proc(c: ^Cond, m: ^Mutex) { } _cond_wait_with_timeout :: proc(c: ^Cond, m: ^Mutex, timeout: time.Duration) -> bool { - return false; + return false } _cond_signal :: proc(c: ^Cond) { diff --git a/core/sync/sync2/primitives_linux.odin b/core/sync/sync2/primitives_linux.odin index 0a5da0880..2fafaed7a 100644 --- a/core/sync/sync2/primitives_linux.odin +++ b/core/sync/sync2/primitives_linux.odin @@ -10,6 +10,6 @@ _current_thread_id :: proc "contextless" () -> int { syscall :: proc(number: i32, #c_vararg args: ..any) -> i32 --- } - SYS_GETTID :: 186; - return int(syscall(SYS_GETTID)); + SYS_GETTID :: 186 + return int(syscall(SYS_GETTID)) } diff --git a/core/sync/sync2/primitives_pthreads.odin b/core/sync/sync2/primitives_pthreads.odin index 98270b739..97c453810 100644 --- a/core/sync/sync2/primitives_pthreads.odin +++ b/core/sync/sync2/primitives_pthreads.odin @@ -18,30 +18,30 @@ _Mutex :: struct { } _mutex_lock :: proc(m: ^Mutex) { - err := unix.pthread_mutex_lock(&m.impl.pthread_mutex); - assert(err == 0); + err := unix.pthread_mutex_lock(&m.impl.pthread_mutex) + assert(err == 0) } _mutex_unlock :: proc(m: ^Mutex) { - err := unix.pthread_mutex_unlock(&m.impl.pthread_mutex); - assert(err == 0); + err := unix.pthread_mutex_unlock(&m.impl.pthread_mutex) + assert(err == 0) } _mutex_try_lock :: proc(m: ^Mutex) -> bool { - err := unix.pthread_mutex_trylock(&m.impl.pthread_mutex); - return err == 0; + err := unix.pthread_mutex_trylock(&m.impl.pthread_mutex) + return err == 0 } -RW_Mutex_State :: distinct uint; -RW_Mutex_State_Half_Width :: size_of(RW_Mutex_State)*8/2; -RW_Mutex_State_Is_Writing :: RW_Mutex_State(1); -RW_Mutex_State_Writer :: RW_Mutex_State(1)<<1; -RW_Mutex_State_Reader :: RW_Mutex_State(1)< bool { if mutex_try_lock(&rw.impl.mutex) { - state := atomic_load(&rw.impl.state); + state := atomic_load(&rw.impl.state) if state & RW_Mutex_State_Reader_Mask == 0 { - _ = atomic_or(&rw.impl.state, RW_Mutex_State_Is_Writing); - return true; + _ = atomic_or(&rw.impl.state, RW_Mutex_State_Is_Writing) + return true } - mutex_unlock(&rw.impl.mutex); + mutex_unlock(&rw.impl.mutex) } - return false; + return false } _rw_mutex_shared_lock :: proc(rw: ^RW_Mutex) { - state := atomic_load(&rw.impl.state); + state := atomic_load(&rw.impl.state) for state & (RW_Mutex_State_Is_Writing|RW_Mutex_State_Writer_Mask) == 0 { - ok: bool; - state, ok = atomic_compare_exchange_weak(&rw.impl.state, state, state + RW_Mutex_State_Reader); + ok: bool + state, ok = atomic_compare_exchange_weak(&rw.impl.state, state, state + RW_Mutex_State_Reader) if ok { - return; + return } } - mutex_lock(&rw.impl.mutex); - _ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader); - mutex_unlock(&rw.impl.mutex); + mutex_lock(&rw.impl.mutex) + _ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader) + mutex_unlock(&rw.impl.mutex) } _rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) { - state := atomic_sub(&rw.impl.state, RW_Mutex_State_Reader); + state := atomic_sub(&rw.impl.state, RW_Mutex_State_Reader) if (state & RW_Mutex_State_Reader_Mask == RW_Mutex_State_Reader) && (state & RW_Mutex_State_Is_Writing != 0) { - sema_post(&rw.impl.sema); + sema_post(&rw.impl.sema) } } _rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool { - state := atomic_load(&rw.impl.state); + state := atomic_load(&rw.impl.state) if state & (RW_Mutex_State_Is_Writing|RW_Mutex_State_Writer_Mask) == 0 { - _, ok := atomic_compare_exchange_strong(&rw.impl.state, state, state + RW_Mutex_State_Reader); + _, ok := atomic_compare_exchange_strong(&rw.impl.state, state, state + RW_Mutex_State_Reader) if ok { - return true; + return true } } if mutex_try_lock(&rw.impl.mutex) { - _ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader); - mutex_unlock(&rw.impl.mutex); - return true; + _ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader) + mutex_unlock(&rw.impl.mutex) + return true } - return false; + return false } @@ -129,42 +129,42 @@ _Recursive_Mutex :: struct { } _recursive_mutex_lock :: proc(m: ^Recursive_Mutex) { - tid := _current_thread_id(); + tid := _current_thread_id() if tid != m.impl.owner { - mutex_lock(&m.impl.mutex); + mutex_lock(&m.impl.mutex) } // inside the lock - m.impl.owner = tid; - m.impl.recursion += 1; + m.impl.owner = tid + m.impl.recursion += 1 } _recursive_mutex_unlock :: proc(m: ^Recursive_Mutex) { - tid := _current_thread_id(); - assert(tid == m.impl.owner); - m.impl.recursion -= 1; - recursion := m.impl.recursion; + tid := _current_thread_id() + assert(tid == m.impl.owner) + m.impl.recursion -= 1 + recursion := m.impl.recursion if recursion == 0 { - m.impl.owner = 0; + m.impl.owner = 0 } if recursion == 0 { - mutex_unlock(&m.impl.mutex); + mutex_unlock(&m.impl.mutex) } // outside the lock } _recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool { - tid := _current_thread_id(); + tid := _current_thread_id() if m.impl.owner == tid { - return mutex_try_lock(&m.impl.mutex); + return mutex_try_lock(&m.impl.mutex) } if !mutex_try_lock(&m.impl.mutex) { - return false; + return false } // inside the lock - m.impl.owner = tid; - m.impl.recursion += 1; - return true; + m.impl.owner = tid + m.impl.recursion += 1 + return true } @@ -173,29 +173,29 @@ _Cond :: struct { } _cond_wait :: proc(c: ^Cond, m: ^Mutex) { - err := unix.pthread_cond_wait(&c.impl.pthread_cond, &m.impl.pthread_mutex); - assert(err == 0); + err := unix.pthread_cond_wait(&c.impl.pthread_cond, &m.impl.pthread_mutex) + assert(err == 0) } _cond_wait_with_timeout :: proc(c: ^Cond, m: ^Mutex, timeout: time.Duration) -> bool { - ns := time.duration_nanoseconds(timeout); + ns := time.duration_nanoseconds(timeout) timeout_timespec := &time.TimeSpec{ tv_sec = ns / 1e9, tv_nsec = ns % 1e9, - }; - err := unix.pthread_cond_timedwait(&c.impl.pthread_cond, &m.impl.pthread_mutex, timeout_timespec); + } + err := unix.pthread_cond_timedwait(&c.impl.pthread_cond, &m.impl.pthread_mutex, timeout_timespec) // TODO(bill): - return err == 0; + return err == 0 } _cond_signal :: proc(c: ^Cond) { - err := unix.pthread_cond_signal(&c.impl.pthread_cond); - assert(err == 0); + err := unix.pthread_cond_signal(&c.impl.pthread_cond) + assert(err == 0) } _cond_broadcast :: proc(c: ^Cond) { - err := unix.pthread_cond_broadcast(&c.impl.pthread_cond); - assert(err == 0); + err := unix.pthread_cond_broadcast(&c.impl.pthread_cond) + assert(err == 0) } _Sema :: struct { @@ -205,25 +205,25 @@ _Sema :: struct { } _sema_wait :: proc(s: ^Sema) { - mutex_lock(&s.impl.mutex); - defer mutex_unlock(&s.impl.mutex); + mutex_lock(&s.impl.mutex) + defer mutex_unlock(&s.impl.mutex) for s.impl.count == 0 { - cond_wait(&s.impl.cond, &s.impl.mutex); + cond_wait(&s.impl.cond, &s.impl.mutex) } - s.impl.count -= 1; + s.impl.count -= 1 if s.impl.count > 0 { - cond_signal(&s.impl.cond); + cond_signal(&s.impl.cond) } } _sema_post :: proc(s: ^Sema, count := 1) { - mutex_lock(&s.impl.mutex); - defer mutex_unlock(&s.impl.mutex); + mutex_lock(&s.impl.mutex) + defer mutex_unlock(&s.impl.mutex) - s.impl.count += count; - cond_signal(&s.impl.cond); + s.impl.count += count + cond_signal(&s.impl.cond) } diff --git a/core/sync/sync_darwin.odin b/core/sync/sync_darwin.odin index 0fd2fc2a7..f3bb4d5a3 100644 --- a/core/sync/sync_darwin.odin +++ b/core/sync/sync_darwin.odin @@ -7,13 +7,13 @@ import "core:c" foreign import pthread "System.framework" current_thread_id :: proc "contextless" () -> int { - tid: u64; + tid: u64 // NOTE(Oskar): available from OSX 10.6 and iOS 3.2. // For older versions there is `syscall(SYS_thread_selfid)`, but not really // the same thing apparently. - foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int ---; } - pthread_threadid_np(nil, &tid); - return int(tid); + foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int --- } + pthread_threadid_np(nil, &tid) + return int(tid) } @@ -28,27 +28,27 @@ Semaphore :: struct #align 16 { // See core/sys/unix/pthread_linux.odin/pthread_t. semaphore_init :: proc(s: ^Semaphore, initial_count := 0) { - ct := darwin.mach_task_self(); - res := darwin.semaphore_create(ct, &s.handle, 0, c.int(initial_count)); - assert(res == 0); + ct := darwin.mach_task_self() + res := darwin.semaphore_create(ct, &s.handle, 0, c.int(initial_count)) + assert(res == 0) } semaphore_destroy :: proc(s: ^Semaphore) { - ct := darwin.mach_task_self(); - res := darwin.semaphore_destroy(ct, s.handle); - assert(res == 0); - s.handle = {}; + ct := darwin.mach_task_self() + res := darwin.semaphore_destroy(ct, s.handle) + assert(res == 0) + s.handle = {} } semaphore_post :: proc(s: ^Semaphore, count := 1) { // NOTE: SPEED: If there's one syscall to do this, we should use it instead of the loop. for in 0.. int { - SYS_GETTID :: 186; - return int(intrinsics.syscall(SYS_GETTID)); + SYS_GETTID :: 186 + return int(intrinsics.syscall(SYS_GETTID)) } @@ -18,21 +18,21 @@ Semaphore :: struct #align 16 { } semaphore_init :: proc(s: ^Semaphore, initial_count := 0) { - assert(unix.sem_init(&s.handle, 0, u32(initial_count)) == 0); + assert(unix.sem_init(&s.handle, 0, u32(initial_count)) == 0) } semaphore_destroy :: proc(s: ^Semaphore) { - assert(unix.sem_destroy(&s.handle) == 0); - s.handle = {}; + assert(unix.sem_destroy(&s.handle) == 0) + s.handle = {} } semaphore_post :: proc(s: ^Semaphore, count := 1) { // NOTE: SPEED: If there's one syscall to do this, we should use it instead of the loop. for in 0.. bool { - return unix.pthread_mutex_trylock(&m.handle) == 0; + return unix.pthread_mutex_trylock(&m.handle) == 0 } mutex_unlock :: proc(m: ^Mutex) { - assert(unix.pthread_mutex_unlock(&m.handle) == 0); + assert(unix.pthread_mutex_unlock(&m.handle) == 0) } @@ -46,29 +46,29 @@ Blocking_Mutex :: struct { blocking_mutex_init :: proc(m: ^Blocking_Mutex) { // NOTE(tetra, 2019-11-01): POSIX OOM if we cannot init the attrs or the mutex. - attrs: unix.pthread_mutexattr_t; - assert(unix.pthread_mutexattr_init(&attrs) == 0); - defer unix.pthread_mutexattr_destroy(&attrs); // ignores destruction error + attrs: unix.pthread_mutexattr_t + assert(unix.pthread_mutexattr_init(&attrs) == 0) + defer unix.pthread_mutexattr_destroy(&attrs) // ignores destruction error - assert(unix.pthread_mutex_init(&m.handle, &attrs) == 0); + assert(unix.pthread_mutex_init(&m.handle, &attrs) == 0) } blocking_mutex_destroy :: proc(m: ^Blocking_Mutex) { - assert(unix.pthread_mutex_destroy(&m.handle) == 0); - m.handle = {}; + assert(unix.pthread_mutex_destroy(&m.handle) == 0) + m.handle = {} } blocking_mutex_lock :: proc(m: ^Blocking_Mutex) { - assert(unix.pthread_mutex_lock(&m.handle) == 0); + assert(unix.pthread_mutex_lock(&m.handle) == 0) } // Returns false if someone else holds the lock. blocking_mutex_try_lock :: proc(m: ^Blocking_Mutex) -> bool { - return unix.pthread_mutex_trylock(&m.handle) == 0; + return unix.pthread_mutex_trylock(&m.handle) == 0 } blocking_mutex_unlock :: proc(m: ^Blocking_Mutex) { - assert(unix.pthread_mutex_unlock(&m.handle) == 0); + assert(unix.pthread_mutex_unlock(&m.handle) == 0) } @@ -90,42 +90,42 @@ Condition :: struct { condition_init :: proc(c: ^Condition, mutex: Condition_Mutex_Ptr) -> bool { // NOTE(tetra, 2019-11-01): POSIX OOM if we cannot init the attrs or the condition. - attrs: unix.pthread_condattr_t; + attrs: unix.pthread_condattr_t if unix.pthread_condattr_init(&attrs) != 0 { - return false; + return false } - defer unix.pthread_condattr_destroy(&attrs); // ignores destruction error + defer unix.pthread_condattr_destroy(&attrs) // ignores destruction error - c.flag = false; - c.mutex = mutex; - return unix.pthread_cond_init(&c.handle, &attrs) == 0; + c.flag = false + c.mutex = mutex + return unix.pthread_cond_init(&c.handle, &attrs) == 0 } condition_destroy :: proc(c: ^Condition) { - assert(unix.pthread_cond_destroy(&c.handle) == 0); - c.handle = {}; + assert(unix.pthread_cond_destroy(&c.handle) == 0) + c.handle = {} } // Awaken exactly one thread who is waiting on the condition condition_signal :: proc(c: ^Condition) -> bool { switch m in c.mutex { case ^Mutex: - mutex_lock(m); - defer mutex_unlock(m); - atomic_swap(&c.flag, true, .Sequentially_Consistent); - return unix.pthread_cond_signal(&c.handle) == 0; + mutex_lock(m) + defer mutex_unlock(m) + atomic_swap(&c.flag, true, .Sequentially_Consistent) + return unix.pthread_cond_signal(&c.handle) == 0 case ^Blocking_Mutex: - blocking_mutex_lock(m); - defer blocking_mutex_unlock(m); - atomic_swap(&c.flag, true, .Sequentially_Consistent); - return unix.pthread_cond_signal(&c.handle) == 0; + blocking_mutex_lock(m) + defer blocking_mutex_unlock(m) + atomic_swap(&c.flag, true, .Sequentially_Consistent) + return unix.pthread_cond_signal(&c.handle) == 0 } - return false; + return false } // Awaken all threads who are waiting on the condition condition_broadcast :: proc(c: ^Condition) -> bool { - return unix.pthread_cond_broadcast(&c.handle) == 0; + return unix.pthread_cond_broadcast(&c.handle) == 0 } // Wait for the condition to be signalled. @@ -134,48 +134,48 @@ condition_broadcast :: proc(c: ^Condition) -> bool { condition_wait_for :: proc(c: ^Condition) -> bool { switch m in c.mutex { case ^Mutex: - mutex_lock(m); - defer mutex_unlock(m); + mutex_lock(m) + defer mutex_unlock(m) // NOTE(tetra): If a thread comes by and steals the flag immediately after the signal occurs, // the thread that gets signalled and wakes up, discovers that the flag was taken and goes // back to sleep. // Though this overall behavior is the most sane, there may be a better way to do this that means that // the first thread to wait, gets the flag first. if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } for { if unix.pthread_cond_wait(&c.handle, &m.handle) != 0 { - return false; + return false } if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } } - return false; + return false case ^Blocking_Mutex: - blocking_mutex_lock(m); - defer blocking_mutex_unlock(m); + blocking_mutex_lock(m) + defer blocking_mutex_unlock(m) // NOTE(tetra): If a thread comes by and steals the flag immediately after the signal occurs, // the thread that gets signalled and wakes up, discovers that the flag was taken and goes // back to sleep. // Though this overall behavior is the most sane, there may be a better way to do this that means that // the first thread to wait, gets the flag first. if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } for { if unix.pthread_cond_wait(&c.handle, &m.handle) != 0 { - return false; + return false } if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } } - return false; + return false } - return false; + return false } // Wait for the condition to be signalled. @@ -184,65 +184,65 @@ condition_wait_for :: proc(c: ^Condition) -> bool { condition_wait_for_timeout :: proc(c: ^Condition, duration: time.Duration) -> bool { switch m in c.mutex { case ^Mutex: - mutex_lock(m); - defer mutex_unlock(m); + mutex_lock(m) + defer mutex_unlock(m) // NOTE(tetra): If a thread comes by and steals the flag immediately after the signal occurs, // the thread that gets signalled and wakes up, discovers that the flag was taken and goes // back to sleep. // Though this overall behavior is the most sane, there may be a better way to do this that means that // the first thread to wait, gets the flag first. if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } - ns := time.duration_nanoseconds(duration); - timeout: time.TimeSpec; - timeout.tv_sec = ns / 1e9; - timeout.tv_nsec = ns % 1e9; + ns := time.duration_nanoseconds(duration) + timeout: time.TimeSpec + timeout.tv_sec = ns / 1e9 + timeout.tv_nsec = ns % 1e9 for { if unix.pthread_cond_timedwait(&c.handle, &m.handle, &timeout) != 0 { - return false; + return false } if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } } - return false; + return false case ^Blocking_Mutex: - blocking_mutex_lock(m); - defer blocking_mutex_unlock(m); + blocking_mutex_lock(m) + defer blocking_mutex_unlock(m) // NOTE(tetra): If a thread comes by and steals the flag immediately after the signal occurs, // the thread that gets signalled and wakes up, discovers that the flag was taken and goes // back to sleep. // Though this overall behavior is the most sane, there may be a better way to do this that means that // the first thread to wait, gets the flag first. if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } - ns := time.duration_nanoseconds(duration); + ns := time.duration_nanoseconds(duration) - timeout: time.TimeSpec; - timeout.tv_sec = ns / 1e9; - timeout.tv_nsec = ns % 1e9; + timeout: time.TimeSpec + timeout.tv_sec = ns / 1e9 + timeout.tv_nsec = ns % 1e9 for { if unix.pthread_cond_timedwait(&c.handle, &m.handle, &timeout) != 0 { - return false; + return false } if atomic_swap(&c.flag, false, .Sequentially_Consistent) { - return true; + return true } } - return false; + return false } - return false; + return false } thread_yield :: proc() { - unix.sched_yield(); + unix.sched_yield() } diff --git a/core/sys/darwin/mach_darwin.odin b/core/sys/darwin/mach_darwin.odin index 25fc63c32..e6272b9aa 100644 --- a/core/sys/darwin/mach_darwin.odin +++ b/core/sys/darwin/mach_darwin.odin @@ -1,4 +1,4 @@ -package darwin; +package darwin foreign import pthread "System.framework" @@ -8,22 +8,22 @@ import "core:c" // However all other sync primitives are aligned for robustness. // I cannot currently align these though. // See core/sys/unix/pthread_linux.odin/pthread_t. -task_t :: distinct u64; -semaphore_t :: distinct u64; +task_t :: distinct u64 +semaphore_t :: distinct u64 -kern_return_t :: distinct u64; -thread_act_t :: distinct u64; +kern_return_t :: distinct u64 +thread_act_t :: distinct u64 @(default_calling_convention="c") foreign pthread { - mach_task_self :: proc() -> task_t ---; + mach_task_self :: proc() -> task_t --- - semaphore_create :: proc(task: task_t, semaphore: ^semaphore_t, policy, value: c.int) -> kern_return_t ---; - semaphore_destroy :: proc(task: task_t, semaphore: semaphore_t) -> kern_return_t ---; + semaphore_create :: proc(task: task_t, semaphore: ^semaphore_t, policy, value: c.int) -> kern_return_t --- + semaphore_destroy :: proc(task: task_t, semaphore: semaphore_t) -> kern_return_t --- - semaphore_signal :: proc(semaphore: semaphore_t) -> kern_return_t ---; - semaphore_signal_all :: proc(semaphore: semaphore_t) -> kern_return_t ---; - semaphore_signal_thread :: proc(semaphore: semaphore_t, thread: thread_act_t) -> kern_return_t ---; + semaphore_signal :: proc(semaphore: semaphore_t) -> kern_return_t --- + semaphore_signal_all :: proc(semaphore: semaphore_t) -> kern_return_t --- + semaphore_signal_thread :: proc(semaphore: semaphore_t, thread: thread_act_t) -> kern_return_t --- - semaphore_wait :: proc(semaphore: semaphore_t) -> kern_return_t ---; + semaphore_wait :: proc(semaphore: semaphore_t) -> kern_return_t --- } diff --git a/core/sys/unix/pthread_darwin.odin b/core/sys/unix/pthread_darwin.odin index a958e0b84..1ff6f44bb 100644 --- a/core/sys/unix/pthread_darwin.odin +++ b/core/sys/unix/pthread_darwin.odin @@ -1,82 +1,82 @@ -package unix; +package unix import "core:c" // NOTE(tetra): No 32-bit Macs. // Source: _pthread_types.h on my Mac. -PTHREAD_SIZE :: 8176; -PTHREAD_ATTR_SIZE :: 56; -PTHREAD_MUTEXATTR_SIZE :: 8; -PTHREAD_MUTEX_SIZE :: 56; -PTHREAD_CONDATTR_SIZE :: 8; -PTHREAD_COND_SIZE :: 40; -PTHREAD_ONCE_SIZE :: 8; -PTHREAD_RWLOCK_SIZE :: 192; -PTHREAD_RWLOCKATTR_SIZE :: 16; +PTHREAD_SIZE :: 8176 +PTHREAD_ATTR_SIZE :: 56 +PTHREAD_MUTEXATTR_SIZE :: 8 +PTHREAD_MUTEX_SIZE :: 56 +PTHREAD_CONDATTR_SIZE :: 8 +PTHREAD_COND_SIZE :: 40 +PTHREAD_ONCE_SIZE :: 8 +PTHREAD_RWLOCK_SIZE :: 192 +PTHREAD_RWLOCKATTR_SIZE :: 16 -pthread_t :: distinct u64; +pthread_t :: distinct u64 pthread_attr_t :: struct #align 16 { sig: c.long, _: [PTHREAD_ATTR_SIZE] c.char, -}; +} pthread_cond_t :: struct #align 16 { sig: c.long, _: [PTHREAD_COND_SIZE] c.char, -}; +} pthread_condattr_t :: struct #align 16 { sig: c.long, _: [PTHREAD_CONDATTR_SIZE] c.char, -}; +} pthread_mutex_t :: struct #align 16 { sig: c.long, _: [PTHREAD_MUTEX_SIZE] c.char, -}; +} pthread_mutexattr_t :: struct #align 16 { sig: c.long, _: [PTHREAD_MUTEXATTR_SIZE] c.char, -}; +} pthread_once_t :: struct #align 16 { sig: c.long, _: [PTHREAD_ONCE_SIZE] c.char, -}; +} pthread_rwlock_t :: struct #align 16 { sig: c.long, _: [PTHREAD_RWLOCK_SIZE] c.char, -}; +} pthread_rwlockattr_t :: struct #align 16 { sig: c.long, _: [PTHREAD_RWLOCKATTR_SIZE] c.char, -}; +} -SCHED_OTHER :: 1; // Avoid if you are writing portable software. -SCHED_FIFO :: 4; -SCHED_RR :: 2; // Round robin. +SCHED_OTHER :: 1 // Avoid if you are writing portable software. +SCHED_FIFO :: 4 +SCHED_RR :: 2 // Round robin. -SCHED_PARAM_SIZE :: 4; +SCHED_PARAM_SIZE :: 4 sched_param :: struct { sched_priority: c.int, _: [SCHED_PARAM_SIZE] c.char, -}; +} // Source: https://github.com/apple/darwin-libpthread/blob/03c4628c8940cca6fd6a82957f683af804f62e7f/pthread/pthread.h#L138 -PTHREAD_CREATE_JOINABLE :: 1; -PTHREAD_CREATE_DETACHED :: 2; -PTHREAD_INHERIT_SCHED :: 1; -PTHREAD_EXPLICIT_SCHED :: 2; -PTHREAD_PROCESS_SHARED :: 1; -PTHREAD_PROCESS_PRIVATE :: 2; +PTHREAD_CREATE_JOINABLE :: 1 +PTHREAD_CREATE_DETACHED :: 2 +PTHREAD_INHERIT_SCHED :: 1 +PTHREAD_EXPLICIT_SCHED :: 2 +PTHREAD_PROCESS_SHARED :: 1 +PTHREAD_PROCESS_PRIVATE :: 2 -PTHREAD_MUTEX_NORMAL :: 0; -PTHREAD_MUTEX_RECURSIVE :: 1; -PTHREAD_MUTEX_ERRORCHECK :: 2; +PTHREAD_MUTEX_NORMAL :: 0 +PTHREAD_MUTEX_RECURSIVE :: 1 +PTHREAD_MUTEX_ERRORCHECK :: 2 diff --git a/core/sys/unix/pthread_linux.odin b/core/sys/unix/pthread_linux.odin index 25d828d81..15164c9f3 100644 --- a/core/sys/unix/pthread_linux.odin +++ b/core/sys/unix/pthread_linux.odin @@ -1,4 +1,4 @@ -package unix; +package unix import "core:c" @@ -6,78 +6,78 @@ import "core:c" // I cannot currently do this. // And at the time of writing there is a bug with putting it // as the only field in a struct. -pthread_t :: distinct u64; +pthread_t :: distinct u64 // pthread_t :: struct #align 16 { x: u64 }; // NOTE(tetra): Got all the size constants from pthreadtypes-arch.h on my // Linux machine. -PTHREAD_COND_T_SIZE :: 48; +PTHREAD_COND_T_SIZE :: 48 -PTHREAD_MUTEXATTR_T_SIZE :: 4; -PTHREAD_CONDATTR_T_SIZE :: 4; -PTHREAD_RWLOCKATTR_T_SIZE :: 8; -PTHREAD_BARRIERATTR_T_SIZE :: 4; +PTHREAD_MUTEXATTR_T_SIZE :: 4 +PTHREAD_CONDATTR_T_SIZE :: 4 +PTHREAD_RWLOCKATTR_T_SIZE :: 8 +PTHREAD_BARRIERATTR_T_SIZE :: 4 // WARNING: The sizes of these things are different yet again // on non-X86! when size_of(int) == 8 { - PTHREAD_ATTR_T_SIZE :: 56; - PTHREAD_MUTEX_T_SIZE :: 40; - PTHREAD_RWLOCK_T_SIZE :: 56; - PTHREAD_BARRIER_T_SIZE :: 32; + PTHREAD_ATTR_T_SIZE :: 56 + PTHREAD_MUTEX_T_SIZE :: 40 + PTHREAD_RWLOCK_T_SIZE :: 56 + PTHREAD_BARRIER_T_SIZE :: 32 } else when size_of(int) == 4 { - PTHREAD_ATTR_T_SIZE :: 32; - PTHREAD_MUTEX_T_SIZE :: 32; - PTHREAD_RWLOCK_T_SIZE :: 44; - PTHREAD_BARRIER_T_SIZE :: 20; + PTHREAD_ATTR_T_SIZE :: 32 + PTHREAD_MUTEX_T_SIZE :: 32 + PTHREAD_RWLOCK_T_SIZE :: 44 + PTHREAD_BARRIER_T_SIZE :: 20 } pthread_cond_t :: struct #align 16 { _: [PTHREAD_COND_T_SIZE] c.char, -}; +} pthread_mutex_t :: struct #align 16 { _: [PTHREAD_MUTEX_T_SIZE] c.char, -}; +} pthread_rwlock_t :: struct #align 16 { _: [PTHREAD_RWLOCK_T_SIZE] c.char, -}; +} pthread_barrier_t :: struct #align 16 { _: [PTHREAD_BARRIER_T_SIZE] c.char, -}; +} pthread_attr_t :: struct #align 16 { _: [PTHREAD_ATTR_T_SIZE] c.char, -}; +} pthread_condattr_t :: struct #align 16 { _: [PTHREAD_CONDATTR_T_SIZE] c.char, -}; +} pthread_mutexattr_t :: struct #align 16 { _: [PTHREAD_MUTEXATTR_T_SIZE] c.char, -}; +} pthread_rwlockattr_t :: struct #align 16 { _: [PTHREAD_RWLOCKATTR_T_SIZE] c.char, -}; +} pthread_barrierattr_t :: struct #align 16 { _: [PTHREAD_BARRIERATTR_T_SIZE] c.char, -}; +} -PTHREAD_MUTEX_NORMAL :: 0; -PTHREAD_MUTEX_RECURSIVE :: 1; -PTHREAD_MUTEX_ERRORCHECK :: 2; +PTHREAD_MUTEX_NORMAL :: 0 +PTHREAD_MUTEX_RECURSIVE :: 1 +PTHREAD_MUTEX_ERRORCHECK :: 2 // TODO(tetra, 2019-11-01): Maybe make `enum c.int`s for these? -PTHREAD_CREATE_JOINABLE :: 0; -PTHREAD_CREATE_DETACHED :: 1; -PTHREAD_INHERIT_SCHED :: 0; -PTHREAD_EXPLICIT_SCHED :: 1; -PTHREAD_PROCESS_PRIVATE :: 0; -PTHREAD_PROCESS_SHARED :: 1; +PTHREAD_CREATE_JOINABLE :: 0 +PTHREAD_CREATE_DETACHED :: 1 +PTHREAD_INHERIT_SCHED :: 0 +PTHREAD_EXPLICIT_SCHED :: 1 +PTHREAD_PROCESS_PRIVATE :: 0 +PTHREAD_PROCESS_SHARED :: 1 -SCHED_OTHER :: 0; -SCHED_FIFO :: 1; -SCHED_RR :: 2; // Round robin. +SCHED_OTHER :: 0 +SCHED_FIFO :: 1 +SCHED_RR :: 2 // Round robin. sched_param :: struct { sched_priority: c.int, @@ -88,9 +88,9 @@ sem_t :: struct #align 16 { } when size_of(int) == 8 { - SEM_T_SIZE :: 32; + SEM_T_SIZE :: 32 } else when size_of(int) == 4 { - SEM_T_SIZE :: 16; + SEM_T_SIZE :: 16 } foreign import "system:pthread" @@ -99,16 +99,16 @@ foreign import "system:pthread" foreign pthread { // create named semaphore. // used in process-shared semaphores. - sem_open :: proc(name: cstring, flags: c.int) -> ^sem_t ---; + sem_open :: proc(name: cstring, flags: c.int) -> ^sem_t --- - sem_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int ---; - sem_destroy :: proc(sem: ^sem_t) -> c.int ---; - sem_post :: proc(sem: ^sem_t) -> c.int ---; - sem_wait :: proc(sem: ^sem_t) -> c.int ---; - sem_trywait :: proc(sem: ^sem_t) -> c.int ---; + sem_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int --- + sem_destroy :: proc(sem: ^sem_t) -> c.int --- + sem_post :: proc(sem: ^sem_t) -> c.int --- + sem_wait :: proc(sem: ^sem_t) -> c.int --- + sem_trywait :: proc(sem: ^sem_t) -> c.int --- // sem_timedwait :: proc(sem: ^sem_t, timeout: time.TimeSpec) -> c.int ---; // NOTE: unclear whether pthread_yield is well-supported on Linux systems, // see https://linux.die.net/man/3/pthread_yield - pthread_yield :: proc() -> c.int ---; + pthread_yield :: proc() -> c.int --- } diff --git a/core/sys/unix/pthread_unix.odin b/core/sys/unix/pthread_unix.odin index a8a680bce..f514d9d3d 100644 --- a/core/sys/unix/pthread_unix.odin +++ b/core/sys/unix/pthread_unix.odin @@ -1,4 +1,4 @@ -package unix; +package unix foreign import "system:pthread" @@ -11,34 +11,34 @@ import "core:time" @(default_calling_convention="c") foreign pthread { - pthread_create :: proc(t: ^pthread_t, attrs: ^pthread_attr_t, routine: proc(data: rawptr) -> rawptr, arg: rawptr) -> c.int ---; + pthread_create :: proc(t: ^pthread_t, attrs: ^pthread_attr_t, routine: proc(data: rawptr) -> rawptr, arg: rawptr) -> c.int --- // retval is a pointer to a location to put the return value of the thread proc. - pthread_join :: proc(t: pthread_t, retval: ^rawptr) -> c.int ---; + pthread_join :: proc(t: pthread_t, retval: ^rawptr) -> c.int --- - pthread_self :: proc() -> pthread_t ---; + pthread_self :: proc() -> pthread_t --- - pthread_equal :: proc(a, b: pthread_t) -> b32 ---; + pthread_equal :: proc(a, b: pthread_t) -> b32 --- - sched_get_priority_min :: proc(policy: c.int) -> c.int ---; - sched_get_priority_max :: proc(policy: c.int) -> c.int ---; + sched_get_priority_min :: proc(policy: c.int) -> c.int --- + sched_get_priority_max :: proc(policy: c.int) -> c.int --- // NOTE: POSIX says this can fail with OOM. - pthread_attr_init :: proc(attrs: ^pthread_attr_t) -> c.int ---; + pthread_attr_init :: proc(attrs: ^pthread_attr_t) -> c.int --- - pthread_attr_destroy :: proc(attrs: ^pthread_attr_t) -> c.int ---; + pthread_attr_destroy :: proc(attrs: ^pthread_attr_t) -> c.int --- - pthread_attr_getschedparam :: proc(attrs: ^pthread_attr_t, param: ^sched_param) -> c.int ---; - pthread_attr_setschedparam :: proc(attrs: ^pthread_attr_t, param: ^sched_param) -> c.int ---; + pthread_attr_getschedparam :: proc(attrs: ^pthread_attr_t, param: ^sched_param) -> c.int --- + pthread_attr_setschedparam :: proc(attrs: ^pthread_attr_t, param: ^sched_param) -> c.int --- - pthread_attr_getschedpolicy :: proc(t: ^pthread_attr_t, policy: ^c.int) -> c.int ---; - pthread_attr_setschedpolicy :: proc(t: ^pthread_attr_t, policy: c.int) -> c.int ---; + pthread_attr_getschedpolicy :: proc(t: ^pthread_attr_t, policy: ^c.int) -> c.int --- + pthread_attr_setschedpolicy :: proc(t: ^pthread_attr_t, policy: c.int) -> c.int --- // states: PTHREAD_CREATE_DETACHED, PTHREAD_CREATE_JOINABLE - pthread_attr_setdetachstate :: proc(attrs: ^pthread_attr_t, detach_state: c.int) -> c.int ---; + pthread_attr_setdetachstate :: proc(attrs: ^pthread_attr_t, detach_state: c.int) -> c.int --- // scheds: PTHREAD_INHERIT_SCHED, PTHREAD_EXPLICIT_SCHED - pthread_attr_setinheritsched :: proc(attrs: ^pthread_attr_t, sched: c.int) -> c.int ---; + pthread_attr_setinheritsched :: proc(attrs: ^pthread_attr_t, sched: c.int) -> c.int --- // NOTE(tetra, 2019-11-06): WARNING: Different systems have different alignment requirements. // For maximum usefulness, use the OS's page size. @@ -49,63 +49,63 @@ foreign pthread { // guard pages. If you are using this procedure, YOU must set them up manually. // If you forget to do this, you WILL get stack corruption bugs if you do not EXTREMELY // know what you are doing! - pthread_attr_setstack :: proc(attrs: ^pthread_attr_t, stack_ptr: rawptr, stack_size: u64) -> c.int ---; - pthread_attr_getstack :: proc(attrs: ^pthread_attr_t, stack_ptr: ^rawptr, stack_size: ^u64) -> c.int ---; + pthread_attr_setstack :: proc(attrs: ^pthread_attr_t, stack_ptr: rawptr, stack_size: u64) -> c.int --- + pthread_attr_getstack :: proc(attrs: ^pthread_attr_t, stack_ptr: ^rawptr, stack_size: ^u64) -> c.int --- - sched_yield :: proc() -> c.int ---; + sched_yield :: proc() -> c.int --- } @(default_calling_convention="c") foreign pthread { // NOTE: POSIX says this can fail with OOM. - pthread_cond_init :: proc(cond: ^pthread_cond_t, attrs: ^pthread_condattr_t) -> c.int ---; + pthread_cond_init :: proc(cond: ^pthread_cond_t, attrs: ^pthread_condattr_t) -> c.int --- - pthread_cond_destroy :: proc(cond: ^pthread_cond_t) -> c.int ---; + pthread_cond_destroy :: proc(cond: ^pthread_cond_t) -> c.int --- - pthread_cond_signal :: proc(cond: ^pthread_cond_t) -> c.int ---; + pthread_cond_signal :: proc(cond: ^pthread_cond_t) -> c.int --- // same as signal, but wakes up _all_ threads that are waiting - pthread_cond_broadcast :: proc(cond: ^pthread_cond_t) -> c.int ---; + pthread_cond_broadcast :: proc(cond: ^pthread_cond_t) -> c.int --- // assumes the mutex is pre-locked - pthread_cond_wait :: proc(cond: ^pthread_cond_t, mutex: ^pthread_mutex_t) -> c.int ---; - pthread_cond_timedwait :: proc(cond: ^pthread_cond_t, mutex: ^pthread_mutex_t, timeout: ^time.TimeSpec) -> c.int ---; + pthread_cond_wait :: proc(cond: ^pthread_cond_t, mutex: ^pthread_mutex_t) -> c.int --- + pthread_cond_timedwait :: proc(cond: ^pthread_cond_t, mutex: ^pthread_mutex_t, timeout: ^time.TimeSpec) -> c.int --- - pthread_condattr_init :: proc(attrs: ^pthread_condattr_t) -> c.int ---; - pthread_condattr_destroy :: proc(attrs: ^pthread_condattr_t) -> c.int ---; + pthread_condattr_init :: proc(attrs: ^pthread_condattr_t) -> c.int --- + pthread_condattr_destroy :: proc(attrs: ^pthread_condattr_t) -> c.int --- // p-shared = "process-shared" - i.e: is this condition shared among multiple processes? // values: PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED - pthread_condattr_setpshared :: proc(attrs: ^pthread_condattr_t, value: c.int) -> c.int ---; - pthread_condattr_getpshared :: proc(attrs: ^pthread_condattr_t, result: ^c.int) -> c.int ---; + pthread_condattr_setpshared :: proc(attrs: ^pthread_condattr_t, value: c.int) -> c.int --- + pthread_condattr_getpshared :: proc(attrs: ^pthread_condattr_t, result: ^c.int) -> c.int --- } @(default_calling_convention="c") foreign pthread { // NOTE: POSIX says this can fail with OOM. - pthread_mutex_init :: proc(mutex: ^pthread_mutex_t, attrs: ^pthread_mutexattr_t) -> c.int ---; + pthread_mutex_init :: proc(mutex: ^pthread_mutex_t, attrs: ^pthread_mutexattr_t) -> c.int --- - pthread_mutex_destroy :: proc(mutex: ^pthread_mutex_t) -> c.int ---; + pthread_mutex_destroy :: proc(mutex: ^pthread_mutex_t) -> c.int --- - pthread_mutex_trylock :: proc(mutex: ^pthread_mutex_t) -> c.int ---; + pthread_mutex_trylock :: proc(mutex: ^pthread_mutex_t) -> c.int --- - pthread_mutex_lock :: proc(mutex: ^pthread_mutex_t) -> c.int ---; + pthread_mutex_lock :: proc(mutex: ^pthread_mutex_t) -> c.int --- - pthread_mutex_timedlock :: proc(mutex: ^pthread_mutex_t, timeout: ^time.TimeSpec) -> c.int ---; + pthread_mutex_timedlock :: proc(mutex: ^pthread_mutex_t, timeout: ^time.TimeSpec) -> c.int --- - pthread_mutex_unlock :: proc(mutex: ^pthread_mutex_t) -> c.int ---; + pthread_mutex_unlock :: proc(mutex: ^pthread_mutex_t) -> c.int --- - pthread_mutexattr_init :: proc(attrs: ^pthread_mutexattr_t) -> c.int ---; - pthread_mutexattr_destroy :: proc(attrs: ^pthread_mutexattr_t) -> c.int ---; - pthread_mutexattr_settype :: proc(attrs: ^pthread_mutexattr_t, type: c.int) -> c.int ---; + pthread_mutexattr_init :: proc(attrs: ^pthread_mutexattr_t) -> c.int --- + pthread_mutexattr_destroy :: proc(attrs: ^pthread_mutexattr_t) -> c.int --- + pthread_mutexattr_settype :: proc(attrs: ^pthread_mutexattr_t, type: c.int) -> c.int --- // p-shared = "process-shared" - i.e: is this mutex shared among multiple processes? // values: PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED - pthread_mutexattr_setpshared :: proc(attrs: ^pthread_mutexattr_t, value: c.int) -> c.int ---; - pthread_mutexattr_getpshared :: proc(attrs: ^pthread_mutexattr_t, result: ^c.int) -> c.int ---; + pthread_mutexattr_setpshared :: proc(attrs: ^pthread_mutexattr_t, value: c.int) -> c.int --- + pthread_mutexattr_getpshared :: proc(attrs: ^pthread_mutexattr_t, result: ^c.int) -> c.int --- } diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin index fa82832ec..f6eafcdae 100644 --- a/core/thread/thread_unix.odin +++ b/core/thread/thread_unix.odin @@ -38,87 +38,87 @@ Thread_Os_Specific :: struct #align 16 { // _create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread { __linux_thread_entry_proc :: proc "c" (t: rawptr) -> rawptr { - context = runtime.default_context(); - t := (^Thread)(t); - sync.condition_wait_for(&t.start_gate); - sync.condition_destroy(&t.start_gate); - sync.mutex_destroy(&t.start_mutex); - t.start_gate = {}; - t.start_mutex = {}; + context = runtime.default_context() + t := (^Thread)(t) + sync.condition_wait_for(&t.start_gate) + sync.condition_destroy(&t.start_gate) + sync.mutex_destroy(&t.start_mutex) + t.start_gate = {} + t.start_mutex = {} - context = t.init_context.? or_else runtime.default_context(); + context = t.init_context.? or_else runtime.default_context() - t.procedure(t); + t.procedure(t) if t.init_context == nil { if context.temp_allocator.data == &runtime.global_default_temp_allocator_data { - runtime.default_temp_allocator_destroy(auto_cast context.temp_allocator.data); + runtime.default_temp_allocator_destroy(auto_cast context.temp_allocator.data) } } - intrinsics.atomic_store(&t.done, true); - return nil; + intrinsics.atomic_store(&t.done, true) + return nil } - attrs: unix.pthread_attr_t; + attrs: unix.pthread_attr_t if unix.pthread_attr_init(&attrs) != 0 { - return nil; // NOTE(tetra, 2019-11-01): POSIX OOM. + return nil // NOTE(tetra, 2019-11-01): POSIX OOM. } - defer unix.pthread_attr_destroy(&attrs); + defer unix.pthread_attr_destroy(&attrs) // NOTE(tetra, 2019-11-01): These only fail if their argument is invalid. - assert(unix.pthread_attr_setdetachstate(&attrs, unix.PTHREAD_CREATE_JOINABLE) == 0); - assert(unix.pthread_attr_setinheritsched(&attrs, unix.PTHREAD_EXPLICIT_SCHED) == 0); + assert(unix.pthread_attr_setdetachstate(&attrs, unix.PTHREAD_CREATE_JOINABLE) == 0) + assert(unix.pthread_attr_setinheritsched(&attrs, unix.PTHREAD_EXPLICIT_SCHED) == 0) - thread := new(Thread); + thread := new(Thread) if thread == nil { - return nil; + return nil } - thread.creation_allocator = context.allocator; + thread.creation_allocator = context.allocator // Set thread priority. - policy: i32; - res := unix.pthread_attr_getschedpolicy(&attrs, &policy); - assert(res == 0); - params: unix.sched_param; - res = unix.pthread_attr_getschedparam(&attrs, ¶ms); - assert(res == 0); - low := unix.sched_get_priority_min(policy); - high := unix.sched_get_priority_max(policy); + policy: i32 + res := unix.pthread_attr_getschedpolicy(&attrs, &policy) + assert(res == 0) + params: unix.sched_param + res = unix.pthread_attr_getschedparam(&attrs, ¶ms) + assert(res == 0) + low := unix.sched_get_priority_min(policy) + high := unix.sched_get_priority_max(policy) switch priority { case .Normal: // Okay - case .Low: params.sched_priority = low + 1; - case .High: params.sched_priority = high; + case .Low: params.sched_priority = low + 1 + case .High: params.sched_priority = high } - res = unix.pthread_attr_setschedparam(&attrs, ¶ms); - assert(res == 0); + res = unix.pthread_attr_setschedparam(&attrs, ¶ms) + assert(res == 0) if unix.pthread_create(&thread.unix_thread, &attrs, __linux_thread_entry_proc, thread) != 0 { - free(thread, thread.creation_allocator); - return nil; + free(thread, thread.creation_allocator) + return nil } - thread.procedure = procedure; + thread.procedure = procedure - sync.mutex_init(&thread.start_mutex); - sync.condition_init(&thread.start_gate, &thread.start_mutex); + sync.mutex_init(&thread.start_mutex) + sync.condition_init(&thread.start_gate, &thread.start_mutex) - return thread; + return thread } _start :: proc(t: ^Thread) { if intrinsics.atomic_xchg(&t.started, true) { - return; + return } - sync.condition_signal(&t.start_gate); + sync.condition_signal(&t.start_gate) } _is_done :: proc(t: ^Thread) -> bool { - return intrinsics.atomic_load(&t.done); + return intrinsics.atomic_load(&t.done) } _join :: proc(t: ^Thread) { if unix.pthread_equal(unix.pthread_self(), t.unix_thread) { - return; + return } // if unix.pthread_self().x == t.unix_thread.x do return; @@ -131,9 +131,9 @@ _join :: proc(t: ^Thread) { if intrinsics.atomic_xchg(&t.already_joined, true) { for { if intrinsics.atomic_load(&t.done) { - return; + return } - intrinsics.cpu_relax(); + intrinsics.cpu_relax() } } @@ -143,29 +143,29 @@ _join :: proc(t: ^Thread) { // that you may join a different thread from the one you called join on, // if the thread handle is reused. if intrinsics.atomic_load(&t.done) { - return; + return } - ret_val: rawptr; - _ = unix.pthread_join(t.unix_thread, &ret_val); + ret_val: rawptr + _ = unix.pthread_join(t.unix_thread, &ret_val) if !intrinsics.atomic_load(&t.done) { - panic("thread not done after join"); + panic("thread not done after join") } } _join_multiple :: proc(threads: ..^Thread) { for t in threads { - _join(t); + _join(t) } } _destroy :: proc(t: ^Thread) { - _join(t); - sync.condition_destroy(&t.start_gate); - sync.mutex_destroy(&t.start_mutex); - t.unix_thread = {}; - free(t, t.creation_allocator); + _join(t) + sync.condition_destroy(&t.start_gate) + sync.mutex_destroy(&t.start_mutex) + t.unix_thread = {} + free(t, t.creation_allocator) } @@ -174,5 +174,5 @@ _terminate :: proc(t: ^Thread, exit_code: int) { } _yield :: proc() { - unix.sched_yield(); + unix.sched_yield() } diff --git a/core/time/time_unix.odin b/core/time/time_unix.odin index cc9699209..8410cd305 100644 --- a/core/time/time_unix.odin +++ b/core/time/time_unix.odin @@ -1,7 +1,7 @@ //+build linux, darwin, freebsd package time -IS_SUPPORTED :: true; // NOTE: Times on Darwin are UTC. +IS_SUPPORTED :: true // NOTE: Times on Darwin are UTC. when ODIN_OS == "darwin" { foreign import libc "System.framework" @@ -12,81 +12,81 @@ when ODIN_OS == "darwin" { @(default_calling_convention="c") foreign libc { - @(link_name="clock_gettime") _unix_clock_gettime :: proc(clock_id: u64, timespec: ^TimeSpec) -> i32 ---; - @(link_name="sleep") _unix_sleep :: proc(seconds: u32) -> i32 ---; - @(link_name="nanosleep") _unix_nanosleep :: proc(requested: ^TimeSpec, remaining: ^TimeSpec) -> i32 ---; + @(link_name="clock_gettime") _unix_clock_gettime :: proc(clock_id: u64, timespec: ^TimeSpec) -> i32 --- + @(link_name="sleep") _unix_sleep :: proc(seconds: u32) -> i32 --- + @(link_name="nanosleep") _unix_nanosleep :: proc(requested: ^TimeSpec, remaining: ^TimeSpec) -> i32 --- } TimeSpec :: struct { tv_sec : i64, /* seconds */ tv_nsec : i64, /* nanoseconds */ -}; +} -CLOCK_REALTIME :: 0; // NOTE(tetra): May jump in time, when user changes the system time. -CLOCK_MONOTONIC :: 1; // NOTE(tetra): May stand still while system is asleep. -CLOCK_PROCESS_CPUTIME_ID :: 2; -CLOCK_THREAD_CPUTIME_ID :: 3; -CLOCK_MONOTONIC_RAW :: 4; // NOTE(tetra): "RAW" means: Not adjusted by NTP. -CLOCK_REALTIME_COARSE :: 5; // NOTE(tetra): "COARSE" clocks are apparently much faster, but not "fine-grained." -CLOCK_MONOTONIC_COARSE :: 6; -CLOCK_BOOTTIME :: 7; // NOTE(tetra): Same as MONOTONIC, except also including time system was asleep. -CLOCK_REALTIME_ALARM :: 8; -CLOCK_BOOTTIME_ALARM :: 9; +CLOCK_REALTIME :: 0 // NOTE(tetra): May jump in time, when user changes the system time. +CLOCK_MONOTONIC :: 1 // NOTE(tetra): May stand still while system is asleep. +CLOCK_PROCESS_CPUTIME_ID :: 2 +CLOCK_THREAD_CPUTIME_ID :: 3 +CLOCK_MONOTONIC_RAW :: 4 // NOTE(tetra): "RAW" means: Not adjusted by NTP. +CLOCK_REALTIME_COARSE :: 5 // NOTE(tetra): "COARSE" clocks are apparently much faster, but not "fine-grained." +CLOCK_MONOTONIC_COARSE :: 6 +CLOCK_BOOTTIME :: 7 // NOTE(tetra): Same as MONOTONIC, except also including time system was asleep. +CLOCK_REALTIME_ALARM :: 8 +CLOCK_BOOTTIME_ALARM :: 9 // TODO(tetra, 2019-11-05): The original implementation of this package for Darwin used this constants. // I do not know if Darwin programmers are used to the existance of these constants or not, so // I'm leaving aliases to them for now. -CLOCK_SYSTEM :: CLOCK_REALTIME; -CLOCK_CALENDAR :: CLOCK_MONOTONIC; +CLOCK_SYSTEM :: CLOCK_REALTIME +CLOCK_CALENDAR :: CLOCK_MONOTONIC clock_gettime :: proc(clock_id: u64) -> TimeSpec { - ts : TimeSpec; // NOTE(tetra): Do we need to initialize this? - _unix_clock_gettime(clock_id, &ts); - return ts; + ts : TimeSpec // NOTE(tetra): Do we need to initialize this? + _unix_clock_gettime(clock_id, &ts) + return ts } now :: proc() -> Time { - time_spec_now := clock_gettime(CLOCK_REALTIME); - ns := time_spec_now.tv_sec * 1e9 + time_spec_now.tv_nsec; - return Time{_nsec=ns}; + time_spec_now := clock_gettime(CLOCK_REALTIME) + ns := time_spec_now.tv_sec * 1e9 + time_spec_now.tv_nsec + return Time{_nsec=ns} } boot_time :: proc() -> Time { - ts_now := clock_gettime(CLOCK_REALTIME); - ts_boottime := clock_gettime(CLOCK_BOOTTIME); + ts_now := clock_gettime(CLOCK_REALTIME) + ts_boottime := clock_gettime(CLOCK_BOOTTIME) - ns := (ts_now.tv_sec - ts_boottime.tv_sec) * 1e9 + ts_now.tv_nsec - ts_boottime.tv_nsec; - return Time{_nsec=ns}; + ns := (ts_now.tv_sec - ts_boottime.tv_sec) * 1e9 + ts_now.tv_nsec - ts_boottime.tv_nsec + return Time{_nsec=ns} } seconds_since_boot :: proc() -> f64 { - ts_boottime := clock_gettime(CLOCK_BOOTTIME); - return f64(ts_boottime.tv_sec) + f64(ts_boottime.tv_nsec) / 1e9; + ts_boottime := clock_gettime(CLOCK_BOOTTIME) + return f64(ts_boottime.tv_sec) + f64(ts_boottime.tv_nsec) / 1e9 } sleep :: proc(d: Duration) { - ds := duration_seconds(d); - seconds := u32(ds); - nanoseconds := i64((ds - f64(seconds)) * 1e9); + ds := duration_seconds(d) + seconds := u32(ds) + nanoseconds := i64((ds - f64(seconds)) * 1e9) - if seconds > 0 { _unix_sleep(seconds); } - if nanoseconds > 0 { nanosleep(nanoseconds); } + if seconds > 0 { _unix_sleep(seconds) } + if nanoseconds > 0 { nanosleep(nanoseconds) } } nanosleep :: proc(nanoseconds: i64) -> int { // NOTE(tetra): Should we remove this assert? We are measuring nanoseconds after all... - assert(nanoseconds <= 999999999); + assert(nanoseconds <= 999999999) - requested := TimeSpec{tv_nsec = nanoseconds}; - remaining: TimeSpec; // NOTE(tetra): Do we need to initialize this? - return int(_unix_nanosleep(&requested, &remaining)); + requested := TimeSpec{tv_nsec = nanoseconds} + remaining: TimeSpec // NOTE(tetra): Do we need to initialize this? + return int(_unix_nanosleep(&requested, &remaining)) } _tick_now :: proc() -> Tick { - t := clock_gettime(CLOCK_MONOTONIC_RAW); - _nsec := t.tv_sec*1e9 + t.tv_nsec; - return Tick{_nsec = _nsec}; + t := clock_gettime(CLOCK_MONOTONIC_RAW) + _nsec := t.tv_sec*1e9 + t.tv_nsec + return Tick{_nsec = _nsec} }