freebsd_amd64 support

core/c/libc/stdio.odin

@@ -103,6 +103,31 @@ when ODIN_OS == .OpenBSD {
 	}
 }
 
+when ODIN_OS == .FreeBSD {
+	fpos_t :: distinct i64
+
+	_IOFBF :: 0
+	_IOLBF :: 1
+	_IONBF :: 1
+
+	BUFSIZ :: 1024
+
+	EOF :: int(-1)
+
+	FOPEN_MAX	:: 20
+	FILENAME_MAX	:: 1024
+
+	SEEK_SET :: 0
+	SEEK_CUR :: 1
+	SEEK_END :: 2
+
+	foreign libc {
+		stderr: ^FILE
+		stdin:  ^FILE
+		stdout: ^FILE
+	}
+}
+
 when ODIN_OS == .Darwin {
 	fpos_t :: distinct i64
 	

core/c/libc/wctype.odin

@@ -13,21 +13,23 @@ when ODIN_OS == .Windows {
 when ODIN_OS == .Windows {
 	wctrans_t :: distinct wchar_t
 	wctype_t  :: distinct ushort
-}
 
-when ODIN_OS == .Linux {
+} else when ODIN_OS == .Linux {
 	wctrans_t :: distinct intptr_t
 	wctype_t  :: distinct ulong
-}
 
-when ODIN_OS == .Darwin {
+} else when ODIN_OS == .Darwin {
 	wctrans_t :: distinct int
 	wctype_t  :: distinct u32
-}
 
-when ODIN_OS == .OpenBSD {
+} else when ODIN_OS == .OpenBSD {
 	wctrans_t :: distinct rawptr
 	wctype_t  :: distinct rawptr
+
+} else when ODIN_OS == .FreeBSD {
+	wctrans_t :: distinct int
+	wctype_t  :: distinct ulong
+	
 }
 
 @(default_calling_convention="c")

core/os/dir_freebsd.odin

@@ -0,0 +1,70 @@
+package os
+
+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)
+	if err != ERROR_NONE {
+		return
+	}
+
+	defer _closedir(dirp)
+
+	dirpath: string
+	dirpath, err = absolute_path_from_handle(fd)
+
+	if err != ERROR_NONE {
+		return
+	}
+
+	defer delete(dirpath)
+
+	n := n
+	size := n
+	if n <= 0 {
+		n = -1
+		size = 100
+	}
+
+	dfi := make([dynamic]File_Info, 0, size, allocator)
+
+	for {
+		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)
+			}
+			delete(dfi)
+			return
+		} else if end_of_stream {
+			break
+		}
+
+		fi_: File_Info
+		filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] })
+
+		if filename == "." || filename == ".." {
+			continue
+		}
+
+		fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator)
+		defer delete(fullpath, context.temp_allocator)
+
+		fi_, err = stat(fullpath, allocator)
+		if err != ERROR_NONE {
+			for fi__ in dfi {
+				file_info_delete(fi__, allocator)
+			}
+			delete(dfi)
+			return
+		}
+
+		append(&dfi, fi_)
+	}
+
+	return dfi[:], ERROR_NONE
+}

core/os/os_freebsd.odin

@@ -10,7 +10,6 @@ import "core:c"
 Handle :: distinct i32
 File_Time :: distinct u64
 Errno :: distinct i32
-Syscall :: distinct i32
 
 INVALID_HANDLE :: ~Handle(0)
 
@@ -142,40 +141,74 @@ RTLD_TRACE        :: 0x200
 RTLD_NODELETE     :: 0x01000
 RTLD_NOLOAD       :: 0x02000
 
+MAX_PATH :: 1024
+
 args := _alloc_command_line_arguments()
 
 Unix_File_Time :: struct {
-	seconds: i64,
+	seconds: time_t,
 	nanoseconds: c.long,
 }
 
+dev_t :: u64
+ino_t :: u64
+nlink_t :: u64
+off_t :: i64
+mode_t :: u16
 pid_t :: u32
+uid_t :: u32
+gid_t :: u32
+blkcnt_t :: i64
+blksize_t :: i32
+fflags_t :: u32
+
+when ODIN_ARCH == .amd64 /* LP64 */ {
+	time_t :: i64
+} else {
+	time_t :: i32
+}
+
 
 OS_Stat :: struct {
-	device_id: u64,
+	device_id: dev_t,
-	serial: u64,
+	serial: ino_t,
-	nlink: u64,
+	nlink: nlink_t,
-	mode: u32,
+	mode: mode_t,
 	_padding0: i16,
-	uid: u32,
+	uid: uid_t,
-	gid: u32,
+	gid: gid_t,
 	_padding1: i32,
-	rdev: u64,
+	rdev: dev_t,
 
 	last_access: Unix_File_Time,
 	modified: Unix_File_Time,
 	status_change: Unix_File_Time,
 	birthtime: Unix_File_Time,
 
-	size: i64,
+	size: off_t,
-	blocks: i64,
+	blocks: blkcnt_t,
-	block_size: i32,
+	block_size: blksize_t,
 
-	flags: u32,
+	flags: fflags_t,
 	gen: u64,
-	lspare: i64,
+	lspare: [10]u64,
 }
 
+
+// since FreeBSD v12
+Dirent :: struct {
+	ino: ino_t,
+	off: off_t,
+	reclen: u16,
+	type: u8,
+	_pad0: u8,
+	namlen: u16,
+	_pad1: u16,
+	name: [256]byte,
+}
+
+Dir :: distinct rawptr // DIR*
+
 // File type
 S_IFMT   :: 0o170000 // Type of file mask
 S_IFIFO  :: 0o010000 // Named pipe (fifo)
@@ -211,13 +244,13 @@ S_ISGID :: 0o2000 // Set group id on execution
 S_ISVTX :: 0o1000 // Directory restrcted delete
 
 
-S_ISLNK  :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK
+S_ISLNK  :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFLNK
-S_ISREG  :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG
+S_ISREG  :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFREG
-S_ISDIR  :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR
+S_ISDIR  :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFDIR
-S_ISCHR  :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR
+S_ISCHR  :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFCHR
-S_ISBLK  :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK
+S_ISBLK  :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFBLK
-S_ISFIFO :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO
+S_ISFIFO :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFIFO
-S_ISSOCK :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK
+S_ISSOCK :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFSOCK
 
 F_OK :: 0 // Test for file existance
 X_OK :: 1 // Test for execute permission
@@ -225,27 +258,38 @@ W_OK :: 2 // Test for write permission
 R_OK :: 4 // Test for read permission
 
 foreign libc {
-	@(link_name="__error") __errno_location :: proc() -> ^int ---
+	@(link_name="__error")		__errno_location :: proc() -> ^int ---
-	@(link_name="syscall")          syscall          :: proc(number: Syscall, #c_vararg args: ..any) -> 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="lseek")          _unix_seek          :: proc(fd: Handle, offset: i64, whence: c.int) -> i64 ---
+	@(link_name="lseek")            _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="stat")           _unix_stat          :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---
+	@(link_name="stat")             _unix_stat          :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---
+	@(link_name="lstat")            _unix_lstat         :: proc(path: cstring, sb: ^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: c.int) -> c.int ---
+	@(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="rename")           _unix_rename        :: proc(old, new: cstring) -> c.int ---
+	@(link_name="unlink")           _unix_unlink        :: proc(path: cstring) -> c.int ---
+	@(link_name="rmdir")            _unix_rmdir         :: proc(path: cstring) -> c.int ---
+	@(link_name="mkdir")            _unix_mkdir         :: proc(path: cstring, mode: mode_t) -> 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="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="realpath")         _unix_realpath      :: proc(path: cstring, resolved_path: rawptr) -> rawptr ---
-	@(link_name="chdir")            _unix_chdir         :: proc(buf: cstring) -> c.int ---
 
 	@(link_name="exit")             _unix_exit          :: proc(status: c.int) -> ! ---
 }
@@ -318,12 +362,102 @@ file_size :: proc(fd: Handle) -> (i64, Errno) {
 	return s.size, ERROR_NONE
 }
 
-stdin: Handle = 0
+rename :: proc(old_path, new_path: string) -> Errno {
+	old_path_cstr := strings.clone_to_cstring(old_path, context.temp_allocator)
+	new_path_cstr := strings.clone_to_cstring(new_path, context.temp_allocator)
+	res := _unix_rename(old_path_cstr, new_path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+remove :: proc(path: string) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_unlink(path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+make_directory :: proc(path: string, mode: mode_t = 0o775) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_mkdir(path_cstr, mode)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+remove_directory :: proc(path: string) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_rmdir(path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+is_file_handle :: proc(fd: Handle) -> bool {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISREG(s.mode)
+}
+
+is_file_path :: proc(path: string, follow_links: bool = true) -> bool {
+	s: OS_Stat
+	err: Errno
+	if follow_links {
+		s, err = _stat(path)
+	} else {
+		s, err = _lstat(path)
+	}
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISREG(s.mode)
+}
+
+is_dir_handle :: proc(fd: Handle) -> bool {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISDIR(s.mode)
+}
+
+is_dir_path :: proc(path: string, follow_links: bool = true) -> bool {
+	s: OS_Stat
+	err: Errno
+	if follow_links {
+		s, err = _stat(path)
+	} else {
+		s, err = _lstat(path)
+	}
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISDIR(s.mode)
+}
+
+is_file :: proc {is_file_path, is_file_handle}
+is_dir :: proc {is_dir_path, is_dir_handle}
+
+// NOTE(bill): Uses startup to initialize it
+
+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
 	}
@@ -332,7 +466,7 @@ last_write_time :: proc(fd: Handle) -> (File_Time, Errno) {
 }
 
 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
 	}
@@ -340,18 +474,33 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
 	return File_Time(modified), ERROR_NONE
 }
 
-stat :: proc(path: string) -> (OS_Stat, Errno) {
+@private
+_stat :: proc(path: string) -> (OS_Stat, Errno) {
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
-	s: OS_Stat
+	s: OS_Stat = ---
-	result := _unix_stat(cstr, &s)
+	result := _unix_lstat(cstr, &s)
 	if result == -1 {
 		return s, Errno(get_last_error())
 	}
 	return s, ERROR_NONE
 }
 
-fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
+@private
-	s: OS_Stat
+_lstat :: proc(path: string) -> (OS_Stat, Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	
+	// deliberately uninitialized
+	s: OS_Stat = ---
+	res := _unix_lstat(cstr, &s)
+	if res == -1 {
+		return s, Errno(get_last_error())
+	}
+	return s, ERROR_NONE
+}
+
+@private
+_fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
+	s: OS_Stat = ---
 	result := _unix_fstat(fd, &s)
 	if result == -1 {
 		return s, Errno(get_last_error())
@@ -359,6 +508,95 @@ fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
 	return s, ERROR_NONE
 }
 
+@private
+_fdopendir :: proc(fd: Handle) -> (Dir, Errno) {
+	dirp := _unix_fdopendir(fd)
+	if dirp == cast(Dir)nil {
+		return nil, Errno(get_last_error())
+	}
+	return dirp, ERROR_NONE
+}
+
+@private
+_closedir :: proc(dirp: Dir) -> Errno {
+	rc := _unix_closedir(dirp)
+	if rc != 0 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+@private
+_rewinddir :: proc(dirp: Dir) {
+	_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)
+
+	if rc != 0 {
+		err = Errno(get_last_error())
+		return
+	}
+	err = ERROR_NONE
+
+	if result == nil {
+		end_of_stream = true
+		return
+	}
+
+	return
+}
+
+@private
+_readlink :: proc(path: string) -> (string, Errno) {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+
+	bufsz : uint = MAX_PATH
+	buf := make([]byte, MAX_PATH)
+	for {
+		rc := _unix_readlink(path_cstr, &(buf[0]), bufsz)
+		if rc == -1 {
+			delete(buf)
+			return "", Errno(get_last_error())
+		} else if rc == int(bufsz) {
+			bufsz += MAX_PATH
+			delete(buf)
+			buf = make([]byte, bufsz)
+		} else {
+			return strings.string_from_ptr(&buf[0], rc), ERROR_NONE
+		}	
+	}
+	unreachable()
+}
+
+// XXX FreeBSD
+absolute_path_from_handle :: proc(fd: Handle) -> (string, Errno) {
+	return "", Errno(ENOSYS)
+}
+
+absolute_path_from_relative :: proc(rel: string) -> (path: string, err: Errno) {
+	rel := rel
+	if rel == "" {
+		rel = "."
+	}
+
+	rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator)
+
+	path_ptr := _unix_realpath(rel_cstr, nil)
+	if path_ptr == nil {
+		return "", Errno(get_last_error())
+	}
+	defer _unix_free(path_ptr)
+
+	path_cstr := transmute(cstring)path_ptr
+	path = strings.clone( string(path_cstr) )
+
+	return path, ERROR_NONE
+}
+
 access :: proc(path: string, mask: int) -> (bool, Errno) {
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
 	result := _unix_access(cstr, c.int(mask))
@@ -464,4 +702,3 @@ _alloc_command_line_arguments :: proc() -> []string {
 	}
 	return res
 }
-

core/os/stat_unix.odin

@@ -1,4 +1,4 @@
-//+build linux, darwin, openbsd
+//+build linux, darwin, freebsd, openbsd
 package os
 
 import "core:time"
@@ -61,7 +61,7 @@ _make_time_from_unix_file_time :: proc(uft: Unix_File_Time) -> time.Time {
 _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.is_dir = S_ISDIR(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)

core/sync/sync2/futex_freebsd.odin

@@ -0,0 +1,75 @@
+//+private
+//+build freebsd
+package sync2
+
+import "core:c"
+import "core:os"
+import "core:time"
+
+UMTX_OP_WAIT :: 2
+UMTX_OP_WAKE :: 3
+
+foreign import libc "system:c"
+
+foreign libc {
+	_umtx_op :: proc "c" (obj: rawptr, op: c.int, val: c.ulong, uaddr: rawptr, uaddr2: rawptr) -> c.int ---
+}
+
+_futex_wait :: proc(f: ^Futex, expected: u32) -> bool {
+	timeout := os.Unix_File_Time{
+		seconds = 5,
+		nanoseconds = 0,
+	}
+
+	for {
+		res := _umtx_op(f, UMTX_OP_WAIT, c.ulong(expected), nil, &timeout)
+
+		if res != -1 {
+			return true
+		}
+
+		if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
+			continue
+		}
+
+		panic("_futex_wait failure")
+	}
+	unreachable()
+}
+
+_futex_wait_with_timeout :: proc(f: ^Futex, expected: u32, duration: time.Duration) -> bool {
+	if duration <= 0 {
+		return false
+	}
+
+	res := _umtx_op(f, UMTX_OP_WAIT, c.ulong(expected), nil, &os.Unix_File_Time{
+		seconds = (os.time_t)(duration/1e9),
+		nanoseconds = (c.long)(duration%1e9),
+	})
+
+	if res != -1 {
+		return true
+	}
+
+	if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
+		return false
+	}
+
+	panic("_futex_wait_with_timeout failure")
+}
+
+_futex_signal :: proc(f: ^Futex) {
+	res := _umtx_op(f, UMTX_OP_WAKE, 1, nil, nil)
+
+	if res == -1 {
+		panic("_futex_signal failure")
+	}
+}
+
+_futex_broadcast :: proc(f: ^Futex)  {
+	res := _umtx_op(f, UMTX_OP_WAKE, c.ulong(max(i32)), nil, nil)
+
+	if res == -1 {
+		panic("_futex_broadcast failure")
+	}
+}

core/sync/sync2/primitives_freebsd.odin

@@ -0,0 +1,9 @@
+//+build freebsd
+//+private
+package sync2
+
+import "core:os"
+
+_current_thread_id :: proc "contextless" () -> int {
+	return os.current_thread_id()
+}

core/sync/sync_freebsd.odin

@@ -5,8 +5,8 @@ import "core:intrinsics"
 
 
 current_thread_id :: proc "contextless" () -> int {
-	SYS_GETTID :: 186;
+	SYS_GETTID :: 186
-	return int(intrinsics.syscall(SYS_GETTID));
+	return int(intrinsics.syscall(SYS_GETTID))
 }
 
 
@@ -19,22 +19,22 @@ 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);
+	assert(unix.sem_destroy(&s.handle) == 0)
-	s.handle = {};
+	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..<count {
-		assert(unix.sem_post(&s.handle) == 0);
+		assert(unix.sem_post(&s.handle) == 0)
 	}
 }
 
 semaphore_wait_for :: proc(s: ^Semaphore) {
-	assert(unix.sem_wait(&s.handle) == 0);
+	assert(unix.sem_wait(&s.handle) == 0)
 }
 

core/sys/unix/pthread_freebsd.odin

@@ -1,76 +1,76 @@
 //+build freebsd
 package unix
 
-import "core:c";
+import "core:c"
 
-pthread_t :: distinct u64;
+pthread_t :: distinct u64
-// pthread_t :: struct #align 16 { x: u64 };
+// pthread_t :: struct #align 16 { x: u64 }
 
-PTHREAD_COND_T_SIZE :: 8;
+PTHREAD_COND_T_SIZE :: 8
 
-PTHREAD_MUTEXATTR_T_SIZE :: 8;
+PTHREAD_MUTEXATTR_T_SIZE :: 8
-PTHREAD_CONDATTR_T_SIZE  :: 8;
+PTHREAD_CONDATTR_T_SIZE  :: 8
-PTHREAD_RWLOCKATTR_T_SIZE  :: 8;
+PTHREAD_RWLOCKATTR_T_SIZE  :: 8
-PTHREAD_BARRIERATTR_T_SIZE :: 8;
+PTHREAD_BARRIERATTR_T_SIZE :: 8
 
 // WARNING: The sizes of these things are different yet again
 // on non-X86!
 when size_of(int) == 8 {
-	PTHREAD_ATTR_T_SIZE  :: 8;
+	PTHREAD_ATTR_T_SIZE  :: 8
-	PTHREAD_MUTEX_T_SIZE :: 8;
+	PTHREAD_MUTEX_T_SIZE :: 8
-	PTHREAD_RWLOCK_T_SIZE  :: 8;
+	PTHREAD_RWLOCK_T_SIZE  :: 8
-	PTHREAD_BARRIER_T_SIZE :: 8;
+	PTHREAD_BARRIER_T_SIZE :: 8
 } else when size_of(int) == 4 { // TODO
-	PTHREAD_ATTR_T_SIZE  :: 32;
+	PTHREAD_ATTR_T_SIZE  :: 32
-	PTHREAD_MUTEX_T_SIZE :: 32;
+	PTHREAD_MUTEX_T_SIZE :: 32
-	PTHREAD_RWLOCK_T_SIZE  :: 44;
+	PTHREAD_RWLOCK_T_SIZE  :: 44
-	PTHREAD_BARRIER_T_SIZE :: 20;
+	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_ERRORCHECK :: 1;
+PTHREAD_MUTEX_ERRORCHECK :: 1
-PTHREAD_MUTEX_RECURSIVE :: 2;
+PTHREAD_MUTEX_RECURSIVE :: 2
-PTHREAD_MUTEX_NORMAL :: 3;
+PTHREAD_MUTEX_NORMAL :: 3
 
 
-PTHREAD_CREATE_JOINABLE :: 0;
+PTHREAD_CREATE_JOINABLE :: 0
-PTHREAD_CREATE_DETACHED :: 1;
+PTHREAD_CREATE_DETACHED :: 1
-PTHREAD_INHERIT_SCHED :: 4;
+PTHREAD_INHERIT_SCHED :: 4
-PTHREAD_EXPLICIT_SCHED :: 0;
+PTHREAD_EXPLICIT_SCHED :: 0
-PTHREAD_PROCESS_PRIVATE :: 0;
+PTHREAD_PROCESS_PRIVATE :: 0
-PTHREAD_PROCESS_SHARED :: 1;
+PTHREAD_PROCESS_SHARED :: 1
 
-SCHED_FIFO  :: 1;
+SCHED_FIFO  :: 1
-SCHED_OTHER :: 2;
+SCHED_OTHER :: 2
-SCHED_RR :: 3; // Round robin.
+SCHED_RR :: 3 // Round robin.
 
 
 sched_param :: struct {
@@ -98,17 +98,17 @@ 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_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int ---
-	sem_destroy :: proc(sem: ^sem_t) -> c.int ---;
+	sem_destroy :: proc(sem: ^sem_t) -> c.int ---
-	sem_post :: proc(sem: ^sem_t) -> c.int ---;
+	sem_post :: proc(sem: ^sem_t) -> c.int ---
-	sem_wait :: proc(sem: ^sem_t) -> c.int ---;
+	sem_wait :: proc(sem: ^sem_t) -> c.int ---
-	sem_trywait :: 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 ---;
+	// 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() ---;
+	pthread_yield :: proc() ---
 }