fix: stale slot indices, cascade OOB, pending over-alloc, collect_dependents bounds, size_t format on Windows

- stk_poll: unify load loops to always append on compacted array, removing stale pre-compaction slot indices
- stk_poll: heap-allocate cascade_indices per iteration, removing fixed 256-slot stack bound
- stk_pending_retry: shrink module array to actual count after retry loop completes
- stk_collect_dependents: add capacity parameter and bounds guard before index write
- stk_log_modules: cast module_count to unsigned long for C89 portable %lu on Windows

CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0-pre.8] - 2026-03-08
+
+### Fixed
+- `stk_poll()`: stale index corruption when simultaneous load and unload events occurred in the same poll cycle. New modules were previously loaded into pre-compaction slot indices; they now always append to the compacted array via `module_count + successful_appends`, matching the `append_modules` path. The two load loops have been unified into one.
+- `stk_poll()`: `cascade_indices` was a fixed-size stack array of `STK_PATH_MAX` (256) elements with no bounds check. It is now heap-allocated to `module_count` entries per iteration, eliminating the silent overflow risk.
+- `stk_pending_retry()`: module array was pre-allocated to `module_count + stk_pending_count` but never shrunk when fewer entries loaded than were pending. Now calls `stk_module_realloc_memory(module_count)` after the retry loop completes.
+- `stk_collect_dependents()`: missing bounds guard on the `indices` write: `(*count)++` had no check against the buffer capacity before writing. Added `capacity` parameter (passed as `module_count` from the call site) and a guard that skips the write if the capacity is reached, preventing a silent overflow.
+- `stk_log_modules()`: `%lu` format specifier used with `size_t` is undefined behaviour on platforms where `unsigned long` is narrower than `size_t` (e.g. MSVC 64-bit). Fixed with an explicit `(unsigned long)` cast, preserving C89 compatibility.
+
+## [1.0.0-pre.7] - 2026-03-07
+
+### Fixed
+- `stk_module_load()`: added missing dependency failure logging when a module is deferred to the pending queue.
+
+## [1.0.0-pre.6] - 2026-03-07
+
+### Changed
+- `stk_poll()`: replaced per-module `stk_pending_add()` calls inside the load holes and `append_modules` loops with batch collection followed by a single `stk_pending_add_batch()` call after both loops complete.
+
+## [1.0.0-pre.5] - 2026-03-07
+
+### Changed
+- `stk_init()`: replaced per-module `stk_pending_add()` calls inside the deferred module loop with batch collection followed by a single `stk_pending_add_batch()` call after the loop.
+
+## [1.0.0-pre.4] - 2026-03-07
+
+### Changed
+- `stk_pending_retry()`: replaced per-module `realloc` at `attempt_load` with a single bulk allocation upfront (`module_count + stk_pending_count`) before the retry loop.
+- `stk_poll()`: replaced per-module `stk_pending_add()` calls inside the unload and cascade loops with batch collection followed by a single `stk_pending_add_batch()` call after each loop.
+
+## [1.0.0-pre.3] - 2026-03-07
+
+### Added
+- `STK_MOD_DEP_LOG_BUFFER` (2048) added to `stk.h`
+
+### Changed
+- Dependency failure logging now emits a single line per module listing all unmet deps with their reason: `not found` or `requires <constraint>, have <version>`
+  - `Deferring 'test_mod_dep': unmet deps: test_mod (not found)`
+  - `Unloading 'test_mod_dep': unmet deps: test_mod (not found), renderer (requires ^2.0.0, have 1.3.0)`
+- Silent defer at `stk_init` and vague `"unmet dependencies"` cascade log in `stk_poll` replaced with `stk_log_dependency_failures()`
+- Kahn topological sort refactored into generic `stk_kahn_sort()` accepting a `has_dep` callback and an `on_cycle` callback, decoupling it from `stk_modules`. `stk_topo_sort()` is now a thin wrapper. `stk_sort_load_order()` uses the same core via `stk_batch_has_dep()`, inspecting tmp files so simultaneous load events are processed dependency-first without a retry cycle
+- `stk_module_load()` split into `stk_module_preload()`, `stk_module_activate()`, `stk_module_discard()`, and `stk_validate_dependencies_single()`. Init is not called if deps are unmet
+- On UNLOAD events in `stk_poll()`, the unload set is expanded to include all transitively dependent modules via `stk_collect_dependents()`, sorted dependents-first via `stk_sort_unload_order()`. Modules unloaded due to expansion are queued to pending
+- On LOAD events with unmet dependencies, the tmp path is added to the pending queue instead of being dropped
+- `stk_pending_retry()` now skips already-loaded entries and prunes entries whose file no longer exists
+- `free_poll` label moved above `stk_pending_retry()` so retry always runs regardless of exit path
+
 ## [1.0.0-pre.2] - 2026-03-06
 
 ### Fixed
@@ -145,7 +192,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Dependency management and versioning not yet implemented
 - API is unstable and subject to change in future releases
 
-[Unreleased]: https://github.com/anth64/stk/compare/v1.0.0-pre.2...HEAD
+[Unreleased]: https://github.com/anth64/stk/compare/v1.0.0-pre.8...HEAD
+[1.0.0-pre.8]: https://github.com/anth64/stk/compare/v1.0.0-pre.7...v1.0.0-pre.8
+[1.0.0-pre.7]: https://github.com/anth64/stk/compare/v1.0.0-pre.6...v1.0.0-pre.7
+[1.0.0-pre.6]: https://github.com/anth64/stk/compare/v1.0.0-pre.5...v1.0.0-pre.6
+[1.0.0-pre.5]: https://github.com/anth64/stk/compare/v1.0.0-pre.4...v1.0.0-pre.5
+[1.0.0-pre.4]: https://github.com/anth64/stk/compare/v1.0.0-pre.3...v1.0.0-pre.4
+[1.0.0-pre.3]: https://github.com/anth64/stk/compare/v1.0.0-pre.2...v1.0.0-pre.3
 [1.0.0-pre.2]: https://github.com/anth64/stk/compare/v1.0.0-pre.1...v1.0.0-pre.2
 [1.0.0-pre.1]: https://github.com/anth64/stk/compare/v0.1.3...v1.0.0-pre.1
 [0.1.3]: https://github.com/anth64/stk/releases/tag/v0.1.3

README.md

@@ -14,7 +14,7 @@ It is designed to run on modern systems running POSIX and Windows using C89.
 - **Hot-swapping** of modules at runtime
 - **Cross-platform** (Linux, BSD, Windows, macOS)
 - **Optional WASM support** for multi-language modules (planned)
-- **Developer tools**: lightweight metadata, logging/tracing, and dependency management (in progress)
+- **Developer tools**: lightweight metadata, logging/tracing, and dependency management
 - **Minimal, portable API**
 
 ---
@@ -234,7 +234,7 @@ stk_init();
 
 ## Project Status
 
-**Current Version:** 1.0.0-pre.1
+**Current Version:** 1.0.0-pre.8
 
 ### What Works
 - Cross-platform module loading and hot-reloading
@@ -244,6 +244,7 @@ stk_init();
 - Runtime-configurable logging behavior
 - Optional module metadata (name, version, description)
 - Dependency declaration, validation, and versioning
+- Detailed dependency failure logging (missing ids, version mismatches)
 - Cascade unload when dependencies are removed
 - Pending queue with automatic retry when deps become available
 - Topological sort with cycle detection

include/stk.h

@@ -7,6 +7,7 @@
 /* Buffers */
 #define STK_LOG_PREFIX_BUFFER 64
 #define STK_MOD_DEP_OPERATOR_BUFFER 3
+#define STK_MOD_DEP_LOG_BUFFER 2048
 #define STK_MOD_DESC_BUFFER 256
 #define STK_MOD_DIR_BUFFER 256
 #define STK_MOD_ID_BUFFER 64

src/module.c

@@ -206,12 +206,15 @@ unsigned char stk_validate_dependencies(size_t count)
 	return result;
 }
 
-unsigned char stk_topo_sort(size_t count, size_t *order)
+typedef int (*stk_dep_query_fn)(size_t i, size_t j, void *ctx);
+
+static unsigned char stk_kahn_sort(size_t count, size_t *order,
+				   stk_dep_query_fn has_dep, void *ctx,
+				   void (*on_cycle)(size_t i))
 {
 	size_t *in_degree = NULL;
 	size_t *queue = NULL;
-	size_t head, tail, sorted, i, d;
-	int dep_index;
+	size_t head, tail, sorted, i, j;
 	unsigned char result = STK_MOD_INIT_SUCCESS;
 
 	if (count == 0)
@@ -229,11 +232,9 @@ unsigned char stk_topo_sort(size_t count, size_t *order)
 		in_degree[i] = 0;
 
 	for (i = 0; i < count; i++)
-		for (d = 0; d < stk_modules[i].dep_count; d++) {
-			dep_index = is_mod_loaded(stk_modules[i].deps[d].id);
-			if (dep_index >= 0)
+		for (j = 0; j < count; j++)
+			if (i != j && has_dep(i, j, ctx))
 				in_degree[i]++;
-		}
 
 	head = tail = sorted = 0;
 
@@ -246,48 +247,59 @@ unsigned char stk_topo_sort(size_t count, size_t *order)
 		order[sorted++] = mod;
 
 		for (i = 0; i < count; i++) {
-			for (d = 0; d < stk_modules[i].dep_count; d++) {
-				dep_index =
-				    is_mod_loaded(stk_modules[i].deps[d].id);
-				if (dep_index != (int)mod)
-					continue;
-				if (--in_degree[i] == 0)
-					queue[tail++] = i;
-				break;
-			}
+			if (i == mod || !has_dep(i, mod, ctx))
+				continue;
+			if (--in_degree[i] == 0)
+				queue[tail++] = i;
 		}
 	}
 
 	if (sorted != count) {
-		size_t j;
+		size_t k;
 		int in_order;
 		for (i = 0; i < count; i++) {
 			in_order = 0;
-			for (j = 0; j < sorted; j++) {
-				if (order[j] == i) {
+			for (k = 0; k < sorted; k++) {
+				if (order[k] == i) {
 					in_order = 1;
 					break;
 				}
 			}
-
-			if (!in_order)
-				stk_log(STK_LOG_ERROR,
-					"Circular dependency detected with %s",
-					stk_modules[i].id);
+			if (!in_order && on_cycle)
+				on_cycle(i);
 		}
-
 		result = STK_MOD_DEP_CIRCULAR_ERROR;
 	}
-done:
-	if (in_degree)
-		free(in_degree);
-	if (queue)
-		free(queue);
 
+done:
+	free(in_degree);
+	free(queue);
 	return result;
 }
 
-unsigned char stk_module_load(const char *path, int index)
+static int stk_loaded_has_dep(size_t i, size_t j, void *ctx)
+{
+	size_t d;
+	(void)ctx;
+	for (d = 0; d < stk_modules[i].dep_count; d++)
+		if (is_mod_loaded(stk_modules[i].deps[d].id) == (int)j)
+			return 1;
+	return 0;
+}
+
+static void stk_log_cycle(size_t i)
+{
+	stk_log(STK_LOG_ERROR, "Circular dependency detected with %s",
+		stk_modules[i].id);
+}
+
+unsigned char stk_topo_sort(size_t count, size_t *order)
+{
+	return stk_kahn_sort(count, order, stk_loaded_has_dep, NULL,
+			     stk_log_cycle);
+}
+
+unsigned char stk_module_preload(const char *path, int index)
 {
 	void *handle;
 	char module_id[STK_MOD_ID_BUFFER];
@@ -323,37 +335,6 @@ unsigned char stk_module_load(const char *path, int index)
 
 	extract_module_id(path, module_id);
 
-	u.obj = platform_get_symbol(handle, stk_mod_deps_sym);
-	if (u.obj) {
-		const stk_dep_t *early_deps = (const stk_dep_t *)u.obj;
-		size_t early_dep_count = 0;
-		size_t di;
-		int found;
-
-		while (early_deps[early_dep_count].id[0] != '\0')
-			early_dep_count++;
-
-		for (di = 0; di < early_dep_count; di++) {
-			found = is_mod_loaded(early_deps[di].id);
-			if (found < 0) {
-				platform_unload_library(handle);
-				return STK_MOD_DEP_NOT_FOUND_ERROR;
-			}
-			if (early_deps[di].version[0] &&
-			    !stk_validate_constraint(
-				early_deps[di].version,
-				stk_modules[found].version)) {
-				platform_unload_library(handle);
-				return STK_MOD_DEP_VERSION_MISMATCH_ERROR;
-			}
-		}
-	}
-
-	if (stk_modules[index].init() != STK_MOD_INIT_SUCCESS) {
-		platform_unload_library(handle);
-		return STK_MOD_INIT_FAILURE;
-	}
-
 	stk_modules[index].handle = handle;
 
 	len = strlen(module_id);
@@ -444,6 +425,152 @@ skip_deps:
 	return STK_MOD_INIT_SUCCESS;
 }
 
+void stk_module_discard(size_t index)
+{
+	platform_unload_library(stk_modules[index].handle);
+	stk_modules[index].handle = NULL;
+	stk_modules[index].init = NULL;
+	stk_modules[index].shutdown = NULL;
+	stk_modules[index].id[0] = '\0';
+	stk_modules[index].name[0] = '\0';
+	stk_modules[index].version[0] = '\0';
+	stk_modules[index].desc[0] = '\0';
+	if (stk_modules[index].deps) {
+		free(stk_modules[index].deps);
+		stk_modules[index].deps = NULL;
+	}
+	stk_modules[index].dep_count = 0;
+}
+
+unsigned char stk_module_activate(size_t index)
+{
+	if (stk_modules[index].init() != STK_MOD_INIT_SUCCESS) {
+		stk_module_discard(index);
+		return STK_MOD_INIT_FAILURE;
+	}
+	return STK_MOD_INIT_SUCCESS;
+}
+
+unsigned char stk_validate_dependencies_single(size_t index)
+{
+	size_t d;
+	int found;
+
+	if (stk_modules[index].dep_count == 0)
+		return STK_MOD_INIT_SUCCESS;
+
+	for (d = 0; d < stk_modules[index].dep_count; d++) {
+		found = is_mod_loaded(stk_modules[index].deps[d].id);
+		if (found < 0)
+			return STK_MOD_DEP_NOT_FOUND_ERROR;
+		if (stk_modules[index].deps[d].version[0] &&
+		    !stk_validate_constraint(stk_modules[index].deps[d].version,
+					     stk_modules[found].version))
+			return STK_MOD_DEP_VERSION_MISMATCH_ERROR;
+	}
+
+	return STK_MOD_INIT_SUCCESS;
+}
+
+void stk_log_dependency_failures(size_t index, const char *action)
+{
+	char buf[STK_MOD_DEP_LOG_BUFFER];
+	size_t d, pos, len;
+	int found;
+	int first = 1;
+
+	if (stk_modules[index].dep_count == 0)
+		return;
+
+	pos = 0;
+	for (d = 0; d < stk_modules[index].dep_count; d++) {
+		found = is_mod_loaded(stk_modules[index].deps[d].id);
+
+		if (found >= 0 &&
+		    (!stk_modules[index].deps[d].version[0] ||
+		     stk_validate_constraint(stk_modules[index].deps[d].version,
+					     stk_modules[found].version)))
+			continue;
+
+		if (!first && pos < sizeof(buf) - 2) {
+			buf[pos++] = ',';
+			buf[pos++] = ' ';
+		}
+		first = 0;
+
+		if (found < 0) {
+			len = strlen(stk_modules[index].deps[d].id);
+			if (pos + len + 12 < sizeof(buf)) {
+				memcpy(buf + pos, stk_modules[index].deps[d].id,
+				       len);
+				pos += len;
+				memcpy(buf + pos, " (not found)", 12);
+				pos += 12;
+			}
+		} else {
+			len = strlen(stk_modules[index].deps[d].id);
+			if (pos + len < sizeof(buf)) {
+				memcpy(buf + pos, stk_modules[index].deps[d].id,
+				       len);
+				pos += len;
+			}
+			if (pos < sizeof(buf) - 1) {
+				buf[pos++] = ' ';
+			}
+			buf[pos++] = '(';
+			len = strlen("requires ");
+			if (pos + len < sizeof(buf)) {
+				memcpy(buf + pos, "requires ", len);
+				pos += len;
+			}
+			len = strlen(stk_modules[index].deps[d].version);
+			if (pos + len < sizeof(buf)) {
+				memcpy(buf + pos,
+				       stk_modules[index].deps[d].version, len);
+				pos += len;
+			}
+			len = strlen(", have ");
+			if (pos + len < sizeof(buf)) {
+				memcpy(buf + pos, ", have ", len);
+				pos += len;
+			}
+			len = strlen(stk_modules[found].version);
+			if (pos + len < sizeof(buf)) {
+				memcpy(buf + pos, stk_modules[found].version,
+				       len);
+				pos += len;
+			}
+			if (pos < sizeof(buf) - 1)
+				buf[pos++] = ')';
+		}
+	}
+
+	if (first)
+		return;
+
+	buf[pos] = '\0';
+	stk_log(STK_LOG_WARN, "%s '%s': unmet deps: %s", action,
+		stk_modules[index].id, buf);
+}
+
+unsigned char stk_module_load(const char *path, int index)
+{
+	unsigned char result;
+
+	result = stk_module_preload(path, index);
+	if (result != STK_MOD_INIT_SUCCESS)
+		return result;
+
+	result = stk_validate_dependencies_single(index);
+	if (result != STK_MOD_INIT_SUCCESS) {
+		stk_log_dependency_failures(index, "Deferring");
+		stk_module_discard(index);
+		return result;
+	}
+
+	return stk_module_activate(index);
+}
+
 unsigned char stk_module_load_init(const char *path, int index)
 {
 	int result;
@@ -537,20 +664,229 @@ unsigned char stk_module_realloc_memory(size_t new_capacity)
 	return 0;
 }
 
+typedef struct {
+	int *file_indices;
+	char (*file_names)[STK_PATH_MAX];
+	const char *tmp_dir;
+} stk_batch_dep_ctx_t;
+
+static int stk_batch_has_dep(size_t i, size_t j, void *ctx)
+{
+	stk_batch_dep_ctx_t *c = (stk_batch_dep_ctx_t *)ctx;
+	char id_j[STK_MOD_ID_BUFFER];
+	char tmp_i[STK_PATH_MAX_OS];
+	void *h;
+	const stk_dep_t *deps;
+	size_t d, dep_count;
+	union {
+		void *obj;
+	} u;
+	int result = 0;
+
+	extract_module_id(c->file_names[c->file_indices[j]], id_j);
+
+	tmp_i[0] = '\0';
+	strncat(tmp_i, c->tmp_dir, STK_PATH_MAX_OS - 1);
+	strncat(tmp_i, STK_PATH_SEP_STR, STK_PATH_MAX_OS - strlen(tmp_i) - 1);
+	strncat(tmp_i, c->file_names[c->file_indices[i]],
+		STK_PATH_MAX_OS - strlen(tmp_i) - 1);
+
+	h = platform_load_library(tmp_i);
+	if (!h)
+		return 0;
+
+	u.obj = platform_get_symbol(h, stk_mod_deps_sym);
+	if (u.obj) {
+		deps = (const stk_dep_t *)u.obj;
+		dep_count = 0;
+		while (deps[dep_count].id[0] != '\0')
+			dep_count++;
+		for (d = 0; d < dep_count; d++) {
+			if (strncmp(deps[d].id, id_j, STK_MOD_ID_BUFFER) == 0) {
+				result = 1;
+				break;
+			}
+		}
+	}
+
+	platform_unload_library(h);
+	return result;
+}
+
+void stk_sort_load_order(int *file_indices, size_t n,
+			 char (*file_names)[STK_PATH_MAX], const char *tmp_dir)
+{
+	size_t *order = NULL;
+	int *result = NULL;
+	stk_batch_dep_ctx_t ctx;
+	size_t i;
+
+	if (n <= 1)
+		return;
+
+	order = malloc(n * sizeof(size_t));
+	result = malloc(n * sizeof(int));
+	if (!order || !result)
+		goto cleanup;
+
+	ctx.file_indices = file_indices;
+	ctx.file_names = file_names;
+	ctx.tmp_dir = tmp_dir;
+
+	if (stk_kahn_sort(n, order, stk_batch_has_dep, &ctx, NULL) !=
+	    STK_MOD_INIT_SUCCESS)
+		goto cleanup;
+
+	for (i = 0; i < n; i++)
+		result[i] = file_indices[order[i]];
+	for (i = 0; i < n; i++)
+		file_indices[i] = result[i];
+
+cleanup:
+	free(order);
+	free(result);
+}
+
+void stk_collect_dependents(size_t *indices, size_t *count, size_t capacity)
+{
+	size_t i, d;
+	int in_set, changed;
+
+	do {
+		changed = 0;
+		for (i = 0; i < module_count; i++) {
+			in_set = 0;
+			{
+				size_t k;
+				for (k = 0; k < *count; k++) {
+					if (indices[k] == i) {
+						in_set = 1;
+						break;
+					}
+				}
+			}
+			if (in_set)
+				continue;
+
+			for (d = 0; d < stk_modules[i].dep_count; d++) {
+				int dep_index =
+				    is_mod_loaded(stk_modules[i].deps[d].id);
+				if (dep_index < 0)
+					continue;
+				{
+					size_t k;
+					for (k = 0; k < *count; k++) {
+						if (indices[k] ==
+						    (size_t)dep_index) {
+							if (*count >= capacity)
+								goto next_module;
+							indices[(*count)++] = i;
+							changed = 1;
+							goto next_module;
+						}
+					}
+				}
+			}
+		next_module:;
+		}
+	} while (changed);
+}
+
+void stk_sort_unload_order(size_t *indices, size_t n)
+{
+	size_t *topo = NULL;
+	size_t *result = NULL;
+	size_t i, j, k;
+	int in_set;
+
+	if (n <= 1)
+		return;
+
+	topo = malloc(module_count * sizeof(size_t));
+	result = malloc(n * sizeof(size_t));
+
+	if (!topo || !result)
+		goto fallback;
+
+	if (stk_topo_sort(module_count, topo) != STK_MOD_INIT_SUCCESS)
+		goto fallback;
+
+	k = 0;
+	for (i = module_count; i > 0; --i) {
+		size_t mod = topo[i - 1];
+		in_set = 0;
+		for (j = 0; j < n; j++) {
+			if (indices[j] == mod) {
+				in_set = 1;
+				break;
+			}
+		}
+		if (in_set)
+			result[k++] = mod;
+	}
+
+	if (k == n) {
+		for (i = 0; i < n; i++)
+			indices[i] = result[i];
+	}
+
+	free(topo);
+	free(result);
+	return;
+
+fallback:
+	free(topo);
+	free(result);
+	for (i = 0; i < n / 2; i++) {
+		size_t tmp = indices[i];
+		indices[i] = indices[n - 1 - i];
+		indices[n - 1 - i] = tmp;
+	}
+}
+
 void stk_module_unload_all(void)
 {
 	size_t i;
-	for (i = module_count; i > 0; --i)
-		stk_module_unload(i - 1);
+	size_t *order = NULL;
 
+	if (module_count == 0)
+		goto free_mem;
+
+	order = malloc(module_count * sizeof(size_t));
+	if (order) {
+		for (i = 0; i < module_count; i++)
+			order[i] = i;
+		stk_sort_unload_order(order, module_count);
+		for (i = 0; i < module_count; i++)
+			stk_module_unload(order[i]);
+		free(order);
+	} else {
+		for (i = module_count; i > 0; --i)
+			stk_module_unload(i - 1);
+	}
+
+free_mem:
 	stk_module_free_memory();
 }
 
 void stk_pending_add(const char *path)
 {
 	char (*new_pending)[STK_PATH_MAX_OS];
+	char incoming_id[STK_MOD_ID_BUFFER];
+	char existing_id[STK_MOD_ID_BUFFER];
 	size_t i;
 
+	extract_module_id(path, incoming_id);
+
+	for (i = 0; i < stk_pending_count; i++) {
+		extract_module_id(stk_pending[i], existing_id);
+		if (strncmp(existing_id, incoming_id, STK_MOD_ID_BUFFER) == 0) {
+			strncpy(stk_pending[i], path, STK_PATH_MAX_OS - 1);
+			stk_pending[i][STK_PATH_MAX_OS - 1] = '\0';
+			return;
+		}
+	}
+
 	new_pending = malloc((stk_pending_count + 1) * sizeof(*stk_pending));
 	if (!new_pending)
 		return;
@@ -566,6 +902,74 @@ void stk_pending_add(const char *path)
 	stk_pending_count++;
 }
 
+void stk_pending_add_batch(const char (*paths)[STK_PATH_MAX_OS], size_t count)
+{
+	char (*new_pending)[STK_PATH_MAX_OS];
+	char incoming_id[STK_MOD_ID_BUFFER];
+	char existing_id[STK_MOD_ID_BUFFER];
+	size_t i, j, new_count;
+
+	if (!paths || count == 0)
+		return;
+
+	new_count = 0;
+	for (i = 0; i < count; i++) {
+		int found = 0;
+		extract_module_id(paths[i], incoming_id);
+
+		for (j = 0; j < stk_pending_count; j++) {
+			extract_module_id(stk_pending[j], existing_id);
+			if (strncmp(existing_id, incoming_id,
+				    STK_MOD_ID_BUFFER) == 0) {
+				strncpy(stk_pending[j], paths[i],
+					STK_PATH_MAX_OS - 1);
+				stk_pending[j][STK_PATH_MAX_OS - 1] = '\0';
+				found = 1;
+				break;
+			}
+		}
+
+		if (!found)
+			new_count++;
+	}
+
+	if (new_count == 0)
+		return;
+
+	new_pending =
+	    malloc((stk_pending_count + new_count) * sizeof(*stk_pending));
+	if (!new_pending)
+		return;
+
+	for (i = 0; i < stk_pending_count; i++)
+		memcpy(new_pending[i], stk_pending[i], STK_PATH_MAX_OS);
+
+	free(stk_pending);
+	stk_pending = new_pending;
+
+	for (i = 0; i < count; i++) {
+		int found = 0;
+		extract_module_id(paths[i], incoming_id);
+
+		for (j = 0; j < stk_pending_count; j++) {
+			extract_module_id(stk_pending[j], existing_id);
+			if (strncmp(existing_id, incoming_id,
+				    STK_MOD_ID_BUFFER) == 0) {
+				found = 1;
+				break;
+			}
+		}
+
+		if (!found) {
+			strncpy(stk_pending[stk_pending_count], paths[i],
+				STK_PATH_MAX_OS - 1);
+			stk_pending[stk_pending_count][STK_PATH_MAX_OS - 1] =
+			    '\0';
+			stk_pending_count++;
+		}
+	}
+}
+
 void stk_pending_remove(const char *id)
 {
 	size_t i, write;
@@ -593,6 +997,7 @@ size_t stk_pending_retry(void)
 	unsigned char deps_satisfied;
 	unsigned char result;
 	void *handle;
+	void *test;
 	union {
 		void *obj;
 		const char *(*meta_func)(void);
@@ -600,11 +1005,44 @@ size_t stk_pending_retry(void)
 	const stk_dep_t *deps;
 	size_t dep_count;
 	int found;
+	size_t write;
+	char pending_id[STK_MOD_ID_BUFFER];
 
 	if (!stk_pending_count)
 		return 0;
 
+	write = 0;
 	for (i = 0; i < stk_pending_count; i++) {
+		test = platform_load_library(stk_pending[i]);
+		if (test) {
+			platform_unload_library(test);
+			if (write != i)
+				memcpy(stk_pending[write], stk_pending[i],
+				       STK_PATH_MAX_OS);
+			write++;
+		}
+	}
+	stk_pending_count = write;
+
+	if (!stk_pending_count) {
+		stk_pending_free();
+		return 0;
+	}
+
+	if (stk_module_realloc_memory(module_count + stk_pending_count) != 0)
+		return 0;
+
+	for (i = 0; i < stk_pending_count; i++) {
+		extract_module_id(stk_pending[i], pending_id);
+		if (is_mod_loaded(pending_id) >= 0) {
+			memcpy(stk_pending[i],
+			       stk_pending[stk_pending_count - 1],
+			       STK_PATH_MAX_OS);
+			stk_pending_count--;
+			i--;
+			continue;
+		}
+
 		handle = platform_load_library(stk_pending[i]);
 		if (!handle)
 			continue;
@@ -641,9 +1079,6 @@ size_t stk_pending_retry(void)
 			continue;
 
 	attempt_load:
-		if (stk_module_realloc_memory(module_count + 1) != 0)
-			continue;
-
 		result = stk_module_load(stk_pending[i], module_count);
 		if (result != STK_MOD_INIT_SUCCESS)
 			continue;
@@ -660,6 +1095,9 @@ size_t stk_pending_retry(void)
 	if (stk_pending_count == 0)
 		stk_pending_free();
 
+	if (loaded > 0)
+		stk_module_realloc_memory(module_count);
+
 	return loaded;
 }
 

src/stk.c

@@ -45,6 +45,11 @@ void extract_module_id(const char *path, char *out_id);
 int is_mod_loaded(const char *module_id);
 
 size_t stk_module_count(void);
+unsigned char stk_module_preload(const char *path, int index);
+unsigned char stk_module_activate(size_t index);
+unsigned char stk_validate_dependencies_single(size_t index);
+void stk_log_dependency_failures(size_t index, const char *action);
+void stk_module_discard(size_t index);
 unsigned char stk_module_load(const char *path, int index);
 unsigned char stk_module_load_init(const char *path, int index);
 unsigned char stk_module_init_memory(size_t capacity);
@@ -54,8 +59,13 @@ void stk_module_unload_all(void);
 unsigned char stk_validate_dependencies(size_t count);
 unsigned char stk_topo_sort(size_t count, size_t *order);
 void stk_pending_add(const char *path);
+void stk_pending_add_batch(const char (*paths)[STK_PATH_MAX_OS], size_t count);
 void stk_pending_remove(const char *id);
 size_t stk_pending_retry(void);
+void stk_sort_unload_order(size_t *indices, size_t n);
+void stk_collect_dependents(size_t *indices, size_t *count, size_t capacity);
+void stk_sort_load_order(int *file_indices, size_t n,
+			 char (*file_names)[STK_PATH_MAX], const char *tmp_dir);
 
 static void build_path(char *dest, size_t dest_size, const char *dir,
 		       const char *file)
@@ -113,7 +123,8 @@ static void stk_log_module(size_t index)
 static void stk_log_modules(void)
 {
 	size_t i;
-	stk_log(STK_LOG_INFO, "Loaded modules (%lu):", module_count);
+	stk_log(STK_LOG_INFO,
+		"Loaded modules (%lu):", (unsigned long)module_count);
 	for (i = 0; i < module_count; i++)
 		stk_log_module(i);
 }
@@ -121,19 +132,20 @@ static void stk_log_modules(void)
 unsigned char stk_init(void)
 {
 	char (*files)[STK_PATH_MAX] = NULL;
-	size_t file_count, i, successful_loads = 0;
+	char (*test_scan)[STK_PATH_MAX];
+	size_t file_count, i, j, write, successful_loads = 0;
+	size_t index, test_count;
 	char full_path[STK_PATH_MAX_OS];
 	char tmp_path[STK_PATH_MAX_OS];
 	int load_result;
 	unsigned char dep_result;
 	size_t *order = NULL;
+	char (*init_batch)[STK_PATH_MAX_OS] = NULL;
+	size_t init_batch_count = 0;
 
 	platform_mkdir(stk_mod_dir);
 	build_path(stk_tmp_dir, sizeof(stk_tmp_dir), stk_mod_dir, stk_tmp_name);
 	if (platform_mkdir(stk_tmp_dir) != STK_PLATFORM_OPERATION_SUCCESS) {
-		char (*test_scan)[STK_PATH_MAX];
-		size_t test_count;
-
 		test_scan =
 		    platform_directory_init_scan(stk_tmp_dir, &test_count);
 		if (test_scan)
@@ -168,13 +180,15 @@ unsigned char stk_init(void)
 			continue;
 		}
 
-		load_result = stk_module_load_init(tmp_path, successful_loads);
+		load_result = stk_module_preload(tmp_path, successful_loads);
 
 		if (load_result != STK_MOD_INIT_SUCCESS) {
-			stk_log(STK_LOG_ERROR, "Failed to load module %s: %s",
-				files[i], stk_error_string(load_result));
+			stk_log(STK_LOG_ERROR,
+				"Failed to preload module %s: %s", files[i],
+				stk_error_string(load_result));
 		} else {
 			successful_loads++;
+			module_count++;
 		}
 	}
 
@@ -186,34 +200,66 @@ unsigned char stk_init(void)
 	if (module_count == 0)
 		goto scanned;
 
-	dep_result = stk_validate_dependencies(module_count);
-	if (dep_result != STK_MOD_INIT_SUCCESS) {
-		size_t j;
-		char mod_tmp_path[STK_PATH_MAX_OS];
-		stk_log(STK_LOG_WARN,
-			"Some modules have unmet dependencies, deferring");
-		for (j = 0; j < module_count; j++) {
-			if (stk_modules[j].dep_count > 0) {
-				build_path(mod_tmp_path, sizeof(mod_tmp_path),
-					   stk_tmp_dir, stk_modules[j].id);
-				strncat(mod_tmp_path, STK_MODULE_EXT,
-					sizeof(mod_tmp_path) -
-					    strlen(mod_tmp_path) - 1);
-				stk_pending_add(mod_tmp_path);
-				stk_module_unload(j);
-			}
-		}
-	}
-
 	order = malloc(module_count * sizeof(size_t));
 	if (order) {
 		dep_result = stk_topo_sort(module_count, order);
 		if (dep_result != STK_MOD_INIT_SUCCESS)
 			stk_log(STK_LOG_ERROR, "Dependency sort failed: %s",
 				stk_error_string(dep_result));
-		free(order);
 	}
 
+	init_batch = malloc(module_count * sizeof(*init_batch));
+
+	for (j = 0; j < module_count; j++) {
+		index = order ? order[j] : j;
+		dep_result = stk_validate_dependencies_single(index);
+		if (dep_result != STK_MOD_INIT_SUCCESS) {
+			stk_log_dependency_failures(index, "Deferring");
+			if (init_batch) {
+				build_path(init_batch[init_batch_count],
+					   sizeof(init_batch[init_batch_count]),
+					   stk_tmp_dir, stk_modules[index].id);
+				strncat(
+				    init_batch[init_batch_count],
+				    STK_MODULE_EXT,
+				    sizeof(init_batch[init_batch_count]) -
+					strlen(init_batch[init_batch_count]) -
+					1);
+				init_batch_count++;
+			}
+			stk_module_discard(index);
+			continue;
+		}
+		if (stk_module_activate(index) != STK_MOD_INIT_SUCCESS) {
+			stk_log(STK_LOG_ERROR, "Failed to init module %s",
+				stk_modules[index].id);
+			stk_module_discard(index);
+		}
+	}
+
+	if (init_batch_count > 0)
+		stk_pending_add_batch(
+		    (const char (*)[STK_PATH_MAX_OS])init_batch,
+		    init_batch_count);
+
+	free(init_batch);
+	init_batch = NULL;
+
+	if (order) {
+		free(order);
+		order = NULL;
+	}
+
+	write = 0;
+	for (j = 0; j < module_count; j++) {
+		if (stk_modules[j].handle != NULL) {
+			if (write != j)
+				stk_modules[write] = stk_modules[j];
+			write++;
+		}
+	}
+	module_count = write;
+
 scanned:
 	watch_handle = platform_directory_watch_start(stk_mod_dir);
 	if (!watch_handle) {
@@ -224,6 +270,8 @@ scanned:
 		return STK_INIT_WATCH_ERROR;
 	}
 
+	stk_pending_retry();
+
 	stk_log(STK_LOG_INFO, "stk v%s initialized, watching %s/",
 		STK_VERSION_STRING, stk_mod_dir);
 	if (module_count > 0)
@@ -261,8 +309,7 @@ size_t stk_poll(void)
 		  unload_count = 0;
 	int *reloaded_mod_indices = NULL, *reloaded_mod_file_indices = NULL,
 	    *unloaded_mod_indices = NULL, *loaded_mod_indices = NULL;
-	size_t remaining_loads, new_capacity, holes_to_fill;
-	size_t write_pos, read_pos;
+	size_t new_capacity;
 	char full_path[STK_PATH_MAX_OS], tmp_path[STK_PATH_MAX_OS];
 	char mod_id[STK_MOD_ID_BUFFER];
 	int load_result;
@@ -270,6 +317,21 @@ size_t stk_poll(void)
 	char (*module_ids)[STK_MOD_ID_BUFFER] = NULL;
 	unsigned char dep_result;
 	size_t *order = NULL;
+	size_t *unload_order = NULL;
+	size_t expanded_count;
+	size_t index, oi;
+	int is_orig;
+	size_t write;
+	int file_index, mod_index;
+	size_t *cascade_indices = NULL;
+	size_t cascade_count;
+	size_t j, k, cascade_write;
+	char (*dep_batch)[STK_PATH_MAX_OS] = NULL;
+	size_t dep_batch_count = 0;
+	char (*cascade_batch)[STK_PATH_MAX_OS] = NULL;
+	size_t cascade_batch_count = 0;
+	char (*load_batch)[STK_PATH_MAX_OS] = NULL;
+	size_t load_batch_count = 0;
 
 	if (module_count > 0) {
 		module_ids = malloc(module_count * sizeof(*module_ids));
@@ -345,22 +407,89 @@ size_t stk_poll(void)
 	goto begin_operations;
 
 handle_grow:
-	remaining_loads = load_count - unload_count;
-	new_capacity = module_count + remaining_loads;
+	new_capacity = module_count + load_count;
 	if (stk_module_realloc_memory(new_capacity) != STK_MOD_INIT_SUCCESS)
 		goto free_poll;
 
 begin_operations:
-	for (i = 0; i < unload_count; ++i) {
-		stk_log(STK_LOG_INFO, "Unloaded module: %s",
-			stk_modules[unloaded_mod_indices[i]].id);
-		stk_pending_remove(stk_modules[unloaded_mod_indices[i]].id);
-		stk_module_unload(unloaded_mod_indices[i]);
+	unload_order = malloc(module_count * sizeof(size_t));
+	if (unload_order) {
+		expanded_count = unload_count;
+
+		for (i = 0; i < unload_count; i++)
+			unload_order[i] = (size_t)unloaded_mod_indices[i];
+
+		stk_collect_dependents(unload_order, &expanded_count,
+				       module_count);
+		stk_sort_unload_order(unload_order, expanded_count);
+
+		dep_batch = malloc(expanded_count * sizeof(*dep_batch));
+		dep_batch_count = 0;
+
+		for (i = 0; i < expanded_count; i++) {
+			index = unload_order[i];
+
+			stk_log(STK_LOG_INFO, "Unloaded module: %s",
+				stk_modules[index].id);
+			stk_pending_remove(stk_modules[index].id);
+
+			is_orig = 0;
+			for (oi = 0; oi < unload_count; oi++) {
+				if ((size_t)unloaded_mod_indices[oi] == index) {
+					is_orig = 1;
+					break;
+				}
+			}
+			if (!is_orig && dep_batch) {
+				build_path(dep_batch[dep_batch_count],
+					   sizeof(dep_batch[dep_batch_count]),
+					   stk_tmp_dir, stk_modules[index].id);
+				strncat(
+				    dep_batch[dep_batch_count], STK_MODULE_EXT,
+				    sizeof(dep_batch[dep_batch_count]) -
+					strlen(dep_batch[dep_batch_count]) - 1);
+				dep_batch_count++;
+			}
+
+			stk_module_unload(index);
+		}
+
+		if (dep_batch_count > 0)
+			stk_pending_add_batch(
+			    (const char (*)[STK_PATH_MAX_OS])dep_batch,
+			    dep_batch_count);
+
+		free(dep_batch);
+		dep_batch = NULL;
+		free(unload_order);
+		unload_order = NULL;
+	} else {
+		for (i = 0; i < unload_count; ++i) {
+			stk_log(STK_LOG_INFO, "Unloaded module: %s",
+				stk_modules[unloaded_mod_indices[i]].id);
+			stk_pending_remove(
+			    stk_modules[unloaded_mod_indices[i]].id);
+			stk_module_unload(unloaded_mod_indices[i]);
+		}
+	}
+
+	if (unload_count > 0) {
+		write = 0;
+		for (i = 0; i < module_count; i++) {
+			if (stk_modules[i].handle != NULL) {
+				if (write != i)
+					stk_modules[write] = stk_modules[i];
+				write++;
+			}
+		}
+		module_count = write;
+		if (module_count > 0)
+			stk_module_realloc_memory(module_count);
 	}
 
 	for (i = 0; i < reload_count; ++i) {
-		int file_index = reloaded_mod_file_indices[i];
-		int mod_index = reloaded_mod_indices[i];
+		file_index = reloaded_mod_file_indices[i];
+		mod_index = reloaded_mod_indices[i];
 
 		build_path(full_path, sizeof(full_path), stk_mod_dir,
 			   file_list[file_index]);
@@ -383,57 +512,36 @@ begin_operations:
 				stk_error_string(load_result));
 	}
 
-	holes_to_fill = (load_count < unload_count) ? load_count : unload_count;
-	for (i = 0; i < holes_to_fill; ++i) {
-		int target_index = unloaded_mod_indices[i];
-		int file_index = loaded_mod_indices[i];
-
+	for (i = 0; i < load_count; i++) {
+		file_index = loaded_mod_indices[i];
 		build_path(full_path, sizeof(full_path), stk_mod_dir,
 			   file_list[file_index]);
 		build_path(tmp_path, sizeof(tmp_path), stk_tmp_dir,
 			   file_list[file_index]);
-
-		if (platform_copy_file(full_path, tmp_path) !=
-		    STK_PLATFORM_OPERATION_SUCCESS) {
-			stk_log(STK_LOG_ERROR, "Failed to copy %s for loading",
-				file_list[file_index]);
-			continue;
-		}
-
-		load_result = stk_module_load(tmp_path, target_index);
-		if (load_result != STK_MOD_INIT_SUCCESS)
-			stk_log(STK_LOG_ERROR, "Failed to load module %s: %s",
-				file_list[file_index],
-				stk_error_string(load_result));
+		platform_copy_file(full_path, tmp_path);
 	}
 
-	if (load_count > unload_count)
-		goto append_modules;
+	if (load_count > 1)
+		stk_sort_load_order(loaded_mod_indices, load_count, file_list,
+				    stk_tmp_dir);
 
-	if (unload_count > load_count)
-		goto trim_arrays;
+	load_batch = malloc(load_count * sizeof(*load_batch));
+	load_batch_count = 0;
 
-	goto validate_deps;
+	for (i = 0; i < load_count; ++i) {
+		file_index = loaded_mod_indices[i];
 
-append_modules:
-	for (; i < load_count; ++i) {
-		int file_index = loaded_mod_indices[i];
-
-		build_path(full_path, sizeof(full_path), stk_mod_dir,
-			   file_list[file_index]);
 		build_path(tmp_path, sizeof(tmp_path), stk_tmp_dir,
 			   file_list[file_index]);
 
-		if (platform_copy_file(full_path, tmp_path) !=
-		    STK_PLATFORM_OPERATION_SUCCESS) {
-			stk_log(STK_LOG_ERROR, "Failed to copy %s for loading",
-				file_list[file_index]);
-			continue;
-		}
-
 		load_result = stk_module_load(tmp_path, module_count +
 							    successful_appends);
-		if (load_result != STK_MOD_INIT_SUCCESS) {
+		if (load_result == STK_MOD_DEP_NOT_FOUND_ERROR ||
+		    load_result == STK_MOD_DEP_VERSION_MISMATCH_ERROR) {
+			if (load_batch)
+				memcpy(load_batch[load_batch_count++], tmp_path,
+				       STK_PATH_MAX_OS);
+		} else if (load_result != STK_MOD_INIT_SUCCESS) {
 			stk_log(STK_LOG_ERROR, "Failed to load module %s: %s",
 				file_list[file_index],
 				stk_error_string(load_result));
@@ -444,86 +552,94 @@ append_modules:
 
 	module_count += successful_appends;
 
-	if (successful_appends < (load_count - holes_to_fill))
+	if (successful_appends < load_count)
 		stk_module_realloc_memory(module_count);
 
+	if (load_batch_count > 0)
+		stk_pending_add_batch(
+		    (const char (*)[STK_PATH_MAX_OS])load_batch,
+		    load_batch_count);
+
+	free(load_batch);
+	load_batch = NULL;
+
 	goto validate_deps;
 
-trim_arrays:
-	write_pos = unloaded_mod_indices[holes_to_fill];
-	for (i = holes_to_fill + 1; i < unload_count; ++i) {
-		if (unloaded_mod_indices[i] < write_pos)
-			write_pos = unloaded_mod_indices[i];
-	}
-
-	for (read_pos = write_pos + 1; read_pos < module_count; ++read_pos) {
-		if (stk_modules[read_pos].handle != NULL) {
-			stk_modules[write_pos] = stk_modules[read_pos];
-			++write_pos;
-		}
-	}
-
-	module_count = write_pos;
-	stk_module_realloc_memory(module_count);
-
 validate_deps:
 	if (module_count == 0)
 		goto free_poll;
 
-	{
-		size_t cascade_indices[STK_PATH_MAX];
-		size_t cascade_count;
-		char cascade_tmp_path[STK_PATH_MAX_OS];
-		size_t j, k, cascade_write;
+	do {
+		cascade_count = 0;
 
-		do {
-			cascade_count = 0;
+		cascade_indices = malloc(module_count * sizeof(size_t));
+		if (!cascade_indices)
+			break;
 
-			for (j = 0; j < module_count; j++) {
-				if (stk_modules[j].dep_count == 0)
-					continue;
-				for (k = 0; k < stk_modules[j].dep_count; k++) {
-					if (is_mod_loaded(
-						stk_modules[j].deps[k].id) <
-					    0) {
-						cascade_indices
-						    [cascade_count++] = j;
-						break;
-					}
+		for (j = 0; j < module_count; j++) {
+			if (stk_modules[j].dep_count == 0)
+				continue;
+			for (k = 0; k < stk_modules[j].dep_count; k++) {
+				if (is_mod_loaded(stk_modules[j].deps[k].id) <
+				    0) {
+					cascade_indices[cascade_count++] = j;
+					break;
 				}
 			}
+		}
 
-			if (cascade_count == 0)
-				break;
+		if (cascade_count == 0) {
+			free(cascade_indices);
+			cascade_indices = NULL;
+			break;
+		}
 
-			for (j = 0; j < cascade_count; j++) {
-				size_t index = cascade_indices[j];
-				stk_log(STK_LOG_WARN,
-					"Unloading '%s': unmet dependencies",
-					stk_modules[index].id);
-				build_path(cascade_tmp_path,
-					   sizeof(cascade_tmp_path),
-					   stk_tmp_dir, stk_modules[index].id);
-				strncat(cascade_tmp_path, STK_MODULE_EXT,
-					sizeof(cascade_tmp_path) -
-					    strlen(cascade_tmp_path) - 1);
-				stk_pending_add(cascade_tmp_path);
-				stk_module_unload(index);
+		cascade_batch = malloc(cascade_count * sizeof(*cascade_batch));
+		cascade_batch_count = 0;
+
+		for (j = 0; j < cascade_count; j++) {
+			index = cascade_indices[j];
+			stk_log_dependency_failures(index, "Unloading");
+			if (cascade_batch) {
+				build_path(
+				    cascade_batch[cascade_batch_count],
+				    sizeof(cascade_batch[cascade_batch_count]),
+				    stk_tmp_dir, stk_modules[index].id);
+				strncat(
+				    cascade_batch[cascade_batch_count],
+				    STK_MODULE_EXT,
+				    sizeof(cascade_batch[cascade_batch_count]) -
+					strlen(cascade_batch
+						   [cascade_batch_count]) -
+					1);
+				cascade_batch_count++;
 			}
+			stk_module_unload(index);
+		}
 
-			cascade_write = 0;
-			for (j = 0; j < module_count; j++) {
-				if (stk_modules[j].handle != NULL) {
-					if (cascade_write != j)
-						stk_modules[cascade_write] =
-						    stk_modules[j];
-					cascade_write++;
-				}
+		if (cascade_batch_count > 0)
+			stk_pending_add_batch(
+			    (const char (*)[STK_PATH_MAX_OS])cascade_batch,
+			    cascade_batch_count);
+
+		free(cascade_batch);
+		cascade_batch = NULL;
+
+		cascade_write = 0;
+		for (j = 0; j < module_count; j++) {
+			if (stk_modules[j].handle != NULL) {
+				if (cascade_write != j)
+					stk_modules[cascade_write] =
+					    stk_modules[j];
+				cascade_write++;
 			}
-			module_count = cascade_write;
+		}
+		module_count = cascade_write;
 
-		} while (cascade_count > 0);
-	}
+		free(cascade_indices);
+		cascade_indices = NULL;
+
+	} while (cascade_count > 0);
 
 	if (module_count > 0)
 		stk_module_realloc_memory(module_count);
@@ -537,12 +653,12 @@ validate_deps:
 		free(order);
 	}
 
+free_poll:
 	stk_pending_retry();
 
 	if (module_count > 0)
 		stk_log_modules();
 
-free_poll:
 	free(reloaded_mod_indices);
 	free(reloaded_mod_file_indices);
 	free(unloaded_mod_indices);