chore: integrate cppcheck into workflow

lsm/include/lsm/bt.h

@@ -28,7 +28,7 @@ void lsm_bt_clear(lsm_bt *bt);
 /**
  * Return the size of the binary tree
  */
-uint64_t lsm_bt_size(lsm_bt *bt);
+uint64_t lsm_bt_size(const lsm_bt *bt);
 
 /**
  * Search for the data stored behind the given key.

lsm/include/lsm/store.h

@@ -117,7 +117,7 @@ lsm_error lsm_store_init(lsm_store **ptr);
  * @param store store to use
  * @return how many elements are in the store
  */
-uint64_t lsm_store_size(lsm_store *store);
+uint64_t lsm_store_size(const lsm_store *store);
 
 /**
  * Open the given database file and load it into a new store object.

lsm/include/lsm/str.h

@@ -34,7 +34,7 @@ lsm_error lsm_str_init_zero(lsm_str **ptr);
  * @param ptr pointer to store newly allocated pointer
  * @param s string to copy into lsm string
  */
-lsm_error lsm_str_init_copy(lsm_str **ptr, char *s);
+lsm_error lsm_str_init_copy(lsm_str **ptr, const char *s);
 
 /**
  * Same as `lsm_str_init_copy`, except that it takes an additional argument
@@ -45,7 +45,7 @@ lsm_error lsm_str_init_copy(lsm_str **ptr, char *s);
  * @param s string to copy into lsm string
  * @param len length of string to copy
  */
-lsm_error lsm_str_init_copy_n(lsm_str **ptr, char *s, uint64_t len);
+lsm_error lsm_str_init_copy_n(lsm_str **ptr, const char *s, uint64_t len);
 
 /**
  * Overwrite an existing lsm_str so it now represents the new provided string.
@@ -65,7 +65,7 @@ void lsm_str_overwrite(lsm_str *str, char *s);
  * @param str lsm_str object to modify
  * @param s string to copy into lsm string
  */
-lsm_error lsm_str_overwrite_copy(lsm_str *str, char *s);
+lsm_error lsm_str_overwrite_copy(lsm_str *str, const char *s);
 
 /**
  * Same as `lsm_str_overwrite_copy`, except the length is explicitely specified,
@@ -75,7 +75,7 @@ lsm_error lsm_str_overwrite_copy(lsm_str *str, char *s);
  * @param s string to copy into lsm string
  * @param len length of the string to copy
  */
-lsm_error lsm_str_overwrite_copy_n(lsm_str *str, char *s, uint64_t len);
+lsm_error lsm_str_overwrite_copy_n(lsm_str *str, const char *s, uint64_t len);
 
 /**
  * Deallocate the existing internal string if needed and replace the lsm_str
@@ -99,7 +99,7 @@ void lsm_str_free(lsm_str *str);
  *
  * @param str string to return length for.
  */
-uint64_t lsm_str_len(lsm_str *str);
+uint64_t lsm_str_len(const lsm_str *str);
 
 /**
  * Return a pointer to the string's underlying char array. Note that this array

lsm/include/lsm/trie.h

@@ -55,6 +55,6 @@ lsm_error lsm_trie_remove(void **data, lsm_trie *trie, lsm_str *key);
  *
  * @param trie trie to return size for
  */
-uint64_t lsm_trie_size(lsm_trie *trie);
+uint64_t lsm_trie_size(const lsm_trie *trie);
 
 #endif

lsm/src/bt/lsm_bt.c

@@ -57,7 +57,7 @@ void lsm_bt_free(lsm_bt *bt) {
   free(bt);
 }
 
-uint64_t lsm_bt_size(lsm_bt *bt) { return bt->size; }
+uint64_t lsm_bt_size(const lsm_bt *bt) { return bt->size; }
 
 lsm_error lsm_bt_insert(lsm_bt *bt, char key, void *data) {
   lsm_bt_node **dest = &bt->root;
@@ -102,10 +102,6 @@ lsm_error lsm_bt_search(void **out, lsm_bt *bt, char key) {
 }
 
 lsm_error lsm_bt_remove(void **out, lsm_bt *bt, char key) {
-  if (bt->root == NULL) {
-    return lsm_error_not_found;
-  }
-
   lsm_bt_node **dest = &bt->root;
 
   while ((*dest != NULL) && ((*dest)->key != key)) {

lsm/src/store/lsm_store.c

@@ -30,7 +30,7 @@ lsm_error lsm_store_init(lsm_store **ptr) {
   return lsm_error_ok;
 }
 
-uint64_t lsm_store_size(lsm_store *store) { return lsm_trie_size(store->trie); }
+uint64_t lsm_store_size(const lsm_store *store) { return lsm_trie_size(store->trie); }
 
 lsm_error lsm_store_open_read(lsm_entry_handle **out, lsm_store *store,
                               lsm_str *key) {
@@ -43,11 +43,9 @@ lsm_error lsm_store_open_read(lsm_entry_handle **out, lsm_store *store,
     return lsm_error_lock_busy;
   }
 
-  lsm_entry *entry = wrapper->entry;
-
   // While the trie's data field will never be NULL, the actual entry pointer
   // might be
-  if (entry == NULL) {
+  if (wrapper->entry == NULL) {
     pthread_rwlock_unlock(&wrapper->lock);
 
     return lsm_error_not_found;
@@ -81,11 +79,9 @@ lsm_error lsm_store_open_write(lsm_entry_handle **out, lsm_store *store,
     return lsm_error_lock_busy;
   }
 
-  lsm_entry *entry = wrapper->entry;
-
   // While the trie's data field will never be NULL, the actual entry pointer
   // might be
-  if (entry == NULL) {
+  if (wrapper->entry == NULL) {
     pthread_rwlock_unlock(&wrapper->lock);
 
     return lsm_error_not_found;
@@ -202,7 +198,7 @@ lsm_error lsm_entry_data_append(lsm_entry_handle *handle, lsm_str *data) {
 
 lsm_error lsm_entry_data_read(uint64_t *out, char *buf,
                               lsm_entry_handle *handle, uint64_t len) {
-  lsm_entry *entry = handle->wrapper->entry;
+  const lsm_entry *entry = handle->wrapper->entry;
 
   if (entry->data_len == 0) {
     *out = 0;

lsm/src/store/lsm_store_disk_read.c

@@ -27,7 +27,7 @@ lsm_error lsm_store_load(lsm_store **ptr, lsm_str *data_path) {
 
     fclose(db_file);
 
-    FILE *db_file = fopen(db_file_path, "r+b");
+    db_file = fopen(db_file_path, "r+b");
 
     if (db_file == NULL) {
       return lsm_error_failed_io;
@@ -62,7 +62,7 @@ lsm_error lsm_store_load(lsm_store **ptr, lsm_str *data_path) {
     fclose(idx_file);
 
     // If opening it in extended read mode still fails now, there's a problem
-    FILE *idx_file = fopen(idx_file_path, "r+b");
+    idx_file = fopen(idx_file_path, "r+b");
 
     if (idx_file == NULL) {
       return lsm_error_failed_io;

lsm/src/store/lsm_store_entry.c

@@ -107,7 +107,7 @@ lsm_error lsm_entry_attr_get_uint64_t(uint64_t *out, lsm_entry_handle *handle,
 
   LSM_RES(lsm_entry_attr_get(&s, handle, type));
 
-  uint64_t num;
+  uint64_t num = 0;
 
   for (uint8_t i = 0; i < sizeof(uint64_t) / sizeof(char); i++) {
     ((char *)&num)[i] = lsm_str_char(s, i);

lsm/src/str/lsm_str.c

@@ -33,7 +33,7 @@ lsm_error lsm_str_init_zero(lsm_str **ptr) {
   return lsm_error_ok;
 }
 
-lsm_error lsm_str_init_copy(lsm_str **ptr, char *s) {
+lsm_error lsm_str_init_copy(lsm_str **ptr, const char *s) {
   lsm_str *str = calloc(1, sizeof(lsm_str));
 
   if (str == NULL) {
@@ -47,7 +47,7 @@ lsm_error lsm_str_init_copy(lsm_str **ptr, char *s) {
   return lsm_error_ok;
 }
 
-lsm_error lsm_str_init_copy_n(lsm_str **ptr, char *s, uint64_t len) {
+lsm_error lsm_str_init_copy_n(lsm_str **ptr, const char *s, uint64_t len) {
   lsm_str *str = calloc(1, sizeof(lsm_str));
 
   if (str == NULL) {
@@ -72,11 +72,11 @@ void lsm_str_overwrite(lsm_str *str, char *s) {
   }
 }
 
-lsm_error lsm_str_overwrite_copy(lsm_str *str, char *s) {
+lsm_error lsm_str_overwrite_copy(lsm_str *str, const char *s) {
   return lsm_str_overwrite_copy_n(str, s, strlen(s));
 }
 
-lsm_error lsm_str_overwrite_copy_n(lsm_str *str, char *s, uint64_t len) {
+lsm_error lsm_str_overwrite_copy_n(lsm_str *str, const char *s, uint64_t len) {
   if (len <= 8) {
     memcpy(str->data.val, s, len);
   } else {
@@ -108,7 +108,7 @@ void lsm_str_free(lsm_str *str) {
   free(str);
 }
 
-uint64_t lsm_str_len(lsm_str *str) { return str->len; }
+uint64_t lsm_str_len(const lsm_str *str) { return str->len; }
 
 const char *lsm_str_ptr(lsm_str *str) {
   if (str->len <= 8) {

lsm/src/trie/lsm_trie.c

@@ -32,6 +32,8 @@ lsm_error lsm_trie_init(lsm_trie **ptr) {
   lsm_error res = lsm_trie_node_init(&root);
 
   if (res != lsm_error_ok) {
+    free(trie);
+
     return res;
   }
 
@@ -41,7 +43,7 @@ lsm_error lsm_trie_init(lsm_trie **ptr) {
   return lsm_error_ok;
 }
 
-uint64_t lsm_trie_size(lsm_trie *trie) { return trie->size; }
+uint64_t lsm_trie_size(const lsm_trie *trie) { return trie->size; }
 
 lsm_error lsm_trie_insert(lsm_trie *trie, lsm_str *key, void *data) {
   // NULL is not allowed as a data value, as it's used to indicate a lack of
@@ -67,11 +69,10 @@ lsm_error lsm_trie_insert(lsm_trie *trie, lsm_str *key, void *data) {
   uint64_t index = 0;
   lsm_trie_node *node = trie->root;
   lsm_trie_node *next_node;
-  lsm_error res;
 
   while (index < key_len) {
     char c = lsm_str_char(key, index);
-    res = lsm_bt_search((void **)&next_node, &node->bt, c);
+    lsm_error res = lsm_bt_search((void **)&next_node, &node->bt, c);
 
     // No child is present yet for this character, so we can insert the string
     // here
@@ -165,11 +166,10 @@ lsm_error lsm_trie_search(void **out, lsm_trie *trie, lsm_str *key) {
   uint64_t index = 0;
   lsm_trie_node *node = trie->root;
   lsm_trie_node *next_node;
-  lsm_error res;
 
   while (index < key_len) {
     char c = lsm_str_char(key, index);
-    res = lsm_bt_search((void **)&next_node, &node->bt, c);
+    lsm_error res = lsm_bt_search((void **)&next_node, &node->bt, c);
 
     if (res != lsm_error_ok) {
       return res;
@@ -220,12 +220,10 @@ lsm_error lsm_trie_remove(void **data, lsm_trie *trie, lsm_str *key) {
   uint64_t index = 0;
   lsm_trie_node *parent = trie->root;
   lsm_trie_node *child;
-  lsm_error res;
-  char c;
 
   while (index < key_len) {
-    c = lsm_str_char(key, index);
-    res = lsm_bt_search((void **)&child, &parent->bt, c);
+    char c = lsm_str_char(key, index);
+    lsm_error res = lsm_bt_search((void **)&child, &parent->bt, c);
 
     if (res != lsm_error_ok) {
       return res;