FS refactoring, 64-bit timestamps

GpApp/About.cpp

@@ -13,6 +13,7 @@
 #include "DialogUtils.h"
 #include "Environ.h"
 #include "Externs.h"
+#include "HostSystemServices.h"
 #include "ScanlineMask.h"
 
 
@@ -143,13 +144,15 @@ static void UnHiLiteOkayButton (void)
 static void UpdateMainPict (DialogPtr theDial)
 {
 	Str255		theStr, theStr2;
-	long		totalSize, contigSize;
+	uint64_t	freeMemory;
 	
 	DrawDialog(theDial);
 
+	freeMemory = PortabilityLayer::HostSystemServices::GetInstance()->GetFreeMemoryCosmetic();
+	
 	PasStringCopy(PSTR("Memory:   "), theStr);		// display free memory
-	PurgeSpace(&totalSize, &contigSize);
+
-	totalSize /= 1024;
+	long totalSize = static_cast<long>(freeMemory / 1024);
 	NumToString(totalSize, theStr2);
 	PasStringConcat(theStr, theStr2);
 	PasStringConcat(theStr, PSTR("K"));

GpApp/HighScores.cpp

@@ -632,13 +632,15 @@ Boolean OpenHighScoresFile (const VFileSpec &scoreSpec, PortabilityLayer::IOStre
 {
 	PLError_t		theErr;
 
-	theErr = PortabilityLayer::FileManager::GetInstance()->OpenFileDF(scoreSpec.m_dir, scoreSpec.m_name, PortabilityLayer::EFilePermission_Any, scoresStream);
+	PortabilityLayer::FileManager *fm = PortabilityLayer::FileManager::GetInstance();
+	
+	theErr = fm->OpenFileData(scoreSpec.m_dir, scoreSpec.m_name, PortabilityLayer::EFilePermission_Any, scoresStream);
 	if (theErr == PLErrors::kFileNotFound)
 	{
-		theErr = FSpCreate(scoreSpec, 'ozm5', 'gliS');
+		theErr = fm->CreateFileAtCurrentTime(scoreSpec.m_dir, scoreSpec.m_name, 'ozm5', 'gliS');
 		if (!CheckFileError(theErr, PSTR("New High Scores File")))
 			return (false);
-		theErr = FSpOpenDF(scoreSpec, fsCurPerm, scoresStream);
+		theErr = fm->OpenFileData(scoreSpec.m_dir, scoreSpec.m_name, PortabilityLayer::EFilePermission_Any, scoresStream);
 		if (!CheckFileError(theErr, PSTR("High Score")))
 			return (false);
 	}

GpApp/House.cpp

@@ -90,7 +90,7 @@ Boolean CreateNewHouse (void)
 			return (false);
 	}
 	
-	theErr = FSpCreate(theSpec, 'ozm5', 'gliH');
+	theErr = fm->CreateFileAtCurrentTime(theSpec.m_dir, theSpec.m_name, 'ozm5', 'gliH');
 	if (!CheckFileError(theErr, PSTR("New House")))
 		return (false);
 	HCreateResFile(theSpec.m_dir, theSpec.m_name);

GpApp/HouseIO.cpp

@@ -13,6 +13,7 @@
 #include "PLPasStr.h"
 #include "Externs.h"
 #include "Environ.h"
+#include "FileManager.h"
 #include "House.h"
 #include "IOStream.h"
 #include "ObjectEdit.h"
@@ -182,7 +183,7 @@ Boolean OpenHouse (void)
 	
 	houseIsReadOnly = IsFileReadOnly(theHousesSpecs[thisHouseIndex]);
 	
-	theErr = FSpOpenDF(theHousesSpecs[thisHouseIndex], fsCurPerm, houseStream);
+	theErr = PortabilityLayer::FileManager::GetInstance()->OpenFileData(theHousesSpecs[thisHouseIndex].m_dir, theHousesSpecs[thisHouseIndex].m_name, PortabilityLayer::EFilePermission_Any, houseStream);
 	if (!CheckFileError(theErr, thisHouseName))
 		return (false);
 	

GpApp/Prefs.cpp

@@ -45,19 +45,21 @@ Boolean WritePrefs (const prefsInfo *thePrefs)
 	long		byteCount;
 	Str255		fileName;
 
+	PortabilityLayer::FileManager *fm = PortabilityLayer::FileManager::GetInstance();
+
 	PasStringCopy(kPrefFileName, fileName);
 	
 	VFileSpec theSpecs = MakeVFileSpec(PortabilityLayer::VirtualDirectories::kPrefs, fileName);
-	if (!PortabilityLayer::FileManager::GetInstance()->FileExists(PortabilityLayer::VirtualDirectories::kPrefs, fileName))
+	if (!fm->FileExists(PortabilityLayer::VirtualDirectories::kPrefs, fileName))
 	{
-		theErr = FSpCreate(theSpecs, kPrefCreatorType, kPrefFileType);
+		theErr = fm->CreateFileAtCurrentTime(theSpecs.m_dir, theSpecs.m_name, kPrefCreatorType, kPrefFileType);
 		if (theErr != PLErrors::kNone)
 		{
 			CheckFileError(theErr, PSTR("Preferences"));
 			return(false);
 		}
 	}
-	theErr = FSpOpenDF(theSpecs, fsRdWrPerm, fileStream);
+	theErr = fm->OpenFileData(theSpecs.m_dir, theSpecs.m_name, PortabilityLayer::EFilePermission_Write, fileStream);
 	if (theErr != PLErrors::kNone)
 	{
 		CheckFileError(theErr, PSTR("Preferences"));
@@ -99,6 +101,8 @@ PLError_t ReadPrefs (prefsInfo *thePrefs)
 	VFileSpec	theSpecs;
 	Str255		fileName;
 
+	PortabilityLayer::FileManager *fm = PortabilityLayer::FileManager::GetInstance();
+	
 	PasStringCopy(kPrefFileName, fileName);
 	
 	theSpecs = MakeVFileSpec(PortabilityLayer::VirtualDirectory_t::kPrefs, fileName);
@@ -106,7 +110,7 @@ PLError_t ReadPrefs (prefsInfo *thePrefs)
 	if (!PortabilityLayer::FileManager::GetInstance()->FileExists(theSpecs.m_dir, theSpecs.m_name))
 		return PLErrors::kFileNotFound;
 	
-	theErr = FSpOpenDF(theSpecs, fsRdWrPerm, fileStream);
+	theErr = fm->OpenFileData(theSpecs.m_dir, theSpecs.m_name, PortabilityLayer::EFilePermission_Read, fileStream);
 	if (theErr != PLErrors::kNone)
 	{
 		CheckFileError(theErr, PSTR("Preferences"));
@@ -139,12 +143,7 @@ Boolean DeletePrefs ()
 	
 	theSpecs = MakeVFileSpec(PortabilityLayer::VirtualDirectories::kPrefs, fileName);
 
-	theErr = FSpDelete(theSpecs);
+	return PortabilityLayer::FileManager::GetInstance()->DeleteFile(theSpecs.m_dir, theSpecs.m_name);
-	
-	if (theErr != PLErrors::kNone)
-		return(false);
-	
-	return(true);
 }
 
 //--------------------------------------------------------------  LoadPrefs

GpApp/SoundSync_Win32.cpp

@@ -7,7 +7,7 @@ static volatile uint64_t gs_prioritiesBlob = 0;
 
 SoundSyncState SoundSync_ReadAll()
 {
-	const uint16_t priorities = gs_prioritiesBlob;
+	const uint64_t priorities = gs_prioritiesBlob;
 
 	SoundSyncState state;
 	state.priority0 = static_cast<uint16_t>((priorities >> 0) & 0xffff);

GpD3D/GpSystemServices_Win32.cpp

@@ -13,10 +13,29 @@ GpSystemServices_Win32::GpSystemServices_Win32()
 {
 }
 
-uint32_t GpSystemServices_Win32::GetTime() const
+int64_t GpSystemServices_Win32::GetTime() const
 {
-	//PL_NotYetImplemented_TODO("Time");
+	SYSTEMTIME epochStart;
-	return 0;
+	epochStart.wYear = 1904;
+	epochStart.wMonth = 1;
+	epochStart.wDayOfWeek = 5;
+	epochStart.wDay = 1;
+	epochStart.wHour = 0;
+	epochStart.wMinute = 0;
+	epochStart.wSecond = 0;
+	epochStart.wMilliseconds = 0;
+
+	FILETIME epochStartFT;
+	if (!SystemTimeToFileTime(&epochStart, &epochStartFT))
+		return 0;
+
+	FILETIME currentTime;
+	GetSystemTimeAsFileTime(&currentTime);
+
+	int64_t epochStart64 = (static_cast<int64_t>(epochStartFT.dwLowDateTime) & 0xffffffff) | (static_cast<int64_t>(epochStartFT.dwHighDateTime) << 32);
+	int64_t currentTime64 = (static_cast<int64_t>(currentTime.dwLowDateTime) & 0xffffffff) | (static_cast<int64_t>(currentTime.dwHighDateTime) << 32);
+
+	return currentTime64 - epochStart64;
 }
 
 void GpSystemServices_Win32::GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const
@@ -42,6 +61,15 @@ PortabilityLayer::HostThreadEvent *GpSystemServices_Win32::CreateThreadEvent(boo
 	return GpThreadEvent_Win32::Create(autoReset, startSignaled);
 }
 
+uint64_t GpSystemServices_Win32::GetFreeMemoryCosmetic() const
+{
+	MEMORYSTATUSEX memStatus;
+	if (!GlobalMemoryStatusEx(&memStatus))
+		return 0;
+
+	return memStatus.ullAvailPhys;
+}
+
 GpSystemServices_Win32 *GpSystemServices_Win32::GetInstance()
 {
 	return &ms_instance;

GpD3D/GpSystemServices_Win32.h

@@ -15,10 +15,11 @@ class GpSystemServices_Win32 final : public PortabilityLayer::HostSystemServices
 public:
 	GpSystemServices_Win32();
 
-	uint32_t GetTime() const override;
+	int64_t GetTime() const override;
 	void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const override;
 	PortabilityLayer::HostMutex *CreateMutex() override;
 	PortabilityLayer::HostThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
+	uint64_t GetFreeMemoryCosmetic() const override;
 
 	static GpSystemServices_Win32 *GetInstance();
 

PortabilityLayer/ByteSwap.cpp

@@ -1,37 +1,54 @@
 #include "ByteSwap.h"
+#include "CoreDefs.h"
 
 namespace PortabilityLayer
 {
 	namespace ByteSwap
 	{
+		template<class TNumberType, class TUnsignedType>
+		void SwapArbitrary(TNumberType &v)
+		{
+			PL_STATIC_ASSERT(sizeof(TNumberType) == sizeof(TUnsignedType));
+
+			uint8_t bytes[sizeof(TNumberType)];
+			for (size_t i = 0; i < sizeof(TNumberType); i++)
+				bytes[i] = reinterpret_cast<const uint8_t*>(&v)[i];
+
+			TUnsignedType result = 0;
+			for (size_t i = 0; i < sizeof(TNumberType); i++)
+				result |= static_cast<TUnsignedType>(bytes[i]) << (sizeof(TUnsignedType) * 8 - 8 - (i * 8));
+
+			v = static_cast<TNumberType>(result);
+		}
+
 		void BigInt16(int16_t &v)
 		{
-			const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
+			SwapArbitrary<int16_t, uint16_t>(v);
-			const int8_t *asS8 = reinterpret_cast<const int8_t*>(&v);
-
-			v = static_cast<int16_t>((asS8[0] << 8) | asU8[1]);
 		}
 
 		void BigInt32(int32_t &v)
 		{
-			const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
+			SwapArbitrary<int32_t, uint32_t>(v);
-			const int8_t *asS8 = reinterpret_cast<const int8_t*>(&v);
+		}
 
-			v = static_cast<int32_t>((asS8[0] << 24) | (asU8[1] << 16) | (asU8[2] << 8) | asU8[3]);
+		void BigInt64(int64_t &v)
+		{
+			SwapArbitrary<int64_t, uint64_t>(v);
 		}
 
 		void BigUInt16(uint16_t &v)
 		{
-			const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
+			SwapArbitrary<uint16_t, uint16_t>(v);
-
-			v = static_cast<uint16_t>((asU8[0] << 8) | asU8[1]);
 		}
 
 		void BigUInt32(uint32_t &v)
 		{
-			const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
+			SwapArbitrary<uint32_t, uint32_t>(v);
+		}
 
-			v = static_cast<uint32_t>((asU8[0] << 24) | (asU8[1] << 16) | (asU8[2] << 8) | asU8[3]);
+		void BigUInt64(uint64_t &v)
+		{
+			SwapArbitrary<uint64_t, uint64_t>(v);
 		}
 	}
 }

PortabilityLayer/ByteSwap.h

@@ -10,8 +10,10 @@ namespace PortabilityLayer
 	{
 		void BigInt16(int16_t &v);
 		void BigInt32(int32_t &v);
+		void BigInt64(int64_t &v);
 		void BigUInt16(uint16_t &v);
 		void BigUInt32(uint32_t &v);
+		void BigUInt64(uint64_t &v);
 	}
 }
 

PortabilityLayer/FileManager.cpp

@@ -7,6 +7,7 @@
 #include "PLPasStr.h"
 #include "PLErrorCodes.h"
 #include "ResTypeID.h"
+#include "HostSystemServices.h"
 
 #include <vector>
 
@@ -21,13 +22,14 @@ namespace PortabilityLayer
 		bool DeleteFile(VirtualDirectory_t dirID, const PLPasStr &filename) override;
 
 		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 OpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outRefNum) override;
+		PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outRefNum) override;
-		PLError_t OpenFileRF(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;
 		bool ReadFileProperties(VirtualDirectory_t dirID, const PLPasStr &filename, MacFileProperties &properties) override;
 
-		PLError_t RawOpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) override;
+		PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) override;
-		PLError_t RawOpenFileRF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) override;
+		PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) override;
 
 		static FileManagerImpl *GetInstance();
 
@@ -86,12 +88,22 @@ namespace PortabilityLayer
 		return PLErrors::kNone;
 	}
 
-	PLError_t FileManagerImpl::OpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
+	PLError_t FileManagerImpl::CreateFileAtCurrentTime(VirtualDirectory_t dirID, const PLPasStr &filename, const ResTypeID &fileCreator, const ResTypeID &fileType)
+	{
+		MacFileProperties mfp;
+		fileCreator.ExportAsChars(mfp.m_fileCreator);
+		fileType.ExportAsChars(mfp.m_fileType);
+		mfp.m_creationDate = mfp.m_modifiedDate = PortabilityLayer::HostSystemServices::GetInstance()->GetTime();
+
+		return CreateFile(dirID, filename, mfp);
+	}
+
+	PLError_t FileManagerImpl::OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
 	{
 		return OpenFileFork(dirID, filename, ".gpd", permission, outStream);
 	}
 
-	PLError_t FileManagerImpl::OpenFileRF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
+	PLError_t FileManagerImpl::OpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, IOStream *&outStream)
 	{
 		return OpenFileFork(dirID, filename, ".gpr", permission, outStream);
 	}
@@ -113,12 +125,12 @@ namespace PortabilityLayer
 		return readOk;
 	}
 
-	PLError_t FileManagerImpl::RawOpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, IOStream *&outStream)
+	PLError_t FileManagerImpl::RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, IOStream *&outStream)
 	{
 		return RawOpenFileFork(dirID, filename, ".gpd", permission, ignoreMeta, false, outStream);
 	}
 
-	PLError_t FileManagerImpl::RawOpenFileRF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, IOStream *&outStream)
+	PLError_t FileManagerImpl::RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission permission, bool ignoreMeta, IOStream *&outStream)
 	{
 		return RawOpenFileFork(dirID, filename, ".gpr", permission, ignoreMeta, false, outStream);
 	}

PortabilityLayer/FileManager.h

@@ -25,13 +25,14 @@ namespace PortabilityLayer
 		virtual bool DeleteFile(VirtualDirectory_t dirID, const PLPasStr &filename) = 0;
 
 		virtual PLError_t CreateFile(VirtualDirectory_t dirID, const PLPasStr &filename, const MacFileProperties &mfp) = 0;
+		virtual PLError_t CreateFileAtCurrentTime(VirtualDirectory_t dirID, const PLPasStr &filename, const ResTypeID &fileCreator, const ResTypeID &fileType) = 0;
 
-		virtual PLError_t OpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outStream) = 0;
+		virtual PLError_t OpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, IOStream *&outStream) = 0;
-		virtual PLError_t OpenFileRF(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 bool ReadFileProperties(VirtualDirectory_t dirID, const PLPasStr &filename, MacFileProperties &properties) = 0;
 
-		virtual PLError_t RawOpenFileDF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) = 0;
+		virtual PLError_t RawOpenFileData(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) = 0;
-		virtual PLError_t RawOpenFileRF(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) = 0;
+		virtual PLError_t RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) = 0;
 
 		static FileManager *GetInstance();
 	};

PortabilityLayer/HostSystemServices.h

@@ -16,10 +16,11 @@ namespace PortabilityLayer
 	class HostSystemServices
 	{
 	public:
-		virtual uint32_t GetTime() const = 0;
+		virtual int64_t GetTime() const = 0;
 		virtual void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const = 0;
 		virtual HostMutex *CreateMutex() = 0;
 		virtual HostThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) = 0;
+		virtual size_t GetFreeMemoryCosmetic() const = 0;	// Returns free memory in bytes, does not have to be accurate
 
 		static void SetInstance(HostSystemServices *instance);
 		static HostSystemServices *GetInstance();

PortabilityLayer/MacFileInfo.cpp

@@ -33,8 +33,8 @@ namespace PortabilityLayer
 		PortabilityLayer::ByteSwap::BigInt16(props.m_xPos);
 		PortabilityLayer::ByteSwap::BigInt16(props.m_yPos);
 		PortabilityLayer::ByteSwap::BigUInt16(props.m_finderFlags);
-		PortabilityLayer::ByteSwap::BigUInt32(props.m_creationDate);
+		PortabilityLayer::ByteSwap::BigInt64(props.m_creationDate);
-		PortabilityLayer::ByteSwap::BigUInt32(props.m_modifiedDate);
+		PortabilityLayer::ByteSwap::BigInt64(props.m_modifiedDate);
 	}
 
 	void MacFilePropertiesSerialized::Serialize(const MacFileProperties &props)
@@ -57,7 +57,7 @@ namespace PortabilityLayer
 		memcpy(m_data + kOffsetYPos, &yPos, 2);
 		memcpy(m_data + kOffsetFinderFlags, &finderFlags, 2);
 		memcpy(m_data + kProtected, &props.m_protected, 1);
-		memcpy(m_data + kCreationDate, &creationDate, 4);
+		memcpy(m_data + kCreationDate, &creationDate, 8);
-		memcpy(m_data + kModifiedDate, &modifiedDate, 4);
+		memcpy(m_data + kModifiedDate, &modifiedDate, 8);
 	}
 }

PortabilityLayer/MacFileInfo.h

@@ -27,8 +27,8 @@ namespace PortabilityLayer
 		int16_t m_yPos;
 		uint16_t m_finderFlags;
 		uint8_t m_protected;
-		uint32_t m_creationDate;
+		int64_t m_creationDate;
-		uint32_t m_modifiedDate;
+		int64_t m_modifiedDate;
 
 		void Serialize(void *buffer) const;
 		void Deserialize(const void *buffer);
@@ -43,9 +43,9 @@ namespace PortabilityLayer
 		static const unsigned int kOffsetFinderFlags = 12;
 		static const unsigned int kProtected = 14;
 		static const unsigned int kCreationDate = 15;
-		static const unsigned int kModifiedDate = 19;
+		static const unsigned int kModifiedDate = 23;
 
-		static const unsigned int kSize = 23;
+		static const unsigned int kSize = 31;
 
 		uint8_t m_data[kSize];
 

PortabilityLayer/PLCore.cpp

@@ -677,53 +677,6 @@ VFileSpec MakeVFileSpec(PortabilityLayer::VirtualDirectory_t dir, const PLPasStr
 	return spec;
 }
 
-PLError_t FSpCreate(const VFileSpec &spec, UInt32 creator, UInt32 fileType)
-{
-	PortabilityLayer::FileManager *fm = PortabilityLayer::FileManager::GetInstance();
-
-	PortabilityLayer::MacFileProperties props;
-	PortabilityLayer::ResTypeIDCodec::Encode(creator, props.m_fileCreator);
-	PortabilityLayer::ResTypeIDCodec::Encode(fileType, props.m_fileType);
-
-	PL_NotYetImplemented_TODO("DateTime");
-
-	return fm->CreateFile(spec.m_dir, spec.m_name, props);
-}
-
-PLError_t FSpDirCreate(const VFileSpec &spec, long *outDirID)
-{
-	PL_NotYetImplemented();
-	return PLErrors::kNone;
-}
-
-PLError_t FSpOpenDF(const VFileSpec &spec, int permission, PortabilityLayer::IOStream *&stream)
-{
-	PortabilityLayer::EFilePermission perm = PortabilityLayer::EFilePermission_Any;
-	switch (permission)
-	{
-	case fsRdPerm:
-		perm = PortabilityLayer::EFilePermission_Read;
-		break;
-	case fsWrPerm:
-	case fsRdWrPerm:
-		perm = PortabilityLayer::EFilePermission_ReadWrite;
-		break;
-	case fsCurPerm:
-		perm = PortabilityLayer::EFilePermission_Any;
-		break;
-	default:
-		return PLErrors::kAccessDenied;
-	}
-
-	return PortabilityLayer::FileManager::GetInstance()->OpenFileDF(spec.m_dir, spec.m_name, perm, stream);
-}
-
-PLError_t FSpDelete(const VFileSpec &spec)
-{
-	PL_NotYetImplemented();
-	return PLErrors::kNone;
-}
-
 PLError_t FSpGetFInfo(const VFileSpec &spec, VFileInfo &finfo)
 {
 	PortabilityLayer::MacFileProperties mfp;
@@ -736,18 +689,6 @@ PLError_t FSpGetFInfo(const VFileSpec &spec, VFileInfo &finfo)
 	return PLErrors::kNone;
 }
 
-PLError_t SetEOF(short refNum, long byteCount)
-{
-	PL_NotYetImplemented();
-	return PLErrors::kNone;
-}
-
-PLError_t PBGetCatInfo(CInfoPBPtr paramBlock, Boolean async)
-{
-	PL_NotYetImplemented();
-	return PLErrors::kNone;
-}
-
 DirectoryFileListEntry *GetDirectoryFiles(PortabilityLayer::VirtualDirectory_t dirID)
 {
 	PortabilityLayer::MemoryManager *mm = PortabilityLayer::MemoryManager::GetInstance();
@@ -1029,20 +970,6 @@ void DisposePtr(void *ptr)
 	PL_NotYetImplemented();
 }
 
-void PurgeSpace(long *totalFree, long *contiguousFree)
-{
-	PL_NotYetImplemented();
-}
-
-void HSetState(Handle handle, char state)
-{
-}
-
-char HGetState(Handle handle)
-{
-	return 0;
-}
-
 void BlockMove(const void *src, void *dest, Size size)
 {
 	memcpy(dest, src, size);

PortabilityLayer/PLCore.h

@@ -300,17 +300,11 @@ UInt32 FreeMem();
 
 PLError_t AEProcessAppleEvent(EventRecord *evt);
 
-PLError_t FindFolder(int refNum, int posType, bool createFolder, short *volumeRef, long *dirID);
 void GetIndString(unsigned char *str, int stringsID, int fnameIndex);	// Fetches a string resource of some sort
 PLError_t PBDirCreate(HFileParam *fileParam, bool asynchronous);
 
 VFileSpec MakeVFileSpec(PortabilityLayer::VirtualDirectory_t dir, const PLPasStr &fileName);
 
-PLError_t FSpCreate(const VFileSpec &spec, UInt32 creator, UInt32 fileType);
-PLError_t FSpDirCreate(const VFileSpec &spec, long *outDirID);
-PLError_t FSpOpenDF(const VFileSpec &spec, int permission, PortabilityLayer::IOStream *&stream);
-PLError_t FSpOpenRF(const VFileSpec &spec, int permission, PortabilityLayer::IOStream *&stream);
-PLError_t FSpDelete(const VFileSpec &spec);
 PLError_t FSpGetFInfo(const VFileSpec &spec, VFileInfo &finfoOut);
 
 PLError_t PBGetCatInfo(CInfoPBPtr paramBlock, Boolean async);
@@ -348,11 +342,8 @@ void *NewPtr(Size size);
 void *NewPtrClear(Size size);
 void DisposePtr(void *ptr);
 
-Size MaxMem(Size *growBytes);
 void PurgeSpace(long *totalFree, long *contiguousFree);
 
-PLError_t MemError();
-
 void BlockMove(const void *src, void *dest, Size size);
 
 Boolean WaitNextEvent(int eventMask, EventRecord *eventOut, long sleep, void *unknown);

PortabilityLayer/PLResourceManager.cpp

@@ -109,7 +109,7 @@ namespace PortabilityLayer
 			return -1;
 
 		IOStream *fStream = nullptr;
-		if (FileManager::GetInstance()->RawOpenFileRF(virtualDir, filename, EFilePermission_Read, true, fStream) != PLErrors::kNone)
+		if (FileManager::GetInstance()->RawOpenFileResources(virtualDir, filename, EFilePermission_Read, true, fStream) != PLErrors::kNone)
 			return -1;
 
 		ResourceFile *resFile = new ResourceFile();

PortabilityLayer/ResTypeID.h

@@ -18,6 +18,8 @@ namespace PortabilityLayer
 		bool operator==(const ResTypeID &other) const;
 		bool operator!=(const ResTypeID &other) const;
 
+		void ExportAsChars(char *chars) const;
+
 	private:
 		char m_id[4];
 	};
@@ -63,6 +65,11 @@ namespace PortabilityLayer
 	{
 		return memcmp(m_id, other.m_id, 4) != 0;
 	}
+
+	inline void ResTypeID::ExportAsChars(char *chars) const
+	{
+		memcpy(chars, m_id, 4);
+	}
 }
 
 #endif