Merge branch 'master' into mac

# Conflicts:
#	GpApp/House.cpp

PortabilityLayer/BinHex4.cpp

@@ -1,8 +1,8 @@
 #include "BinHex4.h"
 #include "GpIOStream.h"
+#include "GpVector.h"
 
 #include <string.h>
-#include <vector>
 #include <assert.h>
 
 // See: https://files.stairways.com/other/binhex-40-specs-info.txt
@@ -59,7 +59,7 @@ namespace
 
 namespace PortabilityLayer
 {
-	MacFileMem *BinHex4::LoadHQX(GpIOStream *stream)
+	MacFileMem *BinHex4::LoadHQX(GpIOStream *stream, IGpAllocator *alloc)
 	{
 		const uint8_t errCodeChar = 64;
 
@@ -108,7 +108,7 @@ namespace PortabilityLayer
 				return nullptr;
 		}
 
-		std::vector<uint8_t> bytesAfter6To8;
+		GpVector<uint8_t> bytesAfter6To8(alloc);
 
 		if (stream->IsSeekable())
 		{
@@ -120,7 +120,10 @@ namespace PortabilityLayer
 					return nullptr;
 
 				if (endPos > filePos && (endPos - filePos) < SIZE_MAX / 6)
-					bytesAfter6To8.reserve(static_cast<size_t>(endPos - filePos) * 6 / 8);
+				{
+					if (!bytesAfter6To8.Reserve(static_cast<size_t>(endPos - filePos) * 6 / 8))
+						return nullptr;
+				}
 			}
 		}
 
@@ -170,19 +173,22 @@ namespace PortabilityLayer
 				break;
 			case 6:
 				decodedByte |= value6Bit;
-				bytesAfter6To8.push_back(decodedByte);
+				if (!bytesAfter6To8.Append(decodedByte))
+					return nullptr;
 				decodedByte = 0;
 				decodedByteBitPos = 8;
 				break;
 			case 4:
 				decodedByte |= (value6Bit >> 2);
-				bytesAfter6To8.push_back(decodedByte);
+				if (!bytesAfter6To8.Append(decodedByte))
+					return nullptr;
 				decodedByte = (value6Bit << 6) & 0xff;
 				decodedByteBitPos = 6;
 				break;
 			case 2:
 				decodedByte |= (value6Bit >> 4);
-				bytesAfter6To8.push_back(decodedByte);
+				if (!bytesAfter6To8.Append(decodedByte))
+					return nullptr;
 				decodedByte = (value6Bit << 4) & 0xff;
 				decodedByteBitPos = 4;
 				break;
@@ -191,7 +197,7 @@ namespace PortabilityLayer
 			}
 		}
 
-		const size_t bytesBeforeRLEDec = bytesAfter6To8.size();
+		const size_t bytesBeforeRLEDec = bytesAfter6To8.Count();
 		size_t decodedDataSize = 0;
 		for (size_t i = 0; i < bytesBeforeRLEDec; i++)
 		{
@@ -212,8 +218,9 @@ namespace PortabilityLayer
 				decodedDataSize++;
 		}
 
-		std::vector<uint8_t> decodedBytes;
-		decodedBytes.reserve(decodedDataSize);
+		GpVector<uint8_t> decodedBytes(alloc);
+		if (!decodedBytes.Reserve(decodedDataSize))
+			return nullptr;
 
 		for (size_t i = 0; i < bytesBeforeRLEDec; i++)
 		{
@@ -224,28 +231,37 @@ namespace PortabilityLayer
 				const uint8_t runLength = bytesAfter6To8[++i];
 
 				if (runLength == 0)
-					decodedBytes.push_back(0x90);
+				{
+					if (!decodedBytes.Append(0x90))
+						return nullptr;
+				}
 				else
 				{
-					if (decodedBytes.size() == 0)
+					if (decodedBytes.Count() == 0)
 						return nullptr;
 
-					const uint8_t lastByte = *(decodedBytes.end() - 1);
+					const uint8_t lastByte = decodedBytes[decodedBytes.Count() - 1];
 					for (size_t r = 1; r < runLength; r++)
-						decodedBytes.push_back(lastByte);
+					{
+						if (!decodedBytes.Append(lastByte))
+							return nullptr;
+					}
 				}
 			}
 			else
-				decodedBytes.push_back(b);
+			{
+				if (!decodedBytes.Append(b))
+					return nullptr;
+			}
 		}
 
-		assert(decodedBytes.size() == decodedDataSize);
+		assert(decodedBytes.Count() == decodedDataSize);
 
-		if (decodedBytes.size() == 0)
+		if (decodedBytes.Count() == 0)
 			return nullptr;
 
 		const uint8_t nameLength = decodedBytes[0];
-		if (decodedBytes.size() < 22 + nameLength || nameLength > 63)
+		if (decodedBytes.Count() < 22 + nameLength || nameLength > 63)
 			return nullptr;
 
 		// Header format:
@@ -272,7 +288,7 @@ namespace PortabilityLayer
 		mfi.m_dataForkSize = ByteUnpack::BigUInt32(&decodedBytes[headerStartLoc + 10]);
 		mfi.m_resourceForkSize = ByteUnpack::BigUInt32(&decodedBytes[headerStartLoc + 14]);
 
-		const size_t availableDataSize = decodedBytes.size() - 26 - nameLength;	// +4 bytes for CRCs
+		const size_t availableDataSize = decodedBytes.Count() - 26 - nameLength;	// +4 bytes for CRCs
 
 		if (mfi.m_dataForkSize > availableDataSize || availableDataSize - mfi.m_dataForkSize < mfi.m_resourceForkSize)
 			return nullptr;
@@ -297,6 +313,6 @@ namespace PortabilityLayer
 		if (expectedResCRC != BinHexCRC(&decodedBytes[resourceForkStart], mfi.m_resourceForkSize))
 			return nullptr;
 
-		return new MacFileMem(&decodedBytes[dataForkStart], &decodedBytes[resourceForkStart], nullptr, mfi);
+		return MacFileMem::Create(alloc, &decodedBytes[dataForkStart], &decodedBytes[resourceForkStart], nullptr, mfi);
 	}
 }

PortabilityLayer/BinHex4.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#ifndef __PL_BINHEX4_H__
-#define __PL_BINHEX4_H__
-
 class GpIOStream;
+struct IGpAllocator;
 
 namespace PortabilityLayer
 {
@@ -11,8 +9,6 @@ namespace PortabilityLayer
 
 	namespace BinHex4
 	{
-		MacFileMem *LoadHQX(GpIOStream *stream);
+		MacFileMem *LoadHQX(GpIOStream *stream, IGpAllocator *alloc);
 	};
 }
-
-#endif

PortabilityLayer/MacBinary2.cpp

@@ -106,7 +106,7 @@ namespace PortabilityLayer
 		stream->Write(padding, resourceForkPadding);
 	}
 
-	MacFileMem *MacBinary2::ReadBin(GpIOStream *stream)
+	MacFileMem *MacBinary2::ReadBin(GpIOStream *stream, IGpAllocator *alloc)
 	{
 		MacFileInfo fileInfo;
 
@@ -153,37 +153,35 @@ namespace PortabilityLayer
 		if (fileInfo.m_resourceForkSize > SIZE_MAX)
 			return nullptr;
 
-		uint8_t *dataBuffer = nullptr;
-		uint8_t *rsrcBuffer = nullptr;
+		GpVector<uint8_t> dataBuffer(alloc);
+		GpVector<uint8_t> rsrcBuffer(alloc);
 
 		if (fileInfo.m_dataForkSize != 0)
-			dataBuffer = new uint8_t[fileInfo.m_dataForkSize];
+			dataBuffer.Resize(fileInfo.m_dataForkSize);
 
 		if (fileInfo.m_resourceForkSize != 0)
-			rsrcBuffer = new uint8_t[fileInfo.m_resourceForkSize];
+			rsrcBuffer.Resize(fileInfo.m_resourceForkSize);
 
-		ScopedArray<uint8_t> dataContents(dataBuffer);
-		ScopedArray<uint8_t> rsrcContents(rsrcBuffer);
 
 		uint8_t *padding = mb2Header;
 
 		const size_t dataForkPadding = 127 - ((fileInfo.m_dataForkSize + 127) % 128);
 		const size_t resourceForkPadding = 127 - ((fileInfo.m_resourceForkSize + 127) % 128);
 
-		if (stream->Read(dataBuffer, fileInfo.m_dataForkSize) != fileInfo.m_dataForkSize)
+		if (stream->Read(dataBuffer.Buffer(), fileInfo.m_dataForkSize) != fileInfo.m_dataForkSize)
 			return nullptr;
 
 		if (stream->Read(padding, dataForkPadding) != dataForkPadding)
 			return nullptr;
 
-		if (stream->Read(rsrcBuffer, fileInfo.m_resourceForkSize) != fileInfo.m_resourceForkSize)
+		if (stream->Read(rsrcBuffer.Buffer(), fileInfo.m_resourceForkSize) != fileInfo.m_resourceForkSize)
 			return nullptr;
 
 		if (stream->Read(padding, resourceForkPadding) != resourceForkPadding)
 			return nullptr;
 
 		// Ignore comment for now
-		return new MacFileMem(dataBuffer, rsrcBuffer, nullptr, fileInfo);
+		return MacFileMem::Create(alloc, dataBuffer.Buffer(), rsrcBuffer.Buffer(), nullptr, fileInfo);
 	}
 }
 

PortabilityLayer/MacBinary2.h

@@ -1,6 +1,7 @@
 #pragma once
 
 class GpIOStream;
+struct IGpAllocator;
 
 namespace PortabilityLayer
 {
@@ -14,6 +15,6 @@ namespace PortabilityLayer
 		void SerializeHeader(unsigned char *headerBytes, const MacFileInfo &macFileInfo);
 
 		void WriteBin(const MacFileMem *file, GpIOStream *stream);
-		MacFileMem *ReadBin(GpIOStream *stream);
+		MacFileMem *ReadBin(GpIOStream *stream, IGpAllocator *alloc);
 	};
 }

PortabilityLayer/MacFileMem.cpp

@@ -1,26 +1,59 @@
 #include "MacFileMem.h"
 
 namespace PortabilityLayer
-{
-	MacFileMem::MacFileMem(const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment, const MacFileInfo &fileInfo)
-		: m_info(fileInfo)
+{
+	MacFileMem::MacFileMem(IGpAllocator *alloc, const MacFileInfo &fileInfo)
+		: m_alloc(alloc)
+		, m_info(fileInfo)
+		, m_data(alloc)
 	{
-		uint8_t *buffer = new uint8_t[fileInfo.m_dataForkSize + fileInfo.m_resourceForkSize + fileInfo.m_commentSize + 1];
-		m_data.Set(buffer);
+	}
 
-		memcpy(buffer, dataFork, fileInfo.m_dataForkSize);
-		buffer += fileInfo.m_dataForkSize;
+	bool MacFileMem::Init(const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment)
+	{
+		const size_t combinedSize = m_info.m_dataForkSize + m_info.m_resourceForkSize + m_info.m_commentSize + 1;
+		if (!m_data.Resize(combinedSize))
+			return false;
+
+		uint8_t *buffer = m_data.Buffer();
+		memcpy(buffer, dataFork, m_info.m_dataForkSize);
+		buffer += m_info.m_dataForkSize;
 
-		memcpy(buffer, resourceFork, fileInfo.m_resourceForkSize);
-		buffer += fileInfo.m_resourceForkSize;
+		memcpy(buffer, resourceFork, m_info.m_resourceForkSize);
+		buffer += m_info.m_resourceForkSize;
 
-		memcpy(buffer, comment, fileInfo.m_commentSize);
-		buffer += fileInfo.m_commentSize;
+		memcpy(buffer, comment, m_info.m_commentSize);
+		buffer += m_info.m_commentSize;
 
-		*buffer = 0;
+		*buffer = 0;
+
+		return true;
 	}
 
 	MacFileMem::~MacFileMem()
 	{
+	}
+
+	MacFileMem *MacFileMem::Create(IGpAllocator *alloc, const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment, const MacFileInfo &fileInfo)
+	{
+		void *storage = alloc->Alloc(sizeof(MacFileMem));
+		if (!storage)
+			return nullptr;
+
+		MacFileMem *result = new (storage) MacFileMem(alloc, fileInfo);
+		if (!result->Init(dataFork, resourceFork, comment))
+		{
+			result->Destroy();
+			return nullptr;
+		}
+
+		return result;
+	}
+
+	void MacFileMem::Destroy()
+	{
+		IGpAllocator *alloc = m_alloc;
+		this->~MacFileMem();
+		alloc->Release(this);
 	}
 }

PortabilityLayer/MacFileMem.h

@@ -1,28 +1,33 @@
 #pragma once
 
-#ifndef __PL_MACFILEMEM_H__
-#define __PL_MACFILEMEM_H__
-
 #include "DataTypes.h"
 #include "MacFileInfo.h"
-#include "ScopedArray.h"
+#include "GpVector.h"
+
+struct IGpAllocator;
 
 namespace PortabilityLayer
 {
 	class MacFileMem
 	{
 	public:
-		MacFileMem(const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment, const MacFileInfo &fileInfo);
-		~MacFileMem();
-
 		const MacFileInfo &FileInfo() const;
 		const uint8_t *DataFork() const;
 		const uint8_t *ResourceFork() const;
-		const char *Comment() const;
+		const char *Comment() const;
+
+		static MacFileMem *Create(IGpAllocator *alloc, const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment, const MacFileInfo &fileInfo);
+		void Destroy();
 
 	private:
-		ScopedArray<uint8_t> m_data;
-		MacFileInfo m_info;
+		MacFileMem(IGpAllocator *alloc, const MacFileInfo &fileInfo);
+		~MacFileMem();
+
+		bool Init(const uint8_t *dataFork, const uint8_t *resourceFork, const char* comment);
+
+		GpVector<uint8_t> m_data;
+		MacFileInfo m_info;
+		IGpAllocator *m_alloc;
 	};
 }
 
@@ -35,18 +40,16 @@ namespace PortabilityLayer
 
 	inline const uint8_t *MacFileMem::DataFork() const
 	{
-		return m_data;
+		return m_data.Buffer();
 	}
 
 	inline const uint8_t *MacFileMem::ResourceFork() const
 	{
-		return m_data + m_info.m_dataForkSize;
+		return m_data.Buffer() + m_info.m_dataForkSize;
 	}
 
 	inline const char *MacFileMem::Comment() const
 	{
-		return reinterpret_cast<const char*>(m_data + m_info.m_dataForkSize + m_info.m_resourceForkSize);
+		return reinterpret_cast<const char*>(m_data.Buffer() + m_info.m_dataForkSize + m_info.m_resourceForkSize);
 	}
 }
-
-#endif

PortabilityLayer/PortabilityLayer.vcxproj

@@ -209,7 +209,6 @@
     <ClInclude Include="VirtualDirectory.h" />
     <ClInclude Include="RCPtr.h" />
     <ClInclude Include="RefCounted.h" />
-    <ClInclude Include="ScopedArray.h" />
     <ClInclude Include="ScopedPtr.h" />
     <ClInclude Include="SmallestInt.h" />
     <ClInclude Include="UnsafePascalStr.h" />

PortabilityLayer/PortabilityLayer.vcxproj.filters

@@ -42,9 +42,6 @@
     <ClInclude Include="ScopedPtr.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="ScopedArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="PascalStr.h">
       <Filter>Header Files</Filter>
     </ClInclude>

PortabilityLayer/ScopedArray.h

@@ -1,83 +0,0 @@
-#pragma once
-
-#ifndef __PL_SCOPEDARRAY_H__
-#define __PL_SCOPEDARRAY_H__
-
-#include "CoreDefs.h"
-
-namespace PortabilityLayer
-{
-	template<class T>
-	class ScopedArray
-	{
-	public:
-		ScopedArray();
-		ScopedArray(T *ref);
-		~ScopedArray();
-
-		void Swap(ScopedArray<T> &other);
-
-		operator T*();
-		operator const T*() const;
-
-		void Set(T *ref);
-
-	private:
-		ScopedArray(const ScopedArray<T> &other) GP_DELETED;
-		void operator=(const ScopedArray<T> &other) GP_DELETED;
-		T *m_ref;
-	};
-}
-
-namespace PortabilityLayer
-{
-	template<class T>
-	inline ScopedArray<T>::ScopedArray()
-		: m_ref(nullptr)
-	{
-	}
-
-	template<class T>
-	inline ScopedArray<T>::ScopedArray(T *ref)
-		: m_ref(ref)
-	{
-	}
-
-	template<class T>
-	inline ScopedArray<T>::~ScopedArray()
-	{
-		if (m_ref)
-			delete[] m_ref;
-	}
-
-	template<class T>
-	inline void ScopedArray<T>::Swap(ScopedArray<T> &other)
-	{
-		T *temp = m_ref;
-		m_ref = other.m_ref;
-		other.m_ref = temp;
-	}
-
-	template<class T>
-	inline ScopedArray<T>::operator T*()
-	{
-		return m_ref;
-	}
-
-	template<class T>
-	inline ScopedArray<T>::operator const T*() const
-	{
-		return m_ref;
-	}
-
-	template<class T>
-	inline void ScopedArray<T>::Set(T *ref)
-	{
-		if (m_ref && m_ref != ref)
-			delete m_ref;
-
-		m_ref = ref;
-	}
-}
-
-#endif

PortabilityLayer/ScopedPtr.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#ifndef __PL_SCOPEDPTR_H__
-#define __PL_SCOPEDPTR_H__
-
 #include "CoreDefs.h"
 
 namespace PortabilityLayer
@@ -49,7 +46,7 @@ namespace PortabilityLayer
 	inline ScopedPtr<T>::~ScopedPtr()
 	{
 		if (m_ref)
-			delete m_ref;
+			m_ref->Destroy();
 	}
 
 	template<class T>
@@ -87,11 +84,9 @@ namespace PortabilityLayer
 	template<class T>
 	inline void ScopedPtr<T>::Set(T *ref)
 	{
-		if (m_ref && m_ref != ref)
-			delete m_ref;
+		if (m_ref && m_ref != ref)
+			m_ref->Destroy();
 
 		m_ref = ref;
 	}
 }
-
-#endif