Fix vector resize in copy constructor

Author: scopeInfinity

src/usr/include/vector.tcc

@@ -17,21 +17,29 @@ static std::size_t next_power2(std::size_t size) {
 }
 
 template <typename T>
-vector<T>::vector() : _data(NULL), _size(0) {
+vector<T>::vector() :
+        _data(NULL),
+        _capacity(0),
+        _size(0) {
     resize_capacity(1);
 }
 
 template <typename T>
-vector<T>::vector(std::size_t size, const T &_default): _size(size)  {
-    this->_data = NULL;
+vector<T>::vector(std::size_t size, const T &_default):
+        _data(NULL),
+        _capacity(0),
+        _size(size) {
     resize_capacity(size);
     for(std::size_t i = 0; i < size; i++) {
         this->_data[i] = _default;
     }
 }
 
 template <typename T>
-vector<T>::vector(const vector<T> &o) : _size(o._size) {
+vector<T>::vector(const vector<T> &o) :
+        _data(NULL),
+        _capacity(0),
+        _size(o._size) {
     resize_capacity(o._capacity);
     std::memcpy(_data, o._data, _capacity*sizeof(T));
 }
@@ -62,14 +70,15 @@ template <typename T>
 typename vector<T>::const_iterator vector<T>::end() const { return this->_data + this->_size; }
 
 template <typename T>
-void vector<T>::resize_capacity(std::size_t capacity) {
+void vector<T>::resize_capacity(volatile std::size_t capacity) {
     // internal; assumes capacity to be power of 2
     // and will also make a copy of array and move _data pointer.
     // assumes size<=current_capacity and size<=new_capacity
-    const std::size_t data_size = capacity*sizeof(T);
+    const std::size_t data_size = std::min(capacity, this->_capacity)*sizeof(T);
     T *_new_data = new T[capacity];
     if (!_new_data) return;  // malloc failed
     std::memcpy(_new_data, this->_data, data_size);
+
     delete[] this->_data;  // should be no-op if _data == NULL
     this->_data = _new_data;
     this->_capacity = capacity;

src/usr/lib/stdlib.c

@@ -156,6 +156,9 @@ int benchmark_get_heap_usage() {
 }
 
 void* malloc(size_t size) {
+    size = ((size + 3) >> 2 ) << 2;
+    size += 4;  // 4 bytes to store size
+
     void* loc = _heap_start + heap_head_offset;
     void* max_loc = get_current_esp()-heap_stack_safety_gap-size;
     if(loc>max_loc) {
@@ -165,11 +168,15 @@ void* malloc(size_t size) {
     }
     heap_head_offset += size;
     benchmark_heap_inuse += size;
-    return loc;
+
+    *((uint32_t*)loc) = size;
+    return (loc+4);
 }
 
 void free(void* ptr) {
     if(ptr == NULL) return;
     // current version of malloc is non-optimal and doesn't
     // do any free operation.
+    size_t size = *((uint32_t*)(ptr-4));
+    benchmark_heap_inuse -= size;
 }

src/usr/local/src/logo.cpp

@@ -20,6 +20,8 @@ void frame_wait() {
     while (counter--);
 }
 
+bool graceful_exit = false;
+
 std::vector<std::string> split(std::string &str) {
     std::vector<std::string> rv;
     std::size_t len = str.length();
@@ -192,7 +194,8 @@ class Display {
             return 0;
         }
         if (cmd == "exit") {
-            std::exit(0);
+            graceful_exit = true;
+            return 0;
         }
         return 10;
     }
@@ -385,7 +388,7 @@ class Interpreter {
     Interpreter() : display(console.get_y_offset()) {
     }
     void execute() {
-        while(1) {
+        while(!graceful_exit) {
             console.update_status(display);
             display.draw();
             console.draw();
@@ -408,7 +411,7 @@ void cleanup_graphics() {
     std::graphics::closegraph();
     std::cout << "logo graphics closed" << std::endl;
     std::cout << "heap memory at exit " <<
-        (std::benchmark_get_heap_usage()/1024) << "KB" << std::endl;
+        (std::benchmark_get_heap_usage()) << " bytes" << std::endl;
 }
 
 int show_usage() {
@@ -448,5 +451,6 @@ int main(int argc,char *argv[]) {
     // graphics started
     std::atexit(cleanup_graphics);
     start_logo();
+    std::cout<<" all over \n";
     return 0;
 }