Move IOStream to GpCommon

PortabilityLayer/BinHex4.cpp

@@ -1,5 +1,5 @@
 #include "BinHex4.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 
 #include <string.h>
 #include <vector>
@@ -59,7 +59,7 @@ namespace
 
 namespace PortabilityLayer
 {
-	MacFileMem *BinHex4::LoadHQX(IOStream *stream)
+	MacFileMem *BinHex4::LoadHQX(GpIOStream *stream)
 	{
 		const uint8_t errCodeChar = 64;
 
@@ -112,10 +112,10 @@ namespace PortabilityLayer
 
 		if (stream->IsSeekable())
 		{
-			UFilePos_t filePos = stream->Tell();
+			GpUFilePos_t filePos = stream->Tell();
 			if (stream->SeekEnd(0))
 			{
-				UFilePos_t endPos = stream->Tell();
+				GpUFilePos_t endPos = stream->Tell();
 				if (!stream->SeekStart(filePos))
 					return nullptr;
 

PortabilityLayer/BinHex4.h

@@ -1,16 +1,17 @@
 #pragma once
 
 #ifndef __PL_BINHEX4_H__
-#define __PL_BINHEX4_H__
+#define __PL_BINHEX4_H__
+
+class GpIOStream;
 
 namespace PortabilityLayer
 {
-	class IOStream;
 	class MacFileMem;
 
 	namespace BinHex4
 	{
-		MacFileMem *LoadHQX(IOStream *stream);
+		MacFileMem *LoadHQX(GpIOStream *stream);
 	};
 }
 

PortabilityLayer/CFileStream.cpp

@@ -49,7 +49,7 @@ namespace PortabilityLayer
 		return m_writeOnly;
 	}
 
-	bool CFileStream::SeekStart(UFilePos_t loc)
+	bool CFileStream::SeekStart(GpUFilePos_t loc)
 	{
 		if (!m_file)
 			return false;
@@ -57,7 +57,7 @@ namespace PortabilityLayer
 		return fseek(m_file, static_cast<long>(loc), SEEK_SET) == 0;
 	}
 
-	bool CFileStream::SeekCurrent(FilePos_t loc)
+	bool CFileStream::SeekCurrent(GpFilePos_t loc)
 	{
 		if (!m_file)
 			return false;
@@ -65,7 +65,7 @@ namespace PortabilityLayer
 		return fseek(m_file, static_cast<long>(loc), SEEK_CUR) == 0;;
 	}
 
-	bool CFileStream::SeekEnd(UFilePos_t loc)
+	bool CFileStream::SeekEnd(GpUFilePos_t loc)
 	{
 		if (!m_file)
 			return false;
@@ -73,17 +73,17 @@ namespace PortabilityLayer
 		return fseek(m_file, static_cast<long>(loc), SEEK_END) == 0;
 	}
 
-	bool CFileStream::Truncate(UFilePos_t loc)
+	bool CFileStream::Truncate(GpUFilePos_t loc)
 	{
 		return false;
 	}
 
-	UFilePos_t CFileStream::Tell() const
+	GpUFilePos_t CFileStream::Tell() const
 	{
 		if (!m_file)
 			return 0;
 
-		return static_cast<UFilePos_t>(ftell(m_file));
+		return static_cast<GpUFilePos_t>(ftell(m_file));
 	}
 
 	void CFileStream::Close()
@@ -102,14 +102,14 @@ namespace PortabilityLayer
 	}
 
 
-	UFilePos_t CFileStream::Size() const
+	GpUFilePos_t CFileStream::Size() const
 	{
 		if (!m_file || !m_seekable)
 			return 0;
 
 		long oldPos = ftell(m_file);
 		fseek(m_file, 0, SEEK_END);
-		const UFilePos_t endPos = static_cast<UFilePos_t>(ftell(m_file));
+		const GpUFilePos_t endPos = static_cast<GpUFilePos_t>(ftell(m_file));
 		fseek(m_file, oldPos, SEEK_SET);
 
 		return endPos;

PortabilityLayer/CFileStream.h

@@ -6,11 +6,11 @@
 #include <stdio.h>
 
 #include "CoreDefs.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 
 namespace PortabilityLayer
 {
-	class CFileStream final : public IOStream
+	class CFileStream final : public GpIOStream
 	{
 	public:
 		explicit CFileStream(FILE *f);
@@ -21,12 +21,12 @@ namespace PortabilityLayer
 		bool IsSeekable() const override;
 		bool IsReadOnly() const override;
 		bool IsWriteOnly() const override;
-		bool SeekStart(UFilePos_t loc) override;
-		bool SeekCurrent(FilePos_t loc) override;
-		bool SeekEnd(UFilePos_t loc) override;
-		bool Truncate(UFilePos_t loc) override;
-		UFilePos_t Size() const override;
-		UFilePos_t Tell() const override;
+		bool SeekStart(GpUFilePos_t loc) override;
+		bool SeekCurrent(GpFilePos_t loc) override;
+		bool SeekEnd(GpUFilePos_t loc) override;
+		bool Truncate(GpUFilePos_t loc) override;
+		GpUFilePos_t Size() const override;
+		GpUFilePos_t Tell() const override;
 		void Close() override;
 		void Flush() override;
 

PortabilityLayer/DeflateCodec.cpp

@@ -1,6 +1,6 @@
 #include "DeflateCodec.h"
 
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "MemoryManager.h"
 
 #include "zlib.h"
@@ -20,7 +20,7 @@ namespace
 
 namespace PortabilityLayer
 {
-	bool DeflateCodec::DecompressStream(IOStream *stream, size_t inSize, void *outBuffer, size_t outSize)
+	bool DeflateCodec::DecompressStream(GpIOStream *stream, size_t inSize, void *outBuffer, size_t outSize)
 	{
 		z_stream zstream;
 		zstream.zalloc = ZlibAllocShim;

PortabilityLayer/DeflateCodec.h

@@ -2,13 +2,13 @@
 
 #include <stdint.h>
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
-
 	class DeflateCodec
 	{
 	public:
-		static bool DecompressStream(IOStream *stream, size_t inSize, void *outBuffer, size_t outSize);
+		static bool DecompressStream(GpIOStream *stream, size_t inSize, void *outBuffer, size_t outSize);
 	};
 }

PortabilityLayer/FileManager.cpp

@@ -26,12 +26,12 @@ namespace PortabilityLayer
 		PLError_t CreateFile(VirtualDirectory_t dirID, const PLPasStr &filename, const MacFileProperties &mfp) override;
 		PLError_t CreateFileAtCurrentTime(VirtualDirectory_t dirID, const PLPasStr &filename, const ResTypeID &fileCreator, const ResTypeID &fileType) override;
 
-		PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outRefNum) override;
-		PLError_t OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outRefNum) override;
+		PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, GpIOStream *&outRefNum) override;
+		PLError_t OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, GpIOStream *&outRefNum) override;
 		bool ReadFileProperties(VirtualDirectory_t dirID, const PLPasStr &filename, MacFileProperties &properties) override;
 
-		PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t creationDisposition, IOStream *&outStream) override;
-		PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t creationDisposition, IOStream *&outStream) override;
+		PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t creationDisposition, GpIOStream *&outStream) override;
+		PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t creationDisposition, GpIOStream *&outStream) override;
 
 		bool PromptSaveFile(VirtualDirectory_t dirID, char *path, size_t &outPathLength, size_t pathCapacity, const PLPasStr &initialFileName) override;
 		bool PromptOpenFile(VirtualDirectory_t dirID, char *path, size_t &outPathLength, size_t pathCapacity) override;
@@ -41,8 +41,8 @@ namespace PortabilityLayer
 	private:
 		typedef char ExtendedFileName_t[64 + 4];
 
-		PLError_t OpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, IOStream *&outRefNum);
-		PLError_t RawOpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream);
+		PLError_t OpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, GpIOStream *&outRefNum);
+		PLError_t RawOpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream);
 
 		static bool ConstructFilename(ExtendedFileName_t& extFN, const PLPasStr &fn, const char *extension);
 
@@ -111,7 +111,7 @@ namespace PortabilityLayer
 		if (!ConstructFilename(extFN, filename, ".gpf"))
 			return PLErrors::kBadFileName;
 
-		IOStream *stream = nullptr;
+		GpIOStream *stream = nullptr;
 		PLError_t err = RawOpenFileFork(dirID, filename, ".gpf", EFilePermission_Write, true, GpFileCreationDispositions::kCreateOrOverwrite, stream);
 		if (err)
 			return err;
@@ -137,19 +137,19 @@ namespace PortabilityLayer
 		return CreateFile(dirID, filename, mfp);
 	}
 
-	PLError_t FileManagerImpl::OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
+	PLError_t FileManagerImpl::OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, GpIOStream *&outStream)
 	{
 		return OpenFileFork(dirID, filename, ".gpd", permission, outStream);
 	}
 
-	PLError_t FileManagerImpl::OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
+	PLError_t FileManagerImpl::OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, GpIOStream *&outStream)
 	{
 		return OpenFileFork(dirID, filename, ".gpa", permission, outStream);
 	}
 
 	bool FileManagerImpl::ReadFileProperties(VirtualDirectory_t dirID, const PLPasStr &filename, MacFileProperties &properties)
 	{
-		IOStream *stream = nullptr;
+		GpIOStream *stream = nullptr;
 		PLError_t err = RawOpenFileFork(dirID, filename, ".gpf", EFilePermission_Read, true, GpFileCreationDispositions::kOpenExisting, stream);
 		if (err)
 			return false;
@@ -164,12 +164,12 @@ namespace PortabilityLayer
 		return readOk;
 	}
 
-	PLError_t FileManagerImpl::RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream)
+	PLError_t FileManagerImpl::RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream)
 	{
 		return RawOpenFileFork(dirID, filename, ".gpd", permission, ignoreMeta, createDisposition, outStream);
 	}
 
-	PLError_t FileManagerImpl::RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream)
+	PLError_t FileManagerImpl::RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream)
 	{
 		return RawOpenFileFork(dirID, filename, ".gpa", permission, ignoreMeta, createDisposition, outStream);
 	}
@@ -193,11 +193,11 @@ namespace PortabilityLayer
 		return &ms_instance;
 	}
 
-	PLError_t FileManagerImpl::OpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *extension, EFilePermission permission, IOStream *&outStream)
+	PLError_t FileManagerImpl::OpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *extension, EFilePermission permission, GpIOStream *&outStream)
 	{
 		bool isWriteAccess = (permission == EFilePermission_Any || permission == EFilePermission_ReadWrite || permission == EFilePermission_Write);
 		GpFileCreationDisposition_t createDisposition = isWriteAccess ? GpFileCreationDispositions::kCreateOrOpen : GpFileCreationDispositions::kOpenExisting;
-		IOStream *stream = nullptr;
+		GpIOStream *stream = nullptr;
 		PLError_t openError = RawOpenFileFork(dirID, filename, extension, permission, false, createDisposition, stream);
 		if (openError != PLErrors::kNone)
 			return openError;
@@ -207,7 +207,7 @@ namespace PortabilityLayer
 		return PLErrors::kNone;
 	}
 
-	PLError_t FileManagerImpl::RawOpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream)
+	PLError_t FileManagerImpl::RawOpenFileFork(VirtualDirectory_t dirID, const PLPasStr &filename, const char *ext, EFilePermission permission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream)
 	{
 		ExtendedFileName_t gpfExtFN;
 		ExtendedFileName_t extFN;
@@ -227,7 +227,7 @@ namespace PortabilityLayer
 		if (!ConstructFilename(extFN, filename, ext))
 			return PLErrors::kBadFileName;
 
-		IOStream *fstream = nullptr;
+		GpIOStream *fstream = nullptr;
 		switch (permission)
 		{
 		case EFilePermission_Any:

PortabilityLayer/FileManager.h

@@ -2,7 +2,6 @@
 
 #include "FilePermission.h"
 #include "CoreDefs.h"
-#include "FilePos.h"
 #include "GpFileCreationDisposition.h"
 #include "PLErrorCodes.h"
 #include "VirtualDirectory.h"
@@ -11,9 +10,10 @@
 
 class PLPasStr;
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
 	class ResTypeID;
 	struct MacFileProperties;
 
@@ -28,12 +28,12 @@ namespace PortabilityLayer
 		virtual PLError_t CreateFileAtCurrentTime(VirtualDirectory_t dirID, const PLPasStr &filename, const ResTypeID &fileCreator, const ResTypeID &fileType) = 0;
 
 		// OpenFileData + OpenFileResources require that the file already exists (i.e. has a .gpf), but the fork may not
-		virtual PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outStream) = 0;
-		virtual PLError_t OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outStream) = 0;
+		virtual PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, GpIOStream *&outStream) = 0;
+		virtual PLError_t OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, GpIOStream *&outStream) = 0;
 		virtual bool ReadFileProperties(VirtualDirectory_t dirID, const PLPasStr &filename, MacFileProperties &properties) = 0;
 
-		virtual PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream) = 0;
-		virtual PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, IOStream *&outStream) = 0;
+		virtual PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream) = 0;
+		virtual PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, GpFileCreationDisposition_t createDisposition, GpIOStream *&outStream) = 0;
 
 		virtual bool PromptSaveFile(VirtualDirectory_t dirID, char *path, size_t &outPathLength, size_t pathCapacity, const PLPasStr &initialFileName) = 0;
 		virtual bool PromptOpenFile(VirtualDirectory_t dirID, char *path, size_t &outPathLength, size_t pathCapacity) = 0;

PortabilityLayer/FilePos.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-namespace PortabilityLayer
-{
-	typedef int64_t FilePos_t;
-	typedef uint64_t UFilePos_t;
-}

PortabilityLayer/FontFamily.cpp

@@ -1,5 +1,5 @@
 #include "FontFamily.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "HostFileSystem.h"
 #include "HostFontHandler.h"
 #include "HostFont.h"
@@ -11,7 +11,7 @@ namespace PortabilityLayer
 {
 	void FontFamily::AddFont(int flags, const char *path, FontHacks fontHacks)
 	{
-		PortabilityLayer::IOStream *sysFontStream = PortabilityLayer::HostFileSystem::GetInstance()->OpenFile(PortabilityLayer::VirtualDirectories::kFonts, path, false, GpFileCreationDispositions::kOpenExisting);
+		GpIOStream *sysFontStream = PortabilityLayer::HostFileSystem::GetInstance()->OpenFile(PortabilityLayer::VirtualDirectories::kFonts, path, false, GpFileCreationDispositions::kOpenExisting);
 		if (!sysFontStream)
 			return;
 

PortabilityLayer/FontManager.cpp

@@ -5,7 +5,7 @@
 #include "HostFileSystem.h"
 #include "HostFont.h"
 #include "HostFontHandler.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "RenderedFont.h"
 
 #include <string.h>

PortabilityLayer/HostFileSystem.h

@@ -5,9 +5,10 @@
 
 #include <stdint.h>
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
 	class HostDirectoryCursor;
 
 	class HostFileSystem
@@ -15,7 +16,7 @@ namespace PortabilityLayer
 	public:
 		virtual bool FileExists(VirtualDirectory_t virtualDirectory, const char *path) = 0;
 		virtual bool FileLocked(VirtualDirectory_t virtualDirectory, const char *path, bool *exists) = 0;
-		virtual IOStream *OpenFile(VirtualDirectory_t virtualDirectory, const char *path, bool writeAccess, GpFileCreationDisposition_t createDisposition) = 0;
+		virtual GpIOStream *OpenFile(VirtualDirectory_t virtualDirectory, const char *path, bool writeAccess, GpFileCreationDisposition_t createDisposition) = 0;
 		virtual bool DeleteFile(VirtualDirectory_t virtualDirectory, const char *path, bool &existed) = 0;
 		virtual HostDirectoryCursor *ScanDirectory(VirtualDirectory_t virtualDirectory) = 0;
 

PortabilityLayer/HostFontHandler.h

@@ -1,9 +1,9 @@
 #pragma once
 
+class GpIOStream;
 
 namespace PortabilityLayer
 {
-	class IOStream;
 	class HostFont;
 
 	class HostFontHandler
@@ -11,7 +11,7 @@ namespace PortabilityLayer
 	public:
 		virtual void Shutdown() = 0;
 
-		virtual HostFont *LoadFont(IOStream *stream) = 0;
+		virtual HostFont *LoadFont(GpIOStream *stream) = 0;
 		virtual bool KeepStreamOpen() const = 0;
 
 		static void SetInstance(HostFontHandler *instance);

PortabilityLayer/IOStream.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#ifndef __PL_IOTREAM_H__
-#define __PL_IOTREAM_H__
-
-#include "DataTypes.h"
-#include "FilePos.h"
-
-namespace PortabilityLayer
-{
-	class IOStream
-	{
-	public:
-		virtual size_t Read(void *bytesOut, size_t size) = 0;
-		virtual size_t Write(const void *bytes, size_t size) = 0;
-		virtual bool IsSeekable() const = 0;
-		virtual bool IsReadOnly() const = 0;
-		virtual bool IsWriteOnly() const = 0;
-		virtual bool SeekStart(UFilePos_t loc) = 0;
-		virtual bool SeekCurrent(FilePos_t loc) = 0;
-		virtual bool SeekEnd(UFilePos_t loc) = 0;
-		virtual bool Truncate(UFilePos_t loc) = 0;
-		virtual UFilePos_t Size() const = 0;
-		virtual UFilePos_t Tell() const = 0;
-		virtual void Close() = 0;
-		virtual void Flush() = 0;
-	};
-}
-
-#endif

PortabilityLayer/MacBinary2.cpp

@@ -3,7 +3,7 @@
 #include "BytePack.h"
 #include "ByteUnpack.h"
 #include "DataTypes.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "MacFileMem.h"
 #include "XModemCRC.h"
 
@@ -40,7 +40,7 @@ namespace
 
 namespace PortabilityLayer
 {
-	void MacBinary2::WriteBin(const MacFileMem *file, IOStream *stream)
+	void MacBinary2::WriteBin(const MacFileMem *file, GpIOStream *stream)
 	{
 		const MacFileInfo &fileInfo = file->FileInfo();
 
@@ -102,7 +102,7 @@ namespace PortabilityLayer
 		stream->Write(padding, resourceForkPadding);
 	}
 
-	MacFileMem *MacBinary2::ReadBin(IOStream *stream)
+	MacFileMem *MacBinary2::ReadBin(GpIOStream *stream)
 	{
 		MacFileInfo fileInfo;
 

PortabilityLayer/MacBinary2.h

@@ -1,17 +1,18 @@
 #pragma once
 
 #ifndef __PL_MACBINARY2_H__
-#define __PL_MACBINARY2_H__
+#define __PL_MACBINARY2_H__
+
+class GpIOStream;
 
 namespace PortabilityLayer
 {
-	class IOStream;
 	class MacFileMem;
 
 	namespace MacBinary2
 	{
-		void WriteBin(const MacFileMem *file, IOStream *stream);
-		MacFileMem *ReadBin(IOStream *stream);
+		void WriteBin(const MacFileMem *file, GpIOStream *stream);
+		MacFileMem *ReadBin(GpIOStream *stream);
 	};
 }
 

PortabilityLayer/MemReaderStream.cpp

@@ -48,7 +48,7 @@ namespace PortabilityLayer
 		return false;
 	}
 
-	bool MemReaderStream::SeekStart(UFilePos_t loc)
+	bool MemReaderStream::SeekStart(GpUFilePos_t loc)
 	{
 		if (loc > m_size)
 			m_loc = m_size;
@@ -58,28 +58,28 @@ namespace PortabilityLayer
 		return true;
 	}
 
-	bool MemReaderStream::SeekCurrent(FilePos_t loc)
+	bool MemReaderStream::SeekCurrent(GpFilePos_t loc)
 	{
 		if (loc < 0)
 		{
-			if (static_cast<FilePos_t>(m_loc) + loc < 0)
+			if (static_cast<GpFilePos_t>(m_loc) + loc < 0)
 				m_loc = 0;
 			else
-				m_loc = static_cast<size_t>(static_cast<FilePos_t>(m_loc) + loc);
+				m_loc = static_cast<size_t>(static_cast<GpFilePos_t>(m_loc) + loc);
 		}
 		else
 		{
 			const size_t available = m_size - m_loc;
-			if (static_cast<UFilePos_t>(loc) > available)
+			if (static_cast<GpUFilePos_t>(loc) > available)
 				m_loc = m_size;
 			else
-				m_loc = static_cast<size_t>(static_cast<FilePos_t>(m_loc) + loc);
+				m_loc = static_cast<size_t>(static_cast<GpFilePos_t>(m_loc) + loc);
 		}
 
 		return true;
 	}
 
-	bool MemReaderStream::SeekEnd(UFilePos_t loc)
+	bool MemReaderStream::SeekEnd(GpUFilePos_t loc)
 	{
 		if (m_size < loc)
 			m_loc = 0;
@@ -89,19 +89,19 @@ namespace PortabilityLayer
 		return true;
 	}
 
-	bool MemReaderStream::Truncate(UFilePos_t loc)
+	bool MemReaderStream::Truncate(GpUFilePos_t loc)
 	{
 		return false;
 	}
 
-	UFilePos_t MemReaderStream::Size() const
+	GpUFilePos_t MemReaderStream::Size() const
 	{
 		return m_size;
 	}
 
-	UFilePos_t MemReaderStream::Tell() const
+	GpUFilePos_t MemReaderStream::Tell() const
 	{
-		return static_cast<UFilePos_t>(m_loc);
+		return static_cast<GpUFilePos_t>(m_loc);
 	}
 
 	void MemReaderStream::Close()

PortabilityLayer/MemReaderStream.h

@@ -3,11 +3,11 @@
 #define __PL_MEM_READER_STREAM_H__
 
 #include "CoreDefs.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 
 namespace PortabilityLayer
 {
-	class MemReaderStream final : public IOStream
+	class MemReaderStream final : public GpIOStream
 	{
 	public:
 		MemReaderStream(const void *memStream, size_t size);
@@ -17,12 +17,12 @@ namespace PortabilityLayer
 		bool IsSeekable() const override;
 		bool IsReadOnly() const override;
 		bool IsWriteOnly() const override;
-		bool SeekStart(UFilePos_t loc) override;
-		bool SeekCurrent(FilePos_t loc) override;
-		bool SeekEnd(UFilePos_t loc) override;
-		bool Truncate(UFilePos_t loc) override;
-		UFilePos_t Size() const override;
-		UFilePos_t Tell() const override;
+		bool SeekStart(GpUFilePos_t loc) override;
+		bool SeekCurrent(GpFilePos_t loc) override;
+		bool SeekEnd(GpUFilePos_t loc) override;
+		bool Truncate(GpUFilePos_t loc) override;
+		GpUFilePos_t Size() const override;
+		GpUFilePos_t Tell() const override;
 		void Close() override;
 		void Flush() override;
 

PortabilityLayer/PLCore.cpp

@@ -430,7 +430,7 @@ DirectoryFileListEntry *GetDirectoryFiles(PortabilityLayer::VirtualDirectory_t d
 		if (!strcmp(&filename[fnLen - 4], ".gpf"))
 		{
 			const size_t dotPos = fnLen - 4;
-			PortabilityLayer::IOStream *stream = fs->OpenFile(dirID, filename, false, GpFileCreationDispositions::kOpenExisting);
+			GpIOStream *stream = fs->OpenFile(dirID, filename, false, GpFileCreationDispositions::kOpenExisting);
 			if (!stream)
 				continue;
 

PortabilityLayer/PLCore.h

@@ -16,6 +16,7 @@
 template<class T>
 class ArrayView;
 struct IGpCursor;
+class GpIOStream;
 struct GpVOSEvent;
 struct GpMouseInputEvent;
 struct TimeTaggedVOSEvent;
@@ -24,7 +25,6 @@ struct TimeTaggedVOSEvent;
 namespace PortabilityLayer
 {
 	struct MMHandleBlock;
-	class IOStream;
 	class Widget;
 	struct Vec2i;
 }

PortabilityLayer/PLResourceManager.cpp

@@ -5,7 +5,7 @@
 #include "GPArchive.h"
 #include "HostFileSystem.h"
 #include "HostMemoryBuffer.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "MacBinary2.h"
 #include "MacFileMem.h"
 #include "MemReaderStream.h"
@@ -169,7 +169,7 @@ namespace PortabilityLayer
 
 	ResourceArchive *ResourceManagerImpl::LoadResFile(VirtualDirectory_t virtualDir, const PLPasStr &filename) const
 	{
-		IOStream *fStream = nullptr;
+		GpIOStream *fStream = nullptr;
 		if (FileManager::GetInstance()->RawOpenFileResources(virtualDir, filename, EFilePermission_Read, true, GpFileCreationDispositions::kOpenExisting, fStream) != PLErrors::kNone)
 			return nullptr;
 
@@ -193,7 +193,7 @@ namespace PortabilityLayer
 
 	PLError_t ResourceManagerImpl::CreateBlankResFile(VirtualDirectory_t virtualDir, const PLPasStr &filename)
 	{
-		PortabilityLayer::IOStream *stream = nullptr;
+		GpIOStream *stream = nullptr;
 		PLError_t error = FileManager::GetInstance()->RawOpenFileResources(virtualDir, filename, EFilePermission_Write, true, GpFileCreationDispositions::kCreateOrOverwrite, stream);
 		if (error)
 			return error;
@@ -245,7 +245,7 @@ namespace PortabilityLayer
 	{
 	}
 
-	ResourceArchive *ResourceArchive::Create(ZipFileProxy *zipFileProxy, IOStream *stream)
+	ResourceArchive *ResourceArchive::Create(ZipFileProxy *zipFileProxy, GpIOStream *stream)
 	{
 		PortabilityLayer::MemoryManager *mm = PortabilityLayer::MemoryManager::GetInstance();
 
@@ -485,7 +485,7 @@ namespace PortabilityLayer
 		return THandle<void>(handle);
 	}
 
-	ResourceArchive::ResourceArchive(ZipFileProxy *zipFileProxy, IOStream *stream, ResourceArchiveRef *resourceHandles)
+	ResourceArchive::ResourceArchive(ZipFileProxy *zipFileProxy, GpIOStream *stream, ResourceArchiveRef *resourceHandles)
 		: m_zipFileProxy(zipFileProxy)
 		, m_stream(stream)
 		, m_resourceHandles(resourceHandles)

PortabilityLayer/QDPictDecoder.cpp

@@ -5,7 +5,7 @@
 #include "QDPictHeader.h"
 #include "QDPictOpcodes.h"
 #include "QDPictEmitScanlineParameters.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "RGBAColor.h"
 #include "Vec2i.h"
 
@@ -42,7 +42,7 @@ namespace PortabilityLayer
 	{
 	}
 
-	bool QDPictDecoder::DecodePict(IOStream *stream, QDPictEmitContext *emitContext)
+	bool QDPictDecoder::DecodePict(GpIOStream *stream, QDPictEmitContext *emitContext)
 	{
 		QDPictHeader header;
 		QDPictDecodeState decodeState;
@@ -288,7 +288,7 @@ namespace PortabilityLayer
 		}
 	}
 
-	int QDPictDecoder::ProcessRasterOp(IOStream *stream, int pictVersion, bool isPackedFlag, bool hasRegion, bool isDirect, const Rect &constraintRect, const Point &origin, QDPictEmitContext *context)
+	int QDPictDecoder::ProcessRasterOp(GpIOStream *stream, int pictVersion, bool isPackedFlag, bool hasRegion, bool isDirect, const Rect &constraintRect, const Point &origin, QDPictEmitContext *context)
 	{
 		uint16_t rowSizeBytes = 0;
 

PortabilityLayer/QDPictDecoder.h

@@ -1,27 +1,27 @@
-#pragma once
-
-#include <stdint.h>
-
+#pragma once
+
+#include <stdint.h>
+
 struct Rect;
-struct Point;
-
-namespace PortabilityLayer
-{
-	class IOStream;
-	class QDPictEmitContext;
-
-	class QDPictDecoder
-	{
-	public:
-		QDPictDecoder();
-
-		bool DecodePict(IOStream *stream, QDPictEmitContext *emitContext);
-
-	private:
-		int ProcessRasterOp(IOStream *stream, int pictVersion, bool isPackedFlag, bool hasRegion, bool isDirect, const Rect &drawArea, const Point &origin, QDPictEmitContext *context);
+struct Point;
+class GpIOStream;
+
+namespace PortabilityLayer
+{
+	class QDPictEmitContext;
+
+	class QDPictDecoder
+	{
+	public:
+		QDPictDecoder();
+
+		bool DecodePict(GpIOStream *stream, QDPictEmitContext *emitContext);
+
+	private:
+		int ProcessRasterOp(GpIOStream *stream, int pictVersion, bool isPackedFlag, bool hasRegion, bool isDirect, const Rect &drawArea, const Point &origin, QDPictEmitContext *context);
 		static bool UnpackBits8(uint8_t *dest, size_t destSize, const uint8_t *src, size_t srcSize);
-		static bool UnpackBits16(uint8_t *dest, size_t destSize, const uint8_t *src, size_t srcSize);
-
-		IOStream *m_stream;
-	};
-}
+		static bool UnpackBits16(uint8_t *dest, size_t destSize, const uint8_t *src, size_t srcSize);
+
+		GpIOStream *m_stream;
+	};
+}

PortabilityLayer/QDPictEmitContext.h

@@ -2,13 +2,13 @@
 
 #include <stdint.h>
 
-struct Rect;
+struct Rect;
+class GpIOStream;
 
 namespace PortabilityLayer
 {
 	struct RGBAColor;
-	struct QDPictEmitScanlineParameters;
-	class IOStream;
+	struct QDPictEmitScanlineParameters;
 
 	enum QDPictBlitSourceType
 	{
@@ -44,7 +44,7 @@ namespace PortabilityLayer
 		virtual Rect ConstrainRegion(const Rect &rect) const = 0;
 		virtual void Start(QDPictBlitSourceType sourceType, const QDPictEmitScanlineParameters &params) = 0;
 		virtual void BlitScanlineAndAdvance(const void *) = 0;
-		virtual bool EmitQTContent(IOStream *stream, uint32_t dataSize, bool isCompressed) = 0;
+		virtual bool EmitQTContent(GpIOStream *stream, uint32_t dataSize, bool isCompressed) = 0;
 		virtual bool AllocTempBuffers(uint8_t *&buffer1, size_t buffer1Size, uint8_t *&buffer2, size_t buffer2Size) = 0;
 
 		virtual void ReportError(int errorType, int errorSubtype) { }

PortabilityLayer/QDPictHeader.cpp

@@ -1,77 +1,77 @@
-#include "QDPictHeader.h"
-#include "IOStream.h"
-#include "SharedTypes.h"
-#include "CoreDefs.h"
-
-#include <string.h>
-#include <assert.h>
-
-namespace PortabilityLayer
-{
-	QDPictHeader::QDPictHeader()
-		: m_pictVersion(0)
-	{
-	}
-
-	bool QDPictHeader::Load(IOStream *stream)
+#include "QDPictHeader.h"
+#include "GpIOStream.h"
+#include "SharedTypes.h"
+#include "CoreDefs.h"
+
+#include <string.h>
+#include <assert.h>
+
+namespace PortabilityLayer
+{
+	QDPictHeader::QDPictHeader()
+		: m_pictVersion(0)
+	{
+	}
+
+	bool QDPictHeader::Load(GpIOStream *stream)
 	{
 		struct PictHeader
-		{
+		{
 			uint8_t m_size[2];
 
-			BERect m_rect;
+			BERect m_rect;
 		};
-
-		GP_STATIC_ASSERT(sizeof(PictHeader) == 10);
-
-		PictHeader pictHeader;
-		if (stream->Read(&pictHeader, sizeof(PictHeader)) != sizeof(PictHeader))
-			return false;
-
-		m_frame = pictHeader.m_rect.ToRect();
-		if (!m_frame.IsValid())
-			return false;
-
-		uint8_t versionTag1[2];
-		if (stream->Read(versionTag1, 2) != 2)
-			return false;
-
-		if (versionTag1[0] == 0x11 && versionTag1[1] == 0x01)
-		{
-			m_pictVersion = 1;
-		}
-		else if (versionTag1[0] == 0x00 && versionTag1[1] == 0x11)
-		{
-			m_pictVersion = 2;
-
-			uint8_t v2Header[28];
-			if (stream->Read(v2Header, 28) != 28)
-				return false;
-
-			if (v2Header[0] != 0x02 || v2Header[1] != 0xff || v2Header[2] != 0x0c || v2Header[3] != 0x00)
-				return false;
-
-			BEInt16_t v2Version;
-			memcpy(&v2Version, v2Header + 4, 2);
-
-			// In version 2 header, v2Version == -1
-			// Followed by fixed-point bounding rectangle (16 bytes) and 4 reserved
-			// In ext. version 2 header, v2Version == -2
-			// Followed by 2-byte reserved, horizontal DPI (fixed point, 4 bytes), vertical DPI (fixed point, 4 bytes) optimal source rect (8 bytes), and 2 reserved
-		}
-		else
-			return false;
-
-		return true;
-	}
-
-	int QDPictHeader::GetVersion() const
-	{
-		return m_pictVersion;
-	}
-
-	const Rect &QDPictHeader::GetFrame() const
-	{
-		return m_frame;
-	}
+
+		GP_STATIC_ASSERT(sizeof(PictHeader) == 10);
+
+		PictHeader pictHeader;
+		if (stream->Read(&pictHeader, sizeof(PictHeader)) != sizeof(PictHeader))
+			return false;
+
+		m_frame = pictHeader.m_rect.ToRect();
+		if (!m_frame.IsValid())
+			return false;
+
+		uint8_t versionTag1[2];
+		if (stream->Read(versionTag1, 2) != 2)
+			return false;
+
+		if (versionTag1[0] == 0x11 && versionTag1[1] == 0x01)
+		{
+			m_pictVersion = 1;
+		}
+		else if (versionTag1[0] == 0x00 && versionTag1[1] == 0x11)
+		{
+			m_pictVersion = 2;
+
+			uint8_t v2Header[28];
+			if (stream->Read(v2Header, 28) != 28)
+				return false;
+
+			if (v2Header[0] != 0x02 || v2Header[1] != 0xff || v2Header[2] != 0x0c || v2Header[3] != 0x00)
+				return false;
+
+			BEInt16_t v2Version;
+			memcpy(&v2Version, v2Header + 4, 2);
+
+			// In version 2 header, v2Version == -1
+			// Followed by fixed-point bounding rectangle (16 bytes) and 4 reserved
+			// In ext. version 2 header, v2Version == -2
+			// Followed by 2-byte reserved, horizontal DPI (fixed point, 4 bytes), vertical DPI (fixed point, 4 bytes) optimal source rect (8 bytes), and 2 reserved
+		}
+		else
+			return false;
+
+		return true;
+	}
+
+	int QDPictHeader::GetVersion() const
+	{
+		return m_pictVersion;
+	}
+
+	const Rect &QDPictHeader::GetFrame() const
+	{
+		return m_frame;
+	}
 }

PortabilityLayer/QDPictHeader.h

@@ -1,17 +1,17 @@
 #pragma once
 
 #include <stdint.h>
-#include "SharedTypes.h"
+#include "SharedTypes.h"
+
+class GpIOStream;
 
 namespace PortabilityLayer
 {
-	class IOStream;
-
 	class QDPictHeader
 	{
 	public:
 		QDPictHeader();
-		bool Load(IOStream *stream);
+		bool Load(GpIOStream *stream);
 
 		int GetVersion() const;
 		const Rect &GetFrame() const;

PortabilityLayer/ResourceFile.cpp

@@ -38,7 +38,7 @@ namespace PortabilityLayer
 			delete[] m_compiledTypeListBlob;
 	}
 
-	bool ResourceFile::Load(IOStream *stream)
+	bool ResourceFile::Load(GpIOStream *stream)
 	{
 		struct ResourceHeader
 		{
@@ -48,7 +48,7 @@ namespace PortabilityLayer
 			uint32_t m_resMapSize;
 		};
 
-		const UFilePos_t streamSize = stream->Size();
+		const GpUFilePos_t streamSize = stream->Size();
 		if (streamSize > UINT32_MAX)
 			return false;
 

PortabilityLayer/ResourceFile.h

@@ -4,9 +4,10 @@
 #include "ResTypeID.h"
 #include <stdint.h>
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
 	class MacFileMem;
 	struct MMHandleBlock;
 	struct ResourceCompiledRef;
@@ -16,7 +17,7 @@ namespace PortabilityLayer
 	class ResourceFile final
 	{
 	public:
-		bool Load(IOStream *stream);
+		bool Load(GpIOStream *stream);
 
 		void GetAllResourceTypeLists(ResourceCompiledTypeList *&outTypeLists, size_t &outCount) const;
 

PortabilityLayer/ResourceManager.h

@@ -6,9 +6,10 @@
 
 class PLPasStr;
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
 	struct MMHandleBlock;
 	struct ResourceCompiledRef;
 	class ResourceFile;
@@ -27,7 +28,7 @@ namespace PortabilityLayer
 	class ResourceArchive final
 	{
 	public:
-		static ResourceArchive *Create(ZipFileProxy *zipFileProxy, IOStream *stream);
+		static ResourceArchive *Create(ZipFileProxy *zipFileProxy, GpIOStream *stream);
 		void Destroy();
 
 		THandle<void> LoadResource(const ResTypeID &resTypeID, int id);
@@ -37,7 +38,7 @@ namespace PortabilityLayer
 		bool FindFirstResourceOfType(const ResTypeID &resTypeID, int16_t &outID) const;
 
 	private:
-		ResourceArchive(ZipFileProxy *zipFileProxy, IOStream *stream, ResourceArchiveRef *resourceHandles);
+		ResourceArchive(ZipFileProxy *zipFileProxy, GpIOStream *stream, ResourceArchiveRef *resourceHandles);
 		~ResourceArchive();
 
 		bool IndexResource(const ResTypeID &resTypeID, int id, size_t &outIndex, int &outValidationRule) const;
@@ -45,7 +46,7 @@ namespace PortabilityLayer
 		THandle<void> GetResource(const ResTypeID &resTypeID, int id, bool load);
 
 		ZipFileProxy *m_zipFileProxy;
-		IOStream *m_stream;
+		GpIOStream *m_stream;
 		ResourceArchiveRef *m_resourceHandles;
 	};
 

PortabilityLayer/WindowDef.cpp

@@ -1,5 +1,5 @@
 #include "WindowDef.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "CoreDefs.h"
 #include "PLPasStr.h"
 
@@ -7,7 +7,7 @@
 
 namespace PortabilityLayer
 {
-	bool WindowDef::Deserialize(IOStream *stream)
+	bool WindowDef::Deserialize(GpIOStream *stream)
 	{
 		struct WindowDefPart1
 		{

PortabilityLayer/WindowDef.h

@@ -4,11 +4,10 @@
 #include "PascalStr.h"
 
 class PLPasStr;
+class GpIOStream;
 
 namespace PortabilityLayer
 {
-	class IOStream;
-
 	namespace WindowStyleFlags
 	{
 		enum WindowStyleFlag
@@ -31,7 +30,7 @@ namespace PortabilityLayer
 		uint16_t m_positionSpec;
 		uint8_t m_title[256];
 
-		bool Deserialize(IOStream *stream);
+		bool Deserialize(GpIOStream *stream);
 
 		static WindowDef Create(const Rect &initialRect, uint16_t styleFlags, bool isVisible, uint32_t refConstant, uint16_t positionSpec, const PLPasStr &title);
 	};

PortabilityLayer/ZipFileProxy.cpp

@@ -1,7 +1,7 @@
 #include "ZipFileProxy.h"
 
 #include "BinarySearch.h"
-#include "IOStream.h"
+#include "GpIOStream.h"
 #include "MemoryManager.h"
 #include "ZipFile.h"
 
@@ -246,7 +246,7 @@ namespace PortabilityLayer
 		outName = GetZipItemName(itemPtr);
 	}
 
-	ZipFileProxy *ZipFileProxy::Create(IOStream *stream)
+	ZipFileProxy *ZipFileProxy::Create(GpIOStream *stream)
 	{
 		MemoryManager *mm = MemoryManager::GetInstance();
 
@@ -380,7 +380,7 @@ namespace PortabilityLayer
 		return new (storage) ZipFileProxy(stream, centralDirImage, centralDirFiles, numFiles);
 	}
 
-	ZipFileProxy::ZipFileProxy(IOStream *stream, void *centralDirImage, UnalignedPtr<ZipCentralDirectoryFileHeader> *sortedFiles, size_t numFiles)
+	ZipFileProxy::ZipFileProxy(GpIOStream *stream, void *centralDirImage, UnalignedPtr<ZipCentralDirectoryFileHeader> *sortedFiles, size_t numFiles)
 		: m_stream(stream)
 		, m_centralDirImage(centralDirImage)
 		, m_sortedFiles(sortedFiles)

PortabilityLayer/ZipFileProxy.h

@@ -2,9 +2,10 @@
 
 #include "PLUnalignedPtr.h"
 
+class GpIOStream;
+
 namespace PortabilityLayer
 {
-	class IOStream;
 	struct ZipCentralDirectoryFileHeader;
 
 	class ZipFileProxy
@@ -23,13 +24,13 @@ namespace PortabilityLayer
 		void GetFileName(size_t index, const char *&outName, size_t &outLength) const;
 
 
-		static ZipFileProxy *Create(IOStream *stream);
+		static ZipFileProxy *Create(GpIOStream *stream);
 
 	private:
-		ZipFileProxy(IOStream *stream, void *centralDirImage, UnalignedPtr<ZipCentralDirectoryFileHeader> *sortedFiles, size_t numFiles);
+		ZipFileProxy(GpIOStream *stream, void *centralDirImage, UnalignedPtr<ZipCentralDirectoryFileHeader> *sortedFiles, size_t numFiles);
 		~ZipFileProxy();
 
-		IOStream *m_stream;
+		GpIOStream *m_stream;
 		void *m_centralDirImage;
 		UnalignedPtr<ZipCentralDirectoryFileHeader> *m_sortedFiles;
 		size_t m_numFiles;