using stdint types

arraylist.hpp

@@ -1,13 +1,14 @@
 #pragma once
 #include <stdlib.h>
+#include "types.hpp"
 
 template <typename type>
 struct Array_List {
     type* data;
-    int length;
+    u32 length;
-    int next_index;
+    u32 next_index;
 
-    void alloc(int initial_capacity = 16) {
+    void alloc(u32 initial_capacity = 16) {
         data = (type*)malloc(initial_capacity * sizeof(type));
         next_index = 0;
         length = initial_capacity;
@@ -24,7 +25,7 @@ struct Array_List {
         ret.next_index = next_index;
 
         ret.data = (type*)malloc(length * sizeof(type));
-        for (int i = 0; i < next_index; ++i) {
+        for (u32 i = 0; i < next_index; ++i) {
             ret.data[i] = data[i];
         }
         return ret;
@@ -38,7 +39,7 @@ struct Array_List {
         return data+(next_index);
     }
 
-    void remove_index(int index) {
+    void remove_index(u32 index) {
         data[index] = data[--next_index];
     }
 
@@ -51,19 +52,19 @@ struct Array_List {
         next_index++;
     }
 
-    void reserve(unsigned int count) {
+    void reserve(u32 count) {
-        if (next_index+count >= (unsigned int)length) {
+        if (next_index+count >= (u32)length) {
             length *= 2;
             data = (type*)realloc(data, length * sizeof(type));
         }
     }
 
-    type& operator[](int index) {
+    type& operator[](u32 index) {
         return data[index];
     }
 
-    void _merge(int start, int mid, int end) {
+    void _merge(u32 start, u32 mid, u32 end) {
-        int start2 = mid + 1;
+        u32 start2 = mid + 1;
 
         /* If the direct merge is already sorted */
         if ((size_t)data[mid] <= (size_t)data[start2]) {
@@ -77,7 +78,7 @@ struct Array_List {
             }
             else {
                 type value = data[start2];
-                int index = start2;
+                u32 index = start2;
 
                 /* Shift all the elements between element 1; element 2, right by 1. */
                 while (index != start) {
@@ -94,7 +95,7 @@ struct Array_List {
         }
     }
 
-    void sort(int left=-1, int right=-1) {
+    void sort(s32 left=-1, s32 right=-1) {
         if (left == -1) {
             if (next_index == 0)
                 return;
@@ -104,7 +105,7 @@ struct Array_List {
             return;
         }
 
-        int middle = left + (right-left) / 2;
+        u32 middle = left + (right-left) / 2;
 
         sort(left, middle);
         sort(middle+1, right);
@@ -112,7 +113,7 @@ struct Array_List {
         _merge(left, middle, right);
     }
 
-    int sorted_find(type elem, int left=-1, int right=-1) {
+    u32 sorted_find(type elem, s32 left=-1, s32 right=-1) {
         if (left == -1) {
             return sorted_find(elem, 0, next_index - 1);
         } else if (left == right) {
@@ -122,7 +123,7 @@ struct Array_List {
         } else if (right < left)
             return -1;
 
-        int middle = left + (right-left) / 2;
+        u32 middle = left + (right-left) / 2;
 
         if ((size_t)data[middle] < (size_t)elem)
             return sorted_find(elem, middle+1, right);

bucket_allocator.hpp

@@ -1,11 +1,12 @@
 #include "arraylist.hpp"
+#include "types.hpp"
 
 template <typename type>
 class Bucket_Allocator {
-    unsigned int next_index_in_latest_bucket;
+    u32 next_index_in_latest_bucket;
-    unsigned int next_bucket_index;
+    u32 next_bucket_index;
-    unsigned int bucket_count;
+    u32 bucket_count;
-    unsigned int bucket_size;
+    u32 bucket_size;
 
     Array_List<type*> free_list;
     type** buckets;
@@ -26,7 +27,7 @@ class Bucket_Allocator {
         buckets[next_bucket_index] = (type*)malloc(bucket_size * sizeof(type));
     }
 
-    void increment_pointers(int amount = 1) {
+    void increment_pointers(s32 amount = 1) {
         next_index_in_latest_bucket += amount;
         if (next_index_in_latest_bucket >= bucket_size) {
             jump_to_next_bucket();
@@ -34,7 +35,7 @@ class Bucket_Allocator {
     }
 
 public:
-    void alloc(unsigned int bucket_size, unsigned int initial_bucket_count) {
+    void alloc(u32 bucket_size, u32 initial_bucket_count) {
         this->free_list.alloc();
         this->bucket_size = bucket_size;
         next_index_in_latest_bucket = 0;
@@ -46,7 +47,7 @@ public:
     }
 
     void dealloc() {
-        for (unsigned int i = 0; i <= next_bucket_index; ++i) {
+        for (u32 i = 0; i <= next_bucket_index; ++i) {
             free(buckets[i]);
         }
         this->free_list.dealloc();
@@ -57,21 +58,21 @@ public:
     void for_each(proc p) {
         free_list.sort();
         type* val;
-        for (unsigned int i = 0; i < next_bucket_index; ++i) {
+        for (u32 i = 0; i < next_bucket_index; ++i) {
-            for (unsigned int j = 0; j < bucket_size; ++j) {
+            for (u32 j = 0; j < bucket_size; ++j) {
                 val = buckets[i]+j;
                 if (free_list.sorted_find(val) == -1)
                     p(val);
             }
         }
-        for (unsigned int j = 0; j < next_index_in_latest_bucket; ++j) {
+        for (u32 j = 0; j < next_index_in_latest_bucket; ++j) {
             val = buckets[next_bucket_index]+j;
             if (free_list.sorted_find(val) == -1)
                 p(val);
         }
     }
 
-    type* allocate(unsigned int amount = 1) {
+    type* allocate(u32 amount = 1) {
         type* ret;
         if (amount == 0) return nullptr;
         if (amount == 1) {

hashmap.hpp

@@ -9,15 +9,15 @@
 #define for_hash_map(hm)                                           \
     if (decltype((hm).data[0].original) key   = 0); else           \
     if (decltype((hm).data[0].object)   value = 0); else           \
-    for(int index = 0; index < (hm).current_capacity; ++index)     \
+    for(u32 index = 0; index < (hm).current_capacity; ++index)     \
         if (!((!(hm).data[index].deleted) &&                       \
               (key   = (hm).data[index].original) &&               \
               (value = (hm).data[index].object))); else
 
 template <typename key_type, typename value_type>
 struct Hash_Map {
-    int current_capacity;
+    u32 current_capacity;
-    int cell_count;
+    u32 cell_count;
     struct HM_Cell {
         key_type original;
         u64  hash;
@@ -25,7 +25,7 @@ struct Hash_Map {
         value_type object;
     }* data;
 
-    void alloc(int initial_capacity = 8) {
+    void alloc(u32 initial_capacity = 8) {
         current_capacity = initial_capacity;
         cell_count = 0;
         data = (HM_Cell*)calloc(initial_capacity, sizeof(HM_Cell));
@@ -36,9 +36,9 @@ struct Hash_Map {
             data = nullptr;
         }
 
-    int get_index_of_living_cell_if_it_exists(key_type key, u64 hash_val) {
+    s32 get_index_of_living_cell_if_it_exists(key_type key, u64 hash_val) {
-        // int index = hash_val & (current_capacity - 1);
+        // s32 index = hash_val & (current_capacity - 1);
-        int index = hash_val % current_capacity;
+        s32 index = hash_val % current_capacity;
         HM_Cell cell = data[index];
         /* test if cell exists at that index */
         if (cell.original) {
@@ -56,8 +56,8 @@ struct Hash_Map {
             } else {
                 /* strings dont match, this means we have */
                 /* a collision. We just search forward */
-                for (int i = 0; i < current_capacity; ++i) {
+                for (u32 i = 0; i < current_capacity; ++i) {
-                    int new_idx = (i + index) % current_capacity;
+                    u32 new_idx = (i + index) % current_capacity;
                     cell = data[new_idx];
                     if (!cell.original)
                         return -1;
@@ -84,7 +84,7 @@ struct Hash_Map {
     }
 
     key_type search_key_to_object(value_type v) {
-        for (int i = 0; i < current_capacity; ++i) {
+        for (u32 i = 0; i < current_capacity; ++i) {
             if (data[i].object == v && !data[i].deleted)
                 return data[i].original;
         }
@@ -94,7 +94,9 @@ struct Hash_Map {
     Array_List<key_type> get_all_keys() {
         Array_List<key_type> ret;
         ret.alloc();
-        for (int i = 0; i < current_capacity; ++i) {
+        // QUESTION(Felix): Does it make sense to
+        // ret.reserve(this->cell_count)?
+        for (u32 i = 0; i < current_capacity; ++i) {
             if (data[i].original && !data[i].deleted)
                 ret.append(data[i].original);
         }
@@ -102,7 +104,7 @@ struct Hash_Map {
     }
 
     value_type get_object(key_type key) {
-        int index = get_index_of_living_cell_if_it_exists(key, hm_hash((key_type)key));
+        s32 index = get_index_of_living_cell_if_it_exists(key, hm_hash((key_type)key));
         if (index != -1) {
             return data[index].object;
         }
@@ -110,14 +112,14 @@ struct Hash_Map {
     }
 
     void delete_object(key_type key) {
-        int index = get_index_of_living_cell_if_it_exists(key, hm_hash((key_type)key));
+        s32 index = get_index_of_living_cell_if_it_exists(key, hm_hash((key_type)key));
         if (index != -1) {
             data[index].deleted = true;
         }
     }
 
     void set_object(key_type key, value_type obj, u64 hash_val) {
-        int index = hash_val % current_capacity;
+        u32 index = hash_val % current_capacity;
 
         /* if we the desired cell is just empty, write to it and done :) */
         if (!data[index].original) {
@@ -137,7 +139,7 @@ struct Hash_Map {
                     current_capacity *= 4;
 
                     /* insert all old items again */
-                    for (int i = 0; i < current_capacity/4; ++i) {
+                    for (u32 i = 0; i < current_capacity/4; ++i) {
                         auto cell = old_data[i];
                         if (cell.original) {
                             set_object(cell.original, cell.object, cell.hash);
@@ -149,7 +151,7 @@ struct Hash_Map {
                 /* search for empty slot for new cell starting at desired index; */
                 /* preventing gotos using lambdas!                               */
                 [&]{
-                    for (int i = index; i < current_capacity; ++i) {
+                    for (u32 i = index; i < current_capacity; ++i) {
                         if (!data[i].original ||
                             hm_objects_match(data[i].original, key))
                         {
@@ -157,7 +159,7 @@ struct Hash_Map {
                             return;
                         }
                     }
-                    for (int i = 0; i < index; ++i) {
+                    for (u32 i = 0; i < index; ++i) {
                         if (!data[i].original ||
                             hm_objects_match(data[i].original, key))
                         {

test.cpp

@@ -1,10 +1,11 @@
 #define _CRT_SECURE_NO_WARNINGS
 #include <stdio.h>
 
+#include "./types.hpp"
 #include "./hooks.hpp"
 
 Hook h;
-int main(int argc, char* argv[]) {
+s32 main(s32 argc, char* argv[]) {
     printf("Hello world");
     system_shutdown_hook << [] {
         printf("Goodbye world\n");