Core: Replace StackAllocation by StackArray

This will cleanup alloca usage a little bit

include/Nazara/Core/MemoryHelper.hpp

@@ -23,12 +23,15 @@
 #endif
 
 #ifdef NAZARA_ALLOCA_SUPPORT
-	#define NazaraStackAllocation(size) Nz::StackAllocation(NAZARA_ALLOCA(size))
+	#define NazaraStackAllocation(T, size) Nz::StackArray<T>(static_cast<T*>(NAZARA_ALLOCA((size) * sizeof(T))), size)
+	#define NazaraStackAllocationNoInit(T, size) Nz::StackArray<T>(static_cast<T*>(NAZARA_ALLOCA((size) * sizeof(T))), size, Nz::NoInitTag())
 #else
-	#define NazaraStackAllocation(size) Nz::StackAllocation(Nz::OperatorNew(size))
+	#define NazaraStackAllocation(T, size) Nz::StackArray<T>(static_cast<T*>(Nz::OperatorNew((size) * sizeof(T))), size)
+	#define NazaraStackAllocationNoInit(T, size) Nz::StackArray<T>(static_cast<T*>(Nz::OperatorNew((size) * sizeof(T))), size, Nz::NoInitTag())
 #endif
 
 #include <cstddef>
+#include <iterator>
 
 namespace Nz
 {
@@ -41,19 +44,70 @@ namespace Nz
 	template<typename T>
 	void PlacementDestroy(T* ptr);
 
-	class StackAllocation
+	struct NoInitTag {};
+
+	template<typename T>
+	class StackArray
 	{
 		public:
-			explicit StackAllocation(void* stackMemory);
+			using value_type = T;
-			~StackAllocation();
+			using const_iterator = const value_type*;
+			using const_pointer = const value_type*;
+			using const_reference = const value_type&;
+			using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+			using difference_type = std::ptrdiff_t;
+			using iterator = value_type*;
+			using pointer = value_type*;
+			using reference = value_type&;
+			using reverse_iterator = std::reverse_iterator<iterator>;
+			using size_type = std::size_t;
 
-			void* GetPtr();
+			StackArray(T* stackMemory, std::size_t size);
+			StackArray(T* stackMemory, std::size_t size, NoInitTag);
+			~StackArray();
 
-			operator void*();
+			reference back();
+			const_reference back() const;
+
+			iterator begin() noexcept;
+			const_iterator begin() const noexcept;
+
+			const_iterator cbegin() const noexcept;
+			const_iterator cend() const noexcept;
+			const_iterator crbegin() const noexcept;
+			const_iterator crend() const noexcept;
+
+			T* data() noexcept;
+			const T* data() const noexcept;
+
+			bool empty() const noexcept;
+
+			iterator end() noexcept;
+			const_iterator end() const noexcept;
+
+			void fill(const T& value);
+
+			reference front() noexcept;
+			const_reference front() const noexcept;
+
+			size_type max_size() const noexcept;
+
+			reverse_iterator rbegin() noexcept;
+			const_reverse_iterator rbegin() const noexcept;
+
+			reverse_iterator rend() noexcept;
+			const_reverse_iterator rend() const noexcept;
+
+			size_type size() const noexcept;
+
+			reference operator[](size_type pos);
+			const_reference operator[](size_type pos) const;
 
 		private:
-			void* m_ptr;
+			std::size_t m_size;
+			T* m_ptr;
 	};
+
 }
 
 #include <Nazara/Core/MemoryHelper.inl>

include/Nazara/Core/MemoryHelper.inl

@@ -11,6 +11,8 @@
 
 #include <Nazara/Core/MemoryHelper.hpp>
 #include <Nazara/Core/MemoryManager.hpp>
+#include <algorithm>
+#include <cassert>
 #include <new>
 #include <utility>
 #include <Nazara/Core/Debug.hpp>
@@ -77,48 +79,184 @@ namespace Nz
 
 	/*!
 	* \ingroup core
-	* \class Nz::StackAllocation
+	* \class Nz::StackArray
-	* \brief Core class that represents a stack allocation
+	* \brief Core class that represents a stack-allocated (if alloca is present) array
 	*/
 
+	template<typename T>
+	StackArray<T>::StackArray(T* stackMemory, std::size_t size) :
+	m_size(size),
+	m_ptr(stackMemory)
+	{
+		for (std::size_t i = 0; i < m_size; ++i)
+			PlacementNew(&m_ptr[i]);
+	}
 
-	/*!
+	template<typename T>
-	* \brief Constructs a StackAllocation object with a pointer to a memory allocated with NAZARA_ALLOCA or OperatorNew is alloca is not supported
+	StackArray<T>::StackArray(T* stackMemory, std::size_t size, NoInitTag) :
-	*
+	m_size(size),
-	* \param ptr Pointer to raw memory
-	*/
-	inline StackAllocation::StackAllocation(void* stackMemory) :
 	m_ptr(stackMemory)
 	{
 	}
 
-	/*!
+	template<typename T>
-	* \brief Destructs the object and release memory if necessary
+	StackArray<T>::~StackArray()
-	*/
-	inline StackAllocation::~StackAllocation()
 	{
+		for (std::size_t i = 0; i < m_size; ++i)
+			m_ptr[i].~T();
+
 		#ifndef NAZARA_ALLOCA_SUPPORT
 		OperatorDelete(m_ptr);
 		#endif
 	}
 
-	/*!
+	template<typename T>
-	* \brief Access the internal pointer
+	typename StackArray<T>::reference StackArray<T>::back()
-	* \return internal memory pointer
+	{
-	*/
+		assert(m_size != 0);
-	inline void* StackAllocation::GetPtr()
+		return m_ptr[m_size - 1];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::back() const
+	{
+		assert(m_size != 0);
+		return m_ptr[m_size - 1];
+	}
+
+	template<typename T>
+	typename StackArray<T>::iterator StackArray<T>::begin() noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::begin() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::cbegin() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::cend() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::crbegin() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::crend() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	T* StackArray<T>::data() noexcept
 	{
 		return m_ptr;
 	}
 
-	/*!
+	template<typename T>
-	* \brief Access the internal pointer
+	const T* StackArray<T>::data() const noexcept
-	* \return internal memory pointer
-	*/
-	inline StackAllocation::operator void*()
 	{
 		return m_ptr;
 	}
+
+	template<typename T>
+	bool StackArray<T>::empty() const noexcept
+	{
+		return m_size == 0;
+	}
+
+	template<typename T>
+	typename StackArray<T>::iterator StackArray<T>::end() noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::end() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	void StackArray<T>::fill(const T& value)
+	{
+		std::fill(begin(), end(), value);
+	}
+
+	template<typename T>
+	typename StackArray<T>::reference StackArray<T>::front() noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::front() const noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::size_type StackArray<T>::max_size() const noexcept
+	{
+		return size();
+	}
+
+	template<typename T>
+	typename StackArray<T>::reverse_iterator StackArray<T>::rbegin() noexcept
+	{
+		return m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reverse_iterator StackArray<T>::rbegin() const noexcept
+	{
+		return m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::reverse_iterator StackArray<T>::rend() noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reverse_iterator StackArray<T>::rend() const noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::size_type StackArray<T>::size() const noexcept
+	{
+		return m_size;
+	}
+
+	template<typename T>
+	typename StackArray<T>::reference StackArray<T>::operator[](size_type pos)
+	{
+		assert(pos < m_size);
+		return m_ptr[pos];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::operator[](size_type pos) const
+	{
+		assert(pos < m_size);
+		return m_ptr[pos];
+	}
 }
 
 #include <Nazara/Core/DebugOff.hpp>

src/Nazara/Network/Posix/SocketImpl.cpp

@@ -566,8 +566,7 @@ namespace Nz
 		NazaraAssert(handle != InvalidHandle, "Invalid handle");
 		NazaraAssert(buffers && bufferCount > 0, "Invalid buffers");
 
-		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(iovec));
+		StackArray<iovec> sysBuffers = NazaraStackAllocation(iovec, bufferCount);
-		struct iovec* sysBuffers = static_cast<struct iovec*>(memory.GetPtr());
 		for (std::size_t i = 0; i < bufferCount; ++i)
 		{
 			sysBuffers[i].iov_base = buffers[i].data;
@@ -577,7 +576,7 @@ namespace Nz
 		struct msghdr msgHdr;
 		std::memset(&msgHdr, 0, sizeof(msgHdr));
 
-		msgHdr.msg_iov = sysBuffers;
+		msgHdr.msg_iov = sysBuffers.data();
 		msgHdr.msg_iovlen = static_cast<int>(bufferCount);
 
 		IpAddressImpl::SockAddrBuffer nameBuffer;
@@ -689,8 +688,7 @@ namespace Nz
 		NazaraAssert(handle != InvalidHandle, "Invalid handle");
 		NazaraAssert(buffers && bufferCount > 0, "Invalid buffers");
 
-		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(iovec));
+		StackArray<iovec> sysBuffers = NazaraStackAllocation(iovec, bufferCount);
-		struct iovec* sysBuffers = static_cast<struct iovec*>(memory.GetPtr());
 		for (std::size_t i = 0; i < bufferCount; ++i)
 		{
 			sysBuffers[i].iov_base = buffers[i].data;
@@ -703,7 +701,7 @@ namespace Nz
 		IpAddressImpl::SockAddrBuffer nameBuffer;
 		msgHdr.msg_namelen = IpAddressImpl::ToSockAddr(to, nameBuffer.data());
 		msgHdr.msg_name = nameBuffer.data();
-		msgHdr.msg_iov = sysBuffers;
+		msgHdr.msg_iov = sysBuffers.data();
 		msgHdr.msg_iovlen = static_cast<int>(bufferCount);
 
 		int byteSent = sendmsg(handle, &msgHdr, MSG_NOSIGNAL);

src/Nazara/Network/Win32/SocketImpl.cpp

@@ -596,8 +596,7 @@ namespace Nz
 
 		IpAddress senderIp;
 
-		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(WSABUF));
+		StackArray<WSABUF> winBuffers = NazaraStackAllocation(WSABUF, bufferCount);
-		WSABUF* winBuffers = static_cast<WSABUF*>(memory.GetPtr());
 		for (std::size_t i = 0; i < bufferCount; ++i)
 		{
 			winBuffers[i].buf = static_cast<CHAR*>(buffers[i].data);
@@ -606,7 +605,7 @@ namespace Nz
 
 		DWORD flags = 0;
 		DWORD byteRead;
-		if (WSARecvFrom(handle, winBuffers, static_cast<DWORD>(bufferCount), &byteRead, &flags, reinterpret_cast<sockaddr*>(nameBuffer.data()), &bufferLength, nullptr, nullptr) == SOCKET_ERROR)
+		if (WSARecvFrom(handle, winBuffers.data(), static_cast<DWORD>(bufferCount), &byteRead, &flags, reinterpret_cast<sockaddr*>(nameBuffer.data()), &bufferLength, nullptr, nullptr) == SOCKET_ERROR)
 		{
 			int errorCode = WSAGetLastError();
 			switch (errorCode)
@@ -696,8 +695,7 @@ namespace Nz
 		IpAddressImpl::SockAddrBuffer nameBuffer;
 		int bufferLength = IpAddressImpl::ToSockAddr(to, nameBuffer.data());
 
-		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(WSABUF));
+		StackArray<WSABUF> winBuffers = NazaraStackAllocation(WSABUF, bufferCount);
-		WSABUF* winBuffers = static_cast<WSABUF*>(memory.GetPtr());
 		for (std::size_t i = 0; i < bufferCount; ++i)
 		{
 			winBuffers[i].buf = static_cast<CHAR*>(buffers[i].data);
@@ -705,7 +703,7 @@ namespace Nz
 		}
 
 		DWORD byteSent;
-		if (WSASendTo(handle, winBuffers, static_cast<DWORD>(bufferCount), &byteSent, 0, reinterpret_cast<const sockaddr*>(nameBuffer.data()), bufferLength, nullptr, nullptr) == SOCKET_ERROR)
+		if (WSASendTo(handle, winBuffers.data(), static_cast<DWORD>(bufferCount), &byteSent, 0, reinterpret_cast<const sockaddr*>(nameBuffer.data()), bufferLength, nullptr, nullptr) == SOCKET_ERROR)
 		{
 			int errorCode = WSAGetLastError();
 			switch (errorCode)

src/Nazara/Physics2D/PhysWorld2D.cpp

@@ -44,12 +44,11 @@ namespace Nz
 			{
 				//TODO: constexpr if to prevent copy/cast if sizeof(cpVect) == sizeof(Vector2f)
 
-				StackAllocation stackAlloc = NazaraStackAllocation(vertexCount * sizeof(Vector2f));
+				StackArray<Vector2f> vertices = NazaraStackAllocation(Vector2f, vertexCount);
-				Vector2f* vec = static_cast<Vector2f*>(stackAlloc.GetPtr());
 				for (int i = 0; i < vertexCount; ++i)
-					vec[i].Set(float(vertices[i].x), float(vertices[i].y));
+					vertices[i].Set(float(vertices[i].x), float(vertices[i].y));
 
-				drawOptions->polygonCallback(vec, vertexCount, float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
+				drawOptions->polygonCallback(vertices.data(), vertexCount, float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
 			}
 		};
 

src/Nazara/Renderer/Renderer.cpp

@@ -1762,9 +1762,7 @@ namespace Nz
 			glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);
 			maxLength++;
 
-			StackAllocation stackAlloc = NazaraStackAllocation((maxLength + 1) * sizeof(GLchar));
+			StackAllocation<GLchar> nameBuffer = NazaraStackAllocation(GLchar, maxLength + 1);
-			GLchar* nameBuffer = static_cast<GLchar*>(stackAlloc.GetPtr());
-
 			for (GLint i = 0; i < count; i++)
 			{
 				GLint size;
@@ -1772,9 +1770,9 @@ namespace Nz
 
 				glGetActiveUniform(program, i, maxLength, nullptr, &size, &type, nameBuffer);
 
-				dump << "Uniform #" << i << ": " << nameBuffer << "(Type: 0x" << String::Number(type, 16);
+				dump << "Uniform #" << i << ": " << nameBuffer.data() << "(Type: 0x" << String::Number(type, 16);
 
-				GLint location = glGetUniformLocation(program, nameBuffer);
+				GLint location = glGetUniformLocation(program, nameBuffer.data());
 				switch (type)
 				{
 					case GL_FLOAT: