25 files changed, 813 insertions, 147 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 04e0e4e..d1fb3ab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,9 +9,10 @@ add_subdirectory(cstring)
 add_subdirectory(error)
 add_subdirectory(filesystem)
 add_subdirectory(list)
-add_subdirectory(mem)
 add_subdirectory(log)
+add_subdirectory(mem)
 add_subdirectory(mempool)
+add_subdirectory(memstack)
 add_subdirectory(plugin)
 add_subdirectory(random)
 add_subdirectory(timer)
diff --git a/cstring/CMakeLists.txt b/cstring/CMakeLists.txt
index a1abde2..92fe5a7 100644
--- a/cstring/CMakeLists.txt
+++ b/cstring/CMakeLists.txt
@@ -15,8 +15,3 @@ target_include_directories(cstring PUBLIC
 
 target_link_libraries(cstring PUBLIC
   cassert)
-
-if(LINUX)
-  target_link_libraries(cstring PUBLIC
-    -lbsd)
-endif()
diff --git a/cstring/include/cstring.h b/cstring/include/cstring.h
index b07dad6..c24cd35 100644
--- a/cstring/include/cstring.h
+++ b/cstring/include/cstring.h
@@ -3,14 +3,23 @@
 
 #include <cassert.h>
 
-#ifdef __linux__
-#include <bsd/string.h>
-#else
-#include <string.h>
-#endif
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <string.h>
+
+// -----------------------------------------------------------------------------
+// C-string helpers.
+
+/// Return a hash of the given string.
+uint64_t cstring_hash(const char* str);
+
+/// Copy 'count' characters from the source to the destination, null-terminating
+/// the destination.
+static inline void cstring_copy(char* dst, const char* src, size_t count) {
+  memcpy(dst, src, count * sizeof(char));
+  dst[count] = '\0';
+}
 
 // -----------------------------------------------------------------------------
 // Fix-sized strings.
@@ -38,11 +47,14 @@
       return (STRING){0};                                                     \
     } else {                                                                  \
       STRING str = (STRING){0};                                               \
-      str.length = strlcpy(str.str, cstr, SIZE);                              \
+      str.length = strlen(cstr);                                              \
+      cstring_copy(str.str, cstr, str.length);                                \
       return str;                                                             \
     }                                                                         \
   }                                                                           \
                                                                               \
+  static inline STRING STRING##_make_empty() { return (STRING){0}; }          \
+                                                                              \
   static inline STRING STRING##_dirname(const STRING path) {                  \
     STRING str = path;                                                        \
     for (int i = str.length - 1; i >= 0; --i) {                               \
@@ -63,7 +75,7 @@
   static inline void STRING##_append_cstr_len(                                \
       STRING* a, const char* b, const size_t b_length) {                      \
     ASSERT(a->length + b_length + 1 <= SIZE);                                 \
-    strlcpy(a->str + a->length, b, SIZE - a->length);                         \
+    cstring_copy(a->str + a->length, b, b_length);                            \
     a->length += b_length;                                                    \
   }                                                                           \
                                                                               \
@@ -79,9 +91,8 @@
       const STRING a, const char* b, const size_t b_length) {                 \
     ASSERT(a.length + b_length + 1 <= SIZE);                                  \
     STRING str = {0};                                                         \
-    strlcpy(str.str, a.str, SIZE);                                            \
-    strlcpy(str.str + a.length, b, SIZE - a.length);                          \
-    str.length = a.length + b_length;                                         \
+    STRING##_append_cstr_len(&str, a.str, a.length);                          \
+    STRING##_append_cstr_len(&str, b, b_length);                              \
     return str;                                                               \
   }                                                                           \
                                                                               \
@@ -97,6 +108,15 @@
     return STRING##_concat(STRING##_concat_cstr(a, "/"), b);                  \
   }                                                                           \
                                                                               \
+  static inline STRING STRING##_slice(                                        \
+      const STRING a, const size_t start, const size_t end) {                 \
+    ASSERT(start < a.length);                                                 \
+    ASSERT(end <= a.length);                                                  \
+    STRING str = {0};                                                         \
+    cstring_copy(str.str, &a.str[start], end - start);                        \
+    return str;                                                               \
+  }                                                                           \
+                                                                              \
   static inline bool STRING##_eq_cstr_len(                                    \
       const STRING a, const char* b, size_t b_length) {                       \
     return (a.length == b_length) && strncmp(a.str, b, a.length) == 0;        \
@@ -124,15 +144,6 @@
     return cstring_hash(str.str);                                             \
   }
 
-/// Return a hash of the given string.
-static inline uint64_t cstring_hash(const char* str) {
-  uint64_t hash = 0;
-  for (size_t i = 0; i < strlen(str); ++i) {
-    hash = (uint64_t)str[i] + (hash << 6) + (hash << 16) - hash;
-  }
-  return hash;
-}
-
 DEF_STRING(sstring, 32)    // Small.
 DEF_STRING(mstring, 256)   // Medium.
 DEF_STRING(lstring, 1024)  // Large.
diff --git a/cstring/src/cstring.c b/cstring/src/cstring.c
index 832cb85..100c130 100644
--- a/cstring/src/cstring.c
+++ b/cstring/src/cstring.c
@@ -23,7 +23,7 @@ string string_new(const char* cstr) {
 void string_del(string* str) {
   if (str->data) {
     free((void*)str->data);
-    str->data   = 0;
+    str->data   = nullptr;
     str->length = 0;
   }
 }
@@ -101,3 +101,11 @@ string string_format_size(size_t size) {
       .length = length,
   };
 }
+
+uint64_t cstring_hash(const char* str) {
+  uint64_t hash = 0;
+  for (size_t i = 0; i < strlen(str); ++i) {
+    hash = (uint64_t)str[i] + (hash << 6) + (hash << 16) - hash;
+  }
+  return hash;
+}
diff --git a/filesystem/include/filesystem.h b/filesystem/include/filesystem.h
index 1c354b7..bc7f953 100644
--- a/filesystem/include/filesystem.h
+++ b/filesystem/include/filesystem.h
@@ -6,8 +6,26 @@
 #include <stddef.h>
 #include <stdio.h>
 
+#define WITH_FILE(FILEPATH, BODY)       \
+  {                                     \
+    assert(FILEPATH);                   \
+    FILE* file = fopen(FILEPATH, "rb"); \
+    if (file) {                         \
+      BODY;                             \
+      fclose(file);                     \
+    }                                   \
+  }
+
+/// Get the file's size.
+size_t get_file_size(const char* filename);
+
 /// Get the file's size.
-size_t get_file_size(FILE* file);
+size_t get_file_size_f(FILE* file);
 
 /// Read the entire contents of the file into memory.
 void* read_file(const char* filepath);
+
+/// Read the entire contents of the file into memory.
+///
+/// The given buffer must be large enough to hold the file's contents.
+bool read_file_f(FILE*, void* buffer);
diff --git a/filesystem/src/filesystem.c b/filesystem/src/filesystem.c
index b228e85..b30c072 100644
--- a/filesystem/src/filesystem.c
+++ b/filesystem/src/filesystem.c
@@ -5,21 +5,27 @@
 #include <stdlib.h>
 #include <string.h>
 
-size_t get_file_size(FILE* file) {
+size_t get_file_size(const char* filename) {
+  size_t size = 0;
+  WITH_FILE(filename, size = get_file_size_f(file));
+  return size;
+}
+
+size_t get_file_size_f(FILE* file) {
   assert(file);
   const long int starting_pos = ftell(file);
   if (starting_pos == -1) {
-    return (size_t)-1;
+    return 0;
   }
   if (fseek(file, 0, SEEK_END) != 0) {
-    return (size_t)-1;
+    return 0;
   }
   const size_t file_size = ftell(file);
   if (file_size == (size_t)-1) {
-    return (size_t)-1;
+    return 0;
   }
   if (fseek(file, starting_pos, SEEK_SET) != 0) {
-    return (size_t)-1;
+    return 0;
   }
   return file_size;
 }
@@ -27,31 +33,38 @@ size_t get_file_size(FILE* file) {
 void* read_file(const char* filepath) {
   assert(filepath);
 
-  void* data = 0;
+  void* data    = nullptr;
+  bool  success = false;
 
-  FILE* file = fopen(filepath, "rb");
-  if (!file) {
-    return 0;
-  }
-  const size_t file_size = get_file_size(file);
-  if (file_size == (size_t)-1) {
-    goto cleanup;
-  }
+  WITH_FILE(filepath, {
+    const size_t file_size = get_file_size_f(file);
+    if (file_size > 0) {
+      data = calloc(1, file_size);
+      if (data != nullptr) {
+        if (fread(data, 1, file_size, file) == file_size) {
+          success = true;
+        }
+      }
+    }
+  });
 
-  data = calloc(1, file_size);
-  if (!data) {
-    goto cleanup;
-  }
-  if (fread(data, 1, file_size, file) != file_size) {
-    goto cleanup;
+  if (!success) {
+    free(data);
+    data = nullptr;
   }
-
   return data;
+}
 
-cleanup:
-  fclose(file);
-  if (data) {
-    free(data);
+bool read_file_f(FILE* file, void* buffer) {
+  assert(file);
+  assert(buffer);
+
+  bool         success   = false;
+  const size_t file_size = get_file_size_f(file);
+  if (file_size > 0) {
+    if (fread(buffer, 1, file_size, file) == file_size) {
+      success = true;
+    }
   }
-  return 0;
+  return success;
 }
diff --git a/filesystem/src/path.c b/filesystem/src/path.c
index 2ce5a04..544a5d1 100644
--- a/filesystem/src/path.c
+++ b/filesystem/src/path.c
@@ -21,7 +21,7 @@ path path_new(const char* str) {
 void path_del(path* path) {
   if (path) {
     free(path->data);
-    path->data = 0;
+    path->data = nullptr;
     path->size = 0;
   }
 }
diff --git a/list/include/list.h b/list/include/list.h
index 24291e1..aadcb88 100644
--- a/list/include/list.h
+++ b/list/include/list.h
@@ -23,7 +23,7 @@ static inline void* alloc(size_t size) {
 
 /// Create a new empty list.
 #define make_list(type) \
-  (type##_list) { 0 }
+  (type##_list) { nullptr }
 
 /// Delete the list.
 #define del_list(list)                                  \
@@ -32,7 +32,7 @@ static inline void* alloc(size_t size) {
     node                 = node->next;                  \
     free(cur);                                          \
   }                                                     \
-  list.head = 0;
+  list.head = nullptr;
 
 /// Prepend a value to the list.
 #define list_add(list, value)                               \
@@ -76,10 +76,10 @@ static inline void* alloc(size_t size) {
       node->next->prev = node->prev; \
     }                                \
     if (list.head == node) {         \
-      list.head = 0;                 \
+      list.head = nullptr;           \
     }                                \
     free(node);                      \
-    node = 0;                        \
+    node = nullptr;                  \
   }
 
 /// Iterate over all the items in the list.
diff --git a/list/test/list_test.c b/list/test/list_test.c
index 418e156..4ac5b5b 100644
--- a/list/test/list_test.c
+++ b/list/test/list_test.c
@@ -52,7 +52,7 @@ TEST_CASE(list_remove_by_value) {
 TEST_CASE(list_remove_by_address) {
   const int N = 3;
 
-  int* ptrs[3] = {0};
+  int* ptrs[3] = {nullptr};
 
   int_list list = make_list(int);
   for (int i = 0; i < N; ++i) {
diff --git a/mem/include/mem.h b/mem/include/mem.h
index 224b069..3050ba8 100644
--- a/mem/include/mem.h
+++ b/mem/include/mem.h
@@ -68,13 +68,13 @@
 /// Allocate a new chunk of N blocks.
 /// Return a pointer to the first block of the chunk.
 /// When there is no space left in the allocator, allocation can either trap
-/// (default) or gracefully return 0. Call mem_enable_traps() to toggle this
+/// (default) or gracefully return null. Call mem_enable_traps() to toggle this
 /// behaviour.
 /// New chunks are conveniently zeroed out.
 #define mem_alloc(MEM, num_blocks) mem_alloc_(&(MEM)->mem, num_blocks)
 
 /// Free the chunk.
-/// The chunk pointer is conveniently set to 0.
+/// The chunk pointer is conveniently set to null.
 #define mem_free(MEM, CHUNK) mem_free_(&(MEM)->mem, (void**)CHUNK)
 
 /// Return a pointer to a chunk given the chunk's handle.
diff --git a/mem/src/mem.c b/mem/src/mem.c
index 4f5e5ef..70648c9 100644
--- a/mem/src/mem.c
+++ b/mem/src/mem.c
@@ -46,24 +46,27 @@ void mem_del_(Memory* mem) {
   if (mem->dynamic) {
     if (mem->chunks) {
       free(mem->chunks);
-      mem->chunks = 0;
+      mem->chunks = nullptr;
     }
     if (mem->blocks) {
       free(mem->blocks);
-      mem->blocks = 0;
+      mem->blocks = nullptr;
     }
   }
 }
 
 void mem_clear_(Memory* mem) {
   assert(mem);
-  mem->next_free_chunk = 0;
-  memset(mem->blocks, 0, mem->num_blocks * mem->block_size_bytes);
-  memset(mem->chunks, 0, mem->num_blocks * sizeof(Chunk));
-
-  // Initialize the head as one large free chunk.
-  Chunk* head      = &mem->chunks[0];
-  head->num_blocks = mem->num_blocks;
+  if (mem->num_blocks > 0) {
+    mem->num_used_blocks = 0;
+    mem->next_free_chunk = 0;
+    memset(mem->blocks, 0, mem->num_blocks * mem->block_size_bytes);
+    memset(mem->chunks, 0, mem->num_blocks * sizeof(Chunk));
+
+    // Initialize the head as one large free chunk.
+    Chunk* head      = &mem->chunks[0];
+    head->num_blocks = mem->num_blocks;
+  }
 }
 
 void* mem_alloc_(Memory* mem, size_t num_blocks) {
@@ -113,10 +116,11 @@ void* mem_alloc_(Memory* mem, size_t num_blocks) {
     return &mem->blocks[chunk_idx * mem->block_size_bytes];
   } else {
     if (mem->trap) {
-      FAIL("Memory allocation failed, increase the allocator's capacity or "
-           "avoid fragmentation.");
+      FAIL(
+          "Memory allocation failed, increase the allocator's capacity or "
+          "avoid fragmentation.");
     }
-    return 0; // Large-enough free chunk not found.
+    return nullptr; // Large-enough free chunk not found.
   }
 }
 
@@ -172,7 +176,7 @@ void mem_free_(Memory* mem, void** chunk_ptr) {
 
   mem->num_used_blocks--;
 
-  *chunk_ptr = 0;
+  *chunk_ptr = nullptr;
 }
 
 // The handle is the chunk's index. We don't call it an index in the public API
diff --git a/mem/test/mem_test.c b/mem/test/mem_test.c
index 14718a5..52ce5a9 100644
--- a/mem/test/mem_test.c
+++ b/mem/test/mem_test.c
@@ -32,6 +32,12 @@ TEST_CASE(mem_create_dyn) {
   mem_make_dyn(&mem, NUM_BLOCKS, sizeof(int));
 }
 
+// Clear an uninitialized allocator.
+TEST_CASE(mem_clear_uninitialized) {
+  test_mem mem = {0};
+  mem_clear(&mem);
+}
+
 // Allocate N chunks of 1 block each.
 TEST_CASE(mem_fully_allocate) {
   test_mem mem;
@@ -39,7 +45,7 @@ TEST_CASE(mem_fully_allocate) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     const int* block = mem_alloc(&mem, 1);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
   }
 
   TEST_TRUE(mem_size(&mem) == NUM_BLOCKS);
@@ -50,15 +56,15 @@ TEST_CASE(mem_fill_then_free) {
   test_mem mem;
   mem_make(&mem);
 
-  int* blocks[NUM_BLOCKS] = {0};
+  int* blocks[NUM_BLOCKS] = {nullptr};
   for (int i = 0; i < NUM_BLOCKS; i++) {
     blocks[i] = mem_alloc(&mem, 1);
-    TEST_TRUE(blocks[i] != 0);
+    TEST_TRUE(blocks[i] != nullptr);
   }
 
   for (int i = 0; i < NUM_BLOCKS; i++) {
     mem_free(&mem, &blocks[i]);
-    TEST_EQUAL(blocks[i], 0); // Pointer should be set to 0 on free.
+    TEST_EQUAL(blocks[i], nullptr); // Pointer should be set to 0 on free.
   }
 
   TEST_EQUAL(count(&mem), 0);
@@ -74,12 +80,12 @@ TEST_CASE(mem_allocate_beyond_max_size) {
 
   // Fully allocate the mem.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    TEST_TRUE(mem_alloc(&mem, 1) != 0);
+    TEST_TRUE(mem_alloc(&mem, 1) != nullptr);
   }
 
   // Past the end.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    TEST_EQUAL(mem_alloc(&mem, 1), 0);
+    TEST_EQUAL(mem_alloc(&mem, 1), nullptr);
   }
 
   TEST_TRUE(mem_size(&mem) == NUM_BLOCKS);
@@ -105,7 +111,7 @@ TEST_CASE(mem_zero_free_block_after_free) {
   mem_make(&mem);
 
   int* val = mem_alloc(&mem, 1);
-  TEST_TRUE(val != 0);
+  TEST_TRUE(val != nullptr);
   *val = 177;
 
   int* old_val = val;
@@ -131,7 +137,7 @@ TEST_CASE(mem_traverse_partially_full) {
 
   for (int i = 0; i < N; ++i) {
     int* val = mem_alloc(&mem, 1);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -146,7 +152,7 @@ TEST_CASE(mem_traverse_full) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* val = mem_alloc(&mem, 1);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -161,7 +167,7 @@ TEST_CASE(mem_get_block) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* block = mem_alloc(&mem, 1);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
     *block = i;
     TEST_EQUAL(mem_get_chunk_handle(&mem, block), (size_t)i);
   }
@@ -179,7 +185,7 @@ TEST_CASE(mem_fragmentation) {
   test_mem mem;
   mem_make(&mem);
 
-  int* blocks[NUM_BLOCKS] = {0};
+  int* blocks[NUM_BLOCKS] = {nullptr};
   int  next_block         = 0;
 
 #define ALLOC(num_blocks)                           \
@@ -205,7 +211,7 @@ TEST_CASE(mem_fragmentation) {
 
   // Should be able to allocate 1 chunk of N blocks.
   const void* chunk = mem_alloc(&mem, NUM_BLOCKS);
-  TEST_TRUE(chunk != 0);
+  TEST_TRUE(chunk != nullptr);
 }
 
 // Clear and re-use an allocator.
@@ -216,15 +222,17 @@ TEST_CASE(mem_clear_then_reuse) {
   // Allocate chunks, contents not important.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* chunk = mem_alloc(&mem, 1);
-    TEST_TRUE(chunk != 0);
+    TEST_TRUE(chunk != nullptr);
   }
 
   mem_clear(&mem);
+  TEST_EQUAL(mem_size(&mem), 0);
+  TEST_EQUAL(mem_capacity(&mem), NUM_BLOCKS);
 
   // Allocate chunks and assign values 0..N.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* chunk = mem_alloc(&mem, 1);
-    TEST_TRUE(chunk != 0);
+    TEST_TRUE(chunk != nullptr);
     *chunk = i + 1;
   }
 
diff --git a/mempool/README.md b/mempool/README.md
index ed2935e..7eb950e 100644
--- a/mempool/README.md
+++ b/mempool/README.md
@@ -1,20 +1,15 @@
 # Mempool
 
-A memory pool implementation.
+A memory pool of fixed-sized blocks with O(1) allocation and deallocation.
 
 Each block in the pool is tagged with a boolean value that indicates whether the
-block is free or in use. The allocator otherwise maintains little additional
-information. Therefore, some operations have linear-time complexity.
-Specifically:
+block is free or in use, as well as a pointer to the next free/used block.
+Blocks thus form two lists, a free list and a used list. The allocator
+maintains the two lists when allocating/deallocating blocks.
 
-- Allocating a block scans the pool for the next free block in linear time.
-- Freeing a block runs in constant time.
-- Iterating over the pool's used blocks is linear over the number of blocks in
-  the pool, as opposed to just the number of used blocks.
+The allocator's internal data is stored separately from the block data so that
+the data remains tightly packed.
 
-The allocator's internal data is also stored separately from the main array of
-blocks so that the block data remains tightly packed.
-
-For convenience of programming and debugging, free blocks in the mempool always
-remain zeroed out. If your data structures are valid when zeroed out, then you
-do not need to explicitly initialize them.
+Free blocks in the mempool always remain zeroed out for convenience of
+programming and debugging. If the application's data structures are valid when
+zeroed out, then they do not need to be explicitly initialized.
diff --git a/mempool/include/mempool.h b/mempool/include/mempool.h
index 245173b..0de7ac6 100644
--- a/mempool/include/mempool.h
+++ b/mempool/include/mempool.h
@@ -64,15 +64,15 @@
 #define mempool_clear(POOL) mempool_clear_(&(POOL)->pool)
 
 /// Allocate a new block.
-/// Return 0 if there is no memory left.
+/// Return null if there is no memory left.
 /// When there is no space left in the pool, allocation can either trap
-/// (default) or gracefully return 0. Call mem_enable_traps() to toggle this
+/// (default) or gracefully return null. Call mem_enable_traps() to toggle this
 /// behaviour.
 /// New blocks are conveniently zeroed out.
 #define mempool_alloc(POOL) mempool_alloc_(&(POOL)->pool)
 
 /// Free the block.
-/// The block pointer is conveniently set to 0.
+/// The block pointer is conveniently set to null.
 #define mempool_free(POOL, BLOCK_PTR) \
   assert(*BLOCK_PTR);                 \
   mempool_free_(&(POOL)->pool, (void**)BLOCK_PTR)
@@ -106,8 +106,8 @@
 /// It is valid to mempool_free() the object at each step of the iteration.
 #define mempool_foreach(POOL, ITER, BODY)                                  \
   {                                                                        \
-    size_t i = (POOL)->pool.used;                                          \
     if ((POOL)->pool.num_used_blocks > 0) {                                \
+      size_t i = (POOL)->pool.used;                                        \
       do {                                                                 \
         if ((POOL)->pool.block_info[i].used) {                             \
           __typeof__((POOL)->object[0])* ITER =                            \
diff --git a/mempool/src/mempool.c b/mempool/src/mempool.c
index 46f1053..2c3c725 100644
--- a/mempool/src/mempool.c
+++ b/mempool/src/mempool.c
@@ -9,6 +9,7 @@
 /// All of the blocks in the pool are assumed free.
 static void init_free_list(mempool* pool) {
   assert(pool);
+  assert(pool->num_blocks > 0);
   for (size_t i = 0; i < pool->num_blocks - 1; ++i) {
     pool->block_info[i].next_free = i + 1;
   }
@@ -34,7 +35,7 @@ bool mempool_make_(
     block_info    = calloc(num_blocks, sizeof(BlockInfo));
     blocks        = calloc(num_blocks, block_size_bytes);
     pool->dynamic = true;
-    if ((block_info == 0) || (blocks == 0)) {
+    if ((block_info == nullptr) || (blocks == nullptr)) {
       return false;
     }
   } else {
@@ -55,22 +56,25 @@ void mempool_del_(mempool* pool) {
   if (pool->dynamic) {
     if (pool->block_info) {
       free(pool->block_info);
-      pool->block_info = 0;
+      pool->block_info = nullptr;
     }
     if (pool->blocks) {
       free(pool->blocks);
-      pool->blocks = 0;
+      pool->blocks = nullptr;
     }
   }
 }
 
 void mempool_clear_(mempool* pool) {
   assert(pool);
-  pool->head = 0;
-  pool->used = 0;
-  memset(pool->blocks, 0, pool->num_blocks * pool->block_size_bytes);
-  memset(pool->block_info, 0, pool->num_blocks * sizeof(BlockInfo));
-  init_free_list(pool);
+  if (pool->num_blocks > 0) {
+    pool->head            = 0;
+    pool->used            = 0;
+    pool->num_used_blocks = 0;
+    memset(pool->blocks, 0, pool->num_blocks * pool->block_size_bytes);
+    memset(pool->block_info, 0, pool->num_blocks * sizeof(BlockInfo));
+    init_free_list(pool);
+  }
 }
 
 void* mempool_alloc_(mempool* pool) {
@@ -81,7 +85,7 @@ void* mempool_alloc_(mempool* pool) {
     if (pool->trap) {
       FAIL("mempool allocation failed, increase the pool's capacity.");
     }
-    return 0; // Pool is full.
+    return nullptr; // Pool is full.
   }
 
   // Allocate the block.
@@ -124,7 +128,7 @@ void mempool_free_(mempool* pool, void** block_ptr) {
 
   pool->num_used_blocks--;
 
-  *block_ptr = 0;
+  *block_ptr = nullptr;
 }
 
 void* mempool_get_block_(const mempool* pool, size_t block_index) {
diff --git a/mempool/test/mempool_test.c b/mempool/test/mempool_test.c
index 843f7e7..69658b9 100644
--- a/mempool/test/mempool_test.c
+++ b/mempool/test/mempool_test.c
@@ -25,13 +25,19 @@ TEST_CASE(mempool_create) {
 }
 
 // Create a dynamically-backed pool.
-TEST_CASE(mem_create_dyn) {
+TEST_CASE(mempool_create_dyn) {
   DEF_MEMPOOL_DYN(dyn_pool, int);
 
   dyn_pool pool;
   mempool_make_dyn(&pool, NUM_BLOCKS, sizeof(int));
 }
 
+// Clear an uninitialized pool.
+TEST_CASE(mempool_clear_uninitialized) {
+  test_pool pool = {0};
+  mempool_clear(&pool);
+}
+
 // Allocate all N blocks.
 TEST_CASE(mempool_allocate_until_full) {
   test_pool pool;
@@ -39,7 +45,7 @@ TEST_CASE(mempool_allocate_until_full) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     const int* block = mempool_alloc(&pool);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
   }
 
   TEST_TRUE(mempool_size(&pool) == NUM_BLOCKS);
@@ -50,10 +56,10 @@ TEST_CASE(mempool_fill_then_free) {
   test_pool pool;
   mempool_make(&pool);
 
-  int* blocks[NUM_BLOCKS] = {0};
+  int* blocks[NUM_BLOCKS] = {nullptr};
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     blocks[i] = mempool_alloc(&pool);
-    TEST_TRUE(blocks[i] != 0);
+    TEST_TRUE(blocks[i] != nullptr);
   }
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
@@ -74,7 +80,7 @@ TEST_CASE(mempool_allocate_beyond_max_size) {
 
   // Fully allocate the pool.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    TEST_TRUE(mempool_alloc(&pool) != 0);
+    TEST_TRUE(mempool_alloc(&pool) != nullptr);
   }
 
   // Past the end.
@@ -105,7 +111,7 @@ TEST_CASE(mempool_zero_free_block_after_free) {
   mempool_make(&pool);
 
   int* val = mempool_alloc(&pool);
-  TEST_TRUE(val != 0);
+  TEST_TRUE(val != nullptr);
   *val = 177;
 
   int* old_val = val;
@@ -131,7 +137,7 @@ TEST_CASE(mempool_traverse_partially_full) {
 
   for (int i = 0; i < N; ++i) {
     int* val = mempool_alloc(&pool);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -146,7 +152,7 @@ TEST_CASE(mempool_traverse_full) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* val = mempool_alloc(&pool);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -161,7 +167,7 @@ TEST_CASE(mempool_get_block) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* block = mempool_alloc(&pool);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
     *block = i;
     TEST_EQUAL(mempool_get_block_index(&pool, block), (size_t)i);
   }
@@ -172,22 +178,24 @@ TEST_CASE(mempool_get_block) {
 }
 
 // Clear and re-use an allocator.
-TEST_CASE(mem_clear_then_reuse) {
+TEST_CASE(mempool_clear_then_reuse) {
   test_pool mem;
   mempool_make(&mem);
 
   // Allocate chunks, contents not important.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    int* chunk = mempool_alloc(&mem);
-    TEST_TRUE(chunk != 0);
+    const int* chunk = mempool_alloc(&mem);
+    TEST_TRUE(chunk != nullptr);
   }
 
   mempool_clear(&mem);
+  TEST_EQUAL(mempool_size(&mem), 0);
+  TEST_EQUAL(mempool_capacity(&mem), NUM_BLOCKS);
 
   // Allocate chunks and assign values 0..N.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* chunk = mempool_alloc(&mem);
-    TEST_TRUE(chunk != 0);
+    TEST_TRUE(chunk != nullptr);
     *chunk = i + 1;
   }
 
diff --git a/memstack/CMakeLists.txt b/memstack/CMakeLists.txt
new file mode 100644
index 0000000..9ad1aa1
--- /dev/null
+++ b/memstack/CMakeLists.txt
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(memstack)
+
+set(CMAKE_C_STANDARD 23)
+set(CMAKE_C_STANDARD_REQUIRED On)
+set(CMAKE_C_EXTENSIONS Off)
+
+# Library
+
+add_library(memstack
+  src/memstack.c)
+
+target_include_directories(memstack PUBLIC
+  include)
+
+target_link_libraries(memstack PRIVATE
+  cassert)
+
+target_compile_options(memstack PRIVATE -Wall -Wextra)
+
+# Test
+
+add_executable(memstack_test
+  test/memstack_test.c)
+
+target_link_libraries(memstack_test
+  memstack)
+
+target_compile_options(memstack_test PRIVATE -DUNIT_TEST -DNDEBUG -Wall -Wextra)
diff --git a/memstack/README.md b/memstack/README.md
new file mode 100644
index 0000000..7eb950e
--- /dev/null
+++ b/memstack/README.md
@@ -0,0 +1,15 @@
+# Mempool
+
+A memory pool of fixed-sized blocks with O(1) allocation and deallocation.
+
+Each block in the pool is tagged with a boolean value that indicates whether the
+block is free or in use, as well as a pointer to the next free/used block.
+Blocks thus form two lists, a free list and a used list. The allocator
+maintains the two lists when allocating/deallocating blocks.
+
+The allocator's internal data is stored separately from the block data so that
+the data remains tightly packed.
+
+Free blocks in the mempool always remain zeroed out for convenience of
+programming and debugging. If the application's data structures are valid when
+zeroed out, then they do not need to be explicitly initialized.
diff --git a/memstack/include/memstack.h b/memstack/include/memstack.h
new file mode 100644
index 0000000..93cd2e6
--- /dev/null
+++ b/memstack/include/memstack.h
@@ -0,0 +1,66 @@
+/*
+ * Stack-based allocator.
+ */
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+/// Stack-based allocator.
+typedef struct memstack {
+  size_t   capacity;  // Total size available.
+  uint8_t* base;      // Base pointer to memory.
+  uint8_t* watermark; // Pointer to next free area of memory.
+  bool     owned;     // True if memory is owned by the memstack.
+  bool     trap;      // Whether to trap when allocating beyond capacity.
+} memstack;
+
+/// Create a stack-based allocator.
+///
+/// `stack` may be user-provided or null.
+/// - If null, the allocator malloc()s the memory for them.
+/// - If given, `stack` must be at least `capacity` bytes.
+///
+/// The memory is zeroed out for convenience.
+bool memstack_make(memstack*, size_t capacity, void* memory);
+
+/// Destroy the stack.
+///
+/// If the allocator owns the memory, then this function frees it.
+void memstack_del(memstack*);
+
+/// Clear the stack.
+void memstack_clear(memstack*);
+
+/// Return the top of the stack.
+size_t memstack_watermark(const memstack*);
+
+/// Set the top of the stack.
+void memstack_set_watermark(memstack*, size_t watermark);
+
+/// Allocate a new block.
+///
+/// Return null if the block does not fit in the remaining memory.
+///
+/// When there is no space left in the stack, allocation can either trap
+/// (default) or gracefully return null. Call mem_enable_traps() to toggle this
+/// behaviour.
+///
+/// Newly allocated blocks are conveniently zeroed out.
+void* memstack_alloc(memstack*, size_t bytes);
+
+/// Allocate a new aligned block.
+///
+/// An alignment of 0 is allowed for convenience and has the same effect as 1.
+///
+/// Has the same properties as memstack_alloc().
+void* memstack_alloc_aligned(memstack*, size_t bytes, size_t alignment);
+
+/// Return the stack's used size in bytes.
+size_t memstack_size(const memstack*);
+
+/// Return the stack's total capacity in bytes.
+size_t memstack_capacity(const memstack*);
+
+/// Set whether to trap when attempting to allocate beyond capacity.
+void memstack_enable_traps(memstack*, bool);
diff --git a/memstack/src/memstack.c b/memstack/src/memstack.c
new file mode 100644
index 0000000..84131ef
--- /dev/null
+++ b/memstack/src/memstack.c
@@ -0,0 +1,119 @@
+#include "memstack.h"
+
+#include <cassert.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+static bool is_pow2_or_0(size_t x) { return (x & (x - 1)) == 0; }
+
+/// Align the given address to the next address that is a multiple of the
+/// alignment. If the given address is already aligned, return the address.
+static uint8_t* align(uint8_t* address, size_t alignment) {
+  assert(is_pow2_or_0(alignment));
+  const size_t mask = alignment - 1;
+  return (uint8_t*)(((uintptr_t)address + mask) & ~mask);
+}
+
+bool memstack_make(memstack* stack, size_t capacity, void* memory) {
+  assert(stack);
+  assert(capacity >= 1);
+
+  // Allocate memory if not user-provided.
+  uint8_t* stack_memory = memory;
+  if (!stack_memory) {
+    stack_memory = calloc(1, capacity);
+    if (stack_memory == nullptr) {
+      return false;
+    }
+  }
+  assert(stack_memory);
+
+  stack->capacity  = capacity;
+  stack->base      = stack_memory;
+  stack->watermark = stack_memory;
+  stack->owned     = (stack_memory != memory);
+  stack->trap      = true;
+
+  return true;
+}
+
+void memstack_del(memstack* stack) {
+  assert(stack);
+
+  if (stack->owned && (stack->base != nullptr)) {
+    free(stack->base);
+    stack->base  = nullptr;
+    stack->owned = false;
+  }
+
+  stack->capacity  = 0;
+  stack->watermark = stack->base;
+}
+
+void memstack_clear(memstack* stack) {
+  assert(stack);
+
+  stack->watermark = stack->base;
+  memset(stack->base, 0, stack->capacity);
+}
+
+size_t memstack_watermark(const memstack* stack) {
+  assert(stack);
+  return stack->watermark - stack->base;
+}
+
+void memstack_set_watermark(memstack* stack, size_t watermark) {
+  assert(stack);
+  const bool fits = (watermark < stack->capacity);
+  if (stack->trap && !fits) {
+    FAIL("memstack watermark update failed, bad watermark");
+  }
+  assert(fits);
+  stack->watermark = stack->base + watermark;
+}
+
+void* memstack_alloc(memstack* stack, size_t bytes) {
+  assert(stack);
+
+  if ((memstack_size(stack) + bytes) > stack->capacity) {
+    if (stack->trap) {
+      FAIL("memstack allocation failed, increase the stack's capacity.");
+    }
+    return nullptr; // Block does not fit in remaining memory.
+  }
+
+  // Allocate the block.
+  uint8_t* const block = stack->watermark;
+  stack->watermark += bytes;
+  assert(memstack_size(stack) <= stack->capacity);
+
+  return block;
+}
+
+void* memstack_alloc_aligned(memstack* stack, size_t bytes, size_t alignment) {
+  assert(stack);
+
+  uint8_t* const new_watermark = align(stack->watermark, alignment);
+  assert(new_watermark >= stack->watermark);
+  assert((size_t)(new_watermark - stack->base) <= stack->capacity);
+  stack->capacity -= (new_watermark - stack->watermark);
+  stack->watermark = new_watermark;
+
+  return memstack_alloc(stack, bytes);
+}
+
+size_t memstack_size(const memstack* stack) {
+  assert(stack);
+  return stack->watermark - stack->base;
+}
+
+size_t memstack_capacity(const memstack* stack) {
+  assert(stack);
+  return stack->capacity;
+}
+
+void memstack_enable_traps(memstack* stack, bool enable) {
+  assert(stack);
+  stack->trap = enable;
+}
diff --git a/memstack/test/memstack_test.c b/memstack/test/memstack_test.c
new file mode 100644
index 0000000..2bcffcd
--- /dev/null
+++ b/memstack/test/memstack_test.c
@@ -0,0 +1,171 @@
+#include "memstack.h"
+
+#include "test.h"
+
+#define NUM_INTS 10
+#define CAPACITY (NUM_INTS * sizeof(int))
+
+// Create and destroy a statically-backed stack.
+TEST_CASE(memstack_create) {
+  int memory[CAPACITY];
+
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, memory);
+  memstack_del(&stack);
+}
+
+// Create and destroy a dynamically-backed stack.
+TEST_CASE(memstack_create_dyn) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+  memstack_del(&stack);
+}
+
+// Clear an uninitialized stack.
+TEST_CASE(memstack_clear_uninitialized) {
+  memstack stack = {0};
+  memstack_clear(&stack);
+}
+
+// Allocate all N ints.
+TEST_CASE(memstack_allocate_until_full) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  for (int i = 0; i < NUM_INTS; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+  }
+
+  TEST_TRUE(memstack_size(&stack) == CAPACITY);
+
+  memstack_del(&stack);
+}
+
+// Allocate all N ints, then free them.
+TEST_CASE(memstack_fill_then_free) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  int* blocks[NUM_INTS] = {nullptr};
+  for (int i = 0; i < NUM_INTS; ++i) {
+    blocks[i] = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(blocks[i] != nullptr);
+  }
+
+  memstack_clear(&stack);
+
+  TEST_EQUAL(memstack_size(&stack), 0);
+
+  memstack_del(&stack);
+}
+
+// Attempt to allocate blocks past the maximum stack size.
+// The stack should handle the failed allocations gracefully.
+TEST_CASE(memstack_allocate_beyond_max_size) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+  memstack_enable_traps(&stack, false);
+
+  // Fully allocate the stack.
+  for (int i = 0; i < NUM_INTS; ++i) {
+    TEST_TRUE(memstack_alloc(&stack, sizeof(int)) != nullptr);
+  }
+
+  // Past the end.
+  for (int i = 0; i < NUM_INTS; ++i) {
+    TEST_EQUAL(memstack_alloc(&stack, sizeof(int)), nullptr);
+  }
+
+  TEST_TRUE(memstack_size(&stack) == CAPACITY);
+
+  memstack_del(&stack);
+}
+
+// Free blocks should always remain zeroed out.
+// This tests the invariant right after creating the stack.
+TEST_CASE(memstack_zero_free_blocks_after_creation) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  for (int i = 0; i < NUM_INTS; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+    TEST_EQUAL(*block, 0);
+  }
+
+  memstack_del(&stack);
+}
+
+// Free blocks should always remain zeroed out.
+// This tests the invariant after clearing the stack and allocating a new block.
+TEST_CASE(memstack_zero_free_block_after_free) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  for (int i = 0; i < NUM_INTS; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+    TEST_EQUAL(*block, 0);
+  }
+
+  memstack_clear(&stack);
+
+  for (int i = 0; i < NUM_INTS; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+    TEST_EQUAL(*block, 0);
+  }
+
+  memstack_del(&stack);
+}
+
+// Aligned allocations should be properly aligned.
+TEST_CASE(memstack_alloc_aligned) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  // -1 because the base address of the memory storage might be unaligned.
+  for (int i = 0; i < NUM_INTS - 1; ++i) {
+    const int* block =
+        memstack_alloc_aligned(&stack, sizeof(int), alignof(int));
+    TEST_TRUE(block != nullptr);
+    TEST_EQUAL(*block, 0);
+    TEST_EQUAL((uintptr_t)block % alignof(int), 0);
+  }
+
+  memstack_del(&stack);
+}
+
+// Get and set the watermark.
+TEST_CASE(memstack_watermark) {
+  memstack stack = {0};
+  memstack_make(&stack, CAPACITY, nullptr);
+
+  // Allocate N/2 ints.
+  for (int i = 0; i < NUM_INTS / 2; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+  }
+
+  const size_t watermark = memstack_watermark(&stack);
+
+  // Allocate the remaining N/2 ints.
+  for (int i = 0; i < NUM_INTS / 2; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+  }
+
+  // Now reset the watermark halfway through.
+  memstack_set_watermark(&stack, watermark);
+
+  // Allocate the remaining N/2 ints (again).
+  for (int i = 0; i < NUM_INTS / 2; ++i) {
+    const int* block = memstack_alloc(&stack, sizeof(int));
+    TEST_TRUE(block != nullptr);
+  }
+
+  memstack_del(&stack);
+}
+
+int main() { return 0; }
diff --git a/memstack/test/test.h b/memstack/test/test.h
new file mode 100644
index 0000000..fd8dc22
--- /dev/null
+++ b/memstack/test/test.h
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+#pragma once
+
+#ifdef UNIT_TEST
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ||     \
+    defined(__NetBSD__) || defined(__OpenBSD__)
+#define USE_SYSCTL_FOR_ARGS 1
+// clang-format off
+#include <sys/types.h>
+#include <sys/sysctl.h>
+// clang-format on
+#include <unistd.h>        // getpid
+#endif
+
+struct test_file_metadata;
+
+struct test_failure {
+        bool present;
+        const char *message;
+        const char *file;
+        int line;
+};
+
+struct test_case_metadata {
+        void (*fn)(struct test_case_metadata *, struct test_file_metadata *);
+        struct test_failure failure;
+        const char *name;
+        struct test_case_metadata *next;
+};
+
+struct test_file_metadata {
+        bool registered;
+        const char *name;
+        struct test_file_metadata *next;
+        struct test_case_metadata *tests;
+};
+
+struct test_file_metadata __attribute__((weak)) * test_file_head;
+
+#define SET_FAILURE(_message)                                                             \
+        metadata->failure = (struct test_failure) {                                       \
+                .message = _message, .file = __FILE__, .line = __LINE__, .present = true, \
+        }
+
+#define TEST_EQUAL(a, b)                                                                 \
+        do {                                                                             \
+                if ((a) != (b)) {                                                        \
+                        SET_FAILURE(#a " != " #b);                                       \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_TRUE(a)                                                                     \
+        do {                                                                             \
+                if (!(a)) {                                                              \
+                        SET_FAILURE(#a " is not true");                                  \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_STREQUAL(a, b)                                                              \
+        do {                                                                             \
+                if (strcmp(a, b) != 0) {                                                 \
+                        SET_FAILURE(#a " != " #b);                                       \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_CASE(_name)                                                                  \
+        static void __test_h_##_name(struct test_case_metadata *,                         \
+                                     struct test_file_metadata *);                        \
+        static struct test_file_metadata __test_h_file;                                   \
+        static struct test_case_metadata __test_h_meta_##_name = {                        \
+            .name = #_name,                                                               \
+            .fn = __test_h_##_name,                                                       \
+        };                                                                                \
+        static void __attribute__((constructor(101))) __test_h_##_name##_register(void) { \
+                __test_h_meta_##_name.next = __test_h_file.tests;                         \
+                __test_h_file.tests = &__test_h_meta_##_name;                             \
+                if (!__test_h_file.registered) {                                          \
+                        __test_h_file.name = __FILE__;                                    \
+                        __test_h_file.next = test_file_head;                              \
+                        test_file_head = &__test_h_file;                                  \
+                        __test_h_file.registered = true;                                  \
+                }                                                                         \
+        }                                                                                 \
+        static void __test_h_##_name(                                                     \
+            struct test_case_metadata *metadata __attribute__((unused)),                  \
+            struct test_file_metadata *file_metadata __attribute__((unused)))
+
+extern void __attribute__((weak)) (*test_h_unittest_setup)(void);
+/// Run defined tests, return true if all tests succeeds
+/// @param[out] tests_run if not NULL, set to whether tests were run
+static inline void __attribute__((constructor(102))) run_tests(void) {
+        bool should_run = false;
+#ifdef USE_SYSCTL_FOR_ARGS
+        int mib[] = {
+                CTL_KERN,
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+                KERN_PROC_ARGS,
+                getpid(),
+                KERN_PROC_ARGV,
+#else
+                KERN_PROC,
+                KERN_PROC_ARGS,
+                getpid(),
+#endif
+        };
+        char *arg = NULL;
+        size_t arglen;
+        sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &arglen, NULL, 0);
+        arg = malloc(arglen);
+        sysctl(mib, sizeof(mib) / sizeof(mib[0]), arg, &arglen, NULL, 0);
+#else
+        FILE *cmdlinef = fopen("/proc/self/cmdline", "r");
+        char *arg = NULL;
+        int arglen;
+        fscanf(cmdlinef, "%ms%n", &arg, &arglen);
+        fclose(cmdlinef);
+#endif
+        for (char *pos = arg; pos < arg + arglen; pos += strlen(pos) + 1) {
+                if (strcmp(pos, "--unittest") == 0) {
+                        should_run = true;
+                        break;
+                }
+        }
+        free(arg);
+
+        if (!should_run) {
+                return;
+        }
+
+        if (&test_h_unittest_setup) {
+                test_h_unittest_setup();
+        }
+
+        struct test_file_metadata *i = test_file_head;
+        int failed = 0, success = 0;
+        while (i) {
+                fprintf(stderr, "Running tests from %s:\n", i->name);
+                struct test_case_metadata *j = i->tests;
+                while (j) {
+                        fprintf(stderr, "\t%s ... ", j->name);
+                        j->failure.present = false;
+                        j->fn(j, i);
+                        if (j->failure.present) {
+                                fprintf(stderr, "failed (%s at %s:%d)\n", j->failure.message,
+                                        j->failure.file, j->failure.line);
+                                failed++;
+                        } else {
+                                fprintf(stderr, "passed\n");
+                                success++;
+                        }
+                        j = j->next;
+                }
+                fprintf(stderr, "\n");
+                i = i->next;
+        }
+        int total = failed + success;
+        fprintf(stderr, "Test results: passed %d/%d, failed %d/%d\n", success, total,
+                failed, total);
+        exit(failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+
+#else
+
+#include <stdbool.h>
+
+#define TEST_CASE(name) static void __attribute__((unused)) __test_h_##name(void)
+
+#define TEST_EQUAL(a, b)                                                                 \
+        (void)(a);                                                                       \
+        (void)(b)
+#define TEST_TRUE(a) (void)(a)
+#define TEST_STREQUAL(a, b)                                                              \
+        (void)(a);                                                                       \
+        (void)(b)
+
+#endif
diff --git a/plugin/src/plugin.c b/plugin/src/plugin.c
index e2aae1f..3a0ef5d 100644
--- a/plugin/src/plugin.c
+++ b/plugin/src/plugin.c
@@ -64,14 +64,14 @@ static bool load_library(Plugin* plugin) {
   // Handle reloading a previously-loaded library.
   if (plugin->handle) {
     dlclose(plugin->handle);
-    plugin->handle = 0;
+    plugin->handle = nullptr;
   }
 
   const mstring lib = plugin_lib_path(plugin);
 
   // If the plugin fails to load, make sure to keep the plugin's old handle to
   // handle the error gracefully. This handles reload failures, specifically.
-  void* handle = 0;
+  void* handle = nullptr;
   if ((handle = dlopen(mstring_cstr(&lib), RTLD_NOW))) {
     LOGD("Plugin [%s] loaded successfully", mstring_cstr(&plugin->filename));
     plugin->handle = handle;
@@ -86,7 +86,7 @@ static bool load_library(Plugin* plugin) {
 static void delete_plugin_state(Plugin* plugin) {
   if (plugin->state) {
     free(plugin->state);
-    plugin->state = 0;
+    plugin->state = nullptr;
   }
 }
 
@@ -105,7 +105,7 @@ static void destroy_plugin(Plugin* plugin) {
   if (plugin) {
     if (plugin->handle) {
       dlclose(plugin->handle);
-      plugin->handle = 0;
+      plugin->handle = nullptr;
     }
     delete_plugin_state(plugin);
   }
@@ -118,7 +118,7 @@ Plugin* load_plugin(PluginEngine* eng, const char* filename) {
   Plugin plugin = (Plugin){.eng = eng, .filename = mstring_make(filename)};
 
   if (!load_library(&plugin)) {
-    return 0;
+    return nullptr;
   }
 
   list_add(eng->plugins, plugin);
@@ -132,7 +132,7 @@ void delete_plugin(Plugin** pPlugin) {
     assert(plugin->eng);
     destroy_plugin(plugin);
     list_remove_ptr(plugin->eng->plugins, plugin);
-    *pPlugin = 0;
+    *pPlugin = nullptr;
   }
 }
 
@@ -148,7 +148,7 @@ bool plugin_reloaded(Plugin* plugin) {
 // -----------------------------------------------------------------------------
 
 PluginEngine* new_plugin_engine(const PluginEngineDesc* desc) {
-  PluginEngine* eng = 0;
+  PluginEngine* eng = nullptr;
 
   if (!(eng = calloc(1, sizeof(PluginEngine)))) {
     goto cleanup;
@@ -173,7 +173,7 @@ PluginEngine* new_plugin_engine(const PluginEngineDesc* desc) {
 
 cleanup:
   delete_plugin_engine(&eng);
-  return 0;
+  return nullptr;
 }
 
 void delete_plugin_engine(PluginEngine** pEng) {
@@ -191,7 +191,7 @@ void delete_plugin_engine(PluginEngine** pEng) {
       close(eng->inotify_instance);
     }
     free(eng);
-    *pEng = 0;
+    *pEng = nullptr;
   }
 }
 
diff --git a/timer/include/timer.h b/timer/include/timer.h
index 94781d6..6dc87d9 100644
--- a/timer/include/timer.h
+++ b/timer/include/timer.h
@@ -20,7 +20,7 @@ typedef struct timespec time_point;
 typedef uint64_t time_delta;
 
 /// A high resolution timer.
-typedef struct {
+typedef struct Timer {
   time_point start_time;   // The instant the timer was last started.
   time_point last_tick;    // The instant the timer was last ticked.
   time_delta running_time; // Time elapsed since the timer was last started.
@@ -53,6 +53,9 @@ time_delta sec_to_time_delta(double seconds);
 /// Convert the time point to nanoseconds.
 uint64_t time_point_to_ns(time_point);
 
+/// Add a time delta to a timestamp.
+time_point time_add(time_point, time_delta);
+
 /// Put the caller thread to sleep for the given amount of time.
 void time_sleep(time_delta dt);
 
diff --git a/timer/src/timer.c b/timer/src/timer.c
index da3485b..d886f59 100644
--- a/timer/src/timer.c
+++ b/timer/src/timer.c
@@ -7,9 +7,9 @@
 #endif
 
 #ifdef _WIN32
-static const int64_t microseconds = 1000000;
+static constexpr uint64_t microseconds = 1000000;
 #endif
-static const int64_t nanoseconds = 1000000000;
+static constexpr uint64_t nanoseconds = 1000000000;
 
 #ifdef _WIN32
 static double seconds_per_count;
@@ -49,7 +49,7 @@ time_point time_now(void) {
 #ifdef _WIN32
   QueryPerformanceCounter((LARGE_INTEGER*)&t);
 #else
-  clock_gettime(CLOCK_REALTIME, &t);
+  clock_gettime(CLOCK_MONOTONIC_RAW, &t);
 #endif
   return t;
 }
@@ -61,7 +61,8 @@ time_delta time_diff(time_point start, time_point end) {
   // another processor, then the delta time can be negative.
   return std::max(0, end - start);
 #else
-  return (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
+  return (end.tv_sec - start.tv_sec) * nanoseconds +
+         (end.tv_nsec - start.tv_nsec);
 #endif
 }
 
@@ -85,19 +86,30 @@ uint64_t time_point_to_ns(time_point t) {
 #ifdef _WIN32
   return (uint64_t)((double)t * seconds_per_count * 1.0e+9);
 #else
-  return (uint64_t)t.tv_sec * 1e+9 + (uint64_t)t.tv_nsec;
+  return (uint64_t)t.tv_sec * nanoseconds + (uint64_t)t.tv_nsec;
 #endif
 }
 
+time_point time_add(time_point t, time_delta dt) {
+  time_point out;
+#ifdef _WIN32
+  out = t + dt;
+#else
+  out.tv_sec  = t.tv_sec + (__time_t)(dt / nanoseconds);
+  out.tv_nsec = t.tv_nsec + (__time_t)(dt % nanoseconds);
+#endif
+  return out;
+}
+
 void time_sleep(time_delta dt) {
 #ifdef _WIN32
-  const int64_t ms = dt / microseconds;
+  const uint64_t ms = dt / microseconds;
   Sleep((DWORD)(ms));
 #else
-  const int64_t   sec = dt / nanoseconds;
+  const uint64_t  sec = dt / nanoseconds;
   struct timespec ts;
   ts.tv_sec  = (long)sec;
   ts.tv_nsec = (long)(dt % nanoseconds);
-  nanosleep(&ts, NULL);
+  nanosleep(&ts, nullptr);
 #endif
 }