ilimination of system code, removal of x-watcher and replacement of it by dmon, fixes in audio code, dynamic asset reload

CMakeLists.txt

@@ -64,18 +64,6 @@ set(PHYSFS_ARCHIVE_7Z OFF CACHE INTERNAL "")
 add_subdirectory(third-party/physfs ${CMAKE_CURRENT_BINARY_DIR}/third-party/physfs SYSTEM)
 add_subdirectory(third-party/libxm ${CMAKE_CURRENT_BINARY_DIR}/third-party/libxm SYSTEM)
 
-
-if(LINUX)
-        set(SYSTEM_SOURCE_FILES
-                src/system/linux/twn_timer.c
-                $<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_linux_game_object.c>)
-elseif(WIN32)
-        set(SYSTEM_SOURCE_FILES
-                $<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_win32_game_object.c>)
-else()
-        set(SYSTEM_SOURCE_FILES)
-endif()
-
 if(EMSCRIPTEN)
         set(TWN_RENDERING_API WEBGL1)
 else()
@@ -96,15 +84,19 @@ set(TWN_THIRD_PARTY_SOURCE_FILES
 
 set(TWN_NONOPT_SOURCE_FILES
         src/twn_stb.c
-        src/twn_loop.c
         src/twn_main.c
+
         src/twn_context.c       include/twn_context.h
         src/twn_audio.c         include/twn_audio.h
         src/twn_util.c          include/twn_util.h
         src/twn_input.c         include/twn_input.h
+
+        src/twn_loop.c          src/twn_loop_c.h
         src/twn_camera.c        src/twn_camera_c.h
         src/twn_textures.c      src/twn_textures_c.h
         src/twn_filewatch.c     src/twn_filewatch_c.h
+        src/twn_filewatch.c     src/twn_filewatch_c.h
+        src/twn_timer.c         src/twn_timer_c.h
 
         src/rendering/twn_draw.c src/rendering/twn_draw_c.h
         src/rendering/twn_quads.c
@@ -114,12 +106,14 @@ set(TWN_NONOPT_SOURCE_FILES
         src/rendering/twn_triangles.c
         src/rendering/twn_billboards.c
         src/rendering/twn_circles.c
-        src/rendering/twn_skybox.c)
+        src/rendering/twn_skybox.c
+)
 
 set(TWN_SOURCE_FILES
         $<IF:$<BOOL:${TWN_USE_AMALGAM}>,src/twn_amalgam.c src/twn_stb.c,${TWN_NONOPT_SOURCE_FILES}>
 
         # for dynamic load based solution main is compiled in a separate target
+        $<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_dynamic_game_object.c>
         $<$<NOT:$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>>:src/twn_main.c
                                                     src/game_object/twn_static_game_object.c>
 
@@ -258,7 +252,7 @@ function(include_deps target)
                 third-party/physfs/extras
                 third-party/libxm/include
                 third-party/stb
-                third-party/x-watcher
+                third-party/dmon
                 third-party/tomlc99
                 $<$<NOT:$<BOOL:${EMSCRIPTEN}>>:third-party/glad/include>)
 

src/game_object/twn_dynamic_game_object.c

@@ -0,0 +1,98 @@
+#include "twn_game_object_c.h"
+#include "twn_engine_context_c.h"
+#include "twn_filewatch_c.h"
+#include "twn_util_c.h"
+#include "twn_util.h"
+#include "twn_loop_c.h"
+
+#include <SDL2/SDL.h>
+
+#ifdef _WIN32
+#define GAME_OBJECT_NAME "libgame.dll"
+#else
+#define GAME_OBJECT_NAME "libgame.so"
+#endif
+
+static void (*game_tick_callback)(void);
+static void (*game_end_callback)(void);
+
+static void *handle = NULL;
+
+
+static void game_object_file_action(char const *path, enum FilewatchAction action) {
+    (void)action;
+
+    if (action == FILEWATCH_ACTION_FILE_DELETED)
+        return;
+
+    if (handle) {
+        SDL_UnloadObject(handle);
+        game_tick_callback = NULL;
+        game_end_callback = NULL;
+        handle = NULL;
+    }
+
+    handle = SDL_LoadObject(path);
+    if (!handle) {
+        CRY_SDL("Hot Reload Error: Cannot open game code shared object");
+        return;
+    }
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+
+    game_tick_callback = (void (*)(void))SDL_LoadFunction(handle, "game_tick");
+    if (!game_tick_callback) {
+        CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
+        goto ERR_GETTING_PROC;
+    }
+
+    game_end_callback = (void (*)(void))SDL_LoadFunction(handle, "game_end");
+    if (!game_end_callback) {
+        CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
+        goto ERR_GETTING_PROC;
+    }
+
+#pragma GCC diagnostic pop
+
+    if (fabsf(0.0f - ctx.game.frame_number) > 0.00001f) {
+        log_info("Game object was reloaded\n");
+        reset_state();
+    }
+
+    return;
+
+ERR_GETTING_PROC:
+    SDL_UnloadObject(handle);
+    handle = NULL;
+    game_tick_callback = NULL;
+    game_end_callback = NULL;
+}
+
+
+void game_object_load(void) {
+    static bool filewatch_attached;
+    if (!filewatch_attached) {
+        char *game_object_path;
+        SDL_asprintf(&game_object_path, "%s%s", ctx.base_dir, GAME_OBJECT_NAME);
+        filewatch_add_file(game_object_path, game_object_file_action);
+        game_object_file_action(game_object_path, FILEWATCH_ACTION_FILE_MODIFIED);
+        SDL_free(game_object_path);
+        filewatch_attached = true;
+    }
+}
+
+
+void game_object_unload(void) {
+    game_end_callback();
+    /* needs to be closed otherwise symbols aren't resolved again */
+    SDL_UnloadObject(handle);
+    game_tick_callback = NULL;
+    game_end_callback = NULL;
+    handle = NULL;
+}
+
+
+void game_object_tick(void) {
+    game_tick_callback();
+}

src/game_object/twn_linux_game_object.c

@@ -1,161 +0,0 @@
-#include "twn_game_object_c.h"
-#include "twn_engine_context_c.h"
-#include "twn_util_c.h"
-#include "twn_util.h"
-
-#include <x-watcher.h>
-#include <SDL2/SDL.h>
-
-#include <dlfcn.h>
-
-
-#define GAME_OBJECT_NAME "libgame.so"
-#define MODIFIED_TICKS_MERGED 10
-
-
-static void (*game_tick_callback)(void);
-static void (*game_end_callback)(void);
-
-static x_watcher *watcher;
-static void *handle = NULL;
-
-static float last_tick_modified;
-static bool loaded_after_modification = true;
-static SDL_mutex *lock;
-
-static char *game_object_path;
-
-static void load_game_object(void) {
-    /* needs to be closed otherwise symbols aren't resolved again */
-    if (handle) {
-        dlclose(handle);
-        handle = NULL;
-        game_tick_callback = NULL;
-        game_end_callback = NULL;
-    }
-
-    void *new_handle = dlopen(game_object_path, RTLD_LAZY);
-    if (!new_handle) {
-        log_critical("Hot Reload Error: Cannot open game code shared object (%s)", dlerror());
-        goto ERR_OPENING_SO;
-    }
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
-    game_tick_callback = (void (*)(void))dlsym(new_handle, "game_tick");
-    if (!game_tick_callback) {
-        CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
-        goto ERR_GETTING_PROC;
-    }
-
-    game_end_callback = (void (*)(void))dlsym(new_handle, "game_end");
-    if (!game_end_callback) {
-        CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
-        goto ERR_GETTING_PROC;
-    }
-
-#pragma GCC diagnostic pop
-
-    handle = new_handle;
-
-    if (fabsf(0.0f - ctx.game.frame_number) > 0.00001f)
-        log_info("Game object was reloaded\n");
-
-    return;
-
-ERR_GETTING_PROC:
-    dlclose(new_handle);
-    game_tick_callback = NULL;
-    game_end_callback = NULL;
-
-ERR_OPENING_SO:
-    SDL_UnlockMutex(lock);
-
-}
-
-static void watcher_callback(XWATCHER_FILE_EVENT event,
-                             const char *path,
-                             int context,
-                             void *data)
-{
-    (void)context;
-    (void)path;
-    (void)data;
-
-    switch(event) {
-        case XWATCHER_FILE_CREATED:
-        case XWATCHER_FILE_MODIFIED:
-            SDL_LockMutex(lock);
-            last_tick_modified = ctx.game.frame_number;
-            loaded_after_modification = false;
-            SDL_UnlockMutex(lock);
-            break;
-
-        case XWATCHER_FILE_UNSPECIFIED:
-        case XWATCHER_FILE_REMOVED:
-        case XWATCHER_FILE_OPENED:
-        case XWATCHER_FILE_ATTRIBUTES_CHANGED:
-        case XWATCHER_FILE_NONE:
-        case XWATCHER_FILE_RENAMED:
-        default:
-            break;
-    }
-}
-
-
-void game_object_load(void) {
-    SDL_asprintf(&game_object_path, "%s%s", ctx.base_dir, GAME_OBJECT_NAME);
-
-    watcher = xWatcher_create();
-
-    xWatcher_reference dir;
-    dir.path = game_object_path;
-    dir.callback_func = watcher_callback;
-
-    xWatcher_appendFile(watcher, &dir);
-    xWatcher_start(watcher);
-
-    lock = SDL_CreateMutex();
-    load_game_object();
-}
-
-
-void game_object_unload(void) {
-    game_end_callback();
-    xWatcher_destroy(watcher);
-    watcher = NULL;
-    dlclose(handle);
-    handle = NULL;
-    game_tick_callback = NULL;
-    game_end_callback = NULL;
-    SDL_DestroyMutex(lock);
-}
-
-
-bool game_object_try_reloading(void) {
-    bool result = false;
-
-    /* only load the modified library after some time, as compilers make a lot of modifications */
-    SDL_LockMutex(lock);
-    if (ctx.game.frame_number - last_tick_modified > MODIFIED_TICKS_MERGED &&
-            !loaded_after_modification) {
-        load_game_object();
-        loaded_after_modification = true;
-        result = true;
-    } SDL_UnlockMutex(lock);
-
-    return result;
-}
-
-
-void game_object_tick(void) {
-    game_tick_callback();
-}
-
-void *game_object_get_game_tick_address(void) {
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wpedantic"
-    return (void *)&game_tick_callback;
-#pragma GCC diagnostic pop
-}

src/game_object/twn_static_game_object.c

@@ -5,24 +5,10 @@
 void game_object_load(void) {
 }
 
-
 void game_object_unload(void) {
     game_end();
 }
 
-
-bool game_object_try_reloading(void) {
-    return false;
-}
-
-
 void game_object_tick(void) {
     game_tick();
 }
-
-void *game_object_get_game_tick_address(void) {
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wpedantic"
-    return (void *)&game_tick;
-#pragma GCC diagnostic pop
-}

src/game_object/twn_win32_game_object.c

@@ -1,90 +0,0 @@
-#include "twn_game_object_c.h"
-#include "twn_engine_context_c.h"
-#include "twn_util_c.h"
-#include "twn_util.h"
-
-#include <errhandlingapi.h>
-#include <libloaderapi.h>
-
-
-#define GAME_OBJECT_PATH "libgame.dll"
-
-
-static void (*game_tick_callback)(void);
-static void (*game_end_callback)(void);
-
-static void *handle = NULL;
-
-
-static void load_game_object(void) {
-    /* needs to be closed otherwise symbols aren't resolved again */
-    if (handle) {
-        FreeLibrary(handle);
-        handle = NULL;
-        game_tick_callback = NULL;
-        game_end_callback = NULL;
-    }
-
-    void *new_handle = LoadLibraryA(GAME_OBJECT_PATH);
-    if (!new_handle) {
-        log_critical("Hot Reload Error: Cannot open game code shared object (%s)", GetLastError());
-        goto ERR_OPENING_SO;
-    }
-
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wpedantic"
-
-    game_tick_callback = (void (*)(void))GetProcAddress(new_handle, "game_tick");
-    if (!game_tick_callback) {
-        CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
-        goto ERR_GETTING_PROC;
-    }
-
-    game_end_callback = (void (*)(void))GetProcAddress(new_handle, "game_end");
-    if (!game_end_callback) {
-        CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
-        goto ERR_GETTING_PROC;
-    }
-
-#pragma GCC diagnostic pop
-
-    handle = new_handle;
-
-    if (ctx.game.frame_number != 0)
-        log_info("Game object was reloaded\n");
-
-    return;
-
-ERR_GETTING_PROC:
-    FreeLibrary(new_handle);
-    game_tick_callback = NULL;
-    game_end_callback = NULL;
-
-ERR_OPENING_SO:
-    die_abruptly();
-}
-
-
-void game_object_load(void) {
-    load_game_object();
-}
-
-
-void game_object_unload(void) {
-    game_end_callback();
-    FreeLibrary(handle);
-    handle = NULL;
-    game_tick_callback = NULL;
-    game_end_callback = NULL;
-}
-
-
-/* doesn't support reloading because of problems with file watching */
-bool game_object_try_reloading(void) {
-    return false;
-}
-
-
-void game_object_tick(void) {
-    game_tick_callback();
-}

src/system/linux/twn_timer.c

@@ -1,76 +0,0 @@
-#include "../twn_timer.h"
-#include "twn_engine_context_c.h"
-
-#include <SDL_messagebox.h>
-
-#include <signal.h>
-#include <stdint.h>
-#include <time.h>
-#include <unistd.h>
-#include <stdbool.h>
-
-
-static timer_t            timerid;
-static struct sigaction   sa;
-static struct sigevent    sev;
-
-static bool created;
-static uint64_t used_milliseconds_to_expire;
-
-#define SANITY_TIMER_MESSAGE_FMT "Game tick exeeded its allocated time (%lu milliseconds), application is closing"
-
-/* stop application */
-static void sanity_timer_handler(int sig, siginfo_t *si, void *uc) {
-    (void)uc; (void)sig; (void)si;
-    size_t text_str_len = snprintf(NULL, 0, SANITY_TIMER_MESSAGE_FMT, used_milliseconds_to_expire) + 1;
-    char *text_str = SDL_malloc(text_str_len);
-    snprintf(text_str, text_str_len, SANITY_TIMER_MESSAGE_FMT, used_milliseconds_to_expire);
-    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "sanity timer", text_str, ctx.window);
-    SDL_free(text_str);
-    raise(SIGKILL);
-}
-
-
-bool start_sanity_timer(uint64_t milliseconds_to_expire) {
-    if (!created) {
-        sa.sa_flags = SA_SIGINFO;
-        sa.sa_sigaction = sanity_timer_handler;
-        sigemptyset(&sa.sa_mask);
-        if (sigaction(SIGRTMIN, &sa, NULL) == -1)
-            goto ERR_SIGACTION;
-
-       sev.sigev_notify = SIGEV_SIGNAL;
-       sev.sigev_signo = SIGRTMIN;
-       sev.sigev_value.sival_ptr = &timerid;
-       if (timer_create(CLOCK_MONOTONIC, &sev, &timerid) == -1)
-            goto ERR_TIMERCREATE;
-
-        created = true;
-
-    ERR_TIMERCREATE:
-    // ERR_SIGPROCMASK:
-    ERR_SIGACTION:
-        return false;
-    }
-
-    struct itimerspec its = {0};
-    its.it_value.tv_sec = milliseconds_to_expire / 1000;
-    its.it_value.tv_nsec = (milliseconds_to_expire * 1000000 % 1000000000);
-    if (timer_settime(timerid, 0, &its, NULL) == -1)
-        return false;
-
-    used_milliseconds_to_expire = milliseconds_to_expire;
-
-    return true;
-}
-
-
-bool end_sanity_timer(void) {
-    struct itimerspec its = {0};
-    its.it_value.tv_sec = 0;
-    its.it_value.tv_nsec = 0;
-    if (timer_settime(timerid, 0, &its, NULL) == -1)
-        return false;
-
-    return false;
-}

src/twn_amalgam.c

@@ -10,6 +10,7 @@
 #include "twn_textures.c"
 #include "twn_util.c"
 #include "twn_filewatch.c"
+#include "twn_timer.c"
 
 #include "rendering/twn_circles.c"
 #include "rendering/twn_draw.c"

src/twn_audio.c

@@ -29,6 +29,7 @@ static const uint8_t audio_exts_len[AUDIO_FILE_TYPE_COUNT] = {
 };
 
 /* TODO: allow for vectorization and packed vectors (alignment care and alike) */
+/* TODO: free channel name duplicates */
 
 /* TODO: count frames without use, free the memory when threshold is met */
 /* TODO: count repeated usages for sound effect cases with rendering to ram? */
@@ -212,6 +213,7 @@ static void free_audio_channel(AudioChannel channel) {
         SDL_assert_always(false);
         break;
     }
+    SDL_free(channel.path);
 }
 
 
@@ -283,32 +285,42 @@ void audio_play(const char *path,
         /* create a channel if it doesn't exist */
         if (!pair) {
             AudioFileType const file_type = infer_audio_file_type(path);
-            AudioChannel new_channel = {
+            AudioChannel const new_channel = {
                 .file_type = file_type,
                 .context = init_audio_context(path, file_type),
-                .path = path,
+                .path = SDL_strdup(path),
-                .name = channel,
                 .repeat = repeat,
                 .volume = volume,
                 .panning = panning,
             };
-            shput(ctx.audio_channels, channel, new_channel);
+            shput(ctx.audio_channels, SDL_strdup(channel), new_channel);
             pair = shgetp_null(ctx.audio_channels, channel);
         }
 
-        /* TODO: destroy and create new context when channel is reused for different file */
+        /* repeat if so */
-
+        else if (strcmp(pair->value.path, path) == 0)
-        /* works for both restarts and new audio */
-        if (strcmp(pair->value.path, path) == 0)
             repeat_audio(&pair->value);
+        else {
+            /* start anew, reuse channel name */
+            free_audio_channel(pair->value);
+            AudioFileType const file_type = infer_audio_file_type(path);
+            AudioChannel const new_channel = {
+                .file_type = file_type,
+                .context = init_audio_context(path, file_type),
+                .path = SDL_strdup(path),
+                .repeat = repeat,
+                .volume = volume,
+                .panning = panning,
+            };
+            pair->value = new_channel;
+        }
     } else {
         /* audio without channel plays without repeat and ability to change parameters over its course, nor stop it */
         AudioFileType const file_type = infer_audio_file_type(path);
         AudioChannel new_channel = {
             .file_type = file_type,
             .context = init_audio_context(path, file_type),
-            .path = path,
+            .path = SDL_strdup(path),
-            .name = NULL,
             .repeat = false,
             .volume = volume,
             .panning = panning,
@@ -506,12 +518,12 @@ static void audio_sample_and_mixin_channel(AudioChannel *channel,
 }
 
 
-static void sanity_check_channel(const AudioChannel *channel) {
+static void sanity_check_channel(const AudioChannelItem channel) {
-    if (channel->volume < 0.0f || channel->volume > 1.0f)
+    if (channel.value.volume < 0.0f || channel.value.volume > 1.0f)
-        log_warn("Volume argument is out of range for channel (%s)", channel->name);
+        log_warn("Volume argument is out of range for channel (%s)", channel.key ? channel.key : "unnamed");
 
-    if (channel->panning < -1.0f || channel->panning > 1.0f)
+    if (channel.value.panning < -1.0f || channel.value.panning > 1.0f)
-        log_warn("Panning argument is out of range for channel (%s)", channel->name);
+        log_warn("Panning argument is out of range for channel (%s)", channel.key ? channel.key : "unnamed");
 }
 
 
@@ -523,7 +535,7 @@ void audio_callback(void *userdata, uint8_t *stream, int len) {
 
     size_t const audio_channels_len = shlen(ctx.audio_channels);
     for (size_t i = 0; i < audio_channels_len; ++i) {
-        sanity_check_channel(&ctx.audio_channels[i].value);
+        sanity_check_channel(ctx.audio_channels[i]);
         audio_sample_and_mixin_channel(&ctx.audio_channels[i].value,
                                        stream, len,
                                        i == audio_channels_len - 1);
@@ -531,7 +543,7 @@ void audio_callback(void *userdata, uint8_t *stream, int len) {
 
     size_t const unnamed_audio_channels_len = shlen(ctx.unnamed_audio_channels);
     for (size_t i = 0; i < unnamed_audio_channels_len; ++i) {
-        sanity_check_channel(&ctx.unnamed_audio_channels[i]);
+        sanity_check_channel((AudioChannelItem){NULL, ctx.unnamed_audio_channels[i]});
         audio_sample_and_mixin_channel(&ctx.unnamed_audio_channels[i],
                                        stream, len,
                                        i == unnamed_audio_channels_len - 1);

src/twn_audio_c.h

@@ -48,8 +48,7 @@ union AudioContext {
 typedef struct AudioChannel {
     AudioFileType file_type;
     union AudioContext context; /* interpreted by `file_type` value */
-    const char *path;
+    char *path;
-    const char *name;
     bool repeat;
     float volume;
     float panning;

src/twn_filewatch.c

@@ -2,169 +2,111 @@
 #include "twn_util.h"
 #include "twn_engine_context_c.h"
 
-#include <x-watcher.h>
+#define DMON_IMPL
+#include <dmon.h>
 #include <stb_ds.h>
 #include <SDL2/SDL.h>
 
 
-struct FilewatchPathToCallback {
+struct FilewatchEntry {
     char *path;
     FileatchCallback callback;
-    float tick_last_reported;
+    enum FilewatchAction *actions_pending;
-    enum FilewatchAction action_pending : 3;
-    bool action_processed : 1;
 };
 
-static struct FilewatchPathToCallback *filewatch_directories;
+static struct FilewatchEntry *filewatch_directories;
-static struct FilewatchPathToCallback *filewatch_files;
+static struct FilewatchEntry *filewatch_files;
 /* note: it gets rebuilt on every addition, as api is such */
 /* TODO: test whether it's possible to miss on update while watcher is being rebuilt */
 /*       we might have to enumerate things, just to make sure */
-static x_watcher *filewatcher;
 static SDL_mutex *filewatcher_lock;
+static bool filewatcher_initialized;
 
-/* TODO: check whether path and p->path match? */
+static void filewatch_callback(dmon_watch_id watch_id,
-static void filewatch_dispatch(XWATCHER_FILE_EVENT event,
+                               dmon_action action,
-                               const char *path,
+                               const char* rootdir,
-                               int context,
+                               const char* filepath,
-                               void *additional_data
+                               const char* oldfilepath,
-) {
+                               void* user)
-    (void)additional_data; (void)path;
+{
+    enum FilewatchAction faction;
 
-    enum FilewatchAction action;
+    switch (action) {
-
+    case DMON_ACTION_CREATE:
-    switch (event) {
+        faction = FILEWATCH_ACTION_FILE_CREATED;
-    case XWATCHER_FILE_CREATED:
-        action = FILEWATCH_ACTION_FILE_CREATED;
         break;
-    case XWATCHER_FILE_REMOVED:
+    case DMON_ACTION_DELETE:
-        action = FILEWATCH_ACTION_FILE_DELETED;
+        faction = FILEWATCH_ACTION_FILE_DELETED;
         break;
-    case XWATCHER_FILE_MODIFIED:
+    case DMON_ACTION_MODIFY:
-        action = FILEWATCH_ACTION_FILE_MODIFIED;
+        faction = FILEWATCH_ACTION_FILE_MODIFIED;
         break;
-    case XWATCHER_FILE_NONE:
-    case XWATCHER_FILE_OPENED:
-    case XWATCHER_FILE_RENAMED:
-    case XWATCHER_FILE_UNSPECIFIED:
-    case XWATCHER_FILE_ATTRIBUTES_CHANGED:
     default:
         return;
     }
 
     SDL_LockMutex(filewatcher_lock);
 
-    struct FilewatchPathToCallback *p;
+    intptr_t const context = (intptr_t)user;
+    struct FilewatchEntry *p;
 
     if (context < 0)
         p = &filewatch_files[-context - 1];
     else
         p = &filewatch_directories[context];
 
-    p->tick_last_reported = ctx.game.frame_number;
+    arrpush(p->actions_pending, faction);
-    p->action_processed = false;
-    p->action_pending = action;
-
     SDL_UnlockMutex(filewatcher_lock);
 }
 
 
-static bool filewatcher_rebuild(void) {
+bool filewatch_add_directory(char const *dir, FileatchCallback callback) {
-    if (filewatcher)
-        xWatcher_destroy(filewatcher);
-
-    filewatcher = xWatcher_create();
-    if (!filewatcher) {
-        log_warn("Error creating xWatcher instance, no file watching is done");
-        return false;
-    }
-
-    int const filewatch_directories_len = arrlen(filewatch_directories);
-    for (int i = 0; i < filewatch_directories_len; ++i) {
-        xWatcher_reference ref = {
-            .path = filewatch_directories[i].path,
-            .callback_func = filewatch_dispatch,
-            .context = i,
-        };
-        if (!xWatcher_appendDir(filewatcher, &ref))
-            log_warn("Error watching dir contents: %s", filewatch_directories[i].path);
-    }
-
-    int const filewatch_files_len = arrlen(filewatch_files);
-    for (int i = 0; i < filewatch_files_len; ++i) {
-        xWatcher_reference ref = {
-            .path = filewatch_files[i].path,
-            .callback_func = filewatch_dispatch,
-            .context = -(i + 1), /* in negative range to allow inrefence */
-        };
-        if (!xWatcher_appendDir(filewatcher, &ref))
-            log_warn("Error watching file: %s", filewatch_files[i].path);
-    }
-
-    if (!xWatcher_start(filewatcher)) {
-        log_warn("Error creating xWatcher instance, no file watching is done");
-        xWatcher_destroy(filewatcher);
-        filewatcher = NULL;
-        return false;
-    }
-
-    return true;
-}
-
-
-bool filewatch_add_directory(char *dir, FileatchCallback callback) {
     SDL_assert(dir && callback);
 
-    struct FilewatchPathToCallback const w = {
+    if (!filewatcher_initialized) {
+        dmon_init();
+        filewatcher_initialized = true;
+    }
+
+    struct FilewatchEntry const w = {
         .callback = callback,
-        .path = SDL_strdup(dir),
+        .path = SDL_strdup(dir), /* TODO: free */
-        .action_processed = true,
-        .tick_last_reported = ctx.game.frame_number,
     };
     arrpush(filewatch_directories, w);
-
+    dmon_watch(dir, filewatch_callback, DMON_WATCHFLAGS_RECURSIVE, (void *)(intptr_t)(arrlen(filewatch_directories) - 1));
-    return filewatcher_rebuild();
 }
 
 
-bool filewatch_add_file(char *filepath, FileatchCallback callback) {
+bool filewatch_add_file(char const *filepath, FileatchCallback callback) {
     SDL_assert(filepath && callback);
 
-    struct FilewatchPathToCallback const f = {
+    if (!filewatcher_initialized) {
+        dmon_init();
+        filewatcher_initialized = true;
+    }
+
+    struct FilewatchEntry const f = {
         .callback = callback,
-        .path = SDL_strdup(filepath),
+        .path = SDL_strdup(filepath), /* TODO: free */
-        .action_processed = true,
-        .tick_last_reported = ctx.game.frame_number,
     };
     arrpush(filewatch_files, f);
-
+    dmon_watch("./", filewatch_callback, 0, (void *)(intptr_t)(-arrlen(filewatch_files)));
-    return filewatcher_rebuild();
 }
 
 
 void filewatch_poll(void) {
     SDL_LockMutex(filewatcher_lock);
 
-    int const filewatch_directories_len = arrlen(filewatch_directories);
+    for (int i = 0; i < arrlen(filewatch_directories); ++i) {
-    for (int i = 0; i < filewatch_directories_len; ++i) {
+        for (int u = 0; u < arrlen(filewatch_directories[i].actions_pending); ++u)
-        if (!filewatch_directories[i].action_processed
+            filewatch_directories[i].callback(filewatch_directories[i].path, filewatch_directories[i].actions_pending[u]);
-                && (ctx.game.frame_number - filewatch_directories[i].tick_last_reported > FILEWATCH_MODIFIED_TICKS_MERGED)) {
+        arrfree(filewatch_directories[i].actions_pending);
-            SDL_assert(filewatch_directories[i].action_pending != FILEWATCH_ACTION_FILE_NONE);
-            filewatch_directories[i].callback(filewatch_directories[i].path, filewatch_directories[i].action_pending);
-            filewatch_directories[i].action_pending = FILEWATCH_ACTION_FILE_NONE;
-            filewatch_directories[i].action_processed = true;
-        }
     }
 
-    int const filewatch_files_len = arrlen(filewatch_files);
+    for (int i = 0; i < arrlen(filewatch_files); ++i) {
-    for (int i = 0; i < filewatch_files_len; ++i) {
+        for (int u = 0; u < arrlen(filewatch_files[i].actions_pending); ++u)
-        if (!filewatch_files[i].action_processed
+            filewatch_files[i].callback(filewatch_files[i].path, filewatch_files[i].actions_pending[u]);
-                && (ctx.game.frame_number - filewatch_files[i].tick_last_reported > FILEWATCH_MODIFIED_TICKS_MERGED)) {
+        arrfree(filewatch_files[i].actions_pending);
-            SDL_assert(filewatch_files[i].action_pending != FILEWATCH_ACTION_FILE_NONE);
-            filewatch_files[i].callback(filewatch_files[i].path, filewatch_files[i].action_pending);
-            filewatch_files[i].action_pending = FILEWATCH_ACTION_FILE_NONE;
-            filewatch_files[i].action_processed = true;
-        }
     }
 
     SDL_UnlockMutex(filewatcher_lock);

src/twn_filewatch_c.h

@@ -3,8 +3,6 @@
 
 #include <stdbool.h>
 
-#define FILEWATCH_MODIFIED_TICKS_MERGED 10
-
 enum FilewatchAction {
     FILEWATCH_ACTION_FILE_NONE,
     FILEWATCH_ACTION_FILE_CREATED,
@@ -14,9 +12,9 @@ enum FilewatchAction {
 
 typedef void (*FileatchCallback)(char const *path, enum FilewatchAction action);
 
-bool filewatch_add_directory(char *dir, FileatchCallback callback);
+bool filewatch_add_directory(char const *dir, FileatchCallback callback);
 
-bool filewatch_add_file(char *file, FileatchCallback callback);
+bool filewatch_add_file(char const *file, FileatchCallback callback);
 
 void filewatch_poll(void);
 

src/twn_game_object_c.h

@@ -11,13 +11,9 @@
 
 void game_object_load(void);
 
+/* note: it should be only called when application is closing */
 void game_object_unload(void);
 
-/* returns true if reload happened, otherwise false */
-bool game_object_try_reloading(void);
-
 void game_object_tick(void);
 
-void *game_object_get_game_tick_address(void);
-
 #endif

src/twn_loop.c

@@ -1,4 +1,4 @@
-#include "twn_loop.h"
+#include "twn_loop_c.h"
 #include "twn_engine_context_c.h"
 #include "twn_filewatch_c.h"
 #include "twn_input_c.h"
@@ -6,7 +6,7 @@
 #include "twn_util_c.h"
 #include "twn_game_object_c.h"
 #include "twn_textures_c.h"
-#include "system/twn_timer.h"
+#include "twn_timer_c.h"
 
 #include <SDL2/SDL.h>
 #include <physfs.h>
@@ -747,15 +747,20 @@ static void clean_up(void) {
 }
 
 
-static void reset_state(void) {
+void reset_state(void) {
+    ctx.game.initialization_needed = true;
     input_reset_state(&ctx.input);
     textures_reset_state();
 }
 
 
 static void pack_contents_modified(char const *path, enum FilewatchAction action) {
+    static uint32_t last_reset_tick;
+    if (last_reset_tick != (uint32_t)ctx.game.frame_number) {
         log_info("Pack contents invalidated: %s, action: %i", path, action);
         reset_state();
+        last_reset_tick = (uint32_t)ctx.game.frame_number;
+    }
 }
 
 
@@ -868,11 +873,7 @@ int enter_loop(int argc, char **argv) {
     profile_end("startup");
 
     while (ctx.is_running) {
-        if (game_object_try_reloading()) {
+        /* dispatch all filewatch driven events, such as game object and asset pack reload */
-            ctx.game.initialization_needed = true;
-            reset_state();
-        }
-
         filewatch_poll();
         main_loop();
     }

src/twn_loop_c.h

@@ -6,5 +6,7 @@
 
 TWN_API int enter_loop(int argc, char **argv);
 
+TWN_API void reset_state(void);
+
 
 #endif

src/twn_main.c

@@ -1,4 +1,4 @@
-#include "twn_loop.h"
+#include "twn_loop_c.h"
 
 #ifndef EMSCRIPTEN
 #define SDL_MAIN_HANDLED

src/twn_timer.c

@@ -0,0 +1,38 @@
+#include "twn_timer_c.h"
+#include "twn_engine_context_c.h"
+
+#include <SDL2/SDL.h>
+
+static SDL_TimerID sanity_timer;
+
+#define SANITY_TIMER_MESSAGE_FMT "Game tick exeeded its allocated time (%u milliseconds), application is closing"
+
+/* stop application */
+static uint32_t sanity_timer_handler(uint32_t interval, void *data) {
+    (void)data;
+
+    size_t text_str_len = snprintf(NULL, 0, SANITY_TIMER_MESSAGE_FMT, interval) + 1;
+    char *text_str = SDL_malloc(text_str_len);
+    snprintf(text_str, text_str_len, SANITY_TIMER_MESSAGE_FMT, interval);
+    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "sanity timer", text_str, ctx.window);
+    SDL_free(text_str);
+
+    /* TODO: figure out the most portable way to do it */
+    /* TODO: different type of behavior is possible, especially for debugging */
+    quick_exit(EXIT_FAILURE);
+}
+
+
+bool start_sanity_timer(uint32_t milliseconds_to_expire) {
+    if (!sanity_timer) {
+        sanity_timer = SDL_AddTimer(milliseconds_to_expire, sanity_timer_handler, NULL);
+    }
+
+    return sanity_timer != 0;
+}
+
+
+bool end_sanity_timer(void) {
+    SDL_RemoveTimer(sanity_timer);
+    sanity_timer = 0;
+}

src/twn_timer_c.h

@@ -4,7 +4,7 @@
 #include <stdbool.h>
 #include <stdbit.h>
 
-bool start_sanity_timer(uint64_t milliseconds_to_expire);
+bool start_sanity_timer(uint32_t milliseconds_to_expire);
 bool end_sanity_timer(void);
 
 #endif // TWN_TIMER_H

third-party/dmon/dmon_extra.h

@@ -0,0 +1,164 @@
+#ifndef __DMON_EXTRA_H__
+#define __DMON_EXTRA_H__
+
+//
+// Copyright 2023 Sepehr Taghdisian (septag@github). All rights reserved.
+// License: https://github.com/septag/dmon#license-bsd-2-clause
+//
+//  Extra header functionality for dmon.h for the backend based on inotify
+//  
+//  Add/Remove directory functions:
+//  dmon_watch_add: Adds a sub-directory to already valid watch_id. sub-directories are assumed to be relative to watch root_dir
+//  dmon_watch_add: Removes a sub-directory from already valid watch_id. sub-directories are assumed to be relative to watch root_dir
+//  Reason: The inotify backend does not work well when watching in recursive mode a root directory of a large tree, it may take
+//          quite a while until all inotify watches are established, and events will not be received in this time.  Also, since one
+//          inotify watch will be established per subdirectory, it is possible that the maximum amount of inotify watches per user
+//          will be reached. The default maximum is 8192.
+//          When using inotify backend users may turn off the DMON_WATCHFLAGS_RECURSIVE flag and add/remove selectively the
+//          sub-directories to be watched based on application-specific logic about which sub-directory actually needs to be watched.
+//          The function dmon_watch_add and dmon_watch_rm are used to this purpose.
+//
+
+#ifndef __DMON_H__
+#error "Include 'dmon.h' before including this file"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DMON_API_DECL bool dmon_watch_add(dmon_watch_id id, const char* subdir);
+DMON_API_DECL bool dmon_watch_rm(dmon_watch_id id, const char* watchdir);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef DMON_IMPL
+#if DMON_OS_LINUX
+DMON_API_IMPL bool dmon_watch_add(dmon_watch_id id, const char* watchdir)
+{
+    DMON_ASSERT(id.id > 0 && id.id <= DMON_MAX_WATCHES);
+
+    bool skip_lock = pthread_self() == _dmon.thread_handle;
+
+    if (!skip_lock)
+        pthread_mutex_lock(&_dmon.mutex);
+
+    dmon__watch_state* watch = _dmon.watches[id.id - 1];
+
+    int dirlen, i, c;
+
+    // check if the directory exists
+    // if watchdir contains absolute/root-included path, try to strip the rootdir from it
+    // else, we assume that watchdir is correct, so save it as it is
+    struct stat st;
+    dmon__watch_subdir subdir;
+    if (stat(watchdir, &st) == 0 && (st.st_mode & S_IFDIR)) {
+        _dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir);
+        if (strstr(subdir.rootdir, watch->rootdir) == subdir.rootdir) {
+            _dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir + strlen(watch->rootdir));
+        }
+    } else {
+        char fullpath[DMON_MAX_PATH];
+        _dmon_strcpy(fullpath, sizeof(fullpath), watch->rootdir);
+        _dmon_strcat(fullpath, sizeof(fullpath), watchdir);
+        if (stat(fullpath, &st) != 0 || (st.st_mode & S_IFDIR) == 0) {
+            _DMON_LOG_ERRORF("Watch directory '%s' is not valid", watchdir);
+            if (!skip_lock)
+                pthread_mutex_unlock(&_dmon.mutex);
+            return false;
+        }
+        _dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir);
+    }
+
+    dirlen = (int)strlen(subdir.rootdir);
+    if (subdir.rootdir[dirlen - 1] != '/') {
+        subdir.rootdir[dirlen] = '/';
+        subdir.rootdir[dirlen + 1] = '\0';
+    }
+
+    // check that the directory is not already added
+    for (i = 0, c = stb_sb_count(watch->subdirs); i < c; i++) {
+        if (strcmp(subdir.rootdir, watch->subdirs[i].rootdir) == 0) {
+            _DMON_LOG_ERRORF("Error watching directory '%s', because it is already added.", watchdir);
+            if (!skip_lock) 
+                pthread_mutex_unlock(&_dmon.mutex);
+            return false;
+        }
+    }
+
+    const uint32_t inotify_mask = IN_MOVED_TO | IN_CREATE | IN_MOVED_FROM | IN_DELETE | IN_MODIFY;
+    char fullpath[DMON_MAX_PATH];
+    _dmon_strcpy(fullpath, sizeof(fullpath), watch->rootdir);
+    _dmon_strcat(fullpath, sizeof(fullpath), subdir.rootdir);
+    int wd = inotify_add_watch(watch->fd, fullpath, inotify_mask);
+    if (wd == -1) {
+        _DMON_LOG_ERRORF("Error watching directory '%s'. (inotify_add_watch:err=%d)", watchdir, errno);
+        if (!skip_lock)
+            pthread_mutex_unlock(&_dmon.mutex);
+        return false;
+    }
+
+    stb_sb_push(watch->subdirs, subdir);
+    stb_sb_push(watch->wds, wd);
+
+    if (!skip_lock)
+        pthread_mutex_unlock(&_dmon.mutex);
+
+    return true;
+}
+
+DMON_API_IMPL bool dmon_watch_rm(dmon_watch_id id, const char* watchdir)
+{
+    DMON_ASSERT(id.id > 0 && id.id <= DMON_MAX_WATCHES);
+
+    bool skip_lock = pthread_self() == _dmon.thread_handle;
+
+    if (!skip_lock)
+        pthread_mutex_lock(&_dmon.mutex);
+
+    dmon__watch_state* watch = _dmon.watches[id.id - 1];
+
+    char subdir[DMON_MAX_PATH];
+    _dmon_strcpy(subdir, sizeof(subdir), watchdir);
+    if (strstr(subdir, watch->rootdir) == subdir) {
+        _dmon_strcpy(subdir, sizeof(subdir), watchdir + strlen(watch->rootdir));
+    }
+
+    int dirlen = (int)strlen(subdir);
+    if (subdir[dirlen - 1] != '/') {
+        subdir[dirlen] = '/';
+        subdir[dirlen + 1] = '\0';
+    }
+
+    int i, c = stb_sb_count(watch->subdirs);
+    for (i = 0; i < c; i++) {
+        if (strcmp(watch->subdirs[i].rootdir, subdir) == 0) {
+            break;
+        }
+    }
+    if (i >= c) {
+        _DMON_LOG_ERRORF("Watch directory '%s' is not valid", watchdir);
+        if (!skip_lock)
+            pthread_mutex_unlock(&_dmon.mutex);
+        return false;
+    }
+    inotify_rm_watch(watch->fd, watch->wds[i]);
+
+    /* Remove entry from subdirs and wds by swapping position with the last entry */
+    watch->subdirs[i] = stb_sb_last(watch->subdirs);
+    stb_sb_pop(watch->subdirs);
+
+    watch->wds[i] = stb_sb_last(watch->wds);
+    stb_sb_pop(watch->wds);
+
+    if (!skip_lock)
+        pthread_mutex_unlock(&_dmon.mutex);
+    return true;
+}
+#endif  // DMON_OS_LINUX
+#endif // DMON_IMPL
+
+#endif // __DMON_EXTRA_H__
+

third-party/x-watcher/array.h

@@ -1,77 +0,0 @@
-#ifndef ARRAY_H
-#define ARRAY_H
-
-#include <string.h>
-#include <stdlib.h>
-
-struct _ArrayHeader {
-   size_t count, capacity;
-};
-
-#define ARRAY_INITIAL_SIZE 8
-
-#define _arr_header(a) ((struct _ArrayHeader*)(a) - 1)
-
-#define arr_init(a) arr_init_n((a), ARRAY_INITIAL_SIZE)
-
-#define arr_init_n(a, n) do { \
-   struct _ArrayHeader *header; \
-   header = malloc(sizeof(*header) + (sizeof(*(a)) * (n))); \
-   header->count    = 0; \
-   header->capacity = (n); \
-   (a) = (void*)(header + 1); \
-} while(0)
-
-#define arr_count(a)    (_arr_header(a)->count)
-#define arr_capacity(a) (_arr_header(a)->capacity)
-
-#define arr_back(a) ((a)[arr_count(a) - 1])
-#define arr_pop(a)  ((a)[_arr_header(a)->count--])
-
-#define arr_reserve(a, n) do { \
-   if(n <= arr_capacity(a)) break; \
-   struct _ArrayHeader *header = _arr_header(a); \
-   header->capacity = n; \
-   (a) = (void*)((struct _ArrayHeader*)realloc( \
-      header, sizeof(*header) + (sizeof(*(a)) * (n))) + 1); \
-} while(0)
-
-#define arr_resize(a, n) do { \
-   arr_reserve((a), (n)); \
-   _arr_header(a)->count = n; \
-} while(0)
-
-#define arr_resize_zero(a, n) do { \
-   size_t initial_count = arr_count(a); \
-   arr_resize((a), (n)); \
-   if(arr_count(a) > initial_count) \
-      memset( \
-         &(a)[initial_count], 0, \
-         (arr_count(a) - initial_count) * sizeof(*a)); \
-} while(0)
-
-// Take a vararg list to support compound literals
-#define arr_add(a, ...) do { \
-   struct _ArrayHeader *header = _arr_header(a); \
-   if(header->count == header->capacity) \
-      arr_reserve((a), header->capacity << 1); \
-   (a)[_arr_header(a)->count++] = (__VA_ARGS__); \
-} while(0)
-
-#define arr_free(a) do { \
-   free(_arr_header(a)); \
-} while(0)
-
-#define arr_find(a, val, idx) do { \
-   *idx = -1; \
-   for(size_t i = 0; i < arr_count((a)); i++) { \
-      if((a)[i] == val) { \
-         *idx = i; \
-         break; \
-      } \
-   } \
-} while(0)
-
-#endif
-
-

third-party/x-watcher/x-watcher.h

@@ -1,838 +0,0 @@
-#ifndef __X_WATCHER_H
-#define __X_WATCHER_H
-
-// necessary includes for the public stuff
-#include <pthread.h>
-#include <stdbool.h>
-#if defined(__linux__)
-	// noop
-#elif defined(__WIN32__)
-	#include <windows.h>
-	#include <stdint.h>
-#else
-	#error "Unsupported"
-#endif
-
-// PUBLIC STUFF
-typedef enum event {
-	XWATCHER_FILE_UNSPECIFIED,
-	XWATCHER_FILE_REMOVED,
-	XWATCHER_FILE_CREATED,
-	XWATCHER_FILE_MODIFIED,
-	XWATCHER_FILE_OPENED,
-	XWATCHER_FILE_ATTRIBUTES_CHANGED,
-	XWATCHER_FILE_NONE,
-	XWATCHER_FILE_RENAMED,
-	// probs more but i couldn't care much
-} XWATCHER_FILE_EVENT;
-
-typedef struct xWatcher_reference {
-	char *path;
-	void (*callback_func)(
-			XWATCHER_FILE_EVENT event,
-			const char *path,
-			int context,
-			void *additional_data);
-	int context;
-	void *additional_data;
-} xWatcher_reference;
-
-typedef struct xWatcher_file {
-	// just the file name alone
-	char *name;
-	// used for adding (additional) context in the handler (if needed)
-	int  context;
-	// in case you'd like to avoid global variables
-	void *additional_data;
-
-	void (*callback_func)(
-			XWATCHER_FILE_EVENT event,
-			const char *path,
-			int context,
-			void *additional_data);
-} xWatcher_file;
-
-typedef struct xWatcher_directory {
-	// list of files
-	struct xWatcher_file   *files;
-
-	char          *path;
-	// used for adding (additional) context in the handler (if needed)
-	int           context;
-	// in case you'd like to avoid global variables
-	void          *additional_data;
-
-	void (*callback_func)(
-			XWATCHER_FILE_EVENT event,
-			const char *path,
-			int context,
-			void *additional_data);
-
-	#if defined(__linux__)
-		// we need additional file descriptors (per directory basis)
-		int inotify_watch_fd;
-	#elif defined(__WIN32__)
-		HANDLE     handle;
-		OVERLAPPED overlapped;
-		uint8_t    *event_buffer;
-	#else
-		#error "Unsupported"
-	#endif
-} xWatcher_directory;
-
-typedef struct x_watcher {
-	struct xWatcher_directory *directories;
-	pthread_t  thread;
-	int        thread_id;
-	bool       alive;
-
-	#if defined(__linux__)
-		int inotify_fd; // fd == file descriptor (a common UNIX thing)
-	#elif defined(__WIN32__)
-		// literal noop
-	#else
-		#error "Unsupported"
-	#endif
-} x_watcher;
-
-// PRIVATE STUFF
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "array.h"
-
-#ifdef __linux__
-	#include <sys/types.h>
-	#include <sys/inotify.h>
-	#include <errno.h>
-	#include <unistd.h>
-	#include <poll.h>  // for POLLIN
-	#include <fcntl.h> // for O_NONBLOCK
-
-	#define EVENT_SIZE  (sizeof(struct inotify_event))
-	#define BUF_LEN     (1024 * (EVENT_SIZE + 16))
-	#define DIRBRK      '/'
-
-	static inline void *__internal_xWatcherProcess(void *argument) {
-		x_watcher *watcher = (x_watcher*) argument;
-		char buffer[BUF_LEN];
-		ssize_t lenght;
-		struct xWatcher_directory *directories = watcher->directories;
-
-		while(watcher->alive) {
-			// poll for events
-			struct pollfd pfd = { watcher->inotify_fd, POLLIN, 0 };
-			int ret = poll(&pfd, 1, 50);  // timeout of 50ms
-
-			if (ret < 0) {
-				// oops
-				fprintf(stderr, "poll failed: %s\n", strerror(errno));
-				break;
-			} else if (ret == 0) {
-				// Timeout with no events, move on.
-				continue;
-			}
-
-			// wait for the kernel to do it's thing
-			lenght = read(watcher->inotify_fd, buffer, BUF_LEN);
-			if(lenght < 0) {
-				// something messed up clearly
-				perror("read");
-				return NULL;
-			}
-
-			// pointer to the event structure
-			ssize_t i = 0;
-			while(i < lenght) {
-				// the event list itself
-				struct inotify_event *event = (struct inotify_event *)
-					&buffer[i];
-
-				// find directory for which this even matches via the descriptor
-				struct xWatcher_directory *directory = NULL;
-				for(size_t j = 0; j < arr_count(directories); j++) {
-					if(directories[j].inotify_watch_fd == event->wd) {
-						directory = &directories[j];
-					}
-				}
-				if(directory == NULL) {
-					fprintf(stderr,
-							"MATCHING FILE DESCRIPTOR NOT FOUND! ERROR!\n");
-					// BAIL????
-				}
-
-				// find matching file (if any)
-				struct xWatcher_file *file = NULL;
-				for(size_t j = 0; j < arr_count(directory->files); j++) {
-					if(strcmp(directory->files[j].name, event->name) == 0) {
-						file = &directory->files[j];
-					}
-				}
-
-				XWATCHER_FILE_EVENT send_event = XWATCHER_FILE_NONE;
-
-				if(event->mask & IN_CREATE)
-					send_event = XWATCHER_FILE_CREATED;
-				if(event->mask & IN_MODIFY)
-					send_event = XWATCHER_FILE_MODIFIED;
-				if(event->mask & IN_DELETE)
-					send_event = XWATCHER_FILE_REMOVED;
-				if(event->mask & IN_CLOSE_WRITE ||
-						event->mask & IN_CLOSE_NOWRITE)
-					send_event = XWATCHER_FILE_REMOVED;
-				if(event->mask & IN_ATTRIB)
-					send_event = XWATCHER_FILE_ATTRIBUTES_CHANGED;
-				if(event->mask & IN_OPEN)
-					send_event = XWATCHER_FILE_OPENED;
-
-				// file found(?)
-				if(file != NULL) {
-					if(send_event != XWATCHER_FILE_NONE) {
-						// figure out the file path size
-						size_t filepath_size = strlen(directory->path);
-						filepath_size += strlen(file->name);
-						filepath_size += 2;
-
-						// create file path string
-						char *filepath = (char*)malloc(filepath_size);
-						snprintf(filepath, filepath_size, "%s/%s",
-								directory->path, file->name);
-
-						// callback
-						file->callback_func(send_event,
-											filepath,
-											file->context,
-											file->additional_data);
-
-						// free that garbage
-						free(filepath);
-					}
-				} else {
-					// Cannot find file, lets try directory
-					if(directory->callback_func != NULL &&
-							send_event != XWATCHER_FILE_NONE) {
-						directory->callback_func(send_event,
-								directory->path,
-								directory->context,
-								directory->additional_data);
-					}
-				}
-
-				i += EVENT_SIZE + event->len;
-			}
-		}
-
-		// cleanup time
-		for(size_t i = 0; i < arr_count(watcher->directories); i++) {
-			struct xWatcher_directory *directory = &watcher->directories[i];
-			for(size_t j = 0; j < arr_count(directory->files); j++) {
-				struct xWatcher_file *file = &directory->files[j];
-				free(file->name);
-			}
-			arr_free(directory->files);
-			free(directory->path);
-			inotify_rm_watch(watcher->inotify_fd, directory->inotify_watch_fd);
-		}
-		close(watcher->inotify_fd);
-		arr_free(watcher->directories);
-		// should we signify that the thread is dead?
-		return NULL;
-	}
-#elif defined(__WIN32__)
-	#include <tchar.h>
-
-	#define BUF_LEN 1024
-	#define DIRBRK  '\\'
-
-	static inline void *__internal_xWatcherProcess(void *argument) {
-		x_watcher *watcher = (x_watcher*) argument;
-		struct xWatcher_directory *directories = watcher->directories;
-
-		// create an event list so we can still make use of the Windows API
-		HANDLE events[arr_count(directories)];
-		for(int i = 0; i < arr_count(directories); i++) {
-			events[i] = directories[i].overlapped.hEvent;
-		}
-
-		// obv first check if we need to stay alive
-		while(watcher->alive) {
-			// wait for any of the objects to respond
-			DWORD result = WaitForMultipleObjects(arr_count(directories),
-					events, FALSE, 50 /** timeout of 50ms **/);
-
-			// test which object was it
-			int object_index = -1;
-			for(int i = 0; i < arr_count(directories); i++) {
-				if(result == (WAIT_OBJECT_0 + i)) {
-					object_index = i;
-					break;
-				}
-			}
-
-			if(object_index == -1) {
-				if(result == WAIT_TIMEOUT) {
-					// it just timed out, let's continue
-					continue;
-				} else {
-					// RUNTIME ERROR! Let's bail
-					ExitProcess(GetLastError());
-				}
-			}
-
-			// shorhand for convenience
-			struct xWatcher_directory *dir = &directories[object_index];
-
-			// retrieve event data
-			DWORD bytes_transferred;
-			GetOverlappedResult(dir->handle,
-					&dir->overlapped,
-					&bytes_transferred, FALSE);
-
-			// assign the data's pointer to a proper format for convenience
-			FILE_NOTIFY_INFORMATION *event = (FILE_NOTIFY_INFORMATION*)
-					dir->event_buffer;
-
-			// loop through the data
-			for (;;) {
-				// figure out the wchar string size and allocate as needed
-				DWORD name_len = event->FileNameLength / sizeof(wchar_t);
-				char *name_char = malloc(sizeof(char)*(name_len+1));
-				size_t converted_chars;
-
-				// convert wchar* filename to char*
-				wcstombs_s(&converted_chars, name_char,
-						name_len+1, event->FileName, name_len);
-
-				// convert to proper event type
-				XWATCHER_FILE_EVENT send_event = XWATCHER_FILE_NONE;
-				switch (event->Action) {
-					case FILE_ACTION_ADDED:
-						send_event = XWATCHER_FILE_CREATED;
-						break;
-					case FILE_ACTION_REMOVED:
-						send_event = XWATCHER_FILE_REMOVED;
-						break;
-					case FILE_ACTION_MODIFIED:
-						send_event = XWATCHER_FILE_MODIFIED;
-						break;
-					case FILE_ACTION_RENAMED_OLD_NAME:
-					case FILE_ACTION_RENAMED_NEW_NAME:
-						send_event = XWATCHER_FILE_RENAMED;
-						break;
-					default:
-						send_event = XWATCHER_FILE_UNSPECIFIED;
-						break;
-				}
-
-				// find matching file (if any)
-				struct xWatcher_file *file = NULL;
-				for(size_t j = 0; j < arr_count(dir->files); j++) {
-					if(strcmp(dir->files[j].name, name_char) == 0) {
-						file = &dir->files[j];
-					}
-				}
-
-				// file found(?)
-				if(file != NULL) {
-					if(send_event != XWATCHER_FILE_NONE) {
-						// figure out the file path size
-						size_t filepath_size = strlen(dir->path);
-						filepath_size += strlen(file->name);
-						filepath_size += 2;
-
-						// create file path string
-						char *filepath = (char*)malloc(filepath_size);
-						snprintf(filepath, filepath_size, "%s%c%s",
-								dir->path, DIRBRK, file->name);
-
-						// callback
-						file->callback_func(send_event,
-											filepath,
-											file->context,
-											file->additional_data);
-
-						// free that garbage
-						free(filepath);
-					}
-				} else {
-					// Cannot find file, lets try directory
-					if(dir->callback_func != NULL &&
-							send_event != XWATCHER_FILE_NONE) {
-						dir->callback_func(send_event,
-								dir->path,
-								dir->context,
-								dir->additional_data);
-					}
-				}
-
-				// free up the converted string
-				free(name_char);
-
-				// Are there more events to handle?
-				if (event->NextEntryOffset) {
-					*((uint8_t**)&event) += event->NextEntryOffset;
-				} else {
-					break;
-				}
-			}
-
-			DWORD dwNotifyFilter =
-					FILE_NOTIFY_CHANGE_FILE_NAME |
-					FILE_NOTIFY_CHANGE_DIR_NAME |
-					FILE_NOTIFY_CHANGE_ATTRIBUTES |
-					FILE_NOTIFY_CHANGE_SIZE |
-					FILE_NOTIFY_CHANGE_LAST_WRITE |
-					FILE_NOTIFY_CHANGE_LAST_ACCESS |
-					FILE_NOTIFY_CHANGE_CREATION |
-					FILE_NOTIFY_CHANGE_SECURITY;
-			BOOL recursive = FALSE;
-
-			// Queue the next event
-			BOOL success = ReadDirectoryChangesW(
-					dir->handle,
-					dir->event_buffer,
-					BUF_LEN,
-					recursive,
-					dwNotifyFilter,
-					NULL,
-					&dir->overlapped,
-					NULL);
-
-			if(!success) {
-				// get error code
-				DWORD error = GetLastError();
-				char *message;
-
-				// get error message
-				FormatMessage(
-					FORMAT_MESSAGE_ALLOCATE_BUFFER |
-					FORMAT_MESSAGE_FROM_SYSTEM |
-					FORMAT_MESSAGE_IGNORE_INSERTS,
-					NULL,
-					error,
-					MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-					(LPTSTR) &message,
-					0, NULL);
-
-				fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
-						message);
-
-				ExitProcess(error);
-			}
-		}
-		// cleanup time
-		for(size_t i = 0; i < arr_count(watcher->directories); i++) {
-			struct xWatcher_directory *directory = &watcher->directories[i];
-			for(size_t j = 0; j < arr_count(directory->files); j++) {
-				struct xWatcher_file *file = &directory->files[j];
-				free(file->name);
-			}
-			arr_free(directory->files);
-			free(directory->path);
-			free(directory->event_buffer);
-			CloseHandle(directory->handle);
-		}
-		arr_free(watcher->directories);
-
-		return NULL;
-	}
-#else
-	#error "Unsupported"
-#endif
-
-
-static inline x_watcher *xWatcher_create(void) {
-	x_watcher *watcher = (x_watcher*)malloc(sizeof(x_watcher));
-
-	arr_init(watcher->directories);
-
-	#if defined(__WIN32__)
-		// literally noop
-	#elif defined(__linux__)
-		watcher->inotify_fd = inotify_init1(O_NONBLOCK);
-		if(watcher->inotify_fd < 0) {
-			perror("inotify_init");
-			return NULL;
-		}
-	#else
-		#error "Unsupported"
-	#endif
-
-	return watcher;
-}
-
-static inline bool xWatcher_appendFile(
-		x_watcher *watcher,
-		xWatcher_reference *reference) {
-	char *path = strdup(reference->path);
-
-	// the file MUST NOT contain slashed at the end
-	if(path[strlen(path)-1] == DIRBRK)
-		return false;
-
-	char *filename = NULL;
-
-	// we need to split the filename and path
-	for(size_t i = strlen(path)-1; i > 0; i--) {
-		if(path[i] == DIRBRK) {
-			path[i]  = '\0'; // break the string, so it splits into two
-			filename = &path[i+1]; // set the rest of it as the filename
-			break;
-		}
-	}
-
-	// If the directory is specifically local, treat it as such.
-	if(filename == NULL) {
-		filename = path;
-	}
-
-	struct xWatcher_directory *dir = NULL;
-
-	// check against the database of (pre-existing) directories
-	for(size_t i = 0; i < arr_count(watcher->directories); i++) {
-		// paths match
-		if(strcmp(watcher->directories[i].path, path) == 0) {
-			dir = &watcher->directories[i];
-		}
-	}
-
-	// directory exists, check if an callback has been already added
-	if(dir == NULL) {
-		struct xWatcher_directory new_dir;
-
-		new_dir.callback_func    = NULL; // DO NOT add callbacks if it's a file
-		new_dir.context          = 0;    // context should be invalid as well
-		new_dir.additional_data  = NULL; // so should the data
-		new_dir.path             = path; // add a path to the directory
-		#if defined(__linux__)
-			new_dir.inotify_watch_fd = -1;   // invalidate inotify
-		#elif defined(__WIN32__)
-			new_dir.handle       = NULL;
-		#else
-			#error "Unsupported"
-		#endif
-
-		// initialize file arrays
-		arr_init(new_dir.files);
-
-		// add the directory to the masses
-		arr_add(watcher->directories, new_dir);
-
-		// move the pointer to the newly added element
-		dir = &watcher->directories[arr_count(watcher->directories)-1];
-	}
-
-	// search for the file
-	struct xWatcher_file *file = NULL;
-	for(size_t i = 0; i < arr_count(dir->files); i++) {
-		if(strcmp(dir->files[i].name, filename) == 0) {
-			file = &dir->files[i];
-		}
-	}
-
-	if(file != NULL) {
-		return false; // file already exists, that's an ERROR
-	}
-
-	struct xWatcher_file new_file;
-	// avoid an invalid free because this shares the memory space
-	// of the full path string
-	new_file.name            = strdup(filename);
-	new_file.context         = reference->context;
-	new_file.additional_data = reference->additional_data;
-	new_file.callback_func   = reference->callback_func;
-
-	// the the element
-	arr_add(dir->files, new_file);
-
-	// and move the pointer to the newly added element
-	file = &dir->files[arr_count(watcher->directories)-1];
-
-	// add the file watcher
-	#if defined(__linux__)
-		if(dir->inotify_watch_fd == -1) {
-			dir->inotify_watch_fd = inotify_add_watch(
-					watcher->inotify_fd,
-					path,
-					IN_ALL_EVENTS);
-			if(dir->inotify_watch_fd == -1) {
-				perror("inotify_watch_fd");
-				return false;
-			}
-		}
-	#elif defined(__WIN32__)
-		// add directory path
-		dir->handle = CreateFile(dir->path,
-				FILE_LIST_DIRECTORY,
-				FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-				NULL,
-				OPEN_EXISTING,
-				FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
-				NULL);
-		if(dir->handle == INVALID_HANDLE_VALUE) {
-			// get error code
-			DWORD error = GetLastError();
-			char *message;
-
-			// get error message
-			FormatMessage(
-				FORMAT_MESSAGE_ALLOCATE_BUFFER |
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS,
-				NULL,
-				error,
-				MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-				(LPTSTR) &message,
-				0, NULL);
-
-			fprintf(stderr, "CreateFile failed: %s\n",
-					message);
-
-			return false;
-		}
-
-		// create event structure
-		dir->overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL);
-		if(dir->overlapped.hEvent == NULL) {
-			// get error code
-			DWORD error = GetLastError();
-			char *message;
-
-			// get error message
-			FormatMessage(
-				FORMAT_MESSAGE_ALLOCATE_BUFFER |
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS,
-				NULL,
-				error,
-				MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-				(LPTSTR) &message,
-				0, NULL);
-
-			fprintf(stderr, "CreateEvent failed: %s\n",
-					message);
-
-			return false;
-		}
-
-		// allocate the event buffer
-		dir->event_buffer = malloc(BUF_LEN);
-		if(dir->event_buffer == NULL) {
-			fprintf(stderr, "malloc failed at __FILE__:__LINE__!\n");
-			return false;
-		}
-
-		// set reading params
-		BOOL success = ReadDirectoryChangesW(
-				dir->handle, dir->event_buffer, BUF_LEN, TRUE,
-				FILE_NOTIFY_CHANGE_FILE_NAME  |
-				FILE_NOTIFY_CHANGE_DIR_NAME   |
-				FILE_NOTIFY_CHANGE_LAST_WRITE,
-				NULL, &dir->overlapped, NULL);
-		if(!success) {
-			// get error code
-			DWORD error = GetLastError();
-			char *message;
-
-			// get error message
-			FormatMessage(
-				FORMAT_MESSAGE_ALLOCATE_BUFFER |
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS,
-				NULL,
-				error,
-				MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-				(LPTSTR) &message,
-				0, NULL);
-
-			fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
-					message);
-
-			return false;
-		}
-	#else
-		#error "Unsupported"
-	#endif
-	return true;
-}
-
-static inline bool xWatcher_appendDir(
-		x_watcher *watcher,
-		xWatcher_reference *reference) {
-	char *path = strdup(reference->path);
-
-	// inotify only works with directories that do NOT have a front-slash
-	// at the end, so we have to make sure to cut that out
-	if(path[strlen(path)-1] == DIRBRK)
-		path[strlen(path)-1] = '\0';
-
-	struct xWatcher_directory *dir = NULL;
-
-	// check against the database of (pre-existing) directories
-	for(size_t i=0; i < arr_count(watcher->directories); i++) {
-		// paths match
-		if(strcmp(watcher->directories[i].path, path) == 0) {
-			dir = &watcher->directories[i];
-		}
-	}
-
-	// directory exists, check if an callback has been already added
-	if(dir) {
-		// ERROR, CALLBACK EXISTS
-		if(dir->callback_func) {
-			return false;
-		}
-
-		dir->callback_func   = reference->callback_func;
-		dir->context         = reference->context;
-		dir->additional_data = reference->additional_data;
-	} else {
-		// keep an eye for this one as it's on the stack
-		struct xWatcher_directory dir;
-
-		dir.path = path;
-		dir.callback_func   = reference->callback_func;
-		dir.context         = reference->context;
-		dir.additional_data = reference->additional_data;
-
-		// initialize file arrays
-		arr_init(dir.files);
-
-		#if defined(__linux__)
-			dir.inotify_watch_fd = inotify_add_watch(
-					watcher->inotify_fd,
-					dir.path,
-					IN_ALL_EVENTS);
-			if(dir.inotify_watch_fd == -1) {
-				perror("inotify_watch_fd");
-				return false;
-			}
-		#elif defined(__WIN32__)
-			// add directory path
-			dir.handle = CreateFile(dir.path,
-					FILE_LIST_DIRECTORY,
-					FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-					NULL,
-					OPEN_EXISTING,
-					FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
-					NULL);
-			if(dir.handle == INVALID_HANDLE_VALUE) {
-				// get error code
-				DWORD error = GetLastError();
-				char *message;
-
-				// get error message
-				FormatMessage(
-					FORMAT_MESSAGE_ALLOCATE_BUFFER |
-					FORMAT_MESSAGE_FROM_SYSTEM |
-					FORMAT_MESSAGE_IGNORE_INSERTS,
-					NULL,
-					error,
-					MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-					(LPTSTR) &message,
-					0, NULL);
-
-				fprintf(stderr, "CreateFile failed: %s\n",
-						message);
-
-				return false;
-			}
-
-			// create event structure
-			dir.overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL);
-			if(dir.overlapped.hEvent == NULL) {
-				// get error code
-				DWORD error = GetLastError();
-				char *message;
-
-				// get error message
-				FormatMessage(
-					FORMAT_MESSAGE_ALLOCATE_BUFFER |
-					FORMAT_MESSAGE_FROM_SYSTEM |
-					FORMAT_MESSAGE_IGNORE_INSERTS,
-					NULL,
-					error,
-					MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-					(LPTSTR) &message,
-					0, NULL);
-
-				fprintf(stderr, "CreateEvent failed: %s\n",
-						message);
-
-				return false;
-			}
-
-			// allocate the event buffer
-			dir.event_buffer = malloc(BUF_LEN);
-			if(dir.event_buffer == NULL) {
-				fprintf(stderr, "malloc failed at __FILE__:__LINE__!\n");
-				return false;
-			}
-
-			// set reading params
-			BOOL success = ReadDirectoryChangesW(
-					dir.handle, dir.event_buffer, BUF_LEN, TRUE,
-					FILE_NOTIFY_CHANGE_FILE_NAME  |
-					FILE_NOTIFY_CHANGE_DIR_NAME   |
-					FILE_NOTIFY_CHANGE_LAST_WRITE,
-					NULL, &dir.overlapped, NULL);
-			if(!success) {
-				// get error code
-				DWORD error = GetLastError();
-				char *message;
-
-				// get error message
-				FormatMessage(
-					FORMAT_MESSAGE_ALLOCATE_BUFFER |
-					FORMAT_MESSAGE_FROM_SYSTEM |
-					FORMAT_MESSAGE_IGNORE_INSERTS,
-					NULL,
-					error,
-					MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-					(LPTSTR) &message,
-					0, NULL);
-
-				fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
-						message);
-
-				return false;
-			}
-		#else
-			#error "Unsupported"
-		#endif
-
-		arr_add(watcher->directories, dir);
-	}
-
-	return true;
-}
-
-static inline bool xWatcher_start(x_watcher *watcher) {
-	watcher->alive = true;
-
-	// create watcher thread
-	watcher->thread_id = pthread_create(
-			&watcher->thread,
-			NULL,
-			__internal_xWatcherProcess,
-			watcher);
-
-	if(watcher->thread_id != 0) {
-		perror("pthread_create");
-		watcher->alive = false;
-		return false;
-	}
-
-	return true;
-}
-
-static inline void xWatcher_destroy(x_watcher *watcher) {
-	void *ret;
-	watcher->alive = false;
-	pthread_join(watcher->thread, &ret);
-	free(watcher);
-}
-
-#endif
-