Initial commit.

1 files changed, 79 insertions, 0 deletions

diff --git a/listpool/include/listpool.h b/listpool/include/listpool.h
new file mode 100644
index 0000000..a5e4955
--- /dev/null
+++ b/listpool/include/listpool.h
@@ -0,0 +1,79 @@
+#pragma once
+
+#include "list.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/// Define a typed listpool of a given size.
+#define DEF_LISTPOOL(POOL, TYPE, NUM_BLOCKS)                                   \
+  typedef struct POOL {                                                        \
+    listpool pool;                                                             \
+    list nodes[NUM_BLOCKS];                                                    \
+    TYPE blocks[NUM_BLOCKS];                                                   \
+  } POOL;
+
+/// Creates a new listpool.
+#define listpool_make(POOL)                                                    \
+  {                                                                            \
+    assert(POOL);                                                              \
+    const size_t block_size = sizeof((POOL)->blocks[0]);                       \
+    const size_t num_blocks = sizeof((POOL)->blocks) / block_size;             \
+    listpool_make_(&(POOL)->pool, (POOL)->nodes, (POOL)->blocks, num_blocks,   \
+                   block_size);                                                \
+  }
+
+/// Allocate a new block.
+/// Return 0 if there is no memory left.
+#define listpool_alloc(POOL) listpool_alloc_(&(POOL)->pool)
+
+/// Free the block.
+/// The block pointer is conveniently set to 0.
+#define listpool_free(POOL, ITEM) listpool_free_(&(POOL)->pool, (void**)ITEM)
+
+/// Remove a value from the list.
+/// Defined here instead of DEF_LISTPOOL_IMPL() because not all types may have
+/// an operator==.
+#define listpool_remove(POOL, VAL)                                             \
+  {                                                                            \
+    listpool_foreach(POOL, iter, {                                             \
+      if (*iter == VAL) {                                                      \
+        listpool_free(POOL, &iter);                                            \
+        break;                                                                 \
+      }                                                                        \
+    });                                                                        \
+  }
+
+/// Iterate over the used items of the pool.
+#define listpool_foreach(POOL, ITER, BODY)                                     \
+  for (list* it_ = (POOL)->pool.used; it_; it_ = it_->next) {                  \
+    typeof((POOL)->blocks[0])* ITER =                                          \
+        &(POOL)->blocks[it_ - (POOL)->pool.nodes];                             \
+    (void)ITER;                                                                \
+    BODY;                                                                      \
+  }
+
+typedef struct listpool {
+  size_t block_size_bytes;
+  size_t num_blocks;
+  list* free;      // Head of the free list.
+  list* used;      // Head of the used list.
+  list* nodes;     // Array of nodes.
+  uint8_t* blocks; // Array of blocks;
+} listpool;
+
+/// Create a new list pool from a user-provided array of memory.
+/// `nodes` must have at least `num_blocks` nodes.
+/// `blocks` must be at least `num_blocks` * `block_size_bytes` bytes.
+/// All blocks are zeroed out for convenience.
+void listpool_make_(listpool* pool, list* nodes, void* blocks,
+                    size_t num_blocks, size_t block_size_bytes);
+
+/// Allocate a new block.
+/// Return 0 if there is no memory left.
+void* listpool_alloc_(listpool* pool);
+
+/// Free the block.
+/// The block pointer is conveniently set to 0.
+void listpool_free_(listpool* pool, void** block_ptr);