fix: also lint internal header files

Makefile

@@ -11,7 +11,7 @@ INC_DIRS ?= include
 LIB := $(BUILD_DIR)/$(LIB_FILENAME)
 
 SRCS != find '$(SRC_DIR)' -iname '*.c'
-SRCS_H != find $(INC_DIRS) -iname '*.h'
+SRCS_H != find $(INC_DIRS) '$(SRC_DIR)' -iname '*.h'
 SRCS_TEST != find '$(TEST_DIR)' -iname '*.c'
 
 OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
@@ -66,15 +66,9 @@ $(TARGETS_TEST): test-%: %
 $(TARGETS_MEM_TEST): test-mem-%: %
 	valgrind --tool=memcheck --error-exitcode=1 --track-origins=yes --leak-check=full ./$^
 
-test-mem: build-test
-	@ $(foreach bin,$(BINS_TEST),valgrind --tool=memcheck --error-exitcode=1 \
-		--track-origins=yes --leak-check=full ./$(bin);)
-
 .PHONY: build-test
 build-test: $(BINS_TEST)
 
-# For simplicity, we link every object file to each of the test files. This
-# might be changed later if this starts to become too slow.
 $(BINS_TEST): %: %.c.o $(LIB)
 	$(CC) \
 		$^ -o $@

src/heap/vieter_heap_tree.h

@@ -5,16 +5,16 @@
 #include <stdlib.h>
 
 typedef struct vieter_heap_node {
-    uint64_t key;
+  uint64_t key;
-    void *data;
+  void *data;
-    struct vieter_heap_node *largest_order;
+  struct vieter_heap_node *largest_order;
-    union {
+  union {
-      // Roots point to next tree in the heap, other nodes point to their first
+    // Roots point to next tree in the heap, other nodes point to their first
-      // neighbour.
+    // neighbour.
-      struct vieter_heap_node *next_tree;
+    struct vieter_heap_node *next_tree;
-      struct vieter_heap_node *next_largest_order;
+    struct vieter_heap_node *next_largest_order;
-    } ptr;
+  } ptr;
-    uint8_t order;
+  uint8_t order;
 } vieter_heap_node;
 
 /*
@@ -36,7 +36,8 @@ void vieter_heap_tree_free(vieter_heap_node *root);
  * Given the roots of the smallest trees in two heaps, merge them into a single
  * large heap.
  */
-vieter_heap_node *vieter_heap_tree_merge(vieter_heap_node *root_a, vieter_heap_node *root_b);
+vieter_heap_node *vieter_heap_tree_merge(vieter_heap_node *root_a,
+                                         vieter_heap_node *root_b);
 
 /*
  * Given the roots of two trees of the same order, merge them into a heap of one

src/tree/vieter_tree_internal.h

@@ -16,7 +16,7 @@ struct vieter_tree {
 bool vieter_tree_validate(vieter_tree *tree);
 
 struct vieter_tree_iterator {
-    vieter_tree_node *current_node;
+  vieter_tree_node *current_node;
-    bool started;
+  bool started;
-    bool done;
+  bool done;
 };

src/tree/vieter_tree_node.h

@@ -2,8 +2,8 @@
 #define VIETER_TREE_NODE
 
 #include "vieter_tree.h"
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 typedef enum vieter_tree_node_flag {
   vieter_tree_node_black = ((uint8_t)1) << 0,
@@ -13,11 +13,11 @@ typedef enum vieter_tree_node_flag {
 } vieter_tree_node_flag;
 
 typedef struct vieter_tree_node {
-    uint64_t key;
+  uint64_t key;
-    void *data;
+  void *data;
-    struct vieter_tree_node *parent;
+  struct vieter_tree_node *parent;
-    struct vieter_tree_node *children[2];
+  struct vieter_tree_node *children[2];
-    uint8_t flags;
+  uint8_t flags;
 } vieter_tree_node;
 
 /*
@@ -33,27 +33,33 @@ void vieter_tree_node_free(vieter_tree_node *node);
 /*
  * Insert a new key into the given tree.
  */
-vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key, void *data);
+vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
+                                          void *data);
 
 /*
  * Return the node representing the requested value.
  */
-vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out, vieter_tree_node *root, uint64_t key);
+vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out,
+                                               vieter_tree_node *root,
+                                               uint64_t key);
 
 /*
  * Search for the data represented by the given key.
  */
-vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root, uint64_t key);
+vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root,
+                                          uint64_t key);
 
 /*
  * Remove the data associated with the given key.
  */
-vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node **root_ptr, uint64_t key);
+vieter_tree_error
+vieter_tree_node_remove(void **out, vieter_tree_node **root_ptr, uint64_t key);
 
 /*
  * Set a node's bit flag to the given value.
  */
-void vieter_tree_node_set(vieter_tree_node *node, vieter_tree_node_flag flag, bool value);
+void vieter_tree_node_set(vieter_tree_node *node, vieter_tree_node_flag flag,
+                          bool value);
 
 /*
  * Get whether a node's bit flag is set.
@@ -70,12 +76,14 @@ void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
 /*
  * Replace a node's children array.
  */
-void vieter_tree_node_set_children(vieter_tree_node *parent, vieter_tree_node **children);
+void vieter_tree_node_set_children(vieter_tree_node *parent,
+                                   vieter_tree_node **children);
 
 /*
  * Set a node's left or right child to the given node.
  */
-void vieter_tree_node_set_child(vieter_tree_node *parent, vieter_tree_node *child, bool right);
+void vieter_tree_node_set_child(vieter_tree_node *parent,
+                                vieter_tree_node *child, bool right);
 
 /*
  * Return the in-order successor of the given node, or NULL if it's the last