[INDEXMAP] better bounds checking and dealloc

[ARRAY] proper dealloc free

Author: dif

kernel/filesystem/fat32.cpp

@@ -50,7 +50,7 @@ bool FAT32FS::init(uint32_t partition_sector){
     kprintf("Data start at %x",data_start_sector*512);
     read_FAT(mbs->reserved_sectors, mbs->sectors_per_fat, mbs->number_of_fats);
 
-    open_files = IndexMap<void*>(128);
+    open_files = IndexMap<void*>(512);
 
     return true;
 }

shared/data_struct/array.hpp

@@ -25,7 +25,7 @@ class Array {
         if (count == 0) return;
         for (uint32_t i = 0; i < count; i++)
             items[i].~T();
-        free(items, sizeof(T) * count);
+        free(items, sizeof(T) * capacity);
     }
 
     bool add(const T& value) {

shared/data_struct/indexmap.hpp

@@ -4,6 +4,7 @@
 
 #include "std/allocator.hpp"
 #include "syscalls/syscalls.h"
+#include "std/memory.h"
 
 template<typename T>
 class IndexMap {
@@ -12,21 +13,30 @@ class IndexMap {
     IndexMap() : items(0), count(0), capacity(0) {
     }
 
+    IndexMap<T>* operator=(const IndexMap<T>& orig){
+        this->count = orig.count;
+        this->capacity = orig.capacity;
+        void *mem = (void*)malloc(sizeof(T) * (capacity + 1));
+        items = reinterpret_cast<T*>(mem);
+        memcpy(this->items, orig.items, sizeof(T) * (capacity + 1));
+        return this;
+    }
+
     IndexMap(uint32_t capacity) : count(0), capacity(capacity) {
         if (capacity == 0) {
             items = 0;
             return;
         }
-        void *mem = (void*)malloc(sizeof(T) * capacity);
+        void *mem = (void*)malloc(sizeof(T) * (capacity + 1));
         items = reinterpret_cast<T*>(mem);
+        default_val = &items[capacity];
     }
 
     ~IndexMap() {
-        //TODO: Deallocation has not been changed since this code was copied off Array
-        if (count == 0) return;
-        for (uint32_t i = 0; i < count; i++)
+        if (capacity == 0) return;
+        for (uint32_t i = 0; i < capacity; i++)
             items[i].~T();
-        free(items, sizeof(T) * count);
+        if (items) free(items, sizeof(T) * (capacity + 1));
     }
 
     bool add(const uint32_t index, const T& value) {
@@ -36,15 +46,22 @@ class IndexMap {
         return true;
     }
 
-    //TODO: we need a function for checking if a value exists
-    T& operator[](uint32_t i) { return items[i]; }
-    const T& operator[](uint32_t i) const { return items[i]; }
+    T& operator[](uint32_t i) { 
+        if (i >= capacity) return *default_val; 
+        return items[i]; 
+    }
+    const T& operator[](uint32_t i) const { 
+        if (i >= capacity) return *default_val; 
+        return items[i]; 
+    }
     uint32_t size() const { return count; }
     uint32_t max_size() const { return capacity; }
 
     T* items;
+    T* default_val;
 
 private:
     uint32_t count;
     uint32_t capacity;
-};
+};
+//TEST: when assigning an indexmap (like in xhci's endpoint_map), it gets copied. Make sure the old one gets freed