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

49
PortabilityLayer/ByteSwap.cpp
View File

@@ -1,37 +1,54 @@
#include "ByteSwap.h"
#include "ByteSwap.h"
#include "CoreDefs.h"
namespace PortabilityLayer
{
namespace ByteSwap
{
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);
{
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<int16_t>((asS8[0] << 8) | asU8[1]);
v = static_cast<TNumberType>(result);
}
void BigInt16(int16_t &v)
{
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);
v = static_cast<int32_t>((asS8[0] << 24) | (asU8[1] << 16) | (asU8[2] << 8) | asU8[3]);
SwapArbitrary<int32_t, uint32_t>(v);
}
void BigUInt16(uint16_t &v)
void BigInt64(int64_t &v)
{
const uint8_t *asU8 = reinterpret_cast<const uint8_t*>(&v);
SwapArbitrary<int64_t, uint64_t>(v);
}
v = static_cast<uint16_t>((asU8[0] << 8) | asU8[1]);
void BigUInt16(uint16_t &v)
{
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();

143
PortabilityLayer/ResTypeID.h
View File

@@ -1,68 +1,75 @@
#pragma once
#ifndef __PL_RES_TYPE_ID_H__
#define __PL_RES_TYPE_ID_H__
#include <stdint.h>
namespace PortabilityLayer
{
class ResTypeID
{
public:
ResTypeID();
ResTypeID(int32_t i);
ResTypeID(const ResTypeID &other);
explicit ResTypeID(const char *chars);
ResTypeID &operator=(const ResTypeID &other);
bool operator==(const ResTypeID &other) const;
bool operator!=(const ResTypeID &other) const;
private:
char m_id[4];
};
}
#include "ResTypeIDCodec.h"
#include <string.h>
namespace PortabilityLayer
{
inline ResTypeID::ResTypeID()
{
m_id[0] = m_id[1] = m_id[2] = m_id[3] = 0;
}
inline ResTypeID::ResTypeID(int32_t i)
{
ResTypeIDCodec::Encode(i, m_id);
}
inline ResTypeID::ResTypeID(const ResTypeID &other)
{
memcpy(m_id, other.m_id, 4);
}
inline ResTypeID::ResTypeID(const char *chars)
{
memcpy(m_id, chars, 4);
}
inline ResTypeID &ResTypeID::operator=(const ResTypeID &other)
{
memcpy(m_id, other.m_id, 4);
return *this;
}
inline bool ResTypeID::operator==(const ResTypeID &other) const
{
return memcmp(m_id, other.m_id, 4) == 0;
}
inline bool ResTypeID::operator!=(const ResTypeID &other) const
{
return memcmp(m_id, other.m_id, 4) != 0;
}
}
#endif
#pragma once
#ifndef __PL_RES_TYPE_ID_H__
#define __PL_RES_TYPE_ID_H__
#include <stdint.h>
namespace PortabilityLayer
{
class ResTypeID
{
public:
ResTypeID();
ResTypeID(int32_t i);
ResTypeID(const ResTypeID &other);
explicit ResTypeID(const char *chars);
ResTypeID &operator=(const ResTypeID &other);
bool operator==(const ResTypeID &other) const;
bool operator!=(const ResTypeID &other) const;
void ExportAsChars(char *chars) const;
private:
char m_id[4];
};
}
#include "ResTypeIDCodec.h"
#include <string.h>
namespace PortabilityLayer
{
inline ResTypeID::ResTypeID()
{
m_id[0] = m_id[1] = m_id[2] = m_id[3] = 0;
}
inline ResTypeID::ResTypeID(int32_t i)
{
ResTypeIDCodec::Encode(i, m_id);
}
inline ResTypeID::ResTypeID(const ResTypeID &other)
{
memcpy(m_id, other.m_id, 4);
}
inline ResTypeID::ResTypeID(const char *chars)
{
memcpy(m_id, chars, 4);
}
inline ResTypeID &ResTypeID::operator=(const ResTypeID &other)
{
memcpy(m_id, other.m_id, 4);
return *this;
}
inline bool ResTypeID::operator==(const ResTypeID &other) const
{
return memcmp(m_id, other.m_id, 4) == 0;
}
inline bool ResTypeID::operator!=(const ResTypeID &other) const
{
return memcmp(m_id, other.m_id, 4) != 0;
}
inline void ResTypeID::ExportAsChars(char *chars) const
{
memcpy(chars, m_id, 4);
}
}
#endif