Merge branch 'master' of https://github.com/odin-lang/Odin

.gitignore

@@ -18,7 +18,7 @@ bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
-
+![Cc]ore/[Ll]og/
 # Visual Studio 2015 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
@@ -264,7 +264,6 @@ bin/
 odin
 odin.dSYM
 
-
 # shared collection
 shared/
 

core/log/file_console_logger.odin

@@ -0,0 +1,142 @@
+package log
+
+import "core:fmt";
+import "core:os";
+import "core:time";
+
+Level_Headers := []string{
+    "[DEBUG] --- ",
+    "[INFO ] --- ",
+    "[WARN ] --- ",
+    "[ERROR] --- ",
+    "[FATAL] --- ",
+};
+
+Default_Console_Logger_Opts :: Options{
+    Option.Level, 
+    Option.Terminal_Color,
+    Option.Short_File_Path,
+    Option.Line, 
+    Option.Procedure, 
+} | Full_Timestamp_Opts;
+
+Default_File_Logger_Opts :: Options{
+    Option.Level, 
+    Option.Short_File_Path,
+    Option.Line, 
+    Option.Procedure, 
+} | Full_Timestamp_Opts;
+
+
+File_Console_Logger_Data :: struct {
+    lowest_level: Level,
+    file_handle:  os.Handle,
+    ident : string,
+}
+
+create_file_logger :: proc(h: os.Handle, lowest := Level.Debug, opt := Default_File_Logger_Opts, ident := "") -> Logger {
+    data := new(File_Console_Logger_Data);
+    data.lowest_level = lowest;
+    data.file_handle = h;
+    data.ident = ident;
+    return Logger{file_console_logger_proc, data, opt};
+}
+
+destroy_file_logger ::proc(log : ^Logger) {
+    data := cast(^File_Console_Logger_Data)log.data;
+    if data.file_handle != os.INVALID_HANDLE do os.close(data.file_handle);
+    free(data);
+    log^ = nil_logger();
+}
+ 
+create_console_logger :: proc(lowest := Level.Debug, opt := Default_Console_Logger_Opts, ident := "") -> Logger {
+    data := new(File_Console_Logger_Data);
+    data.lowest_level = lowest;
+    data.file_handle = os.INVALID_HANDLE;
+    data.ident = ident;
+    return Logger{file_console_logger_proc, data, opt};
+}
+
+destroy_console_logger ::proc(log : ^Logger) {
+    free(log.data);
+    log^ = nil_logger();
+}
+
+file_console_logger_proc :: proc(logger_data: rawptr, level: Level, text: string, options: Options, location := #caller_location) {
+    data := cast(^File_Console_Logger_Data)logger_data;
+    if level < data.lowest_level do return;
+
+    h : os.Handle;
+    if(data.file_handle != os.INVALID_HANDLE) do h = data.file_handle;
+    else                                      do h = level <= Level.Error ? os.stdout : os.stderr;
+    backing: [1024]byte; //NOTE(Hoej): 1024 might be too much for a header backing, unless somebody has really long paths.
+    buf := fmt.string_buffer_from_slice(backing[:]);
+    
+    do_level_header(options, level, &buf);
+
+    when time.IS_SUPPORTED {
+        if Full_Timestamp_Opts & options != nil {
+            fmt.sbprint(&buf, "[");
+            t := time.now(); 
+            y, m, d := time.date(t);
+            h, min, s := time.clock(t);
+            if Option.Date in options do fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d);
+            if Option.Time in options do fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s);
+            fmt.sbprint(&buf, "] ");
+        }
+    }
+
+    do_location_header(options, &buf, location);
+
+    if data.ident != "" do fmt.sbprintf(&buf, "[%s] ", data.ident);
+    //TODO(Hoej): When we have better atomics and such, make this thread-safe
+    fmt.fprintf(h, "%s %s\n", fmt.to_string(buf), text); 
+}
+
+do_level_header :: proc(opts : Options, level : Level, buf : ^fmt.String_Buffer) {
+
+    RESET     :: "\x1b[0m";
+    RED       :: "\x1b[31m";
+    YELLOW    :: "\x1b[33m";
+    DARK_GREY :: "\x1b[90m";
+
+    col := RESET;
+    switch level {
+    case Level.Debug              : col = DARK_GREY;
+    case Level.Info               : col = RESET;
+    case Level.Warning            : col = YELLOW;
+    case Level.Error, Level.Fatal : col = RED;
+    }
+
+    if Option.Level in opts {
+        if Option.Terminal_Color in opts do fmt.sbprint(buf, col);
+        fmt.sbprint(buf, Level_Headers[level]);
+        if Option.Terminal_Color in opts do fmt.sbprint(buf, RESET);
+    }
+}
+
+do_location_header :: proc(opts : Options, buf : ^fmt.String_Buffer, location := #caller_location) {
+    if Location_Header_Opts & opts != nil do fmt.sbprint(buf, "["); else do return;
+
+    file := location.file_path;
+    if Option.Short_File_Path in opts {
+        when os.OS == "windows" do delimiter := '\\'; else do delimiter := '/'; 
+        last := 0;
+        for r, i in location.file_path do if r == delimiter do last = i+1;
+        file = location.file_path[last:];
+    }
+
+    if Location_File_Opts & opts != nil do fmt.sbprint(buf, file);
+
+    if Option.Procedure in opts {
+        if Location_File_Opts & opts != nil do fmt.sbprint(buf, ".");
+        fmt.sbprintf(buf, "%s()", location.procedure);
+    }
+
+    if Option.Line in opts {
+        if Location_File_Opts & opts != nil || Option.Procedure in opts do fmt.sbprint(buf, ":");
+        fmt.sbprint(buf, location.line);
+    }
+
+    fmt.sbprint(buf, "] ");
+}

core/log/log.odin

@@ -1,5 +1,8 @@
 package log
 
+import "core:fmt";
+import "core:runtime";
+
 Level :: enum {
 	Debug,
 	Info,
@@ -9,26 +12,79 @@ Level :: enum {
 }
 
 Option :: enum {
-	Level,
-	Time,
-	File,
-	Line,
-	Procedure,
+    Level,
+    Date,
+    Time,
+    Short_File_Path,
+    Long_File_Path,
+    Line,
+    Procedure,
+    Terminal_Color
 }
-Options :: bit_set[Option];
 
-Logger_Proc :: #type proc(data: rawptr, level: Level, ident, text: string, options: Options, location := #caller_location);
+Options :: bit_set[Option];
+Full_Timestamp_Opts :: Options{
+    Option.Date,
+    Option.Time
+};
+Location_Header_Opts :: Options{
+    Option.Short_File_Path,
+    Option.Long_File_Path,
+    Option.Line,
+    Option.Procedure,
+};
+Location_File_Opts :: Options{
+    Option.Short_File_Path,
+    Option.Long_File_Path
+};
+
+Logger_Proc :: #type proc(data: rawptr, level: Level, text: string, options: Options, location := #caller_location);
 
 Logger :: struct {
 	procedure: Logger_Proc,
 	data:      rawptr,
+    options:   Options,
 }
 
+Multi_Logger_Data :: struct {
+    loggers : []Logger,
+}
 
-nil_logger_proc :: proc(data: rawptr, level: Level, ident, text: string, options: Options, location := #caller_location) {
+create_multi_logger :: proc(logs: ..Logger) -> Logger {
+    data := new(Multi_Logger_Data);
+    data.loggers = make([]Logger, len(logs));
+    copy(data.loggers, logs);
+    return Logger{multi_logger_proc, data, nil};
+}
+
+destroy_multi_logger ::proc(log : ^Logger) {
+    free(log.data);
+    log^ = nil_logger();
+}
+
+multi_logger_proc :: proc(logger_data: rawptr, level: Level, text: string, 
+                          options: Options, location := #caller_location) {
+    data := cast(^Multi_Logger_Data)logger_data;
+    if data.loggers == nil || len(data.loggers) == 0 do return;
+    for log in data.loggers do log.procedure(log.data, level, text, log.options, location);
+}
+
+nil_logger_proc :: proc(data: rawptr, level: Level, text: string, options: Options, location := #caller_location) {
 	// Do nothing
 }
 
 nil_logger :: proc() -> Logger {
-	return Logger{nil_logger_proc, nil};
+	return Logger{nil_logger_proc, nil, nil};
 }
+
+debug :: proc(fmt_str : string, args : ..any, location := #caller_location) do logf(level=Level.Debug,   fmt_str=fmt_str, args=args, location=location);
+info  :: proc(fmt_str : string, args : ..any, location := #caller_location) do logf(level=Level.Info,    fmt_str=fmt_str, args=args, location=location);
+warn  :: proc(fmt_str : string, args : ..any, location := #caller_location) do logf(level=Level.Warning, fmt_str=fmt_str, args=args, location=location);
+error :: proc(fmt_str : string, args : ..any, location := #caller_location) do logf(level=Level.Error,   fmt_str=fmt_str, args=args, location=location);
+fatal :: proc(fmt_str : string, args : ..any, location := #caller_location) do logf(level=Level.Fatal,   fmt_str=fmt_str, args=args, location=location);
+
+logf :: proc(level : Level, fmt_str : string, args : ..any, location := #caller_location) {
+    logger := context.logger;
+    str := len(args) > 0 ? fmt.tprintf(fmt_str, ..args) : fmt.tprint(fmt_str); //NOTE(Hoej): While tprint isn't thread-safe, no logging is.
+    logger.procedure(logger.data, level, str, logger.options, location);
+}

core/os/os_linux.odin

@@ -125,29 +125,49 @@ X_OK :: 1; // Test for execute permission
 W_OK :: 2; // Test for write permission
 R_OK :: 4; // Test for read permission
 
+TimeSpec :: struct {
+	tv_sec  : i64,  /* seconds */
+	tv_nsec : i64,  /* nanoseconds */
+};
+
+CLOCK_REALTIME           :: 0;
+CLOCK_MONOTONIC          :: 1;
+CLOCK_PROCESS_CPUTIME_ID :: 2;
+CLOCK_THREAD_CPUTIME_ID  :: 3;
+CLOCK_MONOTONIC_RAW      :: 4;
+CLOCK_REALTIME_COARSE    :: 5;
+CLOCK_MONOTONIC_COARSE   :: 6;
+CLOCK_BOOTTIME           :: 7;
+CLOCK_REALTIME_ALARM     :: 8;
+CLOCK_BOOTTIME_ALARM     :: 9;
+
 foreign libc {
-	@(link_name="open")    _unix_open    :: proc(path: cstring, mode: int) -> Handle ---;
-	@(link_name="close")   _unix_close   :: proc(fd: Handle) -> i32 ---;
-	@(link_name="read")    _unix_read    :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
-	@(link_name="write")   _unix_write   :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
-	@(link_name="lseek64") _unix_seek    :: proc(fd: Handle, offset: i64, whence: i32) -> i64 ---;
-	@(link_name="gettid")  _unix_gettid  :: proc() -> u64 ---;
-	@(link_name="stat")    _unix_stat    :: proc(path: cstring, stat: ^Stat) -> i32 ---;
-	@(link_name="access")  _unix_access  :: proc(path: cstring, mask: int) -> i32 ---;
+	@(link_name="open")             _unix_open          :: proc(path: cstring, mode: int) -> Handle ---;
+	@(link_name="close")            _unix_close         :: proc(fd: Handle) -> i32 ---;
+	@(link_name="read")             _unix_read          :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="write")            _unix_write         :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="lseek64")          _unix_seek          :: proc(fd: Handle, offset: i64, whence: i32) -> i64 ---;
+	@(link_name="gettid")           _unix_gettid        :: proc() -> u64 ---;
+	@(link_name="stat")             _unix_stat          :: proc(path: cstring, stat: ^Stat) -> i32 ---;
+	@(link_name="access")           _unix_access        :: proc(path: cstring, mask: int) -> i32 ---;
 
-	@(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="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="exit")    _unix_exit    :: proc(status: int) -> ! ---;
+	@(link_name="clock_gettime")    _unix_clock_gettime :: proc(clock_id: u64, timespec: ^TimeSpec) ---;
+	@(link_name="nanosleep")        _unix_nanosleep     :: proc(requested: ^TimeSpec, remaining: ^TimeSpec) -> int ---;
+	@(link_name="sleep")            _unix_sleep         :: proc(seconds: u64) -> 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 ---;
 }
 
 // TODO(zangent): Change this to just `open` when Bill fixes overloading.
@@ -245,6 +265,25 @@ exit :: proc(code: int) -> ! {
 	_unix_exit(code);
 }
 
+clock_gettime :: proc(clock_id: u64) -> TimeSpec {
+	ts : TimeSpec;
+	_unix_clock_gettime(clock_id, &ts);
+	return ts;
+}
+
+sleep :: proc(seconds: u64) -> int {
+
+	return _unix_sleep(seconds);
+}
+
+nanosleep :: proc(nanoseconds: i64) -> int {
+	assert(nanoseconds <= 999999999);
+	requested, remaining : TimeSpec;
+	requested = TimeSpec{tv_nsec = nanoseconds};
+
+	return _unix_nanosleep(&requested, &remaining);
+}
+
 current_thread_id :: proc "contextless" () -> int {
 	// return int(_unix_gettid());
 	return 0;

core/time/time_linux.odin

@@ -0,0 +1,45 @@
+package time
+
+import "core:os";
+import "core:fmt";
+
+// NOTE(Jeroen): The times returned are in UTC
+IS_SUPPORTED :: true;
+
+now :: proc() -> Time {
+
+    time_spec_now := os.clock_gettime(os.CLOCK_REALTIME);
+    ns := time_spec_now.tv_sec * 1e9 + time_spec_now.tv_nsec;
+    return Time{_nsec=ns};
+}
+
+boot_time :: proc() -> Time {
+
+    ts_now := os.clock_gettime(os.CLOCK_REALTIME);
+    ts_boottime := os.clock_gettime(os.CLOCK_BOOTTIME);
+
+    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 := os.clock_gettime(os.CLOCK_BOOTTIME);
+    return f64(ts_boottime.tv_sec) + f64(ts_boottime.tv_nsec) / 1e9;
+}
+
+sleep :: proc(d: Duration) {
+
+    ds := duration_seconds(d);
+    seconds := u64(ds);
+    nanoseconds := i64((ds - f64(seconds)) * 1e9);
+
+    if seconds > 0 do os.sleep(seconds);
+    if nanoseconds > 0 do os.nanosleep(nanoseconds);
+}
+
+nanosleep :: proc(d: Duration) {
+    // NOTE(Jeroen): os.nanosleep returns -1 on failure, 0 on success
+    // duration needs to be [0, 999999999] nanoseconds.
+    os.nanosleep(i64(d));
+}

core/time/time_osx.odin

@@ -0,0 +1,3 @@
+package time
+
+IS_SUPPORTED :: false;

core/time/time_windows.odin

@@ -2,6 +2,8 @@ package time
 
 import "core:sys/win32"
 
+IS_SUPPORTED :: true;
+
 now :: proc() -> Time {
 	file_time: win32.Filetime;
 
@@ -18,5 +20,5 @@ now :: proc() -> Time {
 
 
 sleep :: proc(d: Duration) {
-	win32.Sleep(u32(d/Millisecond));
+	win32.sleep(i32(d/Millisecond));
 }