Block Expressions and `give`

3 files changed, 222 insertions, 78 deletions

diff --git a/core/fmt.odin b/core/fmt.odin
index 5bcc7344a..cfd442d2c 100644
--- a/core/fmt.odin
+++ b/core/fmt.odin
@@ -6,26 +6,26 @@ import {
 
 const PRINT_BUF_SIZE = 1<<12;
 
-proc fprint(f ^os.File, args ..any) -> int {
+proc fprint(fd os.Handle, args ..any) -> int {
 	var data [PRINT_BUF_SIZE]byte;
 	var buf = data[:0];
 	bprint(^buf, ..args);
-	os.write(f, buf);
+	os.write(fd, buf);
 	return buf.count;
 }
 
-proc fprintln(f ^os.File, args ..any) -> int {
+proc fprintln(fd os.Handle, args ..any) -> int {
 	var data [PRINT_BUF_SIZE]byte;
 	var buf = data[:0];
 	bprintln(^buf, ..args);
-	os.write(f, buf);
+	os.write(fd, buf);
 	return buf.count;
 }
-proc fprintf(f ^os.File, fmt string, args ..any) -> int {
+proc fprintf(fd os.Handle, fmt string, args ..any) -> int {
 	var data [PRINT_BUF_SIZE]byte;
 	var buf = data[:0];
 	bprintf(^buf, fmt, ..args);
-	os.write(f, buf);
+	os.write(fd, buf);
 	return buf.count;
 }
 
@@ -42,11 +42,11 @@ proc printf(fmt string, args ..any) -> int {
 
 
 
-proc fprint_type(f ^os.File, info ^Type_Info) {
+proc fprint_type(fd os.Handle, info ^Type_Info) {
 	var data [PRINT_BUF_SIZE]byte;
 	var buf = data[:0];
 	bprint_type(^buf, info);
-	os.write(f, buf);
+	os.write(fd, buf);
 }
 
 
diff --git a/core/os_windows.odin b/core/os_windows.odin
index b0c0d3e9d..6dfeef42c 100644
--- a/core/os_windows.odin
+++ b/core/os_windows.odin
@@ -3,73 +3,191 @@ import {
 	"fmt.odin";
 }
 
+
 type {
+	Handle    uint;
 	File_Time u64;
+	Error     int;
+}
 
-	File_Handle raw_union {
-		p rawptr;
-		i int;
-	}
+const INVALID_HANDLE Handle = ~(0 as Handle);
 
-	File struct {
-		handle          File_Handle;
-		last_write_time File_Time;
-	}
+const {
+	O_RDONLY   = 0x00000;
+	O_WRONLY   = 0x00001;
+	O_RDWR     = 0x00002;
+	O_CREAT    = 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;
 }
 
-proc open(name string) -> (File, bool) {
-	using win32;
-	var buf [300]byte;
-	var f File;
-	copy(buf[:], name as []byte);
-	f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, nil) as rawptr;
-	var success = f.handle.p != INVALID_HANDLE_VALUE;
-	f.last_write_time = last_write_time(^f);
-	return f, success;
+const {
+	ERROR_NONE                Error = 0;
+	ERROR_FILE_NOT_FOUND      Error = 2;
+	ERROR_PATH_NOT_FOUND      Error = 3;
+	ERROR_ACCESS_DENIED       Error = 5;
+	ERROR_NO_MORE_FILES       Error = 18;
+	ERROR_HANDLE_EOF          Error = 38;
+	ERROR_NETNAME_DELETED     Error = 64;
+	ERROR_FILE_EXISTS         Error = 80;
+	ERROR_BROKEN_PIPE         Error = 109;
+	ERROR_BUFFER_OVERFLOW     Error = 111;
+	ERROR_INSUFFICIENT_BUFFER Error = 122;
+	ERROR_MOD_NOT_FOUND       Error = 126;
+	ERROR_PROC_NOT_FOUND      Error = 127;
+	ERROR_DIR_NOT_EMPTY       Error = 145;
+	ERROR_ALREADY_EXISTS      Error = 183;
+	ERROR_ENVVAR_NOT_FOUND    Error = 203;
+	ERROR_MORE_DATA           Error = 234;
+	ERROR_OPERATION_ABORTED   Error = 995;
+	ERROR_IO_PENDING          Error = 997;
+	ERROR_NOT_FOUND           Error = 1168;
+	ERROR_PRIVILEGE_NOT_HELD  Error = 1314;
+	WSAEACCES                 Error = 10013;
+	WSAECONNRESET             Error = 10054;
+}
+
+const { // Windows reserves errors >= 1<<29 for application use
+	ERROR_FILE_IS_PIPE Error = 1<<29 + iota;
 }
 
-proc create(name string) -> (File, bool) {
+
+
+
+proc open(path string, mode int, perm u32) -> (Handle, Error) {
 	using win32;
+	if path.count == 0 {
+		return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
+	}
+
+	var access u32;
+	match mode & (O_RDONLY|O_WRONLY|O_RDWR) {
+	case O_RDONLY: access = FILE_GENERIC_READ;
+	case O_WRONLY: access = FILE_GENERIC_WRITE;
+	case O_RDWR:   access = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
+	}
+
+	if mode&O_CREAT != 0 {
+		access |= FILE_GENERIC_WRITE;
+	}
+	if mode&O_APPEND != 0 {
+		access &~= FILE_GENERIC_WRITE;
+		access |= FILE_APPEND_DATA;
+	}
+
+	var share_mode = (FILE_SHARE_READ|FILE_SHARE_WRITE) as u32;
+	var sa ^SECURITY_ATTRIBUTES = nil;
+	var sa_inherit = SECURITY_ATTRIBUTES{length = size_of(SECURITY_ATTRIBUTES), inherit_handle = 1};
+	if mode&O_CLOEXEC == 0 {
+		sa = ^sa_inherit;
+	}
+
+	var create_mode u32;
+	match {
+	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
+		create_mode = CREATE_NEW;
+	case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
+		create_mode = CREATE_ALWAYS;
+	case mode&O_CREAT == O_CREAT:
+		create_mode = OPEN_ALWAYS;
+	case mode&O_TRUNC == O_TRUNC:
+		create_mode = TRUNCATE_EXISTING;
+	default:
+		create_mode = OPEN_EXISTING;
+	}
+
 	var buf [300]byte;
-	var f File;
-	copy(buf[:], name as []byte);
-	f.handle.p = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, nil, CREATE_ALWAYS, 0, nil) as rawptr;
-	var success = f.handle.p != INVALID_HANDLE_VALUE;
-	f.last_write_time = last_write_time(^f);
-	return f, success;
+	copy(buf[:], path as []byte);
+
+	var handle = CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil) as Handle;
+	if handle == INVALID_HANDLE {
+		return handle, ERROR_NONE;
+	}
+	var err = GetLastError();
+	return INVALID_HANDLE, err as Error;
 }
 
-proc close(using f ^File) {
-	win32.CloseHandle(handle.p as win32.HANDLE);
+proc close(fd Handle) {
+	win32.CloseHandle(fd as win32.HANDLE);
 }
 
-proc write(using f ^File, buf []byte) -> bool {
+proc write(fd Handle, data []byte) -> (int, Error) {
 	var bytes_written i32;
-	return win32.WriteFile(handle.p as win32.HANDLE, buf.data, buf.count as i32, ^bytes_written, nil) != 0;
+	var e = win32.WriteFile(fd as win32.HANDLE, data.data, data.count as i32, ^bytes_written, nil);
+	if e != 0 {
+		return 0, e as Error;
+	}
+	return bytes_written as int, ERROR_NONE;
+}
+
+proc read(fd Handle, data []byte) -> (int, Error) {
+	var bytes_read i32;
+	var e = win32.ReadFile(fd as win32.HANDLE, data.data, data.count as u32, ^bytes_read, nil);
+	if e != win32.FALSE {
+		var err = win32.GetLastError();
+		return 0, err as Error;
+	}
+	return bytes_read as int, ERROR_NONE;
 }
 
-proc file_has_changed(f ^File) -> bool {
-	var last_write_time = last_write_time(f);
-	if f.last_write_time != last_write_time {
-		f.last_write_time = last_write_time;
-		return true;
+proc seek(fd Handle, offset i64, whence int) -> (i64, Error) {
+	using win32;
+	var w u32;
+	match whence {
+	case 0: w = FILE_BEGIN;
+	case 1: w = FILE_CURRENT;
+	case 2: w = FILE_END;
+	}
+	var hi = (offset>>32) as i32;
+	var lo = offset as i32;
+	var ft = GetFileType(fd as HANDLE);
+	if ft == FILE_TYPE_PIPE {
+		return 0, ERROR_FILE_IS_PIPE;
+	}
+	var dw_ptr = SetFilePointer(fd as HANDLE, lo, ^hi, w);
+	if dw_ptr == INVALID_SET_FILE_POINTER {
+		var err = GetLastError();
+		return 0, err as Error;
 	}
-	return false;
+	return (hi as i64)<<32 + (dw_ptr as i64), ERROR_NONE;
+}
+
+
+// NOTE(bill): Uses startup to initialize it
+var {
+	stdin  = get_std_handle(win32.STD_INPUT_HANDLE);
+	stdout = get_std_handle(win32.STD_OUTPUT_HANDLE);
+	stderr = get_std_handle(win32.STD_ERROR_HANDLE);
+}
+
+proc get_std_handle(h int) -> Handle {
+	var fd = win32.GetStdHandle(h as i32);
+	win32.SetHandleInformation(fd, win32.HANDLE_FLAG_INHERIT, 0);
+	return fd as Handle;
 }
 
 
 
-proc last_write_time(f ^File) -> File_Time {
+
+
+
+proc last_write_time(fd Handle) -> File_Time {
 	var file_info win32.BY_HANDLE_FILE_INFORMATION;
-	win32.GetFileInformationByHandle(f.handle.p as win32.HANDLE, ^file_info);
-	var l = file_info.last_write_time.low_date_time as File_Time;
-	var h = file_info.last_write_time.high_date_time as File_Time;
-	return l | h << 32;
+	win32.GetFileInformationByHandle(fd as win32.HANDLE, ^file_info);
+	var lo = file_info.last_write_time.lo as File_Time;
+	var hi = file_info.last_write_time.hi as File_Time;
+	return lo | hi << 32;
 }
 
 proc last_write_time_by_name(name string) -> File_Time {
 	var last_write_time win32.FILETIME;
-	var data win32.WIN32_FILE_ATTRIBUTE_DATA;
+	var data win32.FILE_ATTRIBUTE_DATA;
 	var buf [1024]byte;
 
 	assert(buf.count > name.count);
@@ -80,46 +198,27 @@ proc last_write_time_by_name(name string) -> File_Time {
 		last_write_time = data.last_write_time;
 	}
 
-	var l = last_write_time.low_date_time as File_Time;
-	var h = last_write_time.high_date_time as File_Time;
+	var l = last_write_time.lo as File_Time;
+	var h = last_write_time.hi as File_Time;
 	return l | h << 32;
 }
 
 
 
-const {
-	FILE_STANDARD_INPUT = iota;
-	FILE_STANDARD_OUTPUT;
-	FILE_STANDARD_ERROR;
-
-	FILE_STANDARD_COUNT;
-}
-// NOTE(bill): Uses startup to initialize it
-var {
-	__std_files = [FILE_STANDARD_COUNT]File{
-		{handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE)  transmute File_Handle },
-		{handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) transmute File_Handle },
-		{handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE)  transmute File_Handle },
-	};
-
-	stdin  = ^__std_files[FILE_STANDARD_INPUT];
-	stdout = ^__std_files[FILE_STANDARD_OUTPUT];
-	stderr = ^__std_files[FILE_STANDARD_ERROR];
-}
 
 
 proc read_entire_file(name string) -> ([]byte, bool) {
 	var buf [300]byte;
 	copy(buf[:], name as []byte);
 
-	var f, file_ok = open(name);
-	if !file_ok {
+	var fd, err = open(name, O_RDONLY, 0);
+	if err != ERROR_NONE {
 		return nil, false;
 	}
-	defer close(^f);
+	defer close(fd);
 
 	var length i64;
-	var file_size_ok = win32.GetFileSizeEx(f.handle.p as win32.HANDLE, ^length) != 0;
+	var file_size_ok = win32.GetFileSizeEx(fd as win32.HANDLE, ^length) != 0;
 	if !file_size_ok {
 		return nil, false;
 	}
@@ -142,7 +241,7 @@ proc read_entire_file(name string) -> ([]byte, bool) {
 			to_read = MAX;
 		}
 
-		win32.ReadFile(f.handle.p as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil);
+		win32.ReadFile(fd as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil);
 		if single_read_length <= 0 {
 			free(data.data);
 			return nil, false;
@@ -178,3 +277,5 @@ proc current_thread_id() -> int {
 	return GetCurrentThreadId() as int;
 }
 
+
+
diff --git a/core/sys/windows.odin b/core/sys/windows.odin
index 90f8bd424..3e22e1c40 100644
--- a/core/sys/windows.odin
+++ b/core/sys/windows.odin
@@ -23,6 +23,9 @@ type {
 const {
 	INVALID_HANDLE_VALUE = (-1 as int) as HANDLE;
 
+	FALSE BOOL = 0;
+	TRUE  BOOL = 1;
+
 	CS_VREDRAW    = 0x0001;
 	CS_HREDRAW    = 0x0002;
 	CS_OWNDC      = 0x0020;
@@ -88,7 +91,7 @@ type {
 	}
 
 	FILETIME struct #ordered {
-		low_date_time, high_date_time u32;
+		lo, hi u32;
 	}
 
 	BY_HANDLE_FILE_INFORMATION struct #ordered {
@@ -104,7 +107,7 @@ type {
 		file_index_low       u32;
 	}
 
-	WIN32_FILE_ATTRIBUTE_DATA struct #ordered {
+	FILE_ATTRIBUTE_DATA struct #ordered {
 		file_attributes  u32;
 		creation_time,
 		last_access_time,
@@ -174,8 +177,8 @@ proc GetCurrentThreadId() -> u32 #foreign #dll_import
 proc CloseHandle (h HANDLE) -> i32 #foreign #dll_import
 proc GetStdHandle(h i32) -> HANDLE #foreign #dll_import
 proc CreateFileA (filename ^u8, desired_access, share_mode u32,
-                     security rawptr,
-                     creation, flags_and_attribs u32, template_file HANDLE) -> HANDLE #foreign #dll_import
+                  security rawptr,
+                  creation, flags_and_attribs u32, template_file HANDLE) -> HANDLE #foreign #dll_import
 proc ReadFile    (h HANDLE, buf rawptr, to_read u32, bytes_read ^i32, overlapped rawptr) -> BOOL #foreign #dll_import
 proc WriteFile   (h HANDLE, buf rawptr, len i32, written_result ^i32, overlapped rawptr) -> i32 #foreign #dll_import
 
@@ -183,6 +186,23 @@ proc GetFileSizeEx             (file_handle HANDLE, file_size ^i64) -> BOOL #for
 proc GetFileAttributesExA      (filename ^u8, info_level_id GET_FILEEX_INFO_LEVELS, file_info rawptr) -> BOOL #foreign #dll_import
 proc GetFileInformationByHandle(file_handle HANDLE, file_info ^BY_HANDLE_FILE_INFORMATION) -> BOOL #foreign #dll_import
 
+proc GetFileType(file_handle HANDLE) -> u32 #foreign #dll_import
+proc SetFilePointer(file_handle HANDLE, distance_to_move i32, distance_to_move_high ^i32, move_method u32) -> u32 #foreign #dll_import
+
+proc SetHandleInformation(obj HANDLE, mask, flags u32) -> BOOL #foreign #dll_import
+
+const {
+	HANDLE_FLAG_INHERIT = 1;
+	HANDLE_FLAG_PROTECT_FROM_CLOSE = 2;
+}
+
+
+const {
+	FILE_BEGIN   = 0;
+	FILE_CURRENT = 1;
+	FILE_END     = 2;
+}
+
 const {
 	FILE_SHARE_READ      = 0x00000001;
 	FILE_SHARE_WRITE     = 0x00000002;
@@ -192,6 +212,8 @@ const {
 	FILE_GENERIC_WRITE   = 0x40000000;
 	FILE_GENERIC_READ    = 0x80000000;
 
+	FILE_APPEND_DATA = 0x0004;
+
 	STD_INPUT_HANDLE  = -10;
 	STD_OUTPUT_HANDLE = -11;
 	STD_ERROR_HANDLE  = -12;
@@ -201,6 +223,27 @@ const {
 	OPEN_EXISTING     = 3;
 	OPEN_ALWAYS       = 4;
 	TRUNCATE_EXISTING = 5;
+
+	FILE_ATTRIBUTE_READONLY             = 0x00000001;
+	FILE_ATTRIBUTE_HIDDEN               = 0x00000002;
+	FILE_ATTRIBUTE_SYSTEM               = 0x00000004;
+	FILE_ATTRIBUTE_DIRECTORY            = 0x00000010;
+	FILE_ATTRIBUTE_ARCHIVE              = 0x00000020;
+	FILE_ATTRIBUTE_DEVICE               = 0x00000040;
+	FILE_ATTRIBUTE_NORMAL               = 0x00000080;
+	FILE_ATTRIBUTE_TEMPORARY            = 0x00000100;
+	FILE_ATTRIBUTE_SPARSE_FILE          = 0x00000200;
+	FILE_ATTRIBUTE_REPARSE_POINT        = 0x00000400;
+	FILE_ATTRIBUTE_COMPRESSED           = 0x00000800;
+	FILE_ATTRIBUTE_OFFLINE              = 0x00001000;
+	FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  = 0x00002000;
+	FILE_ATTRIBUTE_ENCRYPTED            = 0x00004000;
+
+	FILE_TYPE_DISK = 0x0001;
+	FILE_TYPE_CHAR = 0x0002;
+	FILE_TYPE_PIPE = 0x0003;
+
+	INVALID_SET_FILE_POINTER = ~(0 as u32);
 }