From 7271b076b82785ffca73ee9e4ae84cabb77018ee Mon Sep 17 00:00:00 2001
From: Daniel Lange <DLange@git.local>
Date: Wed, 10 Jan 2024 12:40:37 +0100
Subject: New upstream version 3.3.0

---
 Vector.c | 50 +++++++++++++++++++++++---------------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

(limited to 'Vector.c')

diff --git a/Vector.c b/Vector.c
index eddbc9a..0e08c65 100644
--- a/Vector.c
+++ b/Vector.c
@@ -5,6 +5,8 @@ Released under the GNU GPLv2+, see the COPYING file
 in the source distribution for its full text.
 */
 
+#include "config.h" // IWYU pragma: keep
+
 #include "Vector.h"
 
 #include <assert.h>
@@ -62,14 +64,6 @@ static bool Vector_isConsistent(const Vector* this) {
    assert(this->items <= this->arraySize);
    assert(!Vector_isDirty(this));
 
-   if (this->owner) {
-      for (int i = 0; i < this->items; i++) {
-         if (!this->array[i]) {
-            return false;
-         }
-      }
-   }
-
    return true;
 }
 
@@ -103,13 +97,13 @@ void Vector_prune(Vector* this) {
       for (int i = 0; i < this->items; i++) {
          if (this->array[i]) {
             Object_delete(this->array[i]);
-            this->array[i] = NULL;
          }
       }
    }
    this->items = 0;
    this->dirty_index = -1;
    this->dirty_count = 0;
+   memset(this->array, '\0', this->arraySize * sizeof(Object*));
 }
 
 //static int comparisons = 0;
@@ -200,15 +194,13 @@ void Vector_insertionSort(Vector* this) {
    assert(Vector_isConsistent(this));
 }
 
-static void Vector_checkArraySize(Vector* this) {
-   assert(Vector_isConsistent(this));
-   if (this->items >= this->arraySize) {
-      //int i;
-      //i = this->arraySize;
-      this->arraySize = this->items + this->growthRate;
-      this->array = (Object**) xRealloc(this->array, sizeof(Object*) * this->arraySize);
-      //for (; i < this->arraySize; i++)
-      //   this->array[i] = NULL;
+static void Vector_resizeIfNecessary(Vector* this, int newSize) {
+   assert(newSize >= 0);
+   if (newSize > this->arraySize) {
+      assert(Vector_isConsistent(this));
+      int oldSize = this->arraySize;
+      this->arraySize = newSize + this->growthRate;
+      this->array = (Object**)xReallocArrayZero(this->array, oldSize, this->arraySize, sizeof(Object*));
    }
    assert(Vector_isConsistent(this));
 }
@@ -223,7 +215,7 @@ void Vector_insert(Vector* this, int idx, void* data_) {
       idx = this->items;
    }
 
-   Vector_checkArraySize(this);
+   Vector_resizeIfNecessary(this, this->items + 1);
    //assert(this->array[this->items] == NULL);
    if (idx < this->items) {
       memmove(&this->array[idx + 1], &this->array[idx], (this->items - idx) * sizeof(this->array[0]));
@@ -242,7 +234,7 @@ Object* Vector_take(Vector* this, int idx) {
    if (idx < this->items) {
       memmove(&this->array[idx], &this->array[idx + 1], (this->items - idx) * sizeof(this->array[0]));
    }
-   //this->array[this->items] = NULL;
+   this->array[this->items] = NULL;
    assert(Vector_isConsistent(this));
    return removed;
 }
@@ -290,16 +282,19 @@ void Vector_compact(Vector* this) {
 
    int idx = this->dirty_index;
 
-   /* one deletion: use memmove, which should be faster */
+   // one deletion: use memmove, which should be faster
    if (this->dirty_count == 1) {
       memmove(&this->array[idx], &this->array[idx + 1], (this->items - idx - 1) * sizeof(this->array[0]));
+      this->array[this->items - 1] = NULL;
    } else {
-      /* multiple deletions */
+      // multiple deletions
       for (int i = idx + 1; i < size; i++) {
          if (this->array[i]) {
             this->array[idx++] = this->array[i];
          }
       }
+      // idx is now at the end of the vector and on the first index which should be set to NULL
+      memset(&this->array[idx], '\0', (size - idx) * sizeof(this->array[0]));
    }
 
    this->items -= this->dirty_count;
@@ -339,14 +334,15 @@ void Vector_set(Vector* this, int idx, void* data_) {
    assert(Object_isA(data, this->type));
    assert(Vector_isConsistent(this));
 
-   Vector_checkArraySize(this);
+   Vector_resizeIfNecessary(this, idx + 1);
    if (idx >= this->items) {
       this->items = idx + 1;
    } else {
       if (this->owner) {
          Object* removed = this->array[idx];
-         assert (removed != NULL);
-         Object_delete(removed);
+         if (removed != NULL) {
+            Object_delete(removed);
+         }
       }
    }
    this->array[idx] = data;
@@ -396,11 +392,11 @@ int Vector_indexOf(const Vector* this, const void* search_, Object_Compare compa
 void Vector_splice(Vector* this, Vector* from) {
    assert(Vector_isConsistent(this));
    assert(Vector_isConsistent(from));
-   assert(!(this->owner && from->owner));
+   assert(!this->owner);
 
    int olditems = this->items;
+   Vector_resizeIfNecessary(this, this->items + from->items);
    this->items += from->items;
-   Vector_checkArraySize(this);
    for (int j = 0; j < from->items; j++) {
       this->array[olditems + j] = from->array[j];
    }
-- 
cgit v1.2.3