std-vector debug (#3027)

6 files changed, 68 insertions, 53 deletions

diff --git a/include/JSystem/JGadget/std-memory.h b/include/JSystem/JGadget/std-memory.h
index 5b5a64b59e..f9cccd9c7b 100644
--- a/include/JSystem/JGadget/std-memory.h
+++ b/include/JSystem/JGadget/std-memory.h
@@ -6,7 +6,7 @@
 namespace JGadget {
 template <typename T>
 struct TAllocator {
-    T* allocate(u32 count, void *param_2) {
+    T* allocate(u32 count, const void *param_2) {
         return AllocateRaw(count * sizeof(T));
     }
 
@@ -18,7 +18,7 @@ struct TAllocator {
         DeallocateRaw(mem);
     }
 
-    void DeallocateRaw(T* mem) {
+    void DeallocateRaw(void* mem) {
         delete mem;
     }
 
diff --git a/include/JSystem/JGadget/std-vector.h b/include/JSystem/JGadget/std-vector.h
index 4e74855e55..33cea8a0a5 100644
--- a/include/JSystem/JGadget/std-vector.h
+++ b/include/JSystem/JGadget/std-vector.h
@@ -1,6 +1,7 @@
 #ifndef STD_VECTOR_H
 #define STD_VECTOR_H
 
+#include "JSystem/JGadget/define.h"
 #include "JSystem/JGadget/std-memory.h"
 #include <algorithm>
 #include <memory>
@@ -33,7 +34,9 @@ struct TVector {
     typedef const T* const_iterator;
 
     TVector(Allocator const& allocator) {
+#if PLATFORM_GCN
         mAllocator = allocator;
+#endif
         pBegin_ = NULL;
         pEnd_ = pBegin_;
         mCapacity = 0;
@@ -41,48 +44,52 @@ struct TVector {
     }
 
     ~TVector() {
+#if DEBUG
+        Confirm();
+#endif
         clear();
+        JGADGET_ASSERTWARN(250, size()==0);
         mAllocator.deallocate(pBegin_, 0);
     }
 
     void insert(T* pos, u32 count, const T& val) {
-        if (count != 0) {
-            T* ptr = Insert_raw(pos, count);
-            if (ptr == end()) {
-                /* JGadget_outMessage sp120(JGadget_outMessage::warning, __FILE__, 0x141);
-                sp120 << "can't allocate memory"; */
-            } else {
-                std::uninitialized_fill_n(ptr, count, val);
-            }
+        if (count == 0) {
+            return;
         }
-    }
 
-    T* Insert_raw(T* pIt, u32 pCount) {
-        JUT_ASSERT(446, (pBegin_ <= pIt) && (pIt <= pEnd_));
+        T* ptr = Insert_raw(pos, count);
+        if (ptr == end()) {
+            JGADGET_WARNMSG(321, "can't allocate memory");
+        } else {
+            std::uninitialized_fill_n(ptr, count, val);
+        }
+    }
 
-        T* const pFirst = pIt;
+    T* Insert_raw(T* pFirst, u32 pCount) {
+        T* const pIt = pFirst;
+        JUT_ASSERT(446, (pBegin_<=pIt)&&(pIt<=pEnd_));
 
         if (pCount == 0) {
-            return pIt;
+            return pFirst;
         }
 
         if (pCount + size() <= mCapacity) {
-            void** newEnd = pFirst + pCount;
+            void** newEnd = pIt + pCount;
 
             if (newEnd < pEnd_) {
                 void** pOverwrittenValues = pEnd_ - pCount;
                 std::uninitialized_copy(pOverwrittenValues, pEnd_, pEnd_);
-                std::copy_backward(pFirst, pOverwrittenValues, pEnd_);
-                DestroyElement_(pFirst, newEnd);
+                std::copy_backward(pIt, pOverwrittenValues, pEnd_);
+                DestroyElement_(pIt, newEnd);
 
                 pEnd_ += pCount;
-                return pIt;
+                return pFirst;
             } else {
-                std::uninitialized_copy(pFirst, pEnd_, newEnd);
-                DestroyElement_(pFirst, pEnd_);
+                std::uninitialized_copy(pIt, pEnd_, newEnd);
+                DestroyElement_(pIt, pEnd_);
 
                 pEnd_ += pCount;
-                return pIt;
+                return pFirst;
             }
         }
 
@@ -95,8 +102,8 @@ struct TVector {
 
         TDestructed_deallocate_ destructionDeallocator(mAllocator, newDataPointer);
 
-        void** const endOfCopy = std::uninitialized_copy(pBegin_, pFirst, newDataPointer);
-        std::uninitialized_copy(pFirst, pEnd_, endOfCopy + pCount);
+        void** const endOfCopy = std::uninitialized_copy(pBegin_, pIt, newDataPointer);
+        std::uninitialized_copy(pIt, pEnd_, endOfCopy + pCount);
 
         DestroyElement_all_();
         destructionDeallocator.set(pBegin_);
@@ -126,10 +133,18 @@ struct TVector {
         return (int)((uintptr_t)pEnd_ - (uintptr_t)pBegin_) / 4;
     }
 
-    u32 capacity() { return mCapacity; }
+    u32 capacity() const { return mCapacity; }
+
+    bool Confirm() const {
+        if (size() > mCapacity) {
+            JGADGET_WARNMSG(507, "illegal size");
+            return false;
+        }
+        return true;
+    }
 
-    u32 GetSize_extend_(u32 count) {
-        JUT_ASSERT(0x22B, pfnExtend_!=NULL);
+    u32 GetSize_extend_(u32 count) const {
+        JUT_ASSERT(555, pfnExtend_!=NULL);
 
         u32 oldSize = size();
         u32 neededNewSpace = oldSize + count;
@@ -138,20 +153,28 @@ struct TVector {
         return neededNewSpace > extendedSize ? neededNewSpace : extendedSize;
     }
 
-    void DestroyElement_(T* start, T* end) {
-        for (; start != end; start++) {
-            mAllocator.destroy(start);
+    void DestroyElement_(T* pFirst, T* pLast) {
+        JUT_ASSERT(536, (pBegin_<=pFirst)&&(pFirst<=pEnd_));
+        JUT_ASSERT(537, (pBegin_<=pLast)&&(pLast<=pEnd_));
+        T* it = pFirst;
+        for (; it != pLast; it++) {
+            mAllocator.destroy(it);
         }
     }
 
     void DestroyElement_all_() { DestroyElement_(pBegin_, pEnd_); }
 
-    T* erase(T* start, T* end) {
-        T* vectorEnd = pEnd_;
-        T* ppvVar3 = std::copy(end, vectorEnd, start);
+    T* erase(T* pFirst, T* pLast) {
+        iterator pItFirst = pFirst;
+        iterator pItLast = pLast;
+        JUT_ASSERT(347, (pBegin_<=pItFirst)&&(pItFirst<=pEnd_))
+        JUT_ASSERT(348, (pBegin_<=pItLast)&&(pItLast<=pEnd_));
+        JUT_ASSERT(349, pItFirst<=pItLast);
+        T* vectorEnd = pEnd_; // DEBUG NONMATCHING
+        T* ppvVar3 = std::copy(pItLast, vectorEnd, pItFirst);
         DestroyElement_(ppvVar3, pEnd_);
         pEnd_ = ppvVar3;
-        return start;
+        return pFirst;
     }
 
     void clear() { erase(begin(), end()); }
diff --git a/include/JSystem/JKernel/JKRHeap.h b/include/JSystem/JKernel/JKRHeap.h
index 77a4acd8e3..c23b72180f 100644
--- a/include/JSystem/JKernel/JKRHeap.h
+++ b/include/JSystem/JKernel/JKRHeap.h
@@ -4,6 +4,7 @@
 #include "JSystem/JKernel/JKRDisposer.h"
 #include <dolphin/os.h>
 #include "global.h"
+#include <new>
 
 class JKRHeap;
 typedef void (*JKRErrorHandler)(void*, u32, int);
@@ -204,16 +205,6 @@ void* operator new[](size_t size, JKRHeap* heap, int alignment);
 void operator delete(void* ptr);
 void operator delete[](void* ptr);
 
-#ifdef __MWERKS__
-inline void* operator new(size_t size, void* ptr) {
-    return ptr;
-}
-#endif
-
-inline void* operator new[](size_t size, void* ptr) {
-    return ptr;
-}
-
 void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment);
 
 inline void* JKRAllocFromHeap(JKRHeap* heap, u32 size, int alignment) {
diff --git a/src/JSystem/JGadget/std-vector.cpp b/src/JSystem/JGadget/std-vector.cpp
index 57a9c29b1b..f89eedf6f4 100644
--- a/src/JSystem/JGadget/std-vector.cpp
+++ b/src/JSystem/JGadget/std-vector.cpp
@@ -9,13 +9,13 @@ u32 JGadget::vector::extend_default(u32 param_0, u32 param_1, u32 param_2) {
 JGadget::TVector_pointer_void::TVector_pointer_void(JGadget::TAllocator<void*> const& param_0) : TVector<void*>(param_0) {
 }
 
-JGadget::TVector_pointer_void::~TVector_pointer_void() {
-}
-
 void dummy_weak_order(JGadget::TVector<void*> vec) {
     vec.insert(NULL, 0, NULL);
 }
 
+JGadget::TVector_pointer_void::~TVector_pointer_void() {
+}
+
 void JGadget::TVector_pointer_void::insert(void** param_0, void* const& param_1) {
     TVector<void*>::insert(param_0, param_1);
 }
diff --git a/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/memory b/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/memory
index bdd83684d7..58a22ef4d7 100644
--- a/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/memory
+++ b/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/memory
@@ -1,16 +1,16 @@
 #ifndef MSL_MEMORY_H_
 #define MSL_MEMORY_H_
 
+#include <new>
+
 namespace std {
 
 template<class ForwardIt, class Size, class T>
-inline ForwardIt uninitialized_fill_n(ForwardIt first, Size count, const T& value) {
+inline void uninitialized_fill_n(ForwardIt first, Size count, const T& value) {
+    ForwardIt r29 = first;
     for (; count--; ++first) {
-        if (first != NULL) {
-            *first = value;
-        }
+        new (first) T(value);
     }
-    return first;
 }
 
 template<class InputIterator, class ForwardIterator>
diff --git a/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/new b/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/new
index 414c6fd5be..743a4e968b 100644
--- a/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/new
+++ b/src/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include/new
@@ -3,6 +3,7 @@
 
 #include <stdio>
 
-inline void* (operator new)(size_t, void *ptr) { return ptr; }
+inline void* operator new(size_t, void *ptr) { return ptr; }
+inline void* operator new[](size_t, void* ptr) { return ptr; }
 
 #endif