List utility

src/util/list.c

@@ -0,0 +1,64 @@
+#include "list.h"
+
+#include <stdlib.h> // memory
+
+#include <util/out.h>
+
+typedef struct ListBlock {
+    void* * array;
+    int size, full;
+    struct ListBlock* next;
+} ListBlock;
+
+struct List {
+    ListBlock *head, *tail;
+    int blocksize;
+};
+
+List* create_list(int blocksize) {
+    List* l = malloc(sizeof(List));
+    if (!l) {
+        PRINT_ERROR("internal: failed to allocate memory");
+        return NULL;
+    }
+    l->blocksize = blocksize;
+    l->head = l->tail = NULL;
+}
+
+int destroy_list(List* l) {
+    // Free all blocks.
+    ListBlock *lb = l->head, *next;
+    while (lb) {
+        next = lb->next;
+        free(lb->array);
+        lb = next;
+    }
+    free(l);
+    return 0;
+}
+
+void* lget_element(List* l, int index) {
+    int i = index;
+    ListBlock* lb = l->head;
+    if (index < 0) {
+        PRINT_ERROR("internal: list index was negative (%d)", index);
+        return NULL;
+    }
+    // We see if the index is in range of the current block length. If not,
+    // repeat with the next block.
+    while (i >= lb->size) {
+        if (lb) {
+            lb = lb->next;
+            i -= lb->size;
+        } else {
+            PRINT_ERROR("internal: list index %d out of bounds", index);
+            return NULL;
+        }
+    }
+    // Now the index is in range and we are at the list block we wish to access.
+    if (i >= lb->full) {
+        PRINT_ERROR("internal: list index %d out of bounds", index);
+        return NULL;
+    }
+    return lb->array[i];
+}

src/util/list.h

@@ -0,0 +1,32 @@
+/**
+ * Utilities for variable-length lists, so we don't always have to use fixed-
+ * length arrays.
+ * The two extreme approaches are linked lists, which are fast to resize but
+ * slow to access (and for that matter, bad for memory management), and fixed-
+ * size arrays, which are fast to access but slow to resize. We can go for an
+ * intermediate approach with a linked list *of* fixed-size arrays to compromise
+ * and get the middlest of both worlds.
+ */
+
+#pragma once
+
+struct List;
+typedef
+    struct List
+    List;
+
+// Make and destroy lists.
+struct List* create_list(int blocksize);
+int destroy_list(List* l);
+
+// Access the n-th element of a list.
+void* lget_element(List* l, int index);
+// Add new element. Returns success (0) or failure (-1).
+int ladd_element(List* l, void* element);
+// Set n-th element.
+int lset_element(List* l, int index, void* value);
+// Iterate over elements. This takes a highly customizable approach. We pass in
+// a function which takes a void* pointer and returns an int, and we pass this
+// function over every void* element in the list. We return the sum of all
+// return values thus accumulated.
+int literate(List* l, int (*fn)(void*));

src/util/out.h

@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include <stdio.h> // stderr
+
 // All of the color codes.
 #define CODE_RED 31
 #define CODE_YELLOW 33