WallyHackenslacker/Aerofoil
1
0
Fork 0
mirror of https://github.com/elasota/Aerofoil.git synced 2025-09-23 06:53:43 +00:00
Code Issues Projects Releases Wiki Activity

FS refactoring, 64-bit timestamps

Browse Source
This commit is contained in:
elasota
2019-12-29 21:31:49 -05:00
parent a546b0ce55
commit dadb21a275
20 changed files with 224 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
GpApp/About.cpp
View File

@@ -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"));

8
GpApp/HighScores.cpp
View File

@@ -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);
}

2
GpApp/House.cpp
View File

@@ -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);

3
GpApp/HouseIO.cpp
View File

@@ -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);

19
GpApp/Prefs.cpp
View File

@@ -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);
if (theErr != PLErrors::kNone)
return(false);
return(true);
return PortabilityLayer::FileManager::GetInstance()->DeleteFile(theSpecs.m_dir, theSpecs.m_name);
}
//-------------------------------------------------------------- LoadPrefs

2
GpApp/SoundSync_Win32.cpp
View File

@@ -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);

32
GpD3D/GpSystemServices_Win32.cpp
View File

@@ -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;
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;

3
GpD3D/GpSystemServices_Win32.h
View File

@@ -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();

41
PortabilityLayer/ByteSwap.cpp
View File

@@ -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);
const int8_t *asS8 = reinterpret_cast<const int8_t*>(&v);
v = static_cast<int16_t>((asS8[0] << 8) | asU8[1]);
SwapArbitrary<int16_t, uint16_t>(v);
}
void BigInt32(int32_t &v)
{
const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
const int8_t *asS8 = reinterpret_cast<const int8_t*>(&v);
SwapArbitrary<int32_t, uint32_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);
v = static_cast<uint16_t>((asU8[0] << 8) | asU8[1]);
SwapArbitrary<uint16_t, uint16_t>(v);
}
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);
}
}
}

2
PortabilityLayer/ByteSwap.h
View File

@@ -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);
}
}

28
PortabilityLayer/FileManager.cpp
View File

@@ -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 OpenFileRF(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 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 RawOpenFileRF(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 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);
}

9
PortabilityLayer/FileManager.h
View File

@@ -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 OpenFileRF(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 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 RawOpenFileRF(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 RawOpenFileResources(VirtualDirectory_t dirID, const PLPasStr &filename, EFilePermission filePermission, bool ignoreMeta, IOStream *&outStream) = 0;
static FileManager *GetInstance();
};

3
PortabilityLayer/HostSystemServices.h
View File

@@ -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();

8
PortabilityLayer/MacFileInfo.cpp
View File

@@ -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::BigUInt32(props.m_modifiedDate);
PortabilityLayer::ByteSwap::BigInt64(props.m_creationDate);
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 + kModifiedDate, &modifiedDate, 4);
memcpy(m_data + kCreationDate, &creationDate, 8);
memcpy(m_data + kModifiedDate, &modifiedDate, 8);
}
}

8
PortabilityLayer/MacFileInfo.h
View File

@@ -27,8 +27,8 @@ namespace PortabilityLayer
int16_t m_yPos;
uint16_t m_finderFlags;
uint8_t m_protected;
uint32_t m_creationDate;
uint32_t m_modifiedDate;
int64_t m_creationDate;
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];

73
PortabilityLayer/PLCore.cpp
View File

@@ -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);

9
PortabilityLayer/PLCore.h
View File

@@ -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);

2
PortabilityLayer/PLResourceManager.cpp
View File

@@ -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();

7
PortabilityLayer/ResTypeID.h
View File

@@ -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