ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-10 21:31:37 -07:00
Code Issues Packages Projects Releases Wiki Activity

Block Expressions and give

Browse Source
This commit is contained in:
Ginger Bill
2016-12-30 15:45:10 +00:00
parent d714bece47
commit 23d32f34e5
12 changed files with 605 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/fmt.odin
+8 -8
View File
@@ -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);
}
core/os_windows.odin
+171 -70
View File
@@ -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);
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;
}
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 open(path string, mode int, perm u32) -> (Handle, Error) {
using win32;
if path.count == 0 {
return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
}
File struct {
handle File_Handle;
last_write_time File_Time;
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;
}
}
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;
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 create(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_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;
proc close(fd Handle) {
win32.CloseHandle(fd as win32.HANDLE);
}
proc close(using f ^File) {
win32.CloseHandle(handle.p 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;
}
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;
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 false;
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 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 (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;
}
core/sys/windows.odin
+47 -4
View File
@@ -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);
}