From aa3145856cd3b25c61de5bd952cd12bdb237544a Mon Sep 17 00:00:00 2001 From: Andy McFadden Date: Mon, 24 Nov 2014 12:56:19 -0800 Subject: [PATCH] Use types with explicit sizes Focusing on the diskimg library this time, which deals with a lot of filesystem structures that have specific widths. This is still a bit lax in places, e.g. using "long" for lengths. Should either specify a bit width or use di_off_t. Also, added "override" keyword where appropriate. Also, bumped library version to 5.0.0. --- app/app.vcxproj | 10 +- diskimg/ASPI.cpp | 33 +- diskimg/CFFA.cpp | 22 +- diskimg/CPM.cpp | 77 +-- diskimg/Container.cpp | 6 +- diskimg/DDD.cpp | 88 ++- diskimg/DIUtil.cpp | 47 +- diskimg/DOS33.cpp | 347 +++++------ diskimg/DOSImage.cpp | 7 +- diskimg/DiskFS.cpp | 63 +- diskimg/DiskImg.cpp | 181 +++--- diskimg/DiskImg.h | 70 +-- diskimg/DiskImgDetail.h | 1231 +++++++++++++++++++------------------- diskimg/DiskImgPriv.h | 52 +- diskimg/FAT.cpp | 136 ++--- diskimg/FDI.cpp | 187 +++--- diskimg/FocusDrive.cpp | 57 +- diskimg/GenericFD.cpp | 110 ++-- diskimg/GenericFD.h | 2 +- diskimg/Global.cpp | 15 +- diskimg/Gutenberg.cpp | 104 ++-- diskimg/HFS.cpp | 280 ++++----- diskimg/ImageWrapper.cpp | 295 ++++----- diskimg/MacPart.cpp | 96 ++- diskimg/MicroDrive.cpp | 69 +-- diskimg/Nibble.cpp | 125 ++-- diskimg/Nibble35.cpp | 59 +- diskimg/OuterWrapper.cpp | 163 ++--- diskimg/OzDOS.cpp | 27 +- diskimg/Pascal.cpp | 204 +++---- diskimg/ProDOS.cpp | 540 +++++++---------- diskimg/RDOS.cpp | 89 +-- diskimg/SPTI.cpp | 48 +- diskimg/SPTI.h | 6 +- diskimg/StdAfx.h | 1 + diskimg/TwoImg.cpp | 59 +- diskimg/TwoImg.h | 50 +- diskimg/UNIDOS.cpp | 28 +- diskimg/VolumeUsage.cpp | 39 +- diskimg/Win32BlockIO.cpp | 183 +++--- diskimg/diskimg.vcxproj | 4 +- mdc/Main.cpp | 3 +- 42 files changed, 2254 insertions(+), 2959 deletions(-) diff --git a/app/app.vcxproj b/app/app.vcxproj index 7bd4b85..8f23832 100644 --- a/app/app.vcxproj +++ b/app/app.vcxproj @@ -93,8 +93,6 @@ - copy Help\CiderPress.hlp Release\ -copy Help\CiderPress.cnt Release\ NDEBUG;%(PreprocessorDefinitions) @@ -137,13 +135,7 @@ copy Help\CiderPress.cnt Release\ .\Debug/app.tlb - - Copying help - copy Help\CiderPress.hlp Debug\ -copy Help\CiderPress.cnt Debug\ - - - + _DEBUG;%(PreprocessorDefinitions) 0x0409 diff --git a/diskimg/ASPI.cpp b/diskimg/ASPI.cpp index 32bf3d1..5bd91d5 100644 --- a/diskimg/ASPI.cpp +++ b/diskimg/ASPI.cpp @@ -25,8 +25,7 @@ /* * Initialize ASPI. */ -DIError -ASPI::Init(void) +DIError ASPI::Init(void) { DWORD aspiStatus; static const char* kASPIDllName = "wnaspi32.dll"; @@ -104,8 +103,7 @@ ASPI::~ASPI(void) * * Pass in a pointer to a struct that receives the result. */ -DIError -ASPI::HostAdapterInquiry(unsigned char adapter, AdapterInfo* pAdapterInfo) +DIError ASPI::HostAdapterInquiry(unsigned char adapter, AdapterInfo* pAdapterInfo) { SRB_HAInquiry req; DWORD result; @@ -140,8 +138,7 @@ ASPI::HostAdapterInquiry(unsigned char adapter, AdapterInfo* pAdapterInfo) /* * Issue an ASPI query on device type. */ -DIError -ASPI::GetDeviceType(unsigned char adapter, unsigned char target, +DIError ASPI::GetDeviceType(unsigned char adapter, unsigned char target, unsigned char lun, unsigned char* pType) { SRB_GDEVBlock req; @@ -170,8 +167,7 @@ ASPI::GetDeviceType(unsigned char adapter, unsigned char target, /* * Return a printable string for the given device type. */ -const char* -ASPI::DeviceTypeToString(unsigned char deviceType) +const char* ASPI::DeviceTypeToString(unsigned char deviceType) { switch (deviceType) { case kScsiDevTypeDASD: return "Disk device"; @@ -192,8 +188,7 @@ ASPI::DeviceTypeToString(unsigned char deviceType) /* * Issue a SCSI device inquiry and return the interesting parts. */ -DIError -ASPI::DeviceInquiry(unsigned char adapter, unsigned char target, +DIError ASPI::DeviceInquiry(unsigned char adapter, unsigned char target, unsigned char lun, Inquiry* pInquiry) { DIError dierr; @@ -245,8 +240,7 @@ ASPI::DeviceInquiry(unsigned char adapter, unsigned char target, /* * Get the capacity of a SCSI block device. */ -DIError -ASPI::GetDeviceCapacity(unsigned char adapter, unsigned char target, +DIError ASPI::GetDeviceCapacity(unsigned char adapter, unsigned char target, unsigned char lun, unsigned long* pLastBlock, unsigned long* pBlockSize) { DIError dierr; @@ -294,8 +288,7 @@ ASPI::GetDeviceCapacity(unsigned char adapter, unsigned char target, * * Returns "true" if the device is ready, "false" if not. */ -DIError -ASPI::TestUnitReady(unsigned char adapter, unsigned char target, +DIError ASPI::TestUnitReady(unsigned char adapter, unsigned char target, unsigned char lun, bool* pReady) { DIError dierr; @@ -355,8 +348,7 @@ ASPI::TestUnitReady(unsigned char adapter, unsigned char target, * (possibly modified by extents, but we'll ignore that). For a CD-ROM * this means 2048-byte blocks. */ -DIError -ASPI::ReadBlocks(unsigned char adapter, unsigned char target, +DIError ASPI::ReadBlocks(unsigned char adapter, unsigned char target, unsigned char lun, long startBlock, short numBlocks, long blockSize, void* buf) { @@ -397,8 +389,7 @@ ASPI::ReadBlocks(unsigned char adapter, unsigned char target, /* * Write one or more blocks to the device. */ -DIError -ASPI::WriteBlocks(unsigned char adapter, unsigned char target, +DIError ASPI::WriteBlocks(unsigned char adapter, unsigned char target, unsigned char lun, long startBlock, short numBlocks, long blockSize, const void* buf) { @@ -446,8 +437,7 @@ ASPI::WriteBlocks(unsigned char adapter, unsigned char target, * The Nero ASPI layer typically returns immediately, and hands back an * SS_ERR when something fails. Win98 ASPI does the SS_PENDING thang. */ -DIError -ASPI::ExecSCSICommand(SRB_ExecSCSICmd* pSRB) +DIError ASPI::ExecSCSICommand(SRB_ExecSCSICmd* pSRB) { HANDLE completionEvent = NULL; DWORD eventStatus; @@ -522,8 +512,7 @@ ASPI::ExecSCSICommand(SRB_ExecSCSICmd* pSRB) * * Only return the devices matching device types in "deviceMask". */ -DIError -ASPI::GetAccessibleDevices(int deviceMask, ASPIDevice** ppDeviceArray, +DIError ASPI::GetAccessibleDevices(int deviceMask, ASPIDevice** ppDeviceArray, int* pNumDevices) { DIError dierr; diff --git a/diskimg/CFFA.cpp b/diskimg/CFFA.cpp index 61c6d1e..a25b45f 100644 --- a/diskimg/CFFA.cpp +++ b/diskimg/CFFA.cpp @@ -50,9 +50,8 @@ * force the "disk format verification" dialog to come up. No such * mechanism exists, and for now it doesn't seem worthwhile to add one. */ -/*static*/ DIError -DiskFSCFFA::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, - DiskImg::FSFormat* pFormatFound) +/*static*/ DIError DiskFSCFFA::TestImage(DiskImg* pImg, + DiskImg::SectorOrder imageOrder, DiskImg::FSFormat* pFormatFound) { DIError dierr; long totalBlocks = pImg->GetNumBlocks(); @@ -359,9 +358,8 @@ bail: * If "scanOnly" is set, the full DiskFS initialization isn't performed. * We just do enough to get the volume size info. */ -/*static*/ DIError -DiskFSCFFA::OpenSubVolume(DiskImg* pImg, long startBlock, long numBlocks, - bool scanOnly, DiskImg** ppNewImg, DiskFS** ppNewFS) +/*static*/ DIError DiskFSCFFA::OpenSubVolume(DiskImg* pImg, long startBlock, + long numBlocks, bool scanOnly, DiskImg** ppNewImg, DiskFS** ppNewFS) { DIError dierr = kDIErrNone; DiskFS* pNewFS = NULL; @@ -439,8 +437,7 @@ bail: /* * Check to see if this is a CFFA volume. */ -/*static*/ DIError -DiskFSCFFA::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSCFFA::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumBlocks() < kMinInterestingBlocks) @@ -467,8 +464,7 @@ DiskFSCFFA::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Prep the CFFA "container" for use. */ -DIError -DiskFSCFFA::Initialize(void) +DIError DiskFSCFFA::Initialize(void) { DIError dierr = kDIErrNone; @@ -494,8 +490,7 @@ DiskFSCFFA::Initialize(void) * We don't handle the volume specially unless it's at least 32MB, which * means there are at least 2 partitions. */ -DIError -DiskFSCFFA::FindSubVolumes(void) +DIError DiskFSCFFA::FindSubVolumes(void) { DIError dierr; long startBlock, blocksLeft; @@ -542,8 +537,7 @@ bail: * * Updates "startBlock" and "totalBlocksLeft". */ -DIError -DiskFSCFFA::AddVolumeSeries(int start, int count, long blocksPerVolume, +DIError DiskFSCFFA::AddVolumeSeries(int start, int count, long blocksPerVolume, long& startBlock, long& totalBlocksLeft) { DIError dierr = kDIErrNone; diff --git a/diskimg/CPM.cpp b/diskimg/CPM.cpp index 7410e86..c502236 100644 --- a/diskimg/CPM.cpp +++ b/diskimg/CPM.cpp @@ -41,12 +41,11 @@ const int kMaxExtent = 31; // extent counter, 0-31 * * We test a few fields in the volume directory for validity. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char dirBuf[kBlkSize * kVolDirCount]; - unsigned char* dptr; + uint8_t dirBuf[kBlkSize * kVolDirCount]; + uint8_t* dptr; int i; assert(sizeof(dirBuf) == DiskFSCPM::kFullDirSize); @@ -79,7 +78,7 @@ TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) } /* check for a valid filename here; high bit may be set on some bytes */ - unsigned char firstLet = *(dptr+1) & 0x7f; + uint8_t firstLet = *(dptr+1) & 0x7f; if (firstLet < 0x20) { dierr = kDIErrFilesystemNotFound; break; @@ -101,8 +100,7 @@ bail: * On the Apple II, these were always on 5.25" disks. However, it's possible * to create hard drive volumes up to 8MB. */ -/*static*/ DIError -DiskFSCPM::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSCPM::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { /* CP/M disks use 1K blocks, so ignore anything with odd count */ @@ -139,8 +137,7 @@ DiskFSCPM::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSCPM::Initialize(void) +DIError DiskFSCPM::Initialize(void) { DIError dierr = kDIErrNone; @@ -178,12 +175,11 @@ bail: * A single file can have more than one directory entry. We only want * to create an A2File object for the first one. */ -DIError -DiskFSCPM::ReadCatalog(void) +DIError DiskFSCPM::ReadCatalog(void) { DIError dierr = kDIErrNone; - unsigned char dirBuf[kFullDirSize]; - unsigned char* dptr; + uint8_t dirBuf[kFullDirSize]; + uint8_t* dptr; int i; for (i = 0; i < kVolDirCount; i++) { @@ -262,8 +258,7 @@ bail: /* * Reformat from 11 chars with spaces into clean xxxxx.yyy format. */ -void -DiskFSCPM::FormatName(char* dstBuf, const char* srcBuf) +void DiskFSCPM::FormatName(char* dstBuf, const char* srcBuf) { char workBuf[kDirFileNameLen+1]; char* cp; @@ -299,8 +294,7 @@ DiskFSCPM::FormatName(char* dstBuf, const char* srcBuf) * (Should probably just get the block list and then walk that, rather than * having directory parse code in two places.) */ -DIError -DiskFSCPM::ComputeLength(A2FileCPM* pFile) +DIError DiskFSCPM::ComputeLength(A2FileCPM* pFile) { int i; int best, maxExtent; @@ -342,8 +336,7 @@ DiskFSCPM::ComputeLength(A2FileCPM* pFile) * Tracks 0, 1, and 2 are always used by the boot loader. The volume directory * is on the first half of track 3 (blocks 0 and 1). */ -DIError -DiskFSCPM::ScanFileUsage(void) +DIError DiskFSCPM::ScanFileUsage(void) { int cpmBlock; int i, j; @@ -379,8 +372,7 @@ DiskFSCPM::ScanFileUsage(void) * "block" is a 512-byte block, so you will have to call here twice for every * 1K CP/M block. */ -void -DiskFSCPM::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) +void DiskFSCPM::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) { VolumeUsage::ChunkState cstate; @@ -409,8 +401,7 @@ DiskFSCPM::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) * * Returns "true" if disk appears to be perfect, "false" otherwise. */ -bool -DiskFSCPM::CheckDiskIsGood(void) +bool DiskFSCPM::CheckDiskIsGood(void) { //DIError dierr; bool result = true; @@ -454,8 +445,7 @@ DiskFSCPM::CheckDiskIsGood(void) * Calling GetBlockList twice is probably not the best way to go through life. * This needs an overhaul. */ -DIError -A2FileCPM::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileCPM::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { DIError dierr; @@ -474,7 +464,7 @@ A2FileCPM::Open(A2FileDescr** ppOpenFile, bool readOnly, if (dierr != kDIErrNone) goto bail; - pOpenFile->fBlockList = new unsigned char[pOpenFile->fBlockCount+1]; + pOpenFile->fBlockList = new uint8_t[pOpenFile->fBlockCount+1]; pOpenFile->fBlockList[pOpenFile->fBlockCount] = 0xff; dierr = GetBlockList(&pOpenFile->fBlockCount, pOpenFile->fBlockList); @@ -503,8 +493,7 @@ bail: * Call this once with "blockBuf" equal to "NULL" to get the block count, * then call a second time after allocating blockBuf. */ -DIError -A2FileCPM::GetBlockList(long* pBlockCount, unsigned char* blockBuf) const +DIError A2FileCPM::GetBlockList(long* pBlockCount, uint8_t* blockBuf) const { di_off_t length = fLength; int blockCount = 0; @@ -565,8 +554,7 @@ A2FileCPM::GetBlockList(long* pBlockCount, unsigned char* blockBuf) const /* * Dump the contents of the A2File structure. */ -void -A2FileCPM::Dump(void) const +void A2FileCPM::Dump(void) const { LOGI("A2FileCPM '%s' length=%ld", fFileName, (long) fLength); } @@ -581,8 +569,7 @@ A2FileCPM::Dump(void) const /* * Read a chunk of data from the current offset. */ -DIError -A2FDCPM::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDCPM::Read(void* buf, size_t len, size_t* pActual) { LOGI(" CP/M reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -602,7 +589,7 @@ A2FDCPM::Read(void* buf, size_t len, size_t* pActual) DIError dierr = kDIErrNone; const int kCPMBlockSize = kBlkSize*2; assert(kCPMBlockSize == 1024); - unsigned char blkBuf[kCPMBlockSize]; + uint8_t blkBuf[kCPMBlockSize]; int blkIndex = (int) (fOffset / kCPMBlockSize); int bufOffset = (int) (fOffset % kCPMBlockSize); // (& 0x3ff) size_t thisCount; @@ -669,8 +656,7 @@ A2FDCPM::Read(void* buf, size_t len, size_t* pActual) /* * Write data at the current offset. */ -DIError -A2FDCPM::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDCPM::Write(const void* buf, size_t len, size_t* pActual) { return kDIErrNotSupported; } @@ -678,8 +664,7 @@ A2FDCPM::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to a new offset. */ -DIError -A2FDCPM::Seek(di_off_t offset, DIWhence whence) +DIError A2FDCPM::Seek(di_off_t offset, DIWhence whence) { di_off_t fileLength = ((A2FileCPM*) fpFile)->fLength; @@ -714,8 +699,7 @@ A2FDCPM::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDCPM::Tell(void) +di_off_t A2FDCPM::Tell(void) { return fOffset; } @@ -723,8 +707,7 @@ A2FDCPM::Tell(void) /* * Release file state, such as it is. */ -DIError -A2FDCPM::Close(void) +DIError A2FDCPM::Close(void) { fpFile->CloseDescr(this); return kDIErrNone; @@ -733,13 +716,11 @@ A2FDCPM::Close(void) /* * Return the #of sectors/blocks in the file. */ -long -A2FDCPM::GetSectorCount(void) const +long A2FDCPM::GetSectorCount(void) const { return fBlockCount * 4; } -long -A2FDCPM::GetBlockCount(void) const +long A2FDCPM::GetBlockCount(void) const { return fBlockCount * 2; } @@ -747,8 +728,7 @@ A2FDCPM::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDCPM::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDCPM::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { long cpmIdx = sectorIdx / 4; // 4 256-byte sectors per 1K CP/M block if (cpmIdx >= fBlockCount) @@ -766,8 +746,7 @@ A2FDCPM::GetStorage(long sectorIdx, long* pTrack, long* pSector) const * Return the Nth 512-byte block in this file. Since things aren't stored * in 512-byte blocks, we grab the appropriate 1K block and pick half. */ -DIError -A2FDCPM::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDCPM::GetStorage(long blockIdx, long* pBlock) const { long cpmIdx = blockIdx / 2; // 4 256-byte sectors per 1K CP/M block if (cpmIdx >= fBlockCount) diff --git a/diskimg/Container.cpp b/diskimg/Container.cpp index 3e82d02..93a5fc2 100644 --- a/diskimg/Container.cpp +++ b/diskimg/Container.cpp @@ -13,8 +13,7 @@ /* * Blank out the volume usage map, setting all entries to "embedded". */ -void -DiskFSContainer::SetVolumeUsageMap(void) +void DiskFSContainer::SetVolumeUsageMap(void) { VolumeUsage::ChunkState cstate; long block; @@ -34,8 +33,7 @@ DiskFSContainer::SetVolumeUsageMap(void) * Create a "placeholder" sub-volume. Useful for some of the tools when * dealing with unformatted (or unknown-formatted) partitions. */ -DIError -DiskFSContainer::CreatePlaceholder(long startBlock, long numBlocks, +DIError DiskFSContainer::CreatePlaceholder(long startBlock, long numBlocks, const char* partName, const char* partType, DiskImg** ppNewImg, DiskFS** ppNewFS) { diff --git a/diskimg/DDD.cpp b/diskimg/DDD.cpp index aa514e5..16f5daa 100644 --- a/diskimg/DDD.cpp +++ b/diskimg/DDD.cpp @@ -103,18 +103,18 @@ public: ~BitBuffer(void) {} void SetFile(GenericFD* pGFD) { fpGFD = pGFD; } - void PutBits(unsigned char bits, int numBits); - unsigned char GetBits(int numBits); + void PutBits(uint8_t bits, int numBits); + uint8_t GetBits(int numBits); bool IOFailure(void) const { return fIOFailure; } - static unsigned char Reverse(unsigned char val); + static uint8_t Reverse(uint8_t val); private: - GenericFD* fpGFD; - unsigned char fBits; - int fBitCount; - bool fIOFailure; + GenericFD* fpGFD; + uint8_t fBits; + int fBitCount; + bool fIOFailure; }; /* @@ -124,8 +124,7 @@ private: * reverse order in which they were passed in). As soon as we get 8 bits * we flush. */ -void -WrapperDDD::BitBuffer::PutBits(unsigned char bits, int numBits) +void WrapperDDD::BitBuffer::PutBits(uint8_t bits, int numBits) { assert(fBitCount >= 0 && fBitCount < 8); assert(numBits > 0 && numBits <= 8); @@ -153,15 +152,14 @@ WrapperDDD::BitBuffer::PutBits(unsigned char bits, int numBits) * These come out in the order in which they appear in the file, which * means that in some cases they will have to be reversed. */ -unsigned char -WrapperDDD::BitBuffer::GetBits(int numBits) +uint8_t WrapperDDD::BitBuffer::GetBits(int numBits) { assert(fBitCount >= 0 && fBitCount < 8); assert(numBits > 0 && numBits <= 8); assert(fpGFD != NULL); DIError dierr; - unsigned char retVal; + uint8_t retVal; if (fBitCount == 0) { /* have no bits */ @@ -199,11 +197,10 @@ WrapperDDD::BitBuffer::GetBits(int numBits) /* * Utility function to reverse the order of bits in a byte. */ -/*static*/ unsigned char -WrapperDDD::BitBuffer::Reverse(unsigned char val) +/*static*/ uint8_t WrapperDDD::BitBuffer::Reverse(uint8_t val) { int i; - unsigned char result = 0; // init is to make valgrind happy + uint8_t result = 0; // init is to make valgrind happy for (i = 0; i < 8; i++) { result = (result << 1) + (val & 0x01); @@ -224,7 +221,7 @@ WrapperDDD::BitBuffer::Reverse(unsigned char val) * These are all odd, which when they're written in reverse order means * they all have their hi bits set. */ -static const unsigned char kFavoriteBitEnc[kNumFavorites] = { +static const uint8_t kFavoriteBitEnc[kNumFavorites] = { 0x03, 0x09, 0x1f, 0x0f, 0x07, 0x1b, 0x0b, 0x0d, 0x15, 0x37, 0x3d, 0x25, 0x05, 0xb1, 0x11, 0x21, 0x01, 0x57, 0x5d, 0x1d }; @@ -240,8 +237,7 @@ static const int kFavoriteBitEncLen[kNumFavorites] = { * Assumes pSrcGFD points to DOS-ordered sectors. (This is enforced when the * disk image is first being created.) */ -/*static*/ DIError -WrapperDDD::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD, +/*static*/ DIError WrapperDDD::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD, short diskVolNum) { DIError dierr = kDIErrNone; @@ -256,13 +252,13 @@ WrapperDDD::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD, bitBuffer.SetFile(pWrapperGFD); bitBuffer.PutBits(0x00, 3); - bitBuffer.PutBits((unsigned char)diskVolNum, 8); + bitBuffer.PutBits((uint8_t)diskVolNum, 8); /* * Process all tracks. */ for (int track = 0; track < kNumTracks; track++) { - unsigned char trackBuf[kTrackLen]; + uint8_t trackBuf[kTrackLen]; dierr = pSrcGFD->Read(trackBuf, kTrackLen); if (dierr != kDIErrNone) { @@ -291,11 +287,10 @@ bail: /* * Compress a track full of data. */ -/*static*/ void -WrapperDDD::PackTrack(const unsigned char* trackBuf, BitBuffer* pBitBuf) +/*static*/ void WrapperDDD::PackTrack(const uint8_t* trackBuf, BitBuffer* pBitBuf) { - unsigned short freqCounts[kNumSymbols]; - unsigned char favorites[kNumFavorites]; + uint16_t freqCounts[kNumSymbols]; + uint8_t favorites[kNumFavorites]; int i, fav; ComputeFreqCounts(trackBuf, freqCounts); @@ -309,7 +304,7 @@ WrapperDDD::PackTrack(const unsigned char* trackBuf, BitBuffer* pBitBuf) * Compress track data. Store runs as { 0x97 char count }, where * a count of zero means 256. */ - const unsigned char* ucp = trackBuf; + const uint8_t* ucp = trackBuf; for (i = 0; i < kTrackLen; i++, ucp++) { if (i < (kTrackLen-3) && *ucp == *(ucp+1) && @@ -361,16 +356,15 @@ WrapperDDD::PackTrack(const unsigned char* trackBuf, BitBuffer* pBitBuf) * bytes or longer are completely ignored. * * "trackBuf" holds kTrackLen bytes of data, and "freqCounts" holds - * kNumSymbols (256) unsigned shorts. + * kNumSymbols (256) 16-bit values. */ -/*static*/ void -WrapperDDD::ComputeFreqCounts(const unsigned char* trackBuf, - unsigned short* freqCounts) +/*static*/ void WrapperDDD::ComputeFreqCounts(const uint8_t* trackBuf, + uint16_t* freqCounts) { - const unsigned char* ucp; + const uint8_t* ucp; int i; - memset(freqCounts, 0, 256 * sizeof(unsigned short)); + memset(freqCounts, 0, 256 * sizeof(uint16_t)); ucp = trackBuf; for (i = 0; i < kTrackLen; i++, ucp++) { @@ -407,19 +401,18 @@ WrapperDDD::ComputeFreqCounts(const unsigned char* trackBuf, * * Modifies "freqCounts". */ -/*static*/ void -WrapperDDD::ComputeFavorites(unsigned short* freqCounts, - unsigned char* favorites) +/*static*/ void WrapperDDD::ComputeFavorites(uint16_t* freqCounts, + uint8_t* favorites) { int i, fav; for (fav = 0; fav < kNumFavorites; fav++) { - unsigned short bestCount = 0; - unsigned char bestSym = 0; + uint16_t bestCount = 0; + uint8_t bestSym = 0; for (i = 0; i < kNumSymbols; i++) { if (freqCounts[i] >= bestCount) { - bestSym = (unsigned char) i; + bestSym = (uint8_t) i; bestCount = freqCounts[i]; } } @@ -445,7 +438,7 @@ WrapperDDD::ComputeFavorites(unsigned short* freqCounts, * This is the reverse of the kFavoriteBitEnc table. The bits are * reversed and lack the high bit. */ -static const unsigned char kFavoriteBitDec[kNumFavorites] = { +static const uint8_t kFavoriteBitDec[kNumFavorites] = { 0x04, 0x01, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a, 0x06, 0x05, 0x1b, 0x0f, 0x09, 0x08, 0x03, 0x02, 0x01, 0x00, 0x35, 0x1d, 0x1c }; @@ -455,13 +448,12 @@ static const unsigned char kFavoriteBitDec[kNumFavorites] = { * * The result is an unadorned DOS-ordered image. */ -/*static*/ DIError -WrapperDDD::UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD, +/*static*/ DIError WrapperDDD::UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD, short* pDiskVolNum) { DIError dierr = kDIErrNone; BitBuffer bitBuffer; - unsigned char val; + uint8_t val; long lbuf; assert(pGFD != NULL); @@ -487,7 +479,7 @@ WrapperDDD::UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD, int track; for (track = 0; track < kNumTracks; track++) { - unsigned char trackBuf[kTrackLen]; + uint8_t trackBuf[kTrackLen]; if (!UnpackTrack(&bitBuffer, trackBuf)) { LOGI(" DDD failed unpacking track %d", track); @@ -543,12 +535,11 @@ bail: * * Returns "true" if all went well, "false" if something failed. */ -/*static*/ bool -WrapperDDD::UnpackTrack(BitBuffer* pBitBuffer, unsigned char* trackBuf) +/*static*/ bool WrapperDDD::UnpackTrack(BitBuffer* pBitBuffer, uint8_t* trackBuf) { - unsigned char favorites[kNumFavorites]; - unsigned char val; - unsigned char* trackPtr; + uint8_t favorites[kNumFavorites]; + uint8_t val; + uint8_t* trackPtr; int fav; /* @@ -609,7 +600,7 @@ WrapperDDD::UnpackTrack(BitBuffer* pBitBuffer, unsigned char* trackBuf) } if (extraBits == 4) { /* we didn't get it, this must be RLE */ - unsigned char rleChar; + uint8_t rleChar; int rleCount; (void) pBitBuffer->GetBits(1); // get last bit of 0x97 @@ -635,4 +626,3 @@ WrapperDDD::UnpackTrack(BitBuffer* pBitBuffer, unsigned char* trackBuf) return true; } - diff --git a/diskimg/DIUtil.cpp b/diskimg/DIUtil.cpp index 4695f0e..9d1038b 100644 --- a/diskimg/DIUtil.cpp +++ b/diskimg/DIUtil.cpp @@ -47,15 +47,13 @@ uint32_t DiskImgLib::Get24BE(const uint8_t* ptr) (uint32_t) *ptr << 16; } -void -DiskImgLib::PutShortLE(uint8_t* ptr, uint16_t val) +void DiskImgLib::PutShortLE(uint8_t* ptr, uint16_t val) { *ptr++ = (uint8_t) val; *ptr = val >> 8; } -void -DiskImgLib::PutLongLE(uint8_t* ptr, uint32_t val) +void DiskImgLib::PutLongLE(uint8_t* ptr, uint32_t val) { *ptr++ = (uint8_t) val; *ptr++ = (uint8_t) (val >> 8); @@ -63,15 +61,13 @@ DiskImgLib::PutLongLE(uint8_t* ptr, uint32_t val) *ptr = (uint8_t) (val >> 24); } -void -DiskImgLib::PutShortBE(uint8_t* ptr, uint16_t val) +void DiskImgLib::PutShortBE(uint8_t* ptr, uint16_t val) { *ptr++ = val >> 8; *ptr = (uint8_t) val; } -void -DiskImgLib::PutLongBE(uint8_t* ptr, uint32_t val) +void DiskImgLib::PutLongBE(uint8_t* ptr, uint32_t val) { *ptr++ = (uint8_t) (val >> 24); *ptr++ = (uint8_t) (val >> 16); @@ -83,8 +79,7 @@ DiskImgLib::PutLongBE(uint8_t* ptr, uint32_t val) /* * Read a two-byte little-endian value. */ -DIError -DiskImgLib::ReadShortLE(GenericFD* pGFD, uint16_t* pBuf) +DIError DiskImgLib::ReadShortLE(GenericFD* pGFD, uint16_t* pBuf) { DIError dierr; uint8_t val[2]; @@ -100,8 +95,7 @@ DiskImgLib::ReadShortLE(GenericFD* pGFD, uint16_t* pBuf) /* * Read a four-byte little-endian value. */ -DIError -DiskImgLib::ReadLongLE(GenericFD* pGFD, uint32_t* pBuf) +DIError DiskImgLib::ReadLongLE(GenericFD* pGFD, uint32_t* pBuf) { DIError dierr; uint8_t val[4]; @@ -159,7 +153,7 @@ DIError DiskImgLib::WriteShortLE(GenericFD* pGFD, uint16_t val) */ DIError DiskImgLib::WriteLongLE(GenericFD* pGFD, uint32_t val) { - unsigned char buf; + uint8_t buf; buf = (uint8_t) val; pGFD->Write(&buf, 1); @@ -176,7 +170,7 @@ DIError DiskImgLib::WriteLongLE(GenericFD* pGFD, uint32_t val) */ DIError DiskImgLib::WriteShortBE(GenericFD* pGFD, uint16_t val) { - unsigned char buf; + uint8_t buf; buf = val >> 8; pGFD->Write(&buf, 1); @@ -189,15 +183,15 @@ DIError DiskImgLib::WriteShortBE(GenericFD* pGFD, uint16_t val) */ DIError DiskImgLib::WriteLongBE(GenericFD* pGFD, uint32_t val) { - unsigned char buf; + uint8_t buf; - buf = (unsigned char) (val >> 24); + buf = (uint8_t) (val >> 24); pGFD->Write(&buf, 1); - buf = (unsigned char) (val >> 16); + buf = (uint8_t) (val >> 16); pGFD->Write(&buf, 1); - buf = (unsigned char) (val >> 8); + buf = (uint8_t) (val >> 8); pGFD->Write(&buf, 1); - buf = (unsigned char) val; + buf = (uint8_t) val; return pGFD->Write(&buf, 1); } @@ -209,8 +203,7 @@ DIError DiskImgLib::WriteLongBE(GenericFD* pGFD, uint32_t val) * * Always returns a pointer to a string; never returns NULL. */ -const char* -DiskImgLib::FilenameOnly(const char* pathname, char fssep) +const char* DiskImgLib::FilenameOnly(const char* pathname, char fssep) { const char* retstr; const char* pSlash; @@ -274,8 +267,7 @@ bail: * * We guarantee that there is at least one character after the '.'. */ -const char* -DiskImgLib::FindExtension(const char* pathname, char fssep) +const char* DiskImgLib::FindExtension(const char* pathname, char fssep) { const char* pFilename; const char* pExt; @@ -302,8 +294,7 @@ DiskImgLib::FindExtension(const char* pathname, char fssep) * * TODO: should be "StrdupNew()" */ -char* -DiskImgLib::StrcpyNew(const char* str) +char* DiskImgLib::StrcpyNew(const char* str) { char* newStr; @@ -320,8 +311,7 @@ DiskImgLib::StrcpyNew(const char* str) /* * Convert the value from GetLastError() to its DIError counterpart. */ -DIError -DiskImgLib::LastErrorToDIError(void) +DIError DiskImgLib::LastErrorToDIError(void) { DWORD lastErr = ::GetLastError(); @@ -353,8 +343,7 @@ DiskImgLib::LastErrorToDIError(void) * Returns "true" if we're running on Win9x (Win95, Win98, WinME), "false" * if not (could be WinNT/2K/XP or even Win31 with Win32s). */ -bool -DiskImgLib::IsWin9x(void) +bool DiskImgLib::IsWin9x(void) { OSVERSIONINFO osvers; BOOL result; diff --git a/diskimg/DOS33.cpp b/diskimg/DOS33.cpp index 7f919e3..8052cd1 100644 --- a/diskimg/DOS33.cpp +++ b/diskimg/DOS33.cpp @@ -39,8 +39,7 @@ const int kMaxTSIterations = 32; /* * Get a pointer to the Nth entry in a catalog sector. */ -static inline unsigned char* -GetCatalogEntryPtr(unsigned char* basePtr, int entryNum) +static inline uint8_t* GetCatalogEntryPtr(uint8_t* basePtr, int entryNum) { assert(entryNum >= 0 && entryNum < kCatalogEntriesPerSect); return basePtr + kCatalogEntryOffset + entryNum * kCatalogEntrySize; @@ -70,11 +69,11 @@ GetCatalogEntryPtr(unsigned char* basePtr, int entryNum) * * DISK198B (Aliens+docs) gets 3 and bails with a self-reference. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, int* pGoodCount) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, + int* pGoodCount) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int numTracks, numSectors; int catTrack, catSect; int foundGood = 0; @@ -147,8 +146,7 @@ bail: /* * Test to see if the image is a DOS 3.2 or DOS 3.3 disk. */ -/*static*/ DIError -DiskFSDOS33::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSDOS33::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumTracks() > kMaxInterestingTracks) @@ -198,8 +196,7 @@ DiskFSDOS33::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSDOS33::Initialize(InitMode initMode) +DIError DiskFSDOS33::Initialize(InitMode initMode) { DIError dierr = kDIErrNone; @@ -250,8 +247,7 @@ bail: /* * Read some fields from the disk Volume Table of Contents. */ -DIError -DiskFSDOS33::ReadVTOC(void) +DIError DiskFSDOS33::ReadVTOC(void) { DIError dierr; @@ -291,8 +287,7 @@ bail: * Call this if fpImg's volume num (derived from nibble formats) or * the VTOC's volume number changes. */ -void -DiskFSDOS33::UpdateVolumeNum(void) +void DiskFSDOS33::UpdateVolumeNum(void) { /* use the sector-embedded volume number, if available */ if (fpImg->GetDOSVolumeNum() == DiskImg::kVolumeNumNotSet) @@ -308,8 +303,7 @@ DiskFSDOS33::UpdateVolumeNum(void) /* * Set the disk volume number (fDiskVolumeNum) and derived fields. */ -void -DiskFSDOS33::SetDiskVolumeNum(int val) +void DiskFSDOS33::SetDiskVolumeNum(int val) { if (val < 0 || val > 255) { // Actual valid range should be 1-254, but it's possible for a @@ -330,8 +324,7 @@ DiskFSDOS33::SetDiskVolumeNum(int val) /* * Dump some VTOC fields. */ -void -DiskFSDOS33::DumpVTOC(void) +void DiskFSDOS33::DumpVTOC(void) { LOGI("VTOC catalog: track=%d sector=%d", @@ -343,8 +336,7 @@ DiskFSDOS33::DumpVTOC(void) /* * Update an entry in the VolumeUsage map, watching for conflicts. */ -void -DiskFSDOS33::SetSectorUsage(long track, long sector, +void DiskFSDOS33::SetSectorUsage(long track, long sector, VolumeUsage::ChunkPurpose purpose) { VolumeUsage::ChunkState cstate; @@ -378,8 +370,7 @@ DiskFSDOS33::SetSectorUsage(long track, long sector, * various files, and mark the tracks as owned by DOS if nobody else * claims them. */ -DIError -DiskFSDOS33::ScanVolBitmap(void) +DIError DiskFSDOS33::ScanVolBitmap(void) { DIError dierr; VolumeUsage::ChunkState cstate; @@ -397,13 +388,13 @@ DiskFSDOS33::ScanVolBitmap(void) int i; for (i = 0; i < kMaxTracks; i++) { - unsigned long val, origVal; + uint32_t val, origVal; int bit; - val = (unsigned long) fVTOC[0x38 + i*4] << 24; - val |= (unsigned long) fVTOC[0x39 + i*4] << 16; - val |= (unsigned long) fVTOC[0x3a + i*4] << 8; - val |= (unsigned long) fVTOC[0x3b + i*4]; + val = (uint32_t) fVTOC[0x38 + i*4] << 24; + val |= (uint32_t) fVTOC[0x39 + i*4] << 16; + val |= (uint32_t) fVTOC[0x3a + i*4] << 8; + val |= (uint32_t) fVTOC[0x3b + i*4]; origVal = val; /* init the VolumeUsage stuff */ @@ -433,8 +424,7 @@ bail: /* * Load the VTOC into the buffer. */ -DIError -DiskFSDOS33::LoadVolBitmap(void) +DIError DiskFSDOS33::LoadVolBitmap(void) { DIError dierr; @@ -451,8 +441,7 @@ DiskFSDOS33::LoadVolBitmap(void) /* * Save our copy of the volume bitmap. */ -DIError -DiskFSDOS33::SaveVolBitmap(void) +DIError DiskFSDOS33::SaveVolBitmap(void) { if (!fVTOCLoaded) { assert(false); @@ -467,8 +456,7 @@ DiskFSDOS33::SaveVolBitmap(void) * * It's okay to call this if the bitmap isn't loaded. */ -void -DiskFSDOS33::FreeVolBitmap(void) +void DiskFSDOS33::FreeVolBitmap(void) { fVTOCLoaded = false; @@ -480,14 +468,13 @@ DiskFSDOS33::FreeVolBitmap(void) /* * Return entry N from the VTOC. */ -inline unsigned long -DiskFSDOS33::GetVTOCEntry(const unsigned char* pVTOC, long track) const +inline uint32_t DiskFSDOS33::GetVTOCEntry(const uint8_t* pVTOC, long track) const { - unsigned long val; - val = (unsigned long) pVTOC[0x38 + track*4] << 24; - val |= (unsigned long) pVTOC[0x39 + track*4] << 16; - val |= (unsigned long) pVTOC[0x3a + track*4] << 8; - val |= (unsigned long) pVTOC[0x3b + track*4]; + uint32_t val; + val = (uint32_t) pVTOC[0x38 + track*4] << 24; + val |= (uint32_t) pVTOC[0x39 + track*4] << 16; + val |= (uint32_t) pVTOC[0x3a + track*4] << 8; + val |= (uint32_t) pVTOC[0x3b + track*4]; return val; } @@ -497,11 +484,10 @@ DiskFSDOS33::GetVTOCEntry(const unsigned char* pVTOC, long track) const * * Only touches the in-memory copy. */ -DIError -DiskFSDOS33::AllocSector(TrackSector* pTS) +DIError DiskFSDOS33::AllocSector(TrackSector* pTS) { - unsigned long val; - unsigned long mask; + uint32_t val; + uint32_t mask; long track, numSectPerTrack; /* we could compute "mask", but it's faster and easier to do this */ @@ -567,7 +553,7 @@ DiskFSDOS33::AllocSector(TrackSector* pTS) /* * Mostly for fun, update the VTOC allocation thingy. */ - fVTOC[0x30] = (unsigned char) track; // last track where alloc happened + fVTOC[0x30] = (uint8_t) track; // last track where alloc happened if (track < kVTOCTrack) fVTOC[0x31] = 0xff; // descending else @@ -584,8 +570,7 @@ DiskFSDOS33::AllocSector(TrackSector* pTS) * * If "withDOS" is set, mark the first 3 tracks as in-use. */ -DIError -DiskFSDOS33::CreateEmptyBlockMap(bool withDOS) +DIError DiskFSDOS33::CreateEmptyBlockMap(bool withDOS) { DIError dierr; long track, sector, maxTrack; @@ -627,20 +612,19 @@ DiskFSDOS33::CreateEmptyBlockMap(bool withDOS) * * Returns "true" if it's in use, "false" otherwise. */ -bool -DiskFSDOS33::GetSectorUseEntry(long track, int sector) const +bool DiskFSDOS33::GetSectorUseEntry(long track, int sector) const { assert(fVTOCLoaded); assert(track >= 0 && track < fpImg->GetNumTracks()); assert(sector >= 0 && sector < fpImg->GetNumSectPerTrack()); - unsigned long val, mask; + uint32_t val, mask; val = GetVTOCEntry(fVTOC, track); - //val = (unsigned long) fVTOC[0x38 + track*4] << 24; - //val |= (unsigned long) fVTOC[0x39 + track*4] << 16; - //val |= (unsigned long) fVTOC[0x3a + track*4] << 8; - //val |= (unsigned long) fVTOC[0x3b + track*4]; + //val = (uint32_t) fVTOC[0x38 + track*4] << 24; + //val |= (uint32_t) fVTOC[0x39 + track*4] << 16; + //val |= (uint32_t) fVTOC[0x3a + track*4] << 8; + //val |= (uint32_t) fVTOC[0x3b + track*4]; /* * The highest-numbered sector is now in the high bit. If this is a @@ -655,14 +639,13 @@ DiskFSDOS33::GetSectorUseEntry(long track, int sector) const /* * Change the state of an entry in the VTOC sector use map. */ -void -DiskFSDOS33::SetSectorUseEntry(long track, int sector, bool inUse) +void DiskFSDOS33::SetSectorUseEntry(long track, int sector, bool inUse) { assert(fVTOCLoaded); assert(track >= 0 && track < fpImg->GetNumTracks()); assert(sector >= 0 && sector < fpImg->GetNumSectPerTrack()); - unsigned long val, mask; + uint32_t val, mask; val = GetVTOCEntry(fVTOC, track); @@ -673,18 +656,17 @@ DiskFSDOS33::SetSectorUseEntry(long track, int sector, bool inUse) else val |= mask; - fVTOC[0x38 + track*4] = (unsigned char) (val >> 24); - fVTOC[0x39 + track*4] = (unsigned char) (val >> 16); - fVTOC[0x3a + track*4] = (unsigned char) (val >> 8); - fVTOC[0x3b + track*4] = (unsigned char) val; + fVTOC[0x38 + track*4] = (uint8_t) (val >> 24); + fVTOC[0x39 + track*4] = (uint8_t) (val >> 16); + fVTOC[0x3a + track*4] = (uint8_t) (val >> 8); + fVTOC[0x3b + track*4] = (uint8_t) val; } /* * Get the amount of free space remaining. */ -DIError -DiskFSDOS33::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, +DIError DiskFSDOS33::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, int* pUnitSize) const { DIError dierr; @@ -720,8 +702,7 @@ DiskFSDOS33::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, * disks had DOS removed to add space, un-set the last few sectors of track 2 * that weren't actually used by DOS, or did some other funky thing. */ -void -DiskFSDOS33::FixVolumeUsageMap(void) +void DiskFSDOS33::FixVolumeUsageMap(void) { VolumeUsage::ChunkState cstate; int track, sector; @@ -749,11 +730,10 @@ DiskFSDOS33::FixVolumeUsageMap(void) * * Fills out "fCatalogSectors" as it works. */ -DIError -DiskFSDOS33::ReadCatalog(void) +DIError DiskFSDOS33::ReadCatalog(void) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int catTrack, catSect; int iterations; @@ -821,12 +801,11 @@ bail: * Pass in the track, sector, and the contents of that track and sector. * (We only use "catTrack" and "catSect" to fill out some fields.) */ -DIError -DiskFSDOS33::ProcessCatalogSector(int catTrack, int catSect, - const unsigned char* sctBuf) +DIError DiskFSDOS33::ProcessCatalogSector(int catTrack, int catSect, + const uint8_t* sctBuf) { A2FileDOS* pFile; - const unsigned char* pEntry; + const uint8_t* pEntry; int i; pEntry = &sctBuf[kCatalogEntryOffset]; @@ -862,7 +841,7 @@ DiskFSDOS33::ProcessCatalogSector(int catTrack, int catSect, pFile->FixFilename(); pFile->fLengthInSectors = pEntry[0x21]; - pFile->fLengthInSectors |= (unsigned short) pEntry[0x22] << 8; + pFile->fLengthInSectors |= (uint16_t) pEntry[0x22] << 8; pFile->fCatTS.track = catTrack; pFile->fCatTS.sector = catSect; @@ -888,8 +867,7 @@ DiskFSDOS33::ProcessCatalogSector(int catTrack, int catSect, * * Returns "true" if disk appears to be perfect, "false" otherwise. */ -bool -DiskFSDOS33::CheckDiskIsGood(void) +bool DiskFSDOS33::CheckDiskIsGood(void) { DIError dierr; const DiskImg* pDiskImg = GetDiskImg(); @@ -994,8 +972,7 @@ bail: * Run through our list of files, computing the lengths and marking file * usage in the VolumeUsage object. */ -DIError -DiskFSDOS33::GetFileLengths(void) +DIError DiskFSDOS33::GetFileLengths(void) { A2FileDOS* pFile; TrackSector* tsList = NULL; @@ -1076,12 +1053,11 @@ DiskFSDOS33::GetFileLengths(void) * pFile->fSparseLength * pFile->fDataOffset */ -DIError -DiskFSDOS33::ComputeLength(A2FileDOS* pFile, const TrackSector* tsList, +DIError DiskFSDOS33::ComputeLength(A2FileDOS* pFile, const TrackSector* tsList, int tsCount) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; assert(pFile != NULL); assert(tsList != NULL); @@ -1110,13 +1086,13 @@ DiskFSDOS33::ComputeLength(A2FileDOS* pFile, const TrackSector* tsList, if (pFile->fFileType == A2FileDOS::kTypeBinary) { pFile->fAuxType = - sctBuf[0x00] | (unsigned short) sctBuf[0x01] << 8; + sctBuf[0x00] | (uint16_t) sctBuf[0x01] << 8; pFile->fLength = - sctBuf[0x02] | (unsigned short) sctBuf[0x03] << 8; + sctBuf[0x02] | (uint16_t) sctBuf[0x03] << 8; pFile->fDataOffset = 4; // take the above into account } else { pFile->fLength = - sctBuf[0x00] | (unsigned short) sctBuf[0x01] << 8; + sctBuf[0x00] | (uint16_t) sctBuf[0x01] << 8; pFile->fDataOffset = 2; // take the above into account } @@ -1208,11 +1184,10 @@ bail: * the body of the file. They're valid in the middle for random-access * text files. */ -DIError -DiskFSDOS33::TrimLastSectorUp(A2FileDOS* pFile, TrackSector lastTS) +DIError DiskFSDOS33::TrimLastSectorUp(A2FileDOS* pFile, TrackSector lastTS) { DIError dierr; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int i; if (lastTS.track == 0) { @@ -1242,8 +1217,7 @@ bail: * Given lists of tracks and sector for data and TS index sectors, set the * entries in the volume usage map. */ -void -DiskFSDOS33::MarkFileUsage(A2FileDOS* pFile, TrackSector* tsList, int tsCount, +void DiskFSDOS33::MarkFileUsage(A2FileDOS* pFile, TrackSector* tsList, int tsCount, TrackSector* indexList, int indexCount) { int i; @@ -1283,11 +1257,11 @@ DiskFSDOS33::MarkFileUsage(A2FileDOS* pFile, TrackSector* tsList, int tsCount, * worthwhile given the otherwise flaky nature of DDD storage. */ DIError -DiskFSDOS33::TrimLastSectorDown(A2FileDOS* pFile, unsigned short* tsBuf, +DiskFSDOS33::TrimLastSectorDown(A2FileDOS* pFile, uint16_t* tsBuf, int maxZeroCount) { DIError dierr; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int i; //LOGI(" DOS reading LAST file sector"); @@ -1328,8 +1302,7 @@ bail: * * We modify the first "len" bytes of "buf" in place. */ -/*static*/ void -DiskFSDOS33::LowerASCII(unsigned char* buf, long len) +/*static*/ void DiskFSDOS33::LowerASCII(uint8_t* buf, long len) { while (len--) { if (*buf & 0x80) { @@ -1358,8 +1331,7 @@ DiskFSDOS33::LowerASCII(unsigned char* buf, long len) * "invalid" character is a trailing space. Because we're using C-style * strings, we implicitly ban the use of '\0' in the name. */ -/*static*/ bool -DiskFSDOS33::IsValidFileName(const char* name) +/*static*/ bool DiskFSDOS33::IsValidFileName(const char* name) { bool nonSpace = false; int len = 0; @@ -1387,8 +1359,7 @@ DiskFSDOS33::IsValidFileName(const char* name) /* * Determine whether "name" is a valid volume number. */ -/*static*/ bool -DiskFSDOS33::IsValidVolumeName(const char* name) +/*static*/ bool DiskFSDOS33::IsValidVolumeName(const char* name) { long val; char* endp; @@ -1418,11 +1389,10 @@ DiskFSDOS33::IsValidVolumeName(const char* name) * some other path for specifying "add DOS image", I continue to use the * defined ways of setting the volume number and abuse "volName" slightly. */ -DIError -DiskFSDOS33::Format(DiskImg* pDiskImg, const char* volName) +DIError DiskFSDOS33::Format(DiskImg* pDiskImg, const char* volName) { DIError dierr = kDIErrNone; - unsigned char sctBuf[256]; + uint8_t sctBuf[256]; bool addDOS = false; if (pDiskImg->GetNumTracks() < kMinTracks || @@ -1493,11 +1463,11 @@ DiskFSDOS33::Format(DiskImg* pDiskImg, const char* volName) if (fpImg->GetDOSVolumeNum() == DiskImg::kVolumeNumNotSet) fVTOC[0x06] = kDefaultVolumeNum; // VTOC volume number else - fVTOC[0x06] = (unsigned char) fpImg->GetDOSVolumeNum(); + fVTOC[0x06] = (uint8_t) fpImg->GetDOSVolumeNum(); fVTOC[0x27] = 122; // max T/S pairs fVTOC[0x30] = kVTOCTrack+1; // last alloc fVTOC[0x31] = 1; // ascending - fVTOC[0x34] = (unsigned char)fpImg->GetNumTracks(); // #of tracks + fVTOC[0x34] = (uint8_t)fpImg->GetNumTracks(); // #of tracks fVTOC[0x35] = fpImg->GetNumSectPerTrack(); // #of sectors fVTOC[0x36] = 0x00; // bytes/sector (lo) fVTOC[0x37] = 0x01; // bytes/sector (hi) @@ -1554,12 +1524,11 @@ bail: * out which version of DOS to write. This probably ought to be an enum so * we can specify various versions of DOS. */ -DIError -DiskFSDOS33::WriteDOSTracks(int sectPerTrack) +DIError DiskFSDOS33::WriteDOSTracks(int sectPerTrack) { DIError dierr = kDIErrNone; long track, sector; - const unsigned char* buf = gDOS33Tracks; + const uint8_t* buf = gDOS33Tracks; if (sectPerTrack == 13) { LOGI(" DOS33 writing DOS 3.3 tracks"); @@ -1604,8 +1573,7 @@ bail: * "*pNormalizedBufLen" is used to pass in the length of the buffer and * pass out the length of the string (should the buffer prove inadequate). */ -DIError -DiskFSDOS33::NormalizePath(const char* path, char fssep, +DIError DiskFSDOS33::NormalizePath(const char* path, char fssep, char* normalizedBuf, int* pNormalizedBufLen) { DIError dierr = kDIErrNone; @@ -1630,8 +1598,7 @@ DiskFSDOS33::NormalizePath(const char* path, char fssep, * * "outBuf" must be able to hold kMaxFileName+1 characters. */ -void -DiskFSDOS33::DoNormalizePath(const char* name, char fssep, char* outBuf) +void DiskFSDOS33::DoNormalizePath(const char* name, char fssep, char* outBuf) { char* outp = outBuf; const char* cp; @@ -1684,8 +1651,7 @@ DiskFSDOS33::DoNormalizePath(const char* name, char fssep, char* outBuf) * sector of the file now, and modifying the Write() function to understand * that the first block is already there. Need to do that someday.) */ -DIError -DiskFSDOS33::CreateFile(const CreateParms* pParms, A2File** ppNewFile) +DIError DiskFSDOS33::CreateFile(const CreateParms* pParms, A2File** ppNewFile) { DIError dierr = kDIErrNone; const bool createUnique = (GetParameter(kParm_CreateUnique) != 0); @@ -1730,7 +1696,7 @@ DiskFSDOS33::CreateFile(const CreateParms* pParms, A2File** ppNewFile) /* * Allocate a directory entry and T/S list. */ - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; TrackSector catSect; TrackSector tsSect; int catEntry; @@ -1764,7 +1730,7 @@ DiskFSDOS33::CreateFile(const CreateParms* pParms, A2File** ppNewFile) /* create the new dir entry at the specified location */ CreateDirEntry(sctBuf, catEntry, normalName, &tsSect, - (unsigned char) fileType, pParms->access); + (uint8_t) fileType, pParms->access); /* * Flush everything to disk. @@ -1796,7 +1762,7 @@ DiskFSDOS33::CreateFile(const CreateParms* pParms, A2File** ppNewFile) pNewFile->fCatTS.sector = catSect.sector; pNewFile->fCatEntryNum = catEntry; - pNewFile->fAuxType = (unsigned short) pParms->auxType; + pNewFile->fAuxType = (uint16_t) pParms->auxType; pNewFile->fDataOffset = 0; switch (pNewFile->fFileType) { case A2FileDOS::kTypeInteger: @@ -1843,8 +1809,7 @@ bail: * * Returns an error on failure, which should be impossible. */ -DIError -DiskFSDOS33::MakeFileNameUnique(char* fileName) +DIError DiskFSDOS33::MakeFileNameUnique(char* fileName) { assert(fileName != NULL); assert(strlen(fileName) <= A2FileDOS::kMaxFileName); @@ -1911,12 +1876,11 @@ DiskFSDOS33::MakeFileNameUnique(char* fileName) * * The contents of the catalog sector will be in "sctBuf". */ -DIError -DiskFSDOS33::GetFreeCatalogEntry(TrackSector* pCatSect, int* pCatEntry, - unsigned char* sctBuf, A2FileDOS** ppPrevEntry) +DIError DiskFSDOS33::GetFreeCatalogEntry(TrackSector* pCatSect, int* pCatEntry, + uint8_t* sctBuf, A2FileDOS** ppPrevEntry) { DIError dierr = kDIErrNone; - unsigned char* pEntry; + uint8_t* pEntry; int sct, ent; bool found = false; @@ -1998,13 +1962,12 @@ bail: /* * Fill out the catalog entry in the location specified. */ -void -DiskFSDOS33::CreateDirEntry(unsigned char* sctBuf, int catEntry, - const char* fileName, TrackSector* pTSSect, unsigned char fileType, +void DiskFSDOS33::CreateDirEntry(uint8_t* sctBuf, int catEntry, + const char* fileName, TrackSector* pTSSect, uint8_t fileType, int access) { char highName[A2FileDOS::kMaxFileName+1]; - unsigned char* pEntry; + uint8_t* pEntry; pEntry = GetCatalogEntryPtr(sctBuf, catEntry); if (pEntry[0x00] != 0x00 && pEntry[0x00] != kEntryDeleted) { @@ -2019,7 +1982,7 @@ DiskFSDOS33::CreateDirEntry(unsigned char* sctBuf, int catEntry, pEntry[0x01] = pTSSect->sector; pEntry[0x02] = fileType; if ((access & A2FileProDOS::kAccessWrite) == 0) - pEntry[0x02] |= (unsigned char) A2FileDOS::kTypeLocked; + pEntry[0x02] |= (uint8_t) A2FileDOS::kTypeLocked; memcpy(&pEntry[0x03], highName, A2FileDOS::kMaxFileName); PutShortLE(&pEntry[0x21], 1); // assume file is 1 sector long } @@ -2030,16 +1993,15 @@ DiskFSDOS33::CreateDirEntry(unsigned char* sctBuf, int catEntry, * This entails freeing up the allocated sectors and changing a byte in * the directory entry. We then remove it from the DiskFS file list. */ -DIError -DiskFSDOS33::DeleteFile(A2File* pGenericFile) +DIError DiskFSDOS33::DeleteFile(A2File* pGenericFile) { DIError dierr = kDIErrNone; A2FileDOS* pFile = (A2FileDOS*) pGenericFile; TrackSector* tsList = NULL; TrackSector* indexList = NULL; int tsCount, indexCount; - unsigned char sctBuf[kSctSize]; - unsigned char* pEntry; + uint8_t sctBuf[kSctSize]; + uint8_t* pEntry; if (pGenericFile == NULL) { assert(false); @@ -2110,8 +2072,7 @@ bail: /* * Mark all of the track/sector entries in "pList" as free. */ -void -DiskFSDOS33::FreeTrackSectors(TrackSector* pList, int count) +void DiskFSDOS33::FreeTrackSectors(TrackSector* pList, int count) { VolumeUsage::ChunkState cstate; int i; @@ -2140,15 +2101,14 @@ DiskFSDOS33::FreeTrackSectors(TrackSector* pList, int count) * * "newName" must already be normalized. */ -DIError -DiskFSDOS33::RenameFile(A2File* pGenericFile, const char* newName) +DIError DiskFSDOS33::RenameFile(A2File* pGenericFile, const char* newName) { DIError dierr = kDIErrNone; A2FileDOS* pFile = (A2FileDOS*) pGenericFile; char normalName[A2FileDOS::kMaxFileName+1]; char dosName[A2FileDOS::kMaxFileName+1]; - unsigned char sctBuf[kSctSize]; - unsigned char* pEntry; + uint8_t sctBuf[kSctSize]; + uint8_t* pEntry; if (pFile == NULL || newName == NULL) return kDIErrInvalidArg; @@ -2185,7 +2145,7 @@ DiskFSDOS33::RenameFile(A2File* pGenericFile, const char* newName) */ char storedName[A2FileDOS::kMaxFileName+1]; strcpy(storedName, dosName); - LowerASCII((unsigned char*)storedName, A2FileDOS::kMaxFileName); + LowerASCII((uint8_t*)storedName, A2FileDOS::kMaxFileName); A2FileDOS::TrimTrailingSpaces(storedName); strcpy(pFile->fFileName, storedName); @@ -2205,8 +2165,7 @@ bail: * * Changing the aux type is only allowed for BIN files. */ -DIError -DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, +DIError DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, long accessFlags) { DIError dierr = kDIErrNone; @@ -2249,8 +2208,8 @@ DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, */ if (nowLocked != pFile->fLocked || typeChanged) { A2FileDOS::FileType newFileType; - unsigned char sctBuf[kSctSize]; - unsigned char* pEntry; + uint8_t sctBuf[kSctSize]; + uint8_t* pEntry; LOGI("Updating file '%s'", pFile->GetPathName()); @@ -2262,7 +2221,7 @@ DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, pEntry = GetCatalogEntryPtr(sctBuf, pFile->fCatEntryNum); newFileType = A2FileDOS::ConvertFileType(fileType, 0); - pEntry[0x02] = (unsigned char) newFileType; + pEntry[0x02] = (uint8_t) newFileType; if (nowLocked) pEntry[0x02] |= 0x80; @@ -2297,8 +2256,8 @@ DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, * On top of all this, if we changed the file type at all then we need to * re-scan the file length and "data offset" value. */ - unsigned short newAuxType; - newAuxType = (unsigned short) auxType; + uint16_t newAuxType; + newAuxType = (uint16_t) auxType; dierr = pFile->LoadTSList(&tsList, &tsCount); if (dierr != kDIErrNone) { @@ -2307,7 +2266,7 @@ DiskFSDOS33::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, } if (fileType == 0x06 && tsCount > 0) { - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; dierr = fpImg->ReadTrackSector(tsList[0].track, tsList[0].sector, sctBuf); @@ -2366,11 +2325,10 @@ bail: * We can't change the 2MG header, and we can't change the values embedded * in the sector headers, so all we do is change the VTOC entry. */ -DIError -DiskFSDOS33::RenameVolume(const char* newName) +DIError DiskFSDOS33::RenameVolume(const char* newName) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; long newNumber; char* endp; @@ -2386,7 +2344,7 @@ DiskFSDOS33::RenameVolume(const char* newName) if (dierr != kDIErrNone) goto bail; - sctBuf[0x06] = (unsigned char) newNumber; + sctBuf[0x06] = (uint8_t) newNumber; dierr = fpImg->WriteTrackSector(kVTOCTrack, kVTOCSector, sctBuf); if (dierr != kDIErrNone) @@ -2453,8 +2411,7 @@ A2FileDOS::~A2FileDOS(void) * because I can't find any information on the REL format. However, Copy ][+ * does convert to REL, and the Binary ][ standard says I should as well. */ -long -A2FileDOS::GetFileType(void) const +long A2FileDOS::GetFileType(void) const { long retval; @@ -2491,8 +2448,8 @@ A2FileDOS::GetFileType(void) const * be hoped. We can make life a little less confusing for the caller by * using type 'S' for any unknown type. */ -/*static*/ A2FileDOS::FileType -A2FileDOS::ConvertFileType(long prodosType, di_off_t fileLen) +/*static*/ A2FileDOS::FileType A2FileDOS::ConvertFileType(long prodosType, + di_off_t fileLen) { const long kMaxBinary = 65535; FileType newType; @@ -2524,8 +2481,7 @@ A2FileDOS::ConvertFileType(long prodosType, di_off_t fileLen) /* * Determine whether the specified type has a valid DOS mapping. */ -/*static*/ bool -A2FileDOS::IsValidType(long prodosType) +/*static*/ bool A2FileDOS::IsValidType(long prodosType) { switch (prodosType) { case 0xb0: // SRC @@ -2546,8 +2502,7 @@ A2FileDOS::IsValidType(long prodosType) /* * Match the ProDOS equivalents of "locked" and "unlocked". */ -long -A2FileDOS::GetAccess(void) const +long A2FileDOS::GetAccess(void) const { if (fLocked) return DiskFS::kFileAccessLocked; // 0x01 read @@ -2559,10 +2514,9 @@ A2FileDOS::GetAccess(void) const * "Fix" a DOS3.3 filename. Convert DOS-ASCII to normal ASCII, and strip * trailing spaces. */ -void -A2FileDOS::FixFilename(void) +void A2FileDOS::FixFilename(void) { - DiskFSDOS33::LowerASCII((unsigned char*)fFileName, kMaxFileName); + DiskFSDOS33::LowerASCII((uint8_t*)fFileName, kMaxFileName); TrimTrailingSpaces(fFileName); } @@ -2571,8 +2525,7 @@ A2FileDOS::FixFilename(void) * * Assumes the filename has already been converted to low ASCII. */ -/*static*/ void -A2FileDOS::TrimTrailingSpaces(char* filename) +/*static*/ void A2FileDOS::TrimTrailingSpaces(char* filename) { char* lastspc = filename + strlen(filename); @@ -2593,8 +2546,7 @@ A2FileDOS::TrimTrailingSpaces(char* filename) * * "buf" must be able to hold kMaxFileName+1 chars. */ -/*static*/ void -A2FileDOS::MakeDOSName(char* buf, const char* name) +/*static*/ void A2FileDOS::MakeDOSName(char* buf, const char* name) { for (int i = 0; i < kMaxFileName; i++) { if (*name == '\0') @@ -2609,8 +2561,7 @@ A2FileDOS::MakeDOSName(char* buf, const char* name) /* * Set up state for this file. */ -DIError -A2FileDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { DIError dierr = kDIErrNone; @@ -2656,8 +2607,7 @@ bail: /* * Dump the contents of an A2FileDOS. */ -void -A2FileDOS::Dump(void) const +void A2FileDOS::Dump(void) const { LOGI("A2FileDOS '%s'", fFileName); LOGI(" TS T=%-2d S=%-2d", fTSListTrack, fTSListSector); @@ -2690,8 +2640,7 @@ A2FileDOS::Dump(void) const * impossible. Currently this isn't a problem, but for e.g. T/S lists * with garbage at the end would could deal with the problem more generally. */ -DIError -A2FileDOS::LoadTSList(TrackSector** pTSList, int* pTSCount, +DIError A2FileDOS::LoadTSList(TrackSector** pTSList, int* pTSCount, TrackSector** pIndexList, int* pIndexCount) { DIError dierr = kDIErrNone; @@ -2702,7 +2651,7 @@ A2FileDOS::LoadTSList(TrackSector** pTSList, int* pTSCount, TrackSector* indexList = NULL; int tsCount, tsAlloc; int indexCount, indexAlloc; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int track, sector, iterations; LOGI("--- DOS loading T/S list for '%s'", GetPathName()); @@ -2742,7 +2691,7 @@ A2FileDOS::LoadTSList(TrackSector** pTSList, int* pTSCount, */ iterations = 0; do { - unsigned short sectorOffset; + uint16_t sectorOffset; int lastNonZero; /* @@ -2875,13 +2824,12 @@ bail: * entries have been copied. If it looks to be partially valid, only the * valid parts are copied out, with the rest zeroed. */ -DIError -A2FileDOS::ExtractTSPairs(const unsigned char* sctBuf, TrackSector* tsList, +DIError A2FileDOS::ExtractTSPairs(const uint8_t* sctBuf, TrackSector* tsList, int* pLastNonZero) { DIError dierr = kDIErrNone; const DiskImg* pDiskImg = fpDiskFS->GetDiskImg(); - const unsigned char* ptr; + const uint8_t* ptr; int i, track, sector; *pLastNonZero = -1; @@ -2935,8 +2883,7 @@ bail: * Files read back as they would from ProDOS, i.e. if you read a binary * file you won't see the 4 bytes of length and address. */ -DIError -A2FDDOS::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDDOS::Read(void* buf, size_t len, size_t* pActual) { LOGI(" DOS reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -2958,7 +2905,7 @@ A2FDDOS::Read(void* buf, size_t len, size_t* pActual) long incrLen = len; DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; di_off_t actualOffset = fOffset + pFile->fDataOffset; // adjust for embedded len int tsIndex = (int) (actualOffset / kSctSize); int bufOffset = (int) (actualOffset % kSctSize); // (& 0xff) @@ -3023,13 +2970,12 @@ A2FDDOS::Read(void* buf, size_t len, size_t* pActual) * * Modifies fOpenEOF, fOpenSectorsUsed, and sets fModified. */ -DIError -A2FDDOS::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDDOS::Write(const void* buf, size_t len, size_t* pActual) { DIError dierr = kDIErrNone; A2FileDOS* pFile = (A2FileDOS*) fpFile; DiskFSDOS33* pDiskFS = (DiskFSDOS33*) fpFile->GetDiskFS(); - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; LOGI(" DOS Write len=%u %s", len, pFile->GetPathName()); @@ -3117,10 +3063,10 @@ A2FDDOS::Write(const void* buf, size_t len, size_t* pActual) /* * Write the sectors into the T/S list. */ - const unsigned char* curPtr; + const uint8_t* curPtr; int sectorIdx; - curPtr = (const unsigned char*) buf; + curPtr = (const uint8_t*) buf; sectorIdx = 0; if (pFile->fDataOffset > 0) { @@ -3229,8 +3175,7 @@ bail: /* * Seek to the specified offset. */ -DIError -A2FDDOS::Seek(di_off_t offset, DIWhence whence) +DIError A2FDDOS::Seek(di_off_t offset, DIWhence whence) { //di_off_t fileLength = fpFile->GetDataLength(); @@ -3265,8 +3210,7 @@ A2FDDOS::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDDOS::Tell(void) +di_off_t A2FDDOS::Tell(void) { return fOffset; } @@ -3285,16 +3229,15 @@ A2FDDOS::Tell(void) * Most applications don't check the value of "Close", or call it from a * destructor, so we call CloseDescr whether we succeed or not. */ -DIError -A2FDDOS::Close(void) +DIError A2FDDOS::Close(void) { DIError dierr = kDIErrNone; if (fModified) { DiskFSDOS33* pDiskFS = (DiskFSDOS33*) fpFile->GetDiskFS(); A2FileDOS* pFile = (A2FileDOS*) fpFile; - unsigned char sctBuf[kSctSize]; - unsigned char* pEntry; + uint8_t sctBuf[kSctSize]; + uint8_t* pEntry; /* * Fill in the length and address, if needed for this type of file. @@ -3307,30 +3250,30 @@ A2FDDOS::Close(void) assert(pFile->fDataOffset > 0); //assert(fOpenEOF < 65536); if (fOpenEOF > 65535) { - LOGI("WARNING: DOS Close trimming A/I/B file from %ld to 65535", + LOGW("WARNING: DOS Close trimming A/I/B file from %ld to 65535", (long) fOpenEOF); fOpenEOF = 65535; } dierr = pDiskFS->GetDiskImg()->ReadTrackSector(fTSList[0].track, fTSList[0].sector, sctBuf); if (dierr != kDIErrNone) { - LOGI("DOS Close: unable to get first sector of file"); + LOGW("DOS Close: unable to get first sector of file"); goto bail; } if (pFile->fFileType == A2FileDOS::kTypeInteger || pFile->fFileType == A2FileDOS::kTypeApplesoft) { - PutShortLE(&sctBuf[0x00], (unsigned short) fOpenEOF); + PutShortLE(&sctBuf[0x00], (uint16_t) fOpenEOF); } else { PutShortLE(&sctBuf[0x00], pFile->fAuxType); - PutShortLE(&sctBuf[0x02], (unsigned short) fOpenEOF); + PutShortLE(&sctBuf[0x02], (uint16_t) fOpenEOF); } dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fTSList[0].track, fTSList[0].sector, sctBuf); if (dierr != kDIErrNone) { - LOGI("DOS Close: unable to write first sector of file"); + LOGW("DOS Close: unable to write first sector of file"); goto bail; } } else if (pFile->fFileType == A2FileDOS::kTypeText) { @@ -3358,7 +3301,7 @@ A2FDDOS::Close(void) */ pFile->fLength = fOpenEOF; pFile->fSparseLength = pFile->fLength; - pFile->fLengthInSectors = (unsigned short) fOpenSectorsUsed; + pFile->fLengthInSectors = (uint16_t) fOpenSectorsUsed; /* * Update the sector count in the directory entry. @@ -3384,13 +3327,12 @@ bail: /* * Return the #of sectors/blocks in the file. */ -long -A2FDDOS::GetSectorCount(void) const +long A2FDDOS::GetSectorCount(void) const { return fTSCount; } -long -A2FDDOS::GetBlockCount(void) const + +long A2FDDOS::GetBlockCount(void) const { return (fTSCount+1)/2; } @@ -3400,8 +3342,7 @@ A2FDDOS::GetBlockCount(void) const * * Returns (0,0) for a sparse sector. */ -DIError -A2FDDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { if (sectorIdx < 0 || sectorIdx >= fTSCount) return kDIErrInvalidIndex; @@ -3415,8 +3356,7 @@ A2FDDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const * in 512-byte blocks, we're reduced to finding storage at (tsIndex*2) and * converting it to a block number. */ -DIError -A2FDDOS::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDDOS::GetStorage(long blockIdx, long* pBlock) const { long sectorIdx = blockIdx * 2; if (sectorIdx < 0 || sectorIdx >= fTSCount) @@ -3433,8 +3373,7 @@ A2FDDOS::GetStorage(long blockIdx, long* pBlock) const /* * Dump the T/S list for an open file. */ -void -A2FDDOS::DumpTSList(void) const +void A2FDDOS::DumpTSList(void) const { //A2FileDOS* pFile = (A2FileDOS*) fpFile; LOGI(" DOS T/S list for '%s' (count=%d)", diff --git a/diskimg/DOSImage.cpp b/diskimg/DOSImage.cpp index cfb158b..73c2962 100644 --- a/diskimg/DOSImage.cpp +++ b/diskimg/DOSImage.cpp @@ -18,7 +18,7 @@ namespace DiskImgLib { * Obtained from tracks 0-2 of a newly-formatted disk created * by "INIT HELLO" after booting the DOS 3.3 system master. */ -/*static*/ const unsigned char DiskFSDOS33::gDOS33Tracks[16 * 3 * 256] = { +/*static*/ const uint8_t DiskFSDOS33::gDOS33Tracks[16 * 3 * 256] = { 0x01, 0xa5, 0x27, 0xc9, 0x09, 0xd0, 0x18, 0xa5, 0x2b, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x3f, 0xa9, 0x5c, 0x85, 0x3e, 0x18, 0xad, 0xfe, @@ -1612,7 +1612,7 @@ namespace DiskImgLib { * Obtained from the DOS 3.2.1 system master. The last two sectors of * track 2 were unreadable, and have been zeroed out here. */ -/*static*/ const unsigned char DiskFSDOS33::gDOS32Tracks[13 * 3 * 256] = { +/*static*/ const uint8_t DiskFSDOS33::gDOS32Tracks[13 * 3 * 256] = { 0xf0, 0x4a, 0x99, 0xff, 0xff, 0x03, 0x3c, 0xad, 0xff, 0xff, 0xff, 0x26, 0xb3, 0xff, 0xff, 0x4d, 0x4a, 0x10, 0xff, 0xff, 0x3d, 0x4a, 0xca, 0xff, @@ -2901,5 +2901,4 @@ namespace DiskImgLib { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - -}; // namespace DiskImgLib +} // namespace DiskImgLib diff --git a/diskimg/DiskFS.cpp b/diskimg/DiskFS.cpp index 3a13da2..239a631 100644 --- a/diskimg/DiskFS.cpp +++ b/diskimg/DiskFS.cpp @@ -21,8 +21,7 @@ * * Refuse to "improve" the quality level of a file. */ -void -A2File::SetQuality(FileQuality quality) +void A2File::SetQuality(FileQuality quality) { if (quality == kQualityGood && (fFileQuality == kQualitySuspicious || fFileQuality == kQualityDamaged)) @@ -41,8 +40,7 @@ A2File::SetQuality(FileQuality quality) /* * Reset the quality level after making repairs. */ -void -A2File::ResetQuality(void) +void A2File::ResetQuality(void) { fFileQuality = kQualityGood; } @@ -59,8 +57,7 @@ A2File::ResetQuality(void) * so that it can be sure there are no DiskFS objects left dangling when the * DiskImg is deleted. */ -void -DiskFS::SetDiskImg(DiskImg* pImg) +void DiskFS::SetDiskImg(DiskImg* pImg) { if (pImg == NULL && fpImg == NULL) { LOGI("SetDiskImg: no-op (both NULL)"); @@ -80,8 +77,7 @@ DiskFS::SetDiskImg(DiskImg* pImg) /* * Flush changes to disk. */ -DIError -DiskFS::Flush(DiskImg::FlushMode mode) +DIError DiskFS::Flush(DiskImg::FlushMode mode) { SubVolume* pSubVol = GetNextSubVolume(NULL); DIError dierr; @@ -106,8 +102,7 @@ DiskFS::Flush(DiskImg::FlushMode mode) /* * Set the "read only" flag on our DiskImg and those of our sub-volumes. */ -void -DiskFS::SetAllReadOnly(bool val) +void DiskFS::SetAllReadOnly(bool val) { SubVolume* pSubVol = GetNextSubVolume(NULL); @@ -161,8 +156,7 @@ DiskFS::SetAllReadOnly(bool val) /* * Add a file to the end of our list. */ -void -DiskFS::AddFileToList(A2File* pFile) +void DiskFS::AddFileToList(A2File* pFile) { assert(pFile->GetNext() == NULL); @@ -193,8 +187,7 @@ DiskFS::AddFileToList(A2File* pFile) * but odds are that there isn't a "next" entry if we're busily creating * files.) */ -void -DiskFS::InsertFileInList(A2File* pFile, A2File* pPrev) +void DiskFS::InsertFileInList(A2File* pFile, A2File* pPrev) { assert(pFile->GetNext() == NULL); @@ -228,8 +221,7 @@ DiskFS::InsertFileInList(A2File* pFile, A2File* pPrev) * * The return value is the very last entry in the subdir. */ -A2File* -DiskFS::SkipSubdir(A2File* pSubdir) +A2File* DiskFS::SkipSubdir(A2File* pSubdir) { if (pSubdir->GetNext() == NULL) return pSubdir; // end of list reached -- subdir is empty @@ -262,8 +254,7 @@ DiskFS::SkipSubdir(A2File* pSubdir) * * We're currently singly-linked, making this rather expensive. */ -void -DiskFS::DeleteFileFromList(A2File* pFile) +void DiskFS::DeleteFileFromList(A2File* pFile) { if (fpA2Head == pFile) { /* delete the head of the list */ @@ -296,8 +287,7 @@ DiskFS::DeleteFileFromList(A2File* pFile) * Because we apparently can't declare an anonymous class as a friend * in MSVC++6.0, this can't be an inline function. */ -A2File* -DiskFS::GetNextFile(A2File* pFile) const +A2File* DiskFS::GetNextFile(A2File* pFile) const { if (pFile == NULL) return fpA2Head; @@ -311,8 +301,7 @@ DiskFS::GetNextFile(A2File* pFile) const * Right now the only code that calls this is the disk info panel in * CiderPress, so we don't need it to be efficient. */ -long -DiskFS::GetFileCount(void) const +long DiskFS::GetFileCount(void) const { long count = 0; @@ -328,8 +317,7 @@ DiskFS::GetFileCount(void) const /* * Delete all entries in the list. */ -void -DiskFS::DeleteFileList(void) +void DiskFS::DeleteFileList(void) { A2File* pFile; A2File* pNext; @@ -345,8 +333,7 @@ DiskFS::DeleteFileList(void) /* * Dump file list. */ -void -DiskFS::DumpFileList(void) +void DiskFS::DumpFileList(void) { A2File* pFile; @@ -367,8 +354,7 @@ DiskFS::DumpFileList(void) * e.g. by prepending the sub-volume's volume name to the filename. May * be best to let the application dig for the sub-volume. */ -A2File* -DiskFS::GetFileByName(const char* fileName, StringCompareFunc func) +A2File* DiskFS::GetFileByName(const char* fileName, StringCompareFunc func) { A2File* pFile; @@ -395,8 +381,7 @@ DiskFS::GetFileByName(const char* fileName, StringCompareFunc func) * * Note this happens AFTER the disk has been scanned. */ -void -DiskFS::AddSubVolumeToList(DiskImg* pDiskImg, DiskFS* pDiskFS) +void DiskFS::AddSubVolumeToList(DiskImg* pDiskImg, DiskFS* pDiskFS) { SubVolume* pSubVol; @@ -458,8 +443,7 @@ DiskFS::AddSubVolumeToList(DiskImg* pDiskImg, DiskFS* pDiskFS) /* * Copy parameters to a sub-volume. */ -void -DiskFS::CopyInheritables(DiskFS* pNewFS) +void DiskFS::CopyInheritables(DiskFS* pNewFS) { for (int i = 0; i < (int) NELEM(fParmTable); i++) pNewFS->fParmTable[i] = fParmTable[i]; @@ -481,8 +465,7 @@ DiskFS::CopyInheritables(DiskFS* pNewFS) * Because we apparently can't declare an anonymous class as a friend * in MSVC++6.0, this can't be an inline function. */ -DiskFS::SubVolume* -DiskFS::GetNextSubVolume(const SubVolume* pSubVol) const +DiskFS::SubVolume* DiskFS::GetNextSubVolume(const SubVolume* pSubVol) const { if (pSubVol == NULL) return fpSubVolumeHead; @@ -493,8 +476,7 @@ DiskFS::GetNextSubVolume(const SubVolume* pSubVol) const /* * Delete all entries in the list. */ -void -DiskFS::DeleteSubVolumeList(void) +void DiskFS::DeleteSubVolumeList(void) { SubVolume* pSubVol; SubVolume* pNext; @@ -511,8 +493,7 @@ DiskFS::DeleteSubVolumeList(void) /* * Get a parameter. */ -long -DiskFS::GetParameter(DiskFSParameter parm) +long DiskFS::GetParameter(DiskFSParameter parm) { assert(parm > kParmUnknown && parm < kParmMax); return fParmTable[parm]; @@ -523,8 +504,7 @@ DiskFS::GetParameter(DiskFSParameter parm) * * The setting propagates to all sub-volumes. */ -void -DiskFS::SetParameter(DiskFSParameter parm, long val) +void DiskFS::SetParameter(DiskFSParameter parm, long val) { assert(parm > kParmUnknown && parm < kParmMax); fParmTable[parm] = val; @@ -540,8 +520,7 @@ DiskFS::SetParameter(DiskFSParameter parm, long val) /* * Scan for damaged or suspicious files. */ -void -DiskFS::ScanForDamagedFiles(bool* pDamaged, bool* pSuspicious) +void DiskFS::ScanForDamagedFiles(bool* pDamaged, bool* pSuspicious) { A2File* pFile; diff --git a/diskimg/DiskImg.cpp b/diskimg/DiskImg.cpp index 3b8f2c5..3f81d89 100644 --- a/diskimg/DiskImg.cpp +++ b/diskimg/DiskImg.cpp @@ -270,8 +270,7 @@ DiskImg::~DiskImg(void) /* * Set the nibble descr pointer. */ -void -DiskImg::SetNibbleDescr(int idx) +void DiskImg::SetNibbleDescr(int idx) { assert(idx >= 0 && idx < kNibbleDescrMAX); fpNibbleDescr = &fpNibbleDescrTable[idx]; @@ -280,8 +279,7 @@ DiskImg::SetNibbleDescr(int idx) /* * Set up a custom nibble descriptor. */ -void -DiskImg::SetCustomNibbleDescr(const NibbleDescr* pDescr) +void DiskImg::SetCustomNibbleDescr(const NibbleDescr* pDescr) { if (pDescr == NULL) { fpNibbleDescr = NULL; @@ -301,8 +299,7 @@ DiskImg::SetCustomNibbleDescr(const NibbleDescr* pDescr) * For Windows, we need to handle logical/physical volumes specially. If * the filename matches the appropriate pattern, use a different GFD. */ -DIError -DiskImg::OpenImage(const char* pathName, char fssep, bool readOnly) +DIError DiskImg::OpenImage(const char* pathName, char fssep, bool readOnly) { DIError dierr = kDIErrNone; bool isWinDevice = false; @@ -393,11 +390,10 @@ DIError DiskImg::OpenImageFromBufferRW(uint8_t* buffer, long length) { * Open from a buffer, which could point to unadorned ready-to-go content * or to a preloaded image file. */ -DIError -DiskImg::OpenImageFromBuffer(uint8_t* buffer, long length, bool readOnly) +DIError DiskImg::OpenImageFromBuffer(uint8_t* buffer, long length, bool readOnly) { if (fpDataGFD != NULL) { - LOGI(" DI already open!"); + LOGW(" DI already open!"); return kDIErrAlreadyOpen; } LOGI(" DI OpenImage %08lx %ld ro=%d", (long) buffer, length, readOnly); @@ -440,13 +436,12 @@ DiskImg::OpenImageFromBuffer(uint8_t* buffer, long length, bool readOnly) * ProDOS-ordered blocks, so it works out okay, but the "linear" requirement * above goes beyond just having contiguous blocks. */ -DIError -DiskImg::OpenImage(DiskImg* pParent, long firstBlock, long numBlocks) +DIError DiskImg::OpenImage(DiskImg* pParent, long firstBlock, long numBlocks) { LOGI(" DI OpenImage parent=0x%08lx %ld %ld", (long) pParent, firstBlock, numBlocks); if (fpDataGFD != NULL) { - LOGI(" DI already open!"); + LOGI(" DW already open!"); return kDIErrAlreadyOpen; } @@ -487,14 +482,14 @@ DiskImg::OpenImage(DiskImg* pParent, long firstBlock, long numBlocks) return dierr; } -DIError -DiskImg::OpenImage(DiskImg* pParent, long firstTrack, long firstSector, + +DIError DiskImg::OpenImage(DiskImg* pParent, long firstTrack, long firstSector, long numSectors) { LOGI(" DI OpenImage parent=0x%08lx %ld %ld %ld", (long) pParent, firstTrack, firstSector, numSectors); if (fpDataGFD != NULL) { - LOGI(" DI already open!"); + LOGW(" DI already open!"); return kDIErrAlreadyOpen; } @@ -547,8 +542,7 @@ DiskImg::OpenImage(DiskImg* pParent, long firstTrack, long firstSector, /* * Enable sector pairing. Useful for OzDOS. */ -void -DiskImg::SetPairedSectors(bool enable, int idx) +void DiskImg::SetPairedSectors(bool enable, int idx) { fSectorPairing = enable; fSectorPairOffset = idx; @@ -571,8 +565,7 @@ DiskImg::SetPairedSectors(bool enable, int idx) * image creation instead of completing it. That's a higher-level decision * though. ++ATM 20040506 ] */ -DIError -DiskImg::CloseImage(void) +DIError DiskImg::CloseImage(void) { DIError dierr; @@ -580,7 +573,7 @@ DiskImg::CloseImage(void) /* check for DiskFS objects that still point to us */ if (fDiskFSRefCnt != 0) { - LOGI("ERROR: CloseImage: fDiskFSRefCnt=%d", fDiskFSRefCnt); + LOGE("ERROR: CloseImage: fDiskFSRefCnt=%d", fDiskFSRefCnt); assert(false); //DebugBreak(); } @@ -640,8 +633,7 @@ DiskImg::CloseImage(void) * changed" to "what's in the file and what's in memory differ". I want it * to be a "dirty" flag. */ -DIError -DiskImg::FlushImage(FlushMode mode) +DIError DiskImg::FlushImage(FlushMode mode) { DIError dierr = kDIErrNone; @@ -726,7 +718,6 @@ DiskImg::FlushImage(FlushMode mode) } - /* * Given the filename extension and a GFD, figure out what's inside. * @@ -773,8 +764,7 @@ DiskImg::FlushImage(FlushMode mode) * This may set fReadOnly if one of the wrappers looks okay but is reporting * a bad checksum. */ -DIError -DiskImg::AnalyzeImageFile(const char* pathName, char fssep) +DIError DiskImg::AnalyzeImageFile(const char* pathName, char fssep) { DIError dierr = kDIErrNone; FileFormat probableFormat; @@ -800,7 +790,7 @@ DiskImg::AnalyzeImageFile(const char* pathName, char fssep) fLength = -1; dierr = fpWrapperGFD->Seek(0, kSeekEnd); if (dierr != kDIErrNone) { - LOGI(" DI Couldn't seek to end of wrapperGFD"); + LOGW(" DI Couldn't seek to end of wrapperGFD"); goto bail; } fWrappedLength = fOuterLength = fpWrapperGFD->Tell(); @@ -878,7 +868,7 @@ DiskImg::AnalyzeImageFile(const char* pathName, char fssep) dierr = fpOuterWrapper->Load(fpWrapperGFD, fOuterLength, fReadOnly, &fWrappedLength, &pNewGFD); if (dierr != kDIErrNone) { - LOGI(" DI outer prep failed"); + LOGI(" DW outer prep failed"); /* extensions are "reliable", so failure is unavoidable */ goto bail; } @@ -1161,8 +1151,7 @@ bail: * fFileSysOrder is set * fpNibbleDescr will be set for nibble images */ -DIError -DiskImg::AnalyzeImage(void) +DIError DiskImg::AnalyzeImage(void) { assert(fLength >= 0); assert(fpDataGFD != NULL); @@ -1329,8 +1318,7 @@ DiskImg::AnalyzeImage(void) * * Sets fFormat, fOrder, and fFileSysOrder. */ -void -DiskImg::AnalyzeImageFS(void) +void DiskImg::AnalyzeImageFS(void) { /* * In some circumstances it would be useful to have a set describing @@ -1438,8 +1426,7 @@ DiskImg::AnalyzeImageFS(void) * structure, the "unadorned" format should be specified, and the contents * identified by the PhysicalFormat. */ -DIError -DiskImg::OverrideFormat(PhysicalFormat physical, FSFormat format, +DIError DiskImg::OverrideFormat(PhysicalFormat physical, FSFormat format, SectorOrder order) { DIError dierr = kDIErrNone; @@ -1568,8 +1555,7 @@ bail: * NOTE: this table is redundant with some knowledge embedded in the * individual "TestFS" functions. */ -DiskImg::SectorOrder -DiskImg::CalcFSSectorOrder(void) const +DiskImg::SectorOrder DiskImg::CalcFSSectorOrder(void) const { /* in the absence of information, just leave it alone */ if (fFormat == kFormatUnknown || fOrder == kSectorOrderUnknown) { @@ -1624,8 +1610,7 @@ DiskImg::CalcFSSectorOrder(void) const * Based on the disk format, figure out if we should prefer blocks or * sectors when examining disk contents. */ -bool -DiskImg::ShowAsBlocks(void) const +bool DiskImg::ShowAsBlocks(void) const { if (!fHasBlocks) return false; @@ -1678,8 +1663,7 @@ DiskImg::ShowAsBlocks(void) const * Format an image with the requested fileystem format. This only works if * the matching DiskFS supports formatting of disks. */ -DIError -DiskImg::FormatImage(FSFormat format, const char* volName) +DIError DiskImg::FormatImage(FSFormat format, const char* volName) { DIError dierr = kDIErrNone; DiskFS* pDiskFS = NULL; @@ -1724,11 +1708,10 @@ bail: * optimized path that just writes to the GFD or something. Maybe even just * a "ZeroBlock" instead of "WriteBlock" so we can memset instead of memcpy? */ -DIError -DiskImg::ZeroImage(void) +DIError DiskImg::ZeroImage(void) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlockSize]; + uint8_t blkBuf[kBlockSize]; long block; LOGI(" DI ZeroImage (%ld blocks)", GetNumBlocks()); @@ -1749,8 +1732,7 @@ DiskImg::ZeroImage(void) * * We want to use the same function for our sub-volumes too. */ -void -DiskImg::SetScanProgressCallback(ScanProgressCallback func, void* cookie) +void DiskImg::SetScanProgressCallback(ScanProgressCallback func, void* cookie) { if (fpParentImg != NULL) { /* unexpected, but perfectly okay */ @@ -1768,8 +1750,7 @@ DiskImg::SetScanProgressCallback(ScanProgressCallback func, void* cookie) * Update the progress. Call with a string at the start of a volume, then * call with a NULL pointer every time we add a file. */ -bool -DiskImg::UpdateScanProgress(const char* newStr) +bool DiskImg::UpdateScanProgress(const char* newStr) { ScanProgressCallback func = fpScanProgressCallback; DiskImg* pImg = this; @@ -1815,8 +1796,7 @@ DiskImg::UpdateScanProgress(const char* newStr) /* * Handle sector order conversions. */ -DIError -DiskImg::CalcSectorAndOffset(long track, int sector, SectorOrder imageOrder, +DIError DiskImg::CalcSectorAndOffset(long track, int sector, SectorOrder imageOrder, SectorOrder fsOrder, di_off_t* pOffset, int* pNewSector) { if (!fHasSectors) @@ -1967,8 +1947,7 @@ DiskImg::CalcSectorAndOffset(long track, int sector, SectorOrder imageOrder, * The "imageOrder" argument usually comes from fOrder, and "fsOrder" * comes from "fFileSysOrder". */ -inline bool -DiskImg::IsLinearBlocks(SectorOrder imageOrder, SectorOrder fsOrder) +inline bool DiskImg::IsLinearBlocks(SectorOrder imageOrder, SectorOrder fsOrder) { /* * Any time fOrder==fFileSysOrder, we know that we have a linear @@ -1987,8 +1966,7 @@ DiskImg::IsLinearBlocks(SectorOrder imageOrder, SectorOrder fsOrder) * * Returns 0 on success, nonzero on failure. */ -DIError -DiskImg::ReadTrackSectorSwapped(long track, int sector, void* buf, +DIError DiskImg::ReadTrackSectorSwapped(long track, int sector, void* buf, SectorOrder imageOrder, SectorOrder fsOrder) { DIError dierr; @@ -2041,8 +2019,7 @@ DiskImg::ReadTrackSectorSwapped(long track, int sector, void* buf, * * Returns 0 on success, nonzero on failure. */ -DIError -DiskImg::WriteTrackSector(long track, int sector, const void* buf) +DIError DiskImg::WriteTrackSector(long track, int sector, const void* buf) { DIError dierr; di_off_t offset; @@ -2093,8 +2070,7 @@ DiskImg::WriteTrackSector(long track, int sector, const void* buf) * * Copies 512 bytes into "*buf". */ -DIError -DiskImg::ReadBlockSwapped(long block, void* buf, SectorOrder imageOrder, +DIError DiskImg::ReadBlockSwapped(long block, void* buf, SectorOrder imageOrder, SectorOrder fsOrder) { if (!fHasBlocks) @@ -2146,8 +2122,7 @@ bail: * probably not contain data from all readable sectors. The application is * expected to retry the blocks individually. */ -DIError -DiskImg::ReadBlocks(long startBlock, int numBlocks, void* buf) +DIError DiskImg::ReadBlocks(long startBlock, int numBlocks, void* buf) { DIError dierr = kDIErrNone; @@ -2182,7 +2157,7 @@ DiskImg::ReadBlocks(long startBlock, int numBlocks, void* buf) if (dierr != kDIErrNone) goto bail; startBlock++; - buf = (unsigned char*)buf + kBlockSize; + buf = (uint8_t*)buf + kBlockSize; } } else { if (startBlock == 0) { @@ -2204,8 +2179,7 @@ bail: * * Returns "true" if we found bad blocks, "false" if not. */ -bool -DiskImg::CheckForBadBlocks(long startBlock, int numBlocks) +bool DiskImg::CheckForBadBlocks(long startBlock, int numBlocks) { int i; @@ -2225,8 +2199,7 @@ DiskImg::CheckForBadBlocks(long startBlock, int numBlocks) * Returns immediately when a block write fails. Does not try to write all * blocks before returning failure. */ -DIError -DiskImg::WriteBlock(long block, const void* buf) +DIError DiskImg::WriteBlock(long block, const void* buf) { if (!fHasBlocks) return kDIErrUnsupportedAccess; @@ -2265,8 +2238,7 @@ DiskImg::WriteBlock(long block, const void* buf) /* * Write multiple blocks. */ -DIError -DiskImg::WriteBlocks(long startBlock, int numBlocks, const void* buf) +DIError DiskImg::WriteBlocks(long startBlock, int numBlocks, const void* buf) { DIError dierr = kDIErrNone; @@ -2295,7 +2267,7 @@ DiskImg::WriteBlocks(long startBlock, int numBlocks, const void* buf) if (dierr != kDIErrNone) goto bail; startBlock++; - buf = (unsigned char*)buf + kBlockSize; + buf = (uint8_t*)buf + kBlockSize; } } else { if (startBlock == 0) { @@ -2315,8 +2287,7 @@ bail: * * (This is the lowest-level read routine in this class.) */ -DIError -DiskImg::CopyBytesOut(void* buf, di_off_t offset, int size) const +DIError DiskImg::CopyBytesOut(void* buf, di_off_t offset, int size) const { DIError dierr; @@ -2343,8 +2314,7 @@ DiskImg::CopyBytesOut(void* buf, di_off_t offset, int size) const * * (This is the lowest-level write routine in DiskImg.) */ -DIError -DiskImg::CopyBytesIn(const void* buf, di_off_t offset, int size) +DIError DiskImg::CopyBytesIn(const void* buf, di_off_t offset, int size) { DIError dierr; @@ -2389,8 +2359,7 @@ DiskImg::CopyBytesIn(const void* buf, di_off_t offset, int size) * * "storageName" and "pNibbleDescr" may be NULL. */ -DIError -DiskImg::CreateImage(const char* pathName, const char* storageName, +DIError DiskImg::CreateImage(const char* pathName, const char* storageName, OuterFormat outerFormat, FileFormat fileFormat, PhysicalFormat physical, const NibbleDescr* pNibbleDescr, SectorOrder order, FSFormat format, long numBlocks, bool skipFormat) @@ -2415,8 +2384,8 @@ DiskImg::CreateImage(const char* pathName, const char* storageName, return CreateImageCommon(pathName, storageName, skipFormat); } -DIError -DiskImg::CreateImage(const char* pathName, const char* storageName, + +DIError DiskImg::CreateImage(const char* pathName, const char* storageName, OuterFormat outerFormat, FileFormat fileFormat, PhysicalFormat physical, const NibbleDescr* pNibbleDescr, SectorOrder order, FSFormat format, long numTracks, long numSectPerTrack, bool skipFormat) @@ -2458,8 +2427,7 @@ DiskImg::CreateImage(const char* pathName, const char* storageName, /* * Do the actual disk image creation. */ -DIError -DiskImg::CreateImageCommon(const char* pathName, const char* storageName, +DIError DiskImg::CreateImageCommon(const char* pathName, const char* storageName, bool skipFormat) { DIError dierr; @@ -2722,8 +2690,7 @@ bail: * to call AnalyzeImage later on to set the actual FS once data has * been written. */ -DIError -DiskImg::ValidateCreateFormat(void) const +DIError DiskImg::ValidateCreateFormat(void) const { /* * Check for invalid arguments. @@ -2916,8 +2883,7 @@ DiskImg::ValidateCreateFormat(void) const * If "quickFormat" is set, only the very last sector is written (to set * the EOF on the file). */ -DIError -DiskImg::FormatSectors(GenericFD* pGFD, bool quickFormat) const +DIError DiskImg::FormatSectors(GenericFD* pGFD, bool quickFormat) const { DIError dierr = kDIErrNone; char sctBuf[kSectorSize]; @@ -3010,8 +2976,7 @@ DiskImg::FormatBlocks(GenericFD* pGFD) const * * The maximum length of a single note is set by the size of "buf". */ -void -DiskImg::AddNote(NoteType type, const char* fmt, ...) +void DiskImg::AddNote(NoteType type, const char* fmt, ...) { char buf[512]; char* cp = buf; @@ -3055,12 +3020,12 @@ DiskImg::AddNote(NoteType type, const char* fmt, ...) len++; } - LOGI("+++ adding note '%s'", buf); + LOGD("+++ adding note '%s'", buf); if (fNotes == NULL) { fNotes = new char[len +1]; if (fNotes == NULL) { - LOGI("Unable to create notes[%d]", len+1); + LOGW("Unable to create notes[%d]", len+1); assert(false); return; } @@ -3069,7 +3034,7 @@ DiskImg::AddNote(NoteType type, const char* fmt, ...) int existingLen = strlen(fNotes); char* newNotes = new char[existingLen + len +1]; if (newNotes == NULL) { - LOGI("Unable to create newNotes[%d]", existingLen+len+1); + LOGW("Unable to create newNotes[%d]", existingLen+len+1); assert(false); return; } @@ -3083,8 +3048,7 @@ DiskImg::AddNote(NoteType type, const char* fmt, ...) /* * Return a string with the notes in it. */ -const char* -DiskImg::GetNotes(void) const +const char* DiskImg::GetNotes(void) const { if (fNotes == NULL) return ""; @@ -3097,14 +3061,13 @@ DiskImg::GetNotes(void) const * Get length and offset of tracks in a nibble image. This is necessary * because of formats with variable-length tracks (e.g. TrackStar). */ -int -DiskImg::GetNibbleTrackLength(long track) const +int DiskImg::GetNibbleTrackLength(long track) const { assert(fpImageWrapper != NULL); return fpImageWrapper->GetNibbleTrackLength(fPhysical, track); } -int -DiskImg::GetNibbleTrackOffset(long track) const + +int DiskImg::GetNibbleTrackOffset(long track) const { assert(fpImageWrapper != NULL); return fpImageWrapper->GetNibbleTrackOffset(fPhysical, track); @@ -3121,8 +3084,7 @@ DiskImg::GetNibbleTrackOffset(long track) const * This doesn't inspire the DiskFS to do any processing, just creates the * new object. */ -DiskFS* -DiskImg::OpenAppropriateDiskFS(bool allowUnknown) +DiskFS* DiskImg::OpenAppropriateDiskFS(bool allowUnknown) { DiskFS* pDiskFS = NULL; @@ -3203,8 +3165,8 @@ DiskImg::OpenAppropriateDiskFS(bool allowUnknown) * * "orderArray" must have kSectorOrderMax elements. */ -/*static*/ void -DiskImg::GetSectorOrderArray(SectorOrder* orderArray, SectorOrder first) +/*static*/ void DiskImg::GetSectorOrderArray(SectorOrder* orderArray, + SectorOrder first) { // init array for (int i = 0; i < kSectorOrderMax; i++) @@ -3226,9 +3188,8 @@ DiskImg::GetSectorOrderArray(SectorOrder* orderArray, SectorOrder first) * * These are semi-duplicated in ImageFormatDialog.cpp in CiderPress. */ -/*static*/ const char* -DiskImg::ToStringCommon(int format, const ToStringLookup* pTable, - int tableSize) +/*static*/ const char* DiskImg::ToStringCommon(int format, + const ToStringLookup* pTable, int tableSize) { for (int i = 0; i < tableSize; i++) { if (pTable[i].format == format) @@ -3239,8 +3200,7 @@ DiskImg::ToStringCommon(int format, const ToStringLookup* pTable, return "(unknown)"; } -/*static*/ const char* -DiskImg::ToString(OuterFormat format) +/*static*/ const char* DiskImg::ToString(OuterFormat format) { static const ToStringLookup kOuterFormats[] = { { DiskImg::kOuterFormatUnknown, "Unknown format" }, @@ -3253,8 +3213,8 @@ DiskImg::ToString(OuterFormat format) return ToStringCommon(format, kOuterFormats, NELEM(kOuterFormats)); } -/*static*/ const char* -DiskImg::ToString(FileFormat format) + +/*static*/ const char* DiskImg::ToString(FileFormat format) { static const ToStringLookup kFileFormats[] = { { DiskImg::kFileFormatUnknown, "Unknown format" }, @@ -3273,8 +3233,8 @@ DiskImg::ToString(FileFormat format) return ToStringCommon(format, kFileFormats, NELEM(kFileFormats)); }; -/*static*/ const char* -DiskImg::ToString(PhysicalFormat format) + +/*static*/ const char* DiskImg::ToString(PhysicalFormat format) { static const ToStringLookup kPhysicalFormats[] = { { DiskImg::kPhysicalFormatUnknown, "Unknown format" }, @@ -3286,8 +3246,8 @@ DiskImg::ToString(PhysicalFormat format) return ToStringCommon(format, kPhysicalFormats, NELEM(kPhysicalFormats)); }; -/*static*/ const char* -DiskImg::ToString(SectorOrder format) + +/*static*/ const char* DiskImg::ToString(SectorOrder format) { static const ToStringLookup kSectorOrders[] = { { DiskImg::kSectorOrderUnknown, "Unknown ordering" }, @@ -3299,8 +3259,8 @@ DiskImg::ToString(SectorOrder format) return ToStringCommon(format, kSectorOrders, NELEM(kSectorOrders)); }; -/*static*/ const char* -DiskImg::ToString(FSFormat format) + +/*static*/ const char* DiskImg::ToString(FSFormat format) { static const ToStringLookup kFSFormats[] = { { DiskImg::kFormatUnknown, "Unknown" }, @@ -3337,8 +3297,7 @@ DiskImg::ToString(FSFormat format) /* * strerror() equivalent for DiskImg errors. */ -const char* -DiskImgLib::DIStrError(DIError dierr) +const char* DiskImgLib::DIStrError(DIError dierr) { if (dierr > 0) { const char* msg; @@ -3517,7 +3476,7 @@ DiskImgLib::DIStrError(DIError dierr) * blurry PDF or a pair of GIFs created with small fonts, but I think I * have mostly captured it. */ -/*static*/ const unsigned char DiskImg::kMacHighASCII[128+1] = +/*static*/ const uint8_t DiskImg::kMacHighASCII[128+1] = "AACENOUaaaaaaceeeeiiiinooooouuuu" // 0x80 - 0x9f "tocL$oPBrct'.=AO%+<>YudsPpSaoOao" // 0xa0 - 0xbf "?!-vf=d<>. AAOOo--\"\"''/oyY/o<> f" // 0xc0 - 0xdf diff --git a/diskimg/DiskImg.h b/diskimg/DiskImg.h index 4939118..cbd8cb0 100644 --- a/diskimg/DiskImg.h +++ b/diskimg/DiskImg.h @@ -43,8 +43,8 @@ namespace DiskImgLib { /* compiled-against versions; call DiskImg::GetVersion for linked-against */ -#define kDiskImgVersionMajor 4 -#define kDiskImgVersionMinor 6 +#define kDiskImgVersionMajor 5 +#define kDiskImgVersionMinor 0 #define kDiskImgVersionBug 0 @@ -346,7 +346,7 @@ public: kFormatMacPart = 44, // Macintosh-style partitioned disk kFormatMicroDrive = 45, // ///SHH Systeme's MicroDrive format kFormatFocusDrive = 46, // Parsons Engineering FocusDrive format - kFormatGutenberg = 47, // Gutenberg word processor format + kFormatGutenberg = 47, // Gutenberg word processor format // try to keep this in an unsigned char, e.g. for CP clipboard } FSFormat; @@ -379,16 +379,16 @@ public: char description[32]; short numSectors; // 13 or 16 (or 18?) - unsigned char addrProlog[kNibbleAddrPrologLen]; - unsigned char addrEpilog[kNibbleAddrEpilogLen]; - unsigned char addrChecksumSeed; + uint8_t addrProlog[kNibbleAddrPrologLen]; + uint8_t addrEpilog[kNibbleAddrEpilogLen]; + uint8_t addrChecksumSeed; bool addrVerifyChecksum; bool addrVerifyTrack; int addrEpilogVerifyCount; - unsigned char dataProlog[kNibbleDataPrologLen]; - unsigned char dataEpilog[kNibbleDataEpilogLen]; - unsigned char dataChecksumSeed; + uint8_t dataProlog[kNibbleDataPrologLen]; + uint8_t dataEpilog[kNibbleDataEpilogLen]; + uint8_t dataChecksumSeed; bool dataVerifyChecksum; int dataEpilogVerifyCount; @@ -522,10 +522,10 @@ public: virtual DIError WriteBlocks(long startBlock, int numBlocks, const void* buf); // read an entire nibblized track - virtual DIError ReadNibbleTrack(long track, unsigned char* buf, + virtual DIError ReadNibbleTrack(long track, uint8_t* buf, long* pTrackLen); // write a track; trackLen must be <= those in image - virtual DIError WriteNibbleTrack(long track, const unsigned char* buf, + virtual DIError WriteNibbleTrack(long track, const uint8_t* buf, long trackLen); // save the current image as a 2MG file @@ -632,8 +632,8 @@ public: // calculate block number from cyl/head/sect on 3.5" disk static int CylHeadSect35ToBlock(int cyl, int head, int sect); // unpack nibble data from a 3.5" disk track - static DIError UnpackNibbleTrack35(const unsigned char* nibbleBuf, - long nibbleLen, unsigned char* outputBuf, int cyl, int head, + static DIError UnpackNibbleTrack35(const uint8_t* nibbleBuf, + long nibbleLen, uint8_t* outputBuf, int cyl, int head, LinearBitmap* pBadBlockMap); // compute the #of sectors per track for cylinder N (0-79) static int SectorsPerTrack35(int cylinder); @@ -642,7 +642,7 @@ public: static void GetSectorOrderArray(SectorOrder* orderArray, SectorOrder first); // utility function used by HFS filename normalizer; available to apps - static inline unsigned char MacToASCII(unsigned char uch) { + static inline uint8_t MacToASCII(uint8_t uch) { if (uch < 0x20) return '?'; else if (uch < 0x80) @@ -722,7 +722,7 @@ private: int fNumSectPerTrack; // (ditto) long fNumBlocks; // for 512-byte block-addressable images - unsigned char* fNibbleTrackBuf; // allocated on heap + uint8_t* fNibbleTrackBuf; // allocated on heap int fNibbleTrackLoaded; // track currently in buffer int fNuFXCompressType; // used when compressing a NuFX image @@ -824,24 +824,24 @@ private: int track, int sector, const NibbleDescr* pNibbleDescr, int* pVol); void DecodeAddr(const CircularBufferAccess& buffer, int offset, short* pVol, short* pTrack, short* pSector, short* pChksum); - inline unsigned int ConvFrom44(unsigned char val1, unsigned char val2) { + inline uint16_t ConvFrom44(uint8_t val1, uint8_t val2) { return ((val1 << 1) | 0x01) & val2; } DIError DecodeNibbleData(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr); + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr); void EncodeNibbleData(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const; + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const; DIError DecodeNibble62(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr); + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr); void EncodeNibble62(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const; + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const; DIError DecodeNibble53(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr); + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr); void EncodeNibble53(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const; + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const; int TestNibbleTrack(int track, const NibbleDescr* pNibbleDescr, int* pVol); DIError AnalyzeNibbleData(void); - inline unsigned char Conv44(unsigned short val, bool first) const { + inline uint8_t Conv44(uint16_t val, bool first) const { if (first) return (val >> 1) | 0xaa; else @@ -849,7 +849,7 @@ private: } DIError FormatNibbles(GenericFD* pGFD) const; - static const unsigned char kMacHighASCII[]; + static const uint8_t kMacHighASCII[]; /* * 3.5" nibble access @@ -857,18 +857,18 @@ private: static int FindNextSector35(const CircularBufferAccess& buffer, int start, int cyl, int head, int* pSector); static bool DecodeNibbleSector35(const CircularBufferAccess& buffer, - int start, unsigned char* sectorBuf, unsigned char* readChecksum, - unsigned char* calcChecksum); + int start, uint8_t* sectorBuf, uint8_t* readChecksum, + uint8_t* calcChecksum); static bool UnpackChecksum35(const CircularBufferAccess& buffer, - int offset, unsigned char* checksumBuf); - static void EncodeNibbleSector35(const unsigned char* sectorData, - unsigned char* outBuf); + int offset, uint8_t* checksumBuf); + static void EncodeNibbleSector35(const uint8_t* sectorData, + uint8_t* outBuf); /* static data tables */ - static unsigned char kDiskBytes53[32]; - static unsigned char kDiskBytes62[64]; - static unsigned char kInvDiskBytes53[256]; - static unsigned char kInvDiskBytes62[256]; + static uint8_t kDiskBytes53[32]; + static uint8_t kDiskBytes62[64]; + static uint8_t kInvDiskBytes53[256]; + static uint8_t kInvDiskBytes62[256]; enum { kInvInvalidValue = 0xff }; private: // some C++ stuff to block behavior we don't support @@ -1035,7 +1035,7 @@ public: long fTotalChunks; long fNumSectors; // only valid if !fByBlocks //long fFreeChunks; - unsigned char* fList; + uint8_t* fList; int fListSize; }; // end of VolumeUsage class @@ -1661,6 +1661,6 @@ private: void* fProgressUpdateState; }; -}; // namespace DiskImgLib +} // namespace DiskImgLib #endif /*DISKIMG_DISKIMG_H*/ diff --git a/diskimg/DiskImgDetail.h b/diskimg/DiskImgDetail.h index f8d89e2..70fc927 100644 --- a/diskimg/DiskImgDetail.h +++ b/diskimg/DiskImgDetail.h @@ -1,7 +1,6 @@ /* * CiderPress * Copyright (C) 2009 by CiderPress authors. All Rights Reserved. - * Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved. * See the file LICENSE for distribution terms. */ /* @@ -76,13 +75,13 @@ public: static DIError Test(GenericFD* pGFD, di_off_t outerLength); virtual DIError Load(GenericFD* pGFD, di_off_t outerLength, bool readOnly, - di_off_t* pTotalLength, GenericFD** ppNewGFD); + di_off_t* pTotalLength, GenericFD** ppNewGFD) override; virtual DIError Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, - di_off_t wrapperLength); + di_off_t wrapperLength) override; - virtual bool IsDamaged(void) const { return fWrapperDamaged; } + virtual bool IsDamaged(void) const override { return fWrapperDamaged; } - virtual const char* GetExtension(void) const { return NULL; } + virtual const char* GetExtension(void) const override { return NULL; } private: DIError ExtractGzipImage(gzFile gzfp, char** pBuf, di_off_t* pLength); @@ -105,13 +104,13 @@ public: static DIError Test(GenericFD* pGFD, di_off_t outerLength); virtual DIError Load(GenericFD* pGFD, di_off_t outerLength, bool readOnly, - di_off_t* pTotalLength, GenericFD** ppNewGFD); + di_off_t* pTotalLength, GenericFD** ppNewGFD) override; virtual DIError Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, - di_off_t wrapperLength); + di_off_t wrapperLength) override; - virtual bool IsDamaged(void) const { return false; } + virtual bool IsDamaged(void) const override { return false; } - virtual const char* GetExtension(void) const { return fExtension; } + virtual const char* GetExtension(void) const override { return fExtension; } private: class LocalFileHeader { @@ -135,18 +134,18 @@ private: DIError Write(GenericFD* pGFD); void SetFileName(const char* name); - // unsigned long fSignature; - unsigned short fVersionToExtract; - unsigned short fGPBitFlag; - unsigned short fCompressionMethod; - unsigned short fLastModFileTime; - unsigned short fLastModFileDate; - unsigned long fCRC32; - unsigned long fCompressedSize; - unsigned long fUncompressedSize; - unsigned short fFileNameLength; - unsigned short fExtraFieldLength; - unsigned char* fFileName; + // uint32_t fSignature; + uint16_t fVersionToExtract; + uint16_t fGPBitFlag; + uint16_t fCompressionMethod; + uint16_t fLastModFileTime; + uint16_t fLastModFileDate; + uint32_t fCRC32; + uint32_t fCompressedSize; + uint32_t fUncompressedSize; + uint16_t fFileNameLength; + uint16_t fExtraFieldLength; + uint8_t* fFileName; // extra field enum { @@ -188,26 +187,26 @@ private: DIError Write(GenericFD* pGFD); void SetFileName(const char* name); - // unsigned long fSignature; - unsigned short fVersionMadeBy; - unsigned short fVersionToExtract; - unsigned short fGPBitFlag; - unsigned short fCompressionMethod; - unsigned short fLastModFileTime; - unsigned short fLastModFileDate; - unsigned long fCRC32; - unsigned long fCompressedSize; - unsigned long fUncompressedSize; - unsigned short fFileNameLength; - unsigned short fExtraFieldLength; - unsigned short fFileCommentLength; - unsigned short fDiskNumberStart; - unsigned short fInternalAttrs; - unsigned long fExternalAttrs; - unsigned long fLocalHeaderRelOffset; - unsigned char* fFileName; + // uint32_t fSignature; + uint16_t fVersionMadeBy; + uint16_t fVersionToExtract; + uint16_t fGPBitFlag; + uint16_t fCompressionMethod; + uint16_t fLastModFileTime; + uint16_t fLastModFileDate; + uint32_t fCRC32; + uint32_t fCompressedSize; + uint32_t fUncompressedSize; + uint16_t fFileNameLength; + uint16_t fExtraFieldLength; + uint16_t fFileCommentLength; + uint16_t fDiskNumberStart; + uint16_t fInternalAttrs; + uint32_t fExternalAttrs; + uint32_t fLocalHeaderRelOffset; + uint8_t* fFileName; // extra field - unsigned char* fFileComment; // alloc with new[] + uint8_t* fFileComment; // alloc with new[] void Dump(void) const; @@ -230,17 +229,17 @@ private: {} virtual ~EndOfCentralDir(void) {} - DIError ReadBuf(const unsigned char* buf, int len); + DIError ReadBuf(const uint8_t* buf, int len); DIError Write(GenericFD* pGFD); - // unsigned long fSignature; - unsigned short fDiskNumber; - unsigned short fDiskWithCentralDir; - unsigned short fNumEntries; - unsigned short fTotalNumEntries; - unsigned long fCentralDirSize; - unsigned long fCentralDirOffset; // offset from first disk - unsigned short fCommentLen; + // uint32_t fSignature; + uint16_t fDiskNumber; + uint16_t fDiskWithCentralDir; + uint16_t fNumEntries; + uint16_t fTotalNumEntries; + uint32_t fCentralDirSize; + uint32_t fCentralDirOffset; // offset from first disk + uint16_t fCommentLen; // archive comment enum { @@ -271,17 +270,17 @@ private: static DIError ReadCentralDir(GenericFD* pGFD, di_off_t outerLength, CentralDirEntry* pDirEntry); DIError ExtractZipEntry(GenericFD* pOuterGFD, CentralDirEntry* pCDE, - unsigned char** pBuf, di_off_t* pLength); + uint8_t** pBuf, di_off_t* pLength); DIError InflateGFDToBuffer(GenericFD* pGFD, unsigned long compSize, - unsigned long uncompSize, unsigned char* buf); + unsigned long uncompSize, uint8_t* buf); DIError DeflateGFDToGFD(GenericFD* pDst, GenericFD* pSrc, di_off_t length, - di_off_t* pCompLength, unsigned long* pCRC); + di_off_t* pCompLength, uint32_t* pCRC); private: void SetExtension(const char* ext); void SetStoredFileName(const char* name); - void GetMSDOSTime(unsigned short* pDate, unsigned short* pTime); - void DOSTime(time_t when, unsigned short* pDate, unsigned short* pTime); + void GetMSDOSTime(uint16_t* pDate, uint16_t* pTime); + void DOSTime(time_t when, uint16_t* pDate, uint16_t* pTime); char* fStoredFileName; char* fExtension; @@ -384,13 +383,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return true; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return true; } //virtual const char* GetComment(void) const { return NULL; } // (need to hold TwoImgHeader in the struct, rather than as temp, or // need to copy the comment out into Wrapper2MG storage e.g. StorageName) @@ -407,13 +406,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return false; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return false; } void SetStorageName(const char* name) { delete[] fStorageName; @@ -452,12 +451,12 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); + di_off_t dataLen, di_off_t* pWrappedLen) override; void SetStorageName(const char* name) { delete[] fStorageName; if (name != NULL) { @@ -467,8 +466,8 @@ public: fStorageName = NULL; } - virtual bool HasFastFlush(void) const { return false; } - virtual bool IsDamaged(void) const { return fBadChecksum; } + virtual bool HasFastFlush(void) const override { return false; } + virtual bool IsDamaged(void) const override { return fBadChecksum; } private: typedef struct DC42Header DC42Header; @@ -477,7 +476,7 @@ private: static int ReadHeader(GenericFD* pGFD, DC42Header* pHeader); DIError WriteHeader(GenericFD* pGFD, const DC42Header* pHeader); static DIError ComputeChecksum(GenericFD* pGFD, - unsigned long* pChecksum); + uint32_t* pChecksum); char* fStorageName; bool fBadChecksum; @@ -489,13 +488,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return false; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return false; } enum { kMaxDDDZeroCount = 4, // 3 observed, 4 suspected @@ -516,14 +515,14 @@ private: static DIError UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD, short* pDiskVolNum); - static bool UnpackTrack(BitBuffer* pBitBuffer, unsigned char* trackBuf); + static bool UnpackTrack(BitBuffer* pBitBuffer, uint8_t* trackBuf); static DIError PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD, short diskVolNum); - static void PackTrack(const unsigned char* trackBuf, BitBuffer* pBitBuf); - static void ComputeFreqCounts(const unsigned char* trackBuf, - unsigned short* freqCounts); - static void ComputeFavorites(unsigned short* freqCounts, - unsigned char* favorites); + static void PackTrack(const uint8_t* trackBuf, BitBuffer* pBitBuf); + static void ComputeFreqCounts(const uint8_t* trackBuf, + uint16_t* freqCounts); + static void ComputeFavorites(uint16_t* freqCounts, + uint8_t* favorites); short fDiskVolumeNum; }; @@ -534,13 +533,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return true; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return true; } }; class WrapperTrackStar : public ImageWrapper { @@ -562,15 +561,15 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return false; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return false; } - virtual void SetStorageName(const char* name) + virtual void SetStorageName(const char* name) override { delete[] fStorageName; if (name != NULL) { @@ -581,7 +580,7 @@ public: } private: - static DIError VerifyTrack(int track, const unsigned char* trackBuf); + static DIError VerifyTrack(int track, const uint8_t* trackBuf); DIError Unpack(GenericFD* pGFD, GenericFD** ppNewGFD); DIError UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD); @@ -638,13 +637,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return false; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return false; } enum { kSignatureLen = 27, @@ -672,15 +671,15 @@ private: // CR + LF char comment[kCommentLen+1]; // MS-DOS EOF - unsigned short version; - unsigned short lastTrack; - unsigned char lastHead; - unsigned char type; // DiskType enum - unsigned char rotSpeed; - unsigned char flags; - unsigned char tpi; - unsigned char headWidth; - unsigned short reserved; + uint16_t version; + uint16_t lastTrack; + uint8_t lastHead; + uint8_t type; // DiskType enum + uint8_t rotSpeed; + uint8_t flags; + uint8_t tpi; + uint8_t headWidth; + uint16_t reserved; // track descriptors follow, at byte 152 } FDIHeader; @@ -698,10 +697,10 @@ private: long idxStreamLen; int idxStreamCompression; - unsigned long* avgStream; // 4 bytes/pulse - unsigned long* minStream; // 4 bytes/pulse; optional - unsigned long* maxStream; // 4 bytes/pulse; optional - unsigned long* idxStream; // 2 bytes/pulse; optional? + uint32_t* avgStream; // 4 bytes/pulse + uint32_t* minStream; // 4 bytes/pulse; optional + uint32_t* maxStream; // 4 bytes/pulse; optional + uint32_t* idxStream; // 2 bytes/pulse; optional? } PulseIndexHeader; enum { @@ -731,7 +730,7 @@ private: /* node in the Huffman tree */ typedef struct HuffNode { - unsigned short val; + uint16_t val; struct HuffNode* left; struct HuffNode* right; } HuffNode; @@ -741,9 +740,9 @@ private: * we're interested in have more than kMaxHeaderBlockTracks tracks in * them, so we don't need anything beyond the initial 512-byte header. */ - unsigned char fHeaderBuf[kMinHeaderLen]; + uint8_t fHeaderBuf[kMinHeaderLen]; - static void UnpackHeader(const unsigned char* headerBuf, FDIHeader* hdr); + static void UnpackHeader(const uint8_t* headerBuf, FDIHeader* hdr); static void DumpHeader(const FDIHeader* pHdr); DIError Unpack525(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, @@ -759,32 +758,32 @@ private: void GetTrackInfo(int trk, int* pType, int* pLength256); int BitRate35(int trk); - void FixBadNibbles(unsigned char* nibbleBuf, long nibbleLen); - bool DecodePulseTrack(const unsigned char* inputBuf, long inputLen, - int bitRate, unsigned char* nibbleBuf, long* pNibbleLen); - bool UncompressPulseStream(const unsigned char* inputBuf, long inputLen, - unsigned long* outputBuf, long numPulses, int format, int bytesPerPulse); - bool ExpandHuffman(const unsigned char* inputBuf, long inputLen, - unsigned long* outputBuf, long numPulses); - const unsigned char* HuffExtractTree(const unsigned char* inputBuf, - HuffNode* pNode, unsigned char* pBits, unsigned char* pBitMask); - const unsigned char* HuffExtractValues16(const unsigned char* inputBuf, + void FixBadNibbles(uint8_t* nibbleBuf, long nibbleLen); + bool DecodePulseTrack(const uint8_t* inputBuf, long inputLen, + int bitRate, uint8_t* nibbleBuf, long* pNibbleLen); + bool UncompressPulseStream(const uint8_t* inputBuf, long inputLen, + uint32_t* outputBuf, long numPulses, int format, int bytesPerPulse); + bool ExpandHuffman(const uint8_t* inputBuf, long inputLen, + uint32_t* outputBuf, long numPulses); + const uint8_t* HuffExtractTree(const uint8_t* inputBuf, + HuffNode* pNode, uint8_t* pBits, uint8_t* pBitMask); + const uint8_t* HuffExtractValues16(const uint8_t* inputBuf, HuffNode* pNode); - const unsigned char* HuffExtractValues8(const unsigned char* inputBuf, + const uint8_t* HuffExtractValues8(const uint8_t* inputBuf, HuffNode* pNode); void HuffFreeNodes(HuffNode* pNode); - unsigned long HuffSignExtend16(unsigned long val); - unsigned long HuffSignExtend8(unsigned long val); + uint32_t HuffSignExtend16(uint32_t val); + uint32_t HuffSignExtend8(uint32_t val); bool ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, - unsigned char* nibbleBuf, long* pNibbleLen); - bool ConvertPulsesToBits(const unsigned long* avgStream, - const unsigned long* minStream, const unsigned long* maxStream, - const unsigned long* idxStream, int numPulses, int maxIndex, - int indexOffset, unsigned long totalAvg, int bitRate, - unsigned char* outputBuf, int* pOutputLen); + uint8_t* nibbleBuf, long* pNibbleLen); + bool ConvertPulsesToBits(const uint32_t* avgStream, + const uint32_t* minStream, const uint32_t* maxStream, + const uint32_t* idxStream, int numPulses, int maxIndex, + int indexOffset, uint32_t totalAvg, int bitRate, + uint8_t* outputBuf, int* pOutputLen); int MyRand(void); - bool ConvertBitsToNibbles(const unsigned char* bitBuffer, int bitCount, - unsigned char* nibbleBuf, long* pNibbleLen); + bool ConvertBitsToNibbles(const uint8_t* bitBuffer, int bitCount, + uint8_t* nibbleBuf, long* pNibbleLen); int fImageTracks; @@ -830,13 +829,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return true; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return true; } }; class WrapperUnadornedSector : public ImageWrapper { @@ -845,13 +844,13 @@ public: virtual DIError Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, - LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD); + LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) override; virtual DIError Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, - di_off_t* pWrappedLength, GenericFD** pDataFD); + di_off_t* pWrappedLength, GenericFD** pDataFD) override; virtual DIError Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, - di_off_t dataLen, di_off_t* pWrappedLen); - virtual bool HasFastFlush(void) const { return true; } + di_off_t dataLen, di_off_t* pWrappedLen) override; + virtual bool HasFastFlush(void) const override { return true; } }; @@ -879,13 +878,13 @@ public: return kDIErrNone; } - virtual const char* GetVolumeName(void) const { return fDiskVolumeName; } - virtual const char* GetVolumeID(void) const { return fDiskVolumeID; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return fDiskVolumeName; } + virtual const char* GetVolumeID(void) const override { return fDiskVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } // Use this if *something* is known about the filesystem, e.g. the @@ -944,22 +943,22 @@ public: static DIError TestWideFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[UNIDOS]"; } - virtual const char* GetVolumeID(void) const { return "[UNIDOS]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[UNIDOS]"; } + virtual const char* GetVolumeID(void) const override { return "[UNIDOS]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "UNIDOS"; } + virtual const char* GetDebugName(void) override { return "UNIDOS"; } DIError Initialize(void); DIError OpenSubVolume(int idx); }; @@ -981,22 +980,22 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[OzDOS]"; } - virtual const char* GetVolumeID(void) const { return "[OzDOS]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[OzDOS]"; } + virtual const char* GetVolumeID(void) const override { return "[OzDOS]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "OzDOS"; } + virtual const char* GetDebugName(void) override { return "OzDOS"; } DIError Initialize(void); DIError OpenSubVolume(int idx); }; @@ -1015,22 +1014,22 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[CFFA]"; } - virtual const char* GetVolumeID(void) const { return "[CFFA]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[CFFA]"; } + virtual const char* GetVolumeID(void) const override { return "[CFFA]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "CFFA"; } + virtual const char* GetDebugName(void) override { return "CFFA"; } static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, DiskImg::FSFormat* pFormatFound); @@ -1063,29 +1062,29 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[MacPartition]"; } - virtual const char* GetVolumeID(void) const { return "[MacPartition]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[MacPartition]"; } + virtual const char* GetVolumeID(void) const override { return "[MacPartition]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "MacPart"; } + virtual const char* GetDebugName(void) override { return "MacPart"; } struct PartitionMap; // fwd struct DriverDescriptorRecord; // fwd - static void UnpackDDR(const unsigned char* buf, + static void UnpackDDR(const uint8_t* buf, DriverDescriptorRecord* pDDR); static void DumpDDR(const DriverDescriptorRecord* pDDR); - static void UnpackPartitionMap(const unsigned char* buf, + static void UnpackPartitionMap(const uint8_t* buf, PartitionMap* pMap); static void DumpPartitionMap(long block, const PartitionMap* pMap); @@ -1116,25 +1115,25 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[MicroDrive]"; } - virtual const char* GetVolumeID(void) const { return "[MicroDrive]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[MicroDrive]"; } + virtual const char* GetVolumeID(void) const override { return "[MicroDrive]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "MicroDrive"; } + virtual const char* GetDebugName(void) override { return "MicroDrive"; } struct PartitionMap; // fwd - static void UnpackPartitionMap(const unsigned char* buf, + static void UnpackPartitionMap(const uint8_t* buf, PartitionMap* pMap); static void DumpPartitionMap(const PartitionMap* pMap); @@ -1165,26 +1164,26 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "[FocusDrive]"; } - virtual const char* GetVolumeID(void) const { return "[FocusDrive]"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return "[FocusDrive]"; } + virtual const char* GetVolumeID(void) const override { return "[FocusDrive]"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: - virtual const char* GetDebugName(void) { return "FocusDrive"; } + virtual const char* GetDebugName(void) override { return "FocusDrive"; } struct PartitionMap; // fwd - static void UnpackPartitionMap(const unsigned char* buf, - const unsigned char* nameBuf, PartitionMap* pMap); + static void UnpackPartitionMap(const uint8_t* buf, + const uint8_t* nameBuf, PartitionMap* pMap); static void DumpPartitionMap(const PartitionMap* pMap); static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder); @@ -1223,31 +1222,31 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(initMode); } - virtual DIError Format(DiskImg* pDiskImg, const char* volName); + virtual DIError Format(DiskImg* pDiskImg, const char* volName) override; - virtual const char* GetVolumeName(void) const { return fDiskVolumeName; } - virtual const char* GetVolumeID(void) const { return fDiskVolumeID; } - virtual const char* GetBareVolumeName(void) const { + virtual const char* GetVolumeName(void) const override { return fDiskVolumeName; } + virtual const char* GetVolumeID(void) const override { return fDiskVolumeID; } + virtual const char* GetBareVolumeName(void) const override { // this is fragile -- skip over the "DOS" part, return 3 digits assert(strlen(fDiskVolumeName) > 3); return fDiskVolumeName+3; } - virtual bool GetReadWriteSupported(void) const { return true; } - virtual bool GetFSDamaged(void) const { return !fDiskIsGood; } + virtual bool GetReadWriteSupported(void) const override { return true; } + virtual bool GetFSDamaged(void) const override { return !fDiskIsGood; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const; + int* pUnitSize) const override; virtual DIError NormalizePath(const char* path, char fssep, - char* normalizedBuf, int* pNormalizedBufLen); - virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile); - virtual DIError DeleteFile(A2File* pFile); - virtual DIError RenameFile(A2File* pFile, const char* newName); + char* normalizedBuf, int* pNormalizedBufLen) override; + virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile) override; + virtual DIError DeleteFile(A2File* pFile) override; + virtual DIError RenameFile(A2File* pFile, const char* newName) override; virtual DIError SetFileInfo(A2File* pFile, long fileType, long auxType, - long accessFlags); - virtual DIError RenameVolume(const char* newName); + long accessFlags) override; + virtual DIError RenameVolume(const char* newName) override; /* * Unique to DOS 3.3 disks. @@ -1259,7 +1258,7 @@ public: static bool IsValidVolumeName(const char* name); // utility function - static void LowerASCII(unsigned char* buf, long len); + static void LowerASCII(uint8_t* buf, long len); static void ReplaceFssep(char* str, char replacement); enum { @@ -1286,21 +1285,21 @@ private: void FixVolumeUsageMap(void); DIError ReadCatalog(void); DIError ProcessCatalogSector(int catTrack, int catSect, - const unsigned char* sctBuf); + const uint8_t* sctBuf); DIError GetFileLengths(void); DIError ComputeLength(A2FileDOS* pFile, const TrackSector* tsList, int tsCount); DIError TrimLastSectorUp(A2FileDOS* pFile, TrackSector lastTS); void MarkFileUsage(A2FileDOS* pFile, TrackSector* tsList, int tsCount, TrackSector* indexList, int indexCount); - //DIError TrimLastSectorDown(A2FileDOS* pFile, unsigned short* tsBuf, + //DIError TrimLastSectorDown(A2FileDOS* pFile, uint16_t* tsBuf, // int maxZeroCount); void DoNormalizePath(const char* name, char fssep, char* outBuf); DIError MakeFileNameUnique(char* fileName); DIError GetFreeCatalogEntry(TrackSector* pCatSect, int* pCatEntry, - unsigned char* sctBuf, A2FileDOS** ppPrevEntry); - void CreateDirEntry(unsigned char* sctBuf, int catEntry, - const char* fileName, TrackSector* pTSSect, unsigned char fileType, + uint8_t* sctBuf, A2FileDOS** ppPrevEntry); + void CreateDirEntry(uint8_t* sctBuf, int catEntry, + const char* fileName, TrackSector* pTSSect, uint8_t fileType, int access); void FreeTrackSectors(TrackSector* pList, int count); @@ -1316,8 +1315,7 @@ private: DIError CreateEmptyBlockMap(bool withDOS); bool GetSectorUseEntry(long track, int sector) const; void SetSectorUseEntry(long track, int sector, bool inUse); - inline unsigned long GetVTOCEntry(const unsigned char* pVTOC, - long track) const; + inline uint32_t GetVTOCEntry(const uint8_t* pVTOC, long track) const; // Largest interesting volume is 400K (50 tracks, 32 sectors), but // we may be looking at it in 16-sector mode, so max tracks is 100. @@ -1329,8 +1327,8 @@ private: }; // DOS track images, for initializing disk images - static const unsigned char gDOS33Tracks[]; - static const unsigned char gDOS32Tracks[]; + static const uint8_t gDOS33Tracks[]; + static const uint8_t gDOS32Tracks[]; /* some fields from the VTOC */ int fFirstCatTrack; @@ -1343,7 +1341,7 @@ private: int fDiskVolumeNum; // usually 254 char fDiskVolumeName[7]; // "DOS" + num, e.g. "DOS001", "DOS254" char fDiskVolumeID[32]; // sizeof "DOS 3.3 Volume " +3 +1 - unsigned char fVTOC[kSectorSize]; + uint8_t fVTOC[kSectorSize]; bool fVTOCLoaded; /* @@ -1378,16 +1376,17 @@ public: friend class A2FileDOS; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: typedef DiskFSDOS33::TrackSector TrackSector; @@ -1447,27 +1446,27 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const; - virtual long GetAuxType(void) const { return fAuxType; } - virtual long GetAccess(void) const; - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const { return 0; } - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fSparseLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override; + virtual long GetAuxType(void) const override { return fAuxType; } + virtual long GetAccess(void) const override; + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override { return 0; } + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fSparseLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** ppOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } void Dump(void) const; @@ -1481,7 +1480,7 @@ public: */ short fTSListTrack; // (could use TrackSector here) short fTSListSector; - unsigned short fLengthInSectors; + uint16_t fLengthInSectors; bool fLocked; char fFileName[kMaxFileName+1]; // "fixed" version FileType fFileType; @@ -1490,10 +1489,10 @@ public: int fCatEntryNum; // entry number within cat sector // these are computed or determined from the file contents - unsigned short fAuxType; // addr for bin, etc. - short fDataOffset; // for 'A'/'B'/'I' with embedded len - di_off_t fLength; // file length, in bytes - di_off_t fSparseLength; // file length, factoring sparse out + uint16_t fAuxType; // addr for bin, etc. + short fDataOffset; // for 'A'/'B'/'I' with embedded len + di_off_t fLength; // file length, in bytes + di_off_t fSparseLength; // file length, factoring sparse out void FixFilename(void); @@ -1505,7 +1504,7 @@ public: static void TrimTrailingSpaces(char* filename); private: - DIError ExtractTSPairs(const unsigned char* sctBuf, TrackSector* tsList, + DIError ExtractTSPairs(const uint8_t* sctBuf, TrackSector* tsList, int* pLastNonZero); A2FDDOS* fpOpenFile; @@ -1550,43 +1549,44 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(initMode); } - virtual DIError Format(DiskImg* pDiskImg, const char* volName); + virtual DIError Format(DiskImg* pDiskImg, const char* volName) override; virtual DIError NormalizePath(const char* path, char fssep, - char* normalizedBuf, int* pNormalizedBufLen); - virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile); - virtual DIError DeleteFile(A2File* pFile); - virtual DIError RenameFile(A2File* pFile, const char* newName); + char* normalizedBuf, int* pNormalizedBufLen) override; + virtual DIError CreateFile(const CreateParms* pParms, + A2File** ppNewFile) override; + virtual DIError DeleteFile(A2File* pFile) override; + virtual DIError RenameFile(A2File* pFile, const char* newName) override; virtual DIError SetFileInfo(A2File* pFile, long fileType, long auxType, - long accessFlags); - virtual DIError RenameVolume(const char* newName); + long accessFlags) override; + virtual DIError RenameVolume(const char* newName) override; // assorted constants enum { kMaxVolumeName = 15, }; - typedef unsigned long ProDate; + typedef uint32_t ProDate; - virtual const char* GetVolumeName(void) const { return fVolumeName; } - virtual const char* GetVolumeID(void) const { return fVolumeID; } - virtual const char* GetBareVolumeName(void) const { return fVolumeName; } - virtual bool GetReadWriteSupported(void) const { return true; } - virtual bool GetFSDamaged(void) const { return !fDiskIsGood; } - virtual long GetFSNumBlocks(void) const { return fTotalBlocks; } + virtual const char* GetVolumeName(void) const override { return fVolumeName; } + virtual const char* GetVolumeID(void) const override { return fVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return fVolumeName; } + virtual bool GetReadWriteSupported(void) const override { return true; } + virtual bool GetFSDamaged(void) const override { return !fDiskIsGood; } + virtual long GetFSNumBlocks(void) const override { return fTotalBlocks; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const; + int* pUnitSize) const override; //A2FileProDOS* GetVolDir(void) const { return fpVolDir; } static bool IsValidFileName(const char* name); static bool IsValidVolumeName(const char* name); - static unsigned short GenerateLowerCaseBits(const char* upperName, + static uint16_t GenerateLowerCaseBits(const char* upperName, const char* lowerName, bool forAppleWorks); static void GenerateLowerCaseName(const char* upperName, - char* lowerNameNoTerm, unsigned short lcFlags, bool fromAppleWorks); + char* lowerNameNoTerm, uint16_t lcFlags, bool fromAppleWorks); friend class A2FDProDOS; @@ -1617,57 +1617,57 @@ private: bool ScanForExtraEntries(void) const; void SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose); - DIError GetDirHeader(const unsigned char* blkBuf, DirHeader* pHeader); - DIError RecursiveDirAdd(A2File* pParent, unsigned short dirBlock, + DIError GetDirHeader(const uint8_t* blkBuf, DirHeader* pHeader); + DIError RecursiveDirAdd(A2File* pParent, uint16_t dirBlock, const char* basePath, int depth); DIError SlurpEntries(A2File* pParent, const DirHeader* pHeader, - const unsigned char* blkBuf, bool skipFirst, int* pCount, - const char* basePath, unsigned short thisBlock, int depth); + const uint8_t* blkBuf, bool skipFirst, int* pCount, + const char* basePath, uint16_t thisBlock, int depth); DIError ReadExtendedInfo(A2FileProDOS* pFile); DIError ScanFileUsage(void); - void ScanBlockList(long blockCount, unsigned short* blockList, - long indexCount, unsigned short* indexList, long* pSparseCount); + void ScanBlockList(long blockCount, uint16_t* blockList, + long indexCount, uint16_t* indexList, long* pSparseCount); DIError ScanForSubVolumes(void); DIError FindSubVolume(long blockStart, long blockCount, DiskImg** ppDiskImg, DiskFS** ppDiskFS); void MarkSubVolumeBlocks(long block, long count); - A2File* FindFileByKeyBlock(A2File* pStart, unsigned short keyBlock); + A2File* FindFileByKeyBlock(A2File* pStart, uint16_t keyBlock); DIError AllocInitialFileStorage(const CreateParms* pParms, - const char* upperName, unsigned short dirBlock, int dirEntrySlot, + const char* upperName, uint16_t dirBlock, int dirEntrySlot, long* pKeyBlock, int* pBlocksUsed, int* pNewEOF); DIError WriteBootBlocks(void); DIError DoNormalizePath(const char* path, char fssep, char** pNormalizedPath); void UpperCaseName(char* upperName, const char* name); bool CheckDiskIsGood(void); - DIError AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, - long* pDirLen, unsigned char** ppDirEntry, unsigned short* pDirKeyBlock, - int* pDirEntrySlot, unsigned short* pDirBlock); - unsigned char* GetPrevDirEntry(unsigned char* buf, unsigned char* ptr); - DIError MakeFileNameUnique(const unsigned char* dirBuf, long dirLen, + DIError AllocDirEntry(A2FileDescr* pOpenSubdir, uint8_t** ppDir, + long* pDirLen, uint8_t** ppDirEntry, uint16_t* pDirKeyBlock, + int* pDirEntrySlot, uint16_t* pDirBlock); + uint8_t* GetPrevDirEntry(uint8_t* buf, uint8_t* ptr); + DIError MakeFileNameUnique(const uint8_t* dirBuf, long dirLen, char* fileName); - bool NameExistsInDir(const unsigned char* dirBuf, long dirLen, + bool NameExistsInDir(const uint8_t* dirBuf, long dirLen, const char* fileName); - DIError FreeBlocks(long blockCount, unsigned short* blockList); + DIError FreeBlocks(long blockCount, uint16_t* blockList); DIError RegeneratePathName(A2FileProDOS* pFile); /* some items from the volume header */ char fVolumeName[kMaxVolumeName+1]; char fVolumeID[kMaxVolumeName + 16]; // add "ProDOS /" - unsigned char fAccess; + uint8_t fAccess; ProDate fCreateWhen; ProDate fModWhen; - unsigned short fBitMapPointer; - unsigned short fTotalBlocks; - //unsigned short fPrevBlock; - //unsigned short fNextBlock; - //unsigned char fVersion; - //unsigned char fMinVersion; - //unsigned char fEntryLength; - //unsigned char fEntriesPerBlock; - unsigned short fVolDirFileCount; + uint16_t fBitMapPointer; + uint16_t fTotalBlocks; + //uint16_t fPrevBlock; + //uint16_t fNextBlock; + //uint8_t fVersion; + //uint8_t fMinVersion; + //uint8_t fEntryLength; + //uint8_t fEntriesPerBlock; + uint16_t fVolDirFileCount; // A2FileProDOS* fpVolDir; // a "fake" file entry for the volume dir @@ -1679,7 +1679,7 @@ private: * one of the bitmap blocks directly (e.g. with the disk sector editor). * It should never be held across calls. */ - unsigned char* fBlockUseMap; + uint8_t* fBlockUseMap; /* * Set this if the disk is "perfect". If it's not, we disallow write @@ -1708,29 +1708,31 @@ public: friend class A2FileProDOS; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; void DumpBlockList(void) const; private: - bool IsEmptyBlock(const unsigned char* blk); + bool IsEmptyBlock(const uint8_t* blk); DIError WriteDirectory(const void* buf, size_t len, size_t* pActual); /* state for open files */ bool fModified; long fBlockCount; - unsigned short* fBlockList; + uint16_t* fBlockList; di_off_t fOpenEOF; // current EOF - unsigned short fOpenBlocksUsed; // #of block used by open piece + uint16_t fOpenBlocksUsed; // #of block used by open piece int fOpenStorageType; bool fOpenRsrcFork; // is this the resource fork? di_off_t fOffset; // current file offset @@ -1776,23 +1778,23 @@ public: typedef struct DirEntry { int storageType; char fileName[kMaxFileName+1]; // shows lower case - unsigned char fileType; - unsigned short keyPointer; - unsigned short blocksUsed; - unsigned long eof; + uint8_t fileType; + uint16_t keyPointer; + uint16_t blocksUsed; + uint32_t eof; ProDate createWhen; - unsigned char version; - unsigned char minVersion; - unsigned char access; - unsigned short auxType; + uint8_t version; + uint8_t minVersion; + uint8_t access; + uint16_t auxType; ProDate modWhen; - unsigned short headerPointer; + uint16_t headerPointer; } DirEntry; typedef struct ExtendedInfo { - unsigned char storageType; - unsigned short keyBlock; - unsigned short blocksUsed; - unsigned long eof; + uint8_t storageType; + uint16_t keyBlock; + uint16_t blocksUsed; + uint32_t eof; } ExtendedInfo; typedef enum StorageType { kStorageDeleted = 0, /* indicates deleted file */ @@ -1814,15 +1816,15 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fDirEntry.fileName; } - virtual const char* GetPathName(void) const { return fPathName; } - virtual char GetFssep(void) const { return kFssep; } - virtual long GetFileType(void) const { return fDirEntry.fileType; } - virtual long GetAuxType(void) const { return fDirEntry.auxType; } - virtual long GetAccess(void) const { return fDirEntry.access; } - virtual time_t GetCreateWhen(void) const; - virtual time_t GetModWhen(void) const; - virtual di_off_t GetDataLength(void) const { + virtual const char* GetFileName(void) const override { return fDirEntry.fileName; } + virtual const char* GetPathName(void) const override { return fPathName; } + virtual char GetFssep(void) const override { return kFssep; } + virtual long GetFileType(void) const override { return fDirEntry.fileType; } + virtual long GetAuxType(void) const override { return fDirEntry.auxType; } + virtual long GetAccess(void) const override { return fDirEntry.access; } + virtual time_t GetCreateWhen(void) const override; + virtual time_t GetModWhen(void) const override; + virtual di_off_t GetDataLength(void) const override { if (GetQuality() == kQualityDamaged) return 0; if (fDirEntry.storageType == kStorageExtended) @@ -1830,7 +1832,7 @@ public: else return fDirEntry.eof; } - virtual di_off_t GetRsrcLength(void) const { + virtual di_off_t GetRsrcLength(void) const override { if (fDirEntry.storageType == kStorageExtended) { if (GetQuality() == kQualityDamaged) return 0; @@ -1839,49 +1841,48 @@ public: } else return -1; } - virtual di_off_t GetDataSparseLength(void) const { + virtual di_off_t GetDataSparseLength(void) const override { if (GetQuality() == kQualityDamaged) return 0; else return fSparseDataEof; } - virtual di_off_t GetRsrcSparseLength(void) const { + virtual di_off_t GetRsrcSparseLength(void) const override { if (GetQuality() == kQualityDamaged) return 0; else return fSparseRsrcEof; } - virtual bool IsDirectory(void) const { + virtual bool IsDirectory(void) const override { return (fDirEntry.storageType == kStorageDirectory || fDirEntry.storageType == kStorageVolumeDirHeader); } - virtual bool IsVolumeDirectory(void) const { + virtual bool IsVolumeDirectory(void) const override { return (fDirEntry.storageType == kStorageVolumeDirHeader); } virtual DIError Open(A2FileDescr** ppOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } - virtual void SetParent(A2File* pParent) { fpParent = pParent; } - virtual A2File* GetParent(void) const { return fpParent; } + virtual void SetParent(A2File* pParent) override { fpParent = pParent; } + virtual A2File* GetParent(void) const override { return fpParent; } static char NameToLower(char ch); - static void InitDirEntry(DirEntry* pEntry, - const unsigned char* entryBuf); + static void InitDirEntry(DirEntry* pEntry, const uint8_t* entryBuf); - virtual void Dump(void) const; + virtual void Dump(void) const override; /* directory entry contents for this file */ DirEntry fDirEntry; /* pointer to directory entry (update dir if file size or dates change) */ - unsigned short fParentDirBlock; // directory block + uint16_t fParentDirBlock; // directory block int fParentDirIdx; // index in dir block /* these are only valid if storageType == kStorageExtended */ @@ -1893,7 +1894,7 @@ public: static ProDate ConvertProDate(time_t unixDate); /* returns "true" if AppleWorks aux type is used for lower-case name */ - static bool UsesAppleWorksAuxType(unsigned char fileType) { + static bool UsesAppleWorksAuxType(uint8_t fileType) { return (fileType >= 0x19 && fileType <= 0x1b); } @@ -1911,20 +1912,20 @@ public: } #endif - DIError LoadBlockList(int storageType, unsigned short keyBlock, - long eof, long* pBlockCount, unsigned short** pBlockList, - long* pIndexBlockCount=NULL, unsigned short** pIndexBlockList=NULL); - DIError LoadDirectoryBlockList(unsigned short keyBlock, - long eof, long* pBlockCount, unsigned short** pBlockList); + DIError LoadBlockList(int storageType, uint16_t keyBlock, + long eof, long* pBlockCount, uint16_t** pBlockList, + long* pIndexBlockCount=NULL, uint16_t** pIndexBlockList=NULL); + DIError LoadDirectoryBlockList(uint16_t keyBlock, + long eof, long* pBlockCount, uint16_t** pBlockList); /* fork lengths without sparseness */ di_off_t fSparseDataEof; di_off_t fSparseRsrcEof; private: - DIError LoadIndexBlock(unsigned short block, unsigned short* list, + DIError LoadIndexBlock(uint16_t block, uint16_t* list, int maxCount); - DIError ValidateBlockList(const unsigned short* list, long count); + DIError ValidateBlockList(const uint16_t* list, long count); char* fPathName; // full pathname to file on this volume @@ -1960,39 +1961,39 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual DIError Format(DiskImg* pDiskImg, const char* volName); + virtual DIError Format(DiskImg* pDiskImg, const char* volName) override; // assorted constants enum { kMaxVolumeName = 7, kDirectoryEntryLen = 26, }; - typedef unsigned short PascalDate; + typedef uint16_t PascalDate; - virtual const char* GetVolumeName(void) const { return fVolumeName; } - virtual const char* GetVolumeID(void) const { return fVolumeID; } - virtual const char* GetBareVolumeName(void) const { return fVolumeName; } - virtual bool GetReadWriteSupported(void) const { return true; } - virtual bool GetFSDamaged(void) const { return !fDiskIsGood; } + virtual const char* GetVolumeName(void) const override { return fVolumeName; } + virtual const char* GetVolumeID(void) const override { return fVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return fVolumeName; } + virtual bool GetReadWriteSupported(void) const override { return true; } + virtual bool GetFSDamaged(void) const override { return !fDiskIsGood; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const; + int* pUnitSize) const override; virtual DIError NormalizePath(const char* path, char fssep, - char* normalizedBuf, int* pNormalizedBufLen); - virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile); - virtual DIError DeleteFile(A2File* pFile); - virtual DIError RenameFile(A2File* pFile, const char* newName); + char* normalizedBuf, int* pNormalizedBufLen) override; + virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile) override; + virtual DIError DeleteFile(A2File* pFile) override; + virtual DIError RenameFile(A2File* pFile, const char* newName) override; virtual DIError SetFileInfo(A2File* pFile, long fileType, long auxType, - long accessFlags); - virtual DIError RenameVolume(const char* newName); + long accessFlags) override; + virtual DIError RenameVolume(const char* newName) override; static bool IsValidVolumeName(const char* name); static bool IsValidFileName(const char* name); - unsigned short GetTotalBlocks(void) const { return fTotalBlocks; } + uint16_t GetTotalBlocks(void) const { return fTotalBlocks; } friend class A2FDPascal; @@ -2012,21 +2013,21 @@ private: void DoNormalizePath(const char* name, char fssep, char* outBuf); DIError MakeFileNameUnique(char* fileName); DIError FindLargestFreeArea(int *pPrevIdx, A2FilePascal** ppPrevFile); - unsigned char* FindDirEntry(A2FilePascal* pFile); + uint8_t* FindDirEntry(A2FilePascal* pFile); enum { kMaxExtensionLen = 5 }; // used when normalizing; ".code" is 4 /* some items from the volume header */ - unsigned short fStartBlock; // first block of dir hdr; always 2 - unsigned short fNextBlock; // i.e. first block with data + uint16_t fStartBlock; // first block of dir hdr; always 2 + uint16_t fNextBlock; // i.e. first block with data char fVolumeName[kMaxVolumeName+1]; char fVolumeID[kMaxVolumeName + 16]; // add "Pascal ___:" - unsigned short fTotalBlocks; - unsigned short fNumFiles; + uint16_t fTotalBlocks; + uint16_t fNumFiles; PascalDate fAccessWhen; // PascalDate last access PascalDate fDateSetWhen; // PascalDate last date setting - unsigned short fStuff1; // - unsigned short fStuff2; // + uint16_t fStuff1; // + uint16_t fStuff2; // /* other goodies */ bool fDiskIsGood; @@ -2043,7 +2044,7 @@ private: * to this longer than necessary. Possibly less efficient that way; * if it becomes a problem it's easy enough to change the behavior. */ - unsigned char* fDirectory; + uint8_t* fDirectory; }; /* @@ -2060,16 +2061,18 @@ public: friend class A2FilePascal; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: di_off_t fOffset; // where we are @@ -2113,41 +2116,41 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const; - virtual long GetAuxType(void) const { return 0; } - virtual long GetAccess(void) const { return DiskFS::kFileAccessUnlocked; } - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const; - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override; + virtual long GetAuxType(void) const override { return 0; } + virtual long GetAccess(void) const override { return DiskFS::kFileAccessUnlocked; } + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override; + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** pOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } - virtual void Dump(void) const; + virtual void Dump(void) const override; static time_t ConvertPascalDate(PascalDate pascalDate); static A2FilePascal::PascalDate ConvertPascalDate(time_t unixDate); static A2FilePascal::FileType ConvertFileType(long prodosType); /* fields pulled out of directory block */ - unsigned short fStartBlock; - unsigned short fNextBlock; + uint16_t fStartBlock; + uint16_t fNextBlock; FileType fFileType; char fFileName[kMaxFileName+1]; - unsigned short fBytesRemaining; + uint16_t fBytesRemaining; PascalDate fModWhen; /* derived fields */ @@ -2189,18 +2192,18 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return "CP/M"; } - virtual const char* GetVolumeID(void) const { return "CP/M"; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return !fDiskIsGood; } + virtual const char* GetVolumeName(void) const override { return "CP/M"; } + virtual const char* GetVolumeID(void) const override { return "CP/M"; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return !fDiskIsGood; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } // assorted constants @@ -2215,6 +2218,7 @@ public: kDirEntryFlagContinued = 0x8000, // "flags" word }; + // Contents of the raw 32-byte directory entry. // // From http://www.seasip.demon.co.uk/Cpm/format31.html @@ -2231,12 +2235,12 @@ public: // Files larger than (1024 * 16) have multiple "extent" entries, i.e. // entries with the same user number and file name. typedef struct DirEntry { - unsigned char userNumber; // 0-15 or 0-31 (usually 0), e5=unused - unsigned char fileName[kDirFileNameLen+1]; - unsigned short extent; // extent (EX + S2 * 32) - unsigned char S1; // Last Record Byte Count (app-specific) - unsigned char records; // #of 128-byte records in this extent - unsigned char blocks[kDirEntryBlockCount]; + uint8_t userNumber; // 0-15 or 0-31 (usually 0), e5=unused + uint8_t fileName[kDirFileNameLen+1]; + uint16_t extent; // extent (EX + S2 * 32) + uint8_t S1; // Last Record Byte Count (app-specific) + uint8_t records; // #of 128-byte records in this extent + uint8_t blocks[kDirEntryBlockCount]; bool readOnly; bool system; bool badBlockList; // set if block list is damaged @@ -2277,22 +2281,24 @@ public: friend class A2FileCPM; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: //bool fOpen; di_off_t fOffset; long fBlockCount; - unsigned char* fBlockList; + uint8_t* fBlockList; }; /* @@ -2320,34 +2326,34 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const { return 0; } - virtual long GetAuxType(void) const { return 0; } - virtual long GetAccess(void) const { + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override { return 0; } + virtual long GetAuxType(void) const override { return 0; } + virtual long GetAccess(void) const override { if (fReadOnly) return DiskFS::kFileAccessLocked; else return DiskFS::kFileAccessUnlocked; } - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const { return 0; } - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override { return 0; } + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** ppOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } - virtual void Dump(void) const; + virtual void Dump(void) const override; /* fields pulled out of directory block */ char fFileName[kMaxFileName+1]; @@ -2357,7 +2363,7 @@ public: di_off_t fLength; int fDirIdx; // index into fDirEntry for part #1 - DIError GetBlockList(long* pBlockCount, unsigned char* blockBuf) const; + DIError GetBlockList(long* pBlockCount, uint8_t* blockBuf) const; private: const DirEntry* fpDirEntry; @@ -2390,18 +2396,18 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } - virtual const char* GetVolumeName(void) const { return fVolumeName; } - virtual const char* GetVolumeID(void) const { return fVolumeName; } - virtual const char* GetBareVolumeName(void) const { return NULL; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } + virtual const char* GetVolumeName(void) const override { return fVolumeName; } + virtual const char* GetVolumeID(void) const override { return fVolumeName; } + virtual const char* GetBareVolumeName(void) const override { return NULL; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } int GetOurSectPerTrack(void) const { return fOurSectPerTrack; } @@ -2434,16 +2440,18 @@ public: friend class A2FileRDOS; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: /* RDOS is unique in that it can put 13-sector disks on 16-sector tracks */ @@ -2483,38 +2491,38 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const; - virtual long GetAuxType(void) const { return fLoadAddr; } - virtual long GetAccess(void) const { return DiskFS::kFileAccessUnlocked; } - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const { return 0; }; - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override; + virtual long GetAuxType(void) const override { return fLoadAddr; } + virtual long GetAccess(void) const override { return DiskFS::kFileAccessUnlocked; } + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override { return 0; }; + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** ppOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } void FixFilename(void); - virtual void Dump(void) const; + virtual void Dump(void) const override; /* fields pulled out of directory block */ char fFileName[kMaxFileName+1]; FileType fFileType; - unsigned short fNumSectors; - unsigned short fLoadAddr; - unsigned short fLength; - unsigned short fStartSector; + uint16_t fNumSectors; + uint16_t fLoadAddr; + uint16_t fLength; + uint16_t fStartSector; private: void TrimTrailingSpaces(char* filename); @@ -2552,21 +2560,21 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(initMode); } #ifndef EXCISE_GPL_CODE /* these are optional, defined as no-ops in the parent class */ - virtual DIError Format(DiskImg* pDiskImg, const char* volName); + virtual DIError Format(DiskImg* pDiskImg, const char* volName) override; virtual DIError NormalizePath(const char* path, char fssep, - char* normalizedBuf, int* pNormalizedBufLen); - virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile); - virtual DIError DeleteFile(A2File* pFile); - virtual DIError RenameFile(A2File* pFile, const char* newName); + char* normalizedBuf, int* pNormalizedBufLen) override; + virtual DIError CreateFile(const CreateParms* pParms, A2File** ppNewFile) override; + virtual DIError DeleteFile(A2File* pFile) override; + virtual DIError RenameFile(A2File* pFile, const char* newName) override; virtual DIError SetFileInfo(A2File* pFile, long fileType, long auxType, - long accessFlags); + long accessFlags) override; virtual DIError RenameVolume(const char* newName); #endif @@ -2577,14 +2585,14 @@ public: }; /* mandatory functions */ - virtual const char* GetVolumeName(void) const { return fVolumeName; } - virtual const char* GetVolumeID(void) const { return fVolumeID; } - virtual const char* GetBareVolumeName(void) const { return fVolumeName; } - virtual bool GetReadWriteSupported(void) const { return true; } - virtual bool GetFSDamaged(void) const { return false; } - virtual long GetFSNumBlocks(void) const { return fTotalBlocks; } + virtual const char* GetVolumeName(void) const override { return fVolumeName; } + virtual const char* GetVolumeID(void) const override { return fVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return fVolumeName; } + virtual bool GetReadWriteSupported(void) const override { return true; } + virtual bool GetFSDamaged(void) const override { return false; } + virtual long GetFSNumBlocks(void) const override { return fTotalBlocks; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const; + int* pUnitSize) const override; #ifndef EXCISE_GPL_CODE hfsvol* GetHfsVol(void) const { return fHfsVol; } @@ -2618,7 +2626,7 @@ private: }; struct MasterDirBlock; // fwd - static void UnpackMDB(const unsigned char* buf, MasterDirBlock* pMDB); + static void UnpackMDB(const uint8_t* buf, MasterDirBlock* pMDB); static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder); DIError Initialize(InitMode initMode); @@ -2631,7 +2639,7 @@ private: void CreateFakeFile(void); #else DIError RecursiveDirAdd(A2File* pParent, const char* basePath, int depth); - //void Sanitize(unsigned char* str); + //void Sanitize(uint8_t* str); DIError DoNormalizePath(const char* path, char fssep, char** pNormalizedPath); static int CompareMacFileNames(const char* str1, const char* str2); @@ -2648,13 +2656,13 @@ private: /* some items from the volume header */ char fVolumeName[kMaxVolumeName+1]; char fVolumeID[kMaxVolumeName + 8]; // add "HFS :" - unsigned long fTotalBlocks; - unsigned long fAllocationBlockSize; - unsigned long fNumAllocationBlocks; - unsigned long fCreatedDateTime; - unsigned long fModifiedDateTime; - unsigned long fNumFiles; - unsigned long fNumDirectories; + uint32_t fTotalBlocks; + uint32_t fAllocationBlockSize; + uint32_t fNumAllocationBlocks; + uint32_t fCreatedDateTime; + uint32_t fModifiedDateTime; + uint32_t fNumFiles; + uint32_t fNumDirectories; long fLocalTimeOffset; bool fDiskIsGood; @@ -2683,16 +2691,18 @@ public: friend class A2FileHFS; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: #ifdef EXCISE_GPL_CODE @@ -2730,29 +2740,29 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fPathName; } - virtual char GetFssep(void) const { return kFssep; } - virtual long GetFileType(void) const; - virtual long GetAuxType(void) const; - virtual long GetAccess(void) const { return fAccess; } - virtual time_t GetCreateWhen(void) const { return fCreateWhen; } - virtual time_t GetModWhen(void) const { return fModWhen; } - virtual di_off_t GetDataLength(void) const { return fDataLength; } - virtual di_off_t GetDataSparseLength(void) const { return fDataLength; } - virtual di_off_t GetRsrcLength(void) const { return fRsrcLength; } - virtual di_off_t GetRsrcSparseLength(void) const { return fRsrcLength; } - virtual bool IsDirectory(void) const { return fIsDir; } - virtual bool IsVolumeDirectory(void) const { return fIsVolumeDir; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fPathName; } + virtual char GetFssep(void) const override { return kFssep; } + virtual long GetFileType(void) const override; + virtual long GetAuxType(void) const override; + virtual long GetAccess(void) const override { return fAccess; } + virtual time_t GetCreateWhen(void) const override { return fCreateWhen; } + virtual time_t GetModWhen(void) const override { return fModWhen; } + virtual di_off_t GetDataLength(void) const override { return fDataLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fDataLength; } + virtual di_off_t GetRsrcLength(void) const override { return fRsrcLength; } + virtual di_off_t GetRsrcSparseLength(void) const override { return fRsrcLength; } + virtual bool IsDirectory(void) const override { return fIsDir; } + virtual bool IsVolumeDirectory(void) const override { return fIsVolumeDir; } virtual DIError Open(A2FileDescr** pOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } enum { kMaxFileName = 31, @@ -2761,7 +2771,7 @@ public: }; void SetPathName(const char* basePath, const char* fileName); - virtual void Dump(void) const; + virtual void Dump(void) const override; #ifdef EXCISE_GPL_CODE void SetFakeFile(void* buf, long len) { @@ -2776,8 +2786,8 @@ public: #else void InitEntry(const hfsdirent* dirEntry); void SetOrigPathName(const char* pathName); - virtual void SetParent(A2File* pParent) { fpParent = pParent; } - virtual A2File* GetParent(void) const { return fpParent; } + virtual void SetParent(A2File* pParent) override { fpParent = pParent; } + virtual A2File* GetParent(void) const override { return fpParent; } char* GetLibHFSPathName(void) const; static void ConvertTypeToHFS(long fileType, long auxType, char* pType, char* pCreator); @@ -2828,26 +2838,26 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(initMode); } - virtual const char* GetVolumeName(void) const { return fDiskVolumeName; } - virtual const char* GetVolumeID(void) const { return fDiskVolumeID; } - virtual const char* GetBareVolumeName(void) const { + virtual const char* GetVolumeName(void) const override { return fDiskVolumeName; } + virtual const char* GetVolumeID(void) const override { return fDiskVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return fDiskVolumeName; } - virtual bool GetReadWriteSupported(void) const { return true; } - virtual bool GetFSDamaged(void) const { return !fDiskIsGood; } + virtual bool GetReadWriteSupported(void) const override { return true; } + virtual bool GetFSDamaged(void) const override { return !fDiskIsGood; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const; + int* pUnitSize) const override; static bool IsValidFileName(const char* name); static bool IsValidVolumeName(const char* name); // utility function - static void LowerASCII(unsigned char* buf, long len); + static void LowerASCII(uint8_t* buf, long len); static void ReplaceFssep(char* str, char replacement); enum { @@ -2874,7 +2884,7 @@ private: void FixVolumeUsageMap(void); DIError ReadCatalog(void); DIError ProcessCatalogSector(int catTrack, int catSect, - const unsigned char* sctBuf); + const uint8_t* sctBuf); DIError GetFileLengths(void); DIError ComputeLength(A2FileGutenberg* pFile, const TrackSector* tsList, int tsCount); @@ -2883,9 +2893,9 @@ private: TrackSector* indexList, int indexCount); DIError MakeFileNameUnique(char* fileName); DIError GetFreeCatalogEntry(TrackSector* pCatSect, int* pCatEntry, - unsigned char* sctBuf, A2FileGutenberg** ppPrevEntry); - void CreateDirEntry(unsigned char* sctBuf, int catEntry, - const char* fileName, TrackSector* pTSSect, unsigned char fileType, + uint8_t* sctBuf, A2FileGutenberg** ppPrevEntry); + void CreateDirEntry(uint8_t* sctBuf, int catEntry, + const char* fileName, TrackSector* pTSSect, uint8_t fileType, int access); void FreeTrackSectors(TrackSector* pList, int count); @@ -2901,8 +2911,7 @@ private: DIError CreateEmptyBlockMap(bool withDOS); bool GetSectorUseEntry(long track, int sector) const; void SetSectorUseEntry(long track, int sector, bool inUse); - inline unsigned long GetVTOCEntry(const unsigned char* pVTOC, - long track) const; + inline uint32_t GetVTOCEntry(const uint8_t* pVTOC, long track) const; // Largest interesting volume is 400K (50 tracks, 32 sectors), but // we may be looking at it in 16-sector mode, so max tracks is 100. @@ -2923,7 +2932,7 @@ private: /* private data */ char fDiskVolumeName[10]; // char fDiskVolumeID[11+12+1]; // sizeof "Gutenberg: " + 12 + null - unsigned char fVTOC[kSectorSize]; + uint8_t fVTOC[kSectorSize]; bool fVTOCLoaded; /* @@ -2951,16 +2960,18 @@ public: friend class A2FileGutenberg; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: typedef DiskFSGutenberg::TrackSector TrackSector; @@ -2995,27 +3006,27 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const; - virtual long GetAuxType(void) const { return fAuxType; } - virtual long GetAccess(void) const { return DiskFS::kFileAccessUnlocked; } - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const { return 0; } - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fSparseLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override; + virtual long GetAuxType(void) const override { return fAuxType; } + virtual long GetAccess(void) const override { return DiskFS::kFileAccessUnlocked; } + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override { return 0; } + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fSparseLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** ppOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } void Dump(void) const; @@ -3029,7 +3040,7 @@ public: */ short fTrack; // (could use TrackSector here) short fSector; - unsigned short fLengthInSectors; + uint16_t fLengthInSectors; bool fLocked; char fFileName[kMaxFileName+1]; // "fixed" version FileType fFileType; @@ -3038,7 +3049,7 @@ public: int fCatEntryNum; // entry number within cat sector // these are computed or determined from the file contents - unsigned short fAuxType; // addr for bin, etc. + uint16_t fAuxType; // addr for bin, etc. short fDataOffset; // for 'A'/'B'/'I' with embedded len di_off_t fLength; // file length, in bytes di_off_t fSparseLength; // file length, factoring sparse out @@ -3051,7 +3062,7 @@ public: static void TrimTrailingSpaces(char* filename); private: - DIError ExtractTSPairs(const unsigned char* sctBuf, TrackSector* tsList, + DIError ExtractTSPairs(const uint8_t* sctBuf, TrackSector* tsList, int* pLastNonZero); A2FDGutenberg* fpOpenFile; @@ -3079,7 +3090,7 @@ public: static DIError TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency); - virtual DIError Initialize(DiskImg* pImg, InitMode initMode) { + virtual DIError Initialize(DiskImg* pImg, InitMode initMode) override { SetDiskImg(pImg); return Initialize(); } @@ -3089,14 +3100,14 @@ public: kMaxVolumeName = 11, }; - virtual const char* GetVolumeName(void) const { return fVolumeName; } - virtual const char* GetVolumeID(void) const { return fVolumeID; } - virtual const char* GetBareVolumeName(void) const { return fVolumeName; } - virtual bool GetReadWriteSupported(void) const { return false; } - virtual bool GetFSDamaged(void) const { return false; } - virtual long GetFSNumBlocks(void) const { return fTotalBlocks; } + virtual const char* GetVolumeName(void) const override { return fVolumeName; } + virtual const char* GetVolumeID(void) const override { return fVolumeID; } + virtual const char* GetBareVolumeName(void) const override { return fVolumeName; } + virtual bool GetReadWriteSupported(void) const override { return false; } + virtual bool GetFSDamaged(void) const override { return false; } + virtual long GetFSNumBlocks(void) const override { return fTotalBlocks; } virtual DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, - int* pUnitSize) const + int* pUnitSize) const override { return kDIErrNotSupported; } private: @@ -3106,8 +3117,8 @@ private: struct MasterBootRecord; // fwd struct BootSector; - static bool UnpackMBR(const unsigned char* buf, MasterBootRecord* pOut); - static bool UnpackBootSector(const unsigned char* buf, BootSector* pOut); + static bool UnpackMBR(const uint8_t* buf, MasterBootRecord* pOut); + static bool UnpackBootSector(const uint8_t* buf, BootSector* pOut); static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder); DIError Initialize(void); @@ -3119,7 +3130,7 @@ private: /* some items from the volume header */ char fVolumeName[kMaxVolumeName+1]; char fVolumeID[kMaxVolumeName + 8]; // add "FAT %s:" - unsigned long fTotalBlocks; + uint32_t fTotalBlocks; }; /* @@ -3136,16 +3147,18 @@ public: friend class A2FileFAT; - virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Write(const void* buf, size_t len, size_t* pActual = NULL); - virtual DIError Seek(di_off_t offset, DIWhence whence); - virtual di_off_t Tell(void); - virtual DIError Close(void); + virtual DIError Read(void* buf, size_t len, size_t* pActual = NULL) override; + virtual DIError Write(const void* buf, size_t len, + size_t* pActual = NULL) override; + virtual DIError Seek(di_off_t offset, DIWhence whence) override; + virtual di_off_t Tell(void) override; + virtual DIError Close(void) override; - virtual long GetSectorCount(void) const; - virtual long GetBlockCount(void) const; - virtual DIError GetStorage(long sectorIdx, long* pTrack, long* pSector) const; - virtual DIError GetStorage(long blockIdx, long* pBlock) const; + virtual long GetSectorCount(void) const override; + virtual long GetBlockCount(void) const override; + virtual DIError GetStorage(long sectorIdx, long* pTrack, + long* pSector) const override; + virtual DIError GetStorage(long blockIdx, long* pBlock) const override; private: di_off_t fOffset; @@ -3169,31 +3182,31 @@ public: /* * Implementations of standard interfaces. */ - virtual const char* GetFileName(void) const { return fFileName; } - virtual const char* GetPathName(void) const { return fFileName; } - virtual char GetFssep(void) const { return '\0'; } - virtual long GetFileType(void) const { return 0; }; - virtual long GetAuxType(void) const { return 0; } - virtual long GetAccess(void) const { return DiskFS::kFileAccessUnlocked; } - virtual time_t GetCreateWhen(void) const { return 0; } - virtual time_t GetModWhen(void) const { return 0; } - virtual di_off_t GetDataLength(void) const { return fLength; } - virtual di_off_t GetDataSparseLength(void) const { return fLength; } - virtual di_off_t GetRsrcLength(void) const { return -1; } - virtual di_off_t GetRsrcSparseLength(void) const { return -1; } + virtual const char* GetFileName(void) const override { return fFileName; } + virtual const char* GetPathName(void) const override { return fFileName; } + virtual char GetFssep(void) const override { return '\0'; } + virtual long GetFileType(void) const override { return 0; }; + virtual long GetAuxType(void) const override { return 0; } + virtual long GetAccess(void) const override { return DiskFS::kFileAccessUnlocked; } + virtual time_t GetCreateWhen(void) const override { return 0; } + virtual time_t GetModWhen(void) const override { return 0; } + virtual di_off_t GetDataLength(void) const override { return fLength; } + virtual di_off_t GetDataSparseLength(void) const override { return fLength; } + virtual di_off_t GetRsrcLength(void) const override { return -1; } + virtual di_off_t GetRsrcSparseLength(void) const override { return -1; } virtual DIError Open(A2FileDescr** pOpenFile, bool readOnly, - bool rsrcFork = false); - virtual void CloseDescr(A2FileDescr* pOpenFile) { + bool rsrcFork = false) override; + virtual void CloseDescr(A2FileDescr* pOpenFile) override { assert(pOpenFile == fpOpenFile); delete fpOpenFile; fpOpenFile = NULL; } - virtual bool IsFileOpen(void) const { return fpOpenFile != NULL; } + virtual bool IsFileOpen(void) const override { return fpOpenFile != NULL; } enum { kMaxFileName = 31 }; - virtual void Dump(void) const; + virtual void Dump(void) const override; void SetFakeFile(void* buf, long len) { assert(len > 0); diff --git a/diskimg/DiskImgPriv.h b/diskimg/DiskImgPriv.h index b347ad3..6fc16a3 100644 --- a/diskimg/DiskImgPriv.h +++ b/diskimg/DiskImgPriv.h @@ -96,11 +96,11 @@ bool IsWin9x(void); */ class CircularBufferAccess { public: - CircularBufferAccess(unsigned char* buf, long len) : + CircularBufferAccess(uint8_t* buf, long len) : fBuf(buf), fLen(len) { assert(fLen > 0); assert(fBuf != NULL); } - CircularBufferAccess(const unsigned char* buf, long len) : - fBuf(const_cast(buf)), fLen(len) + CircularBufferAccess(const uint8_t* buf, long len) : + fBuf(const_cast(buf)), fLen(len) { assert(fLen > 0); assert(fBuf != NULL); } ~CircularBufferAccess(void) {} @@ -108,7 +108,7 @@ public: * Be circular. Assume that we won't stray far past the end, so * it's cheaper to subtract than mod. */ - unsigned char& operator[](int idx) const { + uint8_t& operator[](int idx) const { if (idx < 0) { assert(false); } @@ -117,7 +117,7 @@ public: return fBuf[idx]; } - //unsigned char* GetPointer(int idx) const { + //uint8_t* GetPointer(int idx) const { // while (idx >= fLen) // idx -= fLen; // return &fBuf[idx]; @@ -134,8 +134,8 @@ public: } private: - unsigned char* fBuf; - long fLen; + uint8_t* fBuf; + long fLen; }; /* @@ -152,7 +152,7 @@ private: class BitOutputBuffer { public: /* pass in the output buffer and the output buffer's size */ - BitOutputBuffer(unsigned char* buf, int size) { + BitOutputBuffer(uint8_t* buf, int size) { fBufStart = fBuf = buf; fBufSize = size; fBitMask = 0x80; @@ -204,12 +204,12 @@ public: } private: - unsigned char* fBufStart; - unsigned char* fBuf; - int fBufSize; - unsigned char fBitMask; - unsigned char fByte; - bool fOverflow; + uint8_t* fBufStart; + uint8_t* fBuf; + int fBufSize; + uint8_t fBitMask; + uint8_t fByte; + bool fOverflow; }; /* @@ -217,7 +217,7 @@ private: */ class BitInputBuffer { public: - BitInputBuffer(const unsigned char* buf, int bitCount) { + BitInputBuffer(const uint8_t* buf, int bitCount) { fBufStart = fBuf = buf; fBitCount = bitCount; fCurrentBit = 0; @@ -233,8 +233,8 @@ public: * non-null, set "*pWrap". (This does *not* set it to "false" if we * don't wrap.) */ - unsigned char GetBit(bool* pWrap) { - unsigned char val; + uint8_t GetBit(bool* pWrap) { + uint8_t val; //assert(fBitPosn == 7 - (fCurrentBit & 0x07)); @@ -264,8 +264,8 @@ public: /* * Get the next 8 bits. */ - unsigned char GetByte(bool* pWrap) { - unsigned char val; + uint8_t GetByte(bool* pWrap) { + uint8_t val; int i; if (true || fCurrentBit > fBitCount-8) { @@ -295,12 +295,12 @@ public: int GetBitsConsumed(void) const { return fBitsConsumed; } private: - const unsigned char* fBufStart; - const unsigned char* fBuf; + const uint8_t* fBufStart; + const uint8_t* fBuf; int fBitCount; // #of bits in buffer int fCurrentBit; // where we are in buffer int fBitPosn; // which bit to access within byte - //unsigned char fByte; + //uint8_t fByte; int fBitsConsumed; // sanity check - all bits used? }; @@ -312,7 +312,7 @@ class LinearBitmap { public: LinearBitmap(int numBits) { assert(numBits > 0); - fBits = new unsigned char[(numBits + 7) / 8]; + fBits = new uint8_t[(numBits + 7) / 8]; memset(fBits, 0, (numBits + 7) / 8); fNumBits = numBits; } @@ -333,12 +333,12 @@ public: } private: - unsigned char* fBits; - int fNumBits; + uint8_t* fBits; + int fNumBits; }; -} // namespace DiskImgLib +} // namespace DiskImgLib /* * Most of the code needs these. diff --git a/diskimg/FAT.cpp b/diskimg/FAT.cpp index e9a80cd..77b816c 100644 --- a/diskimg/FAT.cpp +++ b/diskimg/FAT.cpp @@ -22,23 +22,23 @@ const int kBlkSize = 512; const long kBootBlock = 0; -const unsigned short kSignature = 0xaa55; // MBR or boot sector +const uint16_t kSignature = 0xaa55; // MBR or boot sector const int kSignatureOffset = 0x1fe; -const unsigned char kOpcodeMumble = 0x33; // seen on 2nd drive -const unsigned char kOpcodeBranch = 0xeb; -const unsigned char kOpcodeSetInt = 0xfa; +const uint8_t kOpcodeMumble = 0x33; // seen on 2nd drive +const uint8_t kOpcodeBranch = 0xeb; +const uint8_t kOpcodeSetInt = 0xfa; typedef struct PartitionTableEntry { - unsigned char driveNum; // dl (0x80 or 0x00) - unsigned char startHead; // dh - unsigned char startSector; // cl (&0x3f=sector, +two hi bits cyl) - unsigned char startCylinder; // ch (low 8 bits of 10-bit cylinder) - unsigned char type; // partition type - unsigned char endHead; // dh - unsigned char endSector; // cl - unsigned char endCylinder; // ch - unsigned long startLBA; // in blocks - unsigned long size; // in blocks + uint8_t driveNum; // dl (0x80 or 0x00) + uint8_t startHead; // dh + uint8_t startSector; // cl (&0x3f=sector, +two hi bits cyl) + uint8_t startCylinder; // ch (low 8 bits of 10-bit cylinder) + uint8_t type; // partition type + uint8_t endHead; // dh + uint8_t endSector; // cl + uint8_t endCylinder; // ch + uint32_t startLBA; // in blocks + uint32_t size; // in blocks } PartitionTableEntry; /* @@ -49,7 +49,7 @@ typedef struct DiskFSFAT::MasterBootRecord { * Begins immediately with code, usually 0xfa (set interrupt flag) or * 0xeb (relative branch). */ - unsigned char firstByte; + uint8_t firstByte; /* * Partition table starts at 0x1be. Four entries, each 16 bytes. @@ -65,20 +65,20 @@ typedef struct DiskFSFAT::BootSector { * The first few bytes of the boot sector is called the BIOS Parameter * Block, or BPB. */ - unsigned char jump[3]; // usually EB XX 90 - unsigned char oemName[8]; // e.g. "MSWIN4.1" or "MSDOS5.0" - unsigned short bytesPerSector; // usually (always?) 512 - unsigned char sectPerCluster; - unsigned short reservedSectors; - unsigned char numFAT; - unsigned short numRootDirEntries; - unsigned short numSectors; // if set, ignore numSectorsHuge - unsigned char mediaType; - unsigned short numFATSectors; - unsigned short sectorsPerTrack; - unsigned short numHeads; - unsigned long numHiddenSectors; - unsigned long numSectorsHuge; // only if numSectors==0 + uint8_t jump[3]; // usually EB XX 90 + uint8_t oemName[8]; // e.g. "MSWIN4.1" or "MSDOS5.0" + uint16_t bytesPerSector; // usually (always?) 512 + uint8_t sectPerCluster; + uint16_t reservedSectors; + uint8_t numFAT; + uint16_t numRootDirEntries; + uint16_t numSectors; // if set, ignore numSectorsHuge + uint8_t mediaType; + uint16_t numFATSectors; + uint16_t sectorsPerTrack; + uint16_t numHeads; + uint32_t numHiddenSectors; + uint32_t numSectorsHuge; // only if numSectors==0 /* * This next part can start immediately after the above (at 0x24) for * FAT12/FAT16, or somewhat later (0x42) for FAT32. It doesn't seem @@ -88,12 +88,12 @@ typedef struct DiskFSFAT::BootSector { * partition type, but if this is our block 0 then we can't know what * that is. */ - unsigned char driveNum; - unsigned char reserved; - unsigned char signature; // 0x29 - unsigned long volumeID; - unsigned char volumeLabel[11]; // e.g. "FUBAR " - unsigned char fileSysType[8]; // e.g. "FAT12 " + uint8_t driveNum; + uint8_t reserved; + uint8_t signature; // 0x29 + uint32_t volumeID; + uint8_t volumeLabel[11]; // e.g. "FUBAR " + uint8_t fileSysType[8]; // e.g. "FAT12 " /* * Code follows. Signature 0xaa55 in the last two bytes. @@ -114,10 +114,9 @@ enum MediaType { * * Returns "true" if this looks like an MBR, "false" otherwise. */ -/*static*/ bool -DiskFSFAT::UnpackMBR(const unsigned char* buf, MasterBootRecord* pOut) +/*static*/ bool DiskFSFAT::UnpackMBR(const uint8_t* buf, MasterBootRecord* pOut) { - const unsigned char* ptr; + const uint8_t* ptr; int i; pOut->firstByte = buf[0x00]; @@ -160,8 +159,7 @@ DiskFSFAT::UnpackMBR(const unsigned char* buf, MasterBootRecord* pOut) * * Returns "true" if this looks like a boot sector, "false" otherwise. */ -/*static*/ bool -DiskFSFAT::UnpackBootSector(const unsigned char* buf, BootSector* pOut) +/*static*/ bool DiskFSFAT::UnpackBootSector(const uint8_t* buf, BootSector* pOut) { memcpy(pOut->jump, &buf[0x00], sizeof(pOut->jump)); memcpy(pOut->oemName, &buf[0x03], sizeof(pOut->oemName)); @@ -188,11 +186,10 @@ DiskFSFAT::UnpackBootSector(const unsigned char* buf, BootSector* pOut) /* * See if this looks like a FAT volume. */ -/*static*/ DIError -DiskFSFAT::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +/*static*/ DIError DiskFSFAT::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; MasterBootRecord mbr; BootSector bs; @@ -244,8 +241,7 @@ bail: /* * Test to see if the image is a FAT disk. */ -/*static*/ DIError -DiskFSFAT::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSFAT::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { /* must be block format, should be at least 360K */ @@ -275,8 +271,7 @@ DiskFSFAT::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Get things rolling. */ -DIError -DiskFSFAT::Initialize(void) +DIError DiskFSFAT::Initialize(void) { DIError dierr = kDIErrNone; @@ -297,8 +292,7 @@ DiskFSFAT::Initialize(void) /* * Blank out the volume usage map. */ -void -DiskFSFAT::SetVolumeUsageMap(void) +void DiskFSFAT::SetVolumeUsageMap(void) { VolumeUsage::ChunkState cstate; long block; @@ -317,8 +311,7 @@ DiskFSFAT::SetVolumeUsageMap(void) /* * Fill a buffer with some interesting stuff, and add it to the file list. */ -void -DiskFSFAT::CreateFakeFile(void) +void DiskFSFAT::CreateFakeFile(void) { A2FileFAT* pFile; char buf[768]; // currently running about 430 @@ -340,7 +333,7 @@ DiskFSFAT::CreateFakeFile(void) capacity = fTotalBlocks; memset(buf, 0, sizeof(buf)); - sprintf(buf, kFormatMsg, + snprintf(buf, NELEM(buf), kFormatMsg, fVolumeName, capacity, (double) capacity / 2048.0); @@ -362,17 +355,15 @@ DiskFSFAT::CreateFakeFile(void) /* * Dump the contents of the A2File structure. */ -void -A2FileFAT::Dump(void) const +void A2FileFAT::Dump(void) const { - LOGI("A2FileFAT '%s'", fFileName); + LOGD("A2FileFAT '%s'", fFileName); } /* * Not a whole lot to do. */ -DIError -A2FileFAT::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileFAT::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { A2FDFAT* pOpenFile = NULL; @@ -401,10 +392,9 @@ A2FileFAT::Open(A2FileDescr** ppOpenFile, bool readOnly, /* * Read a chunk of data from the fake file. */ -DIError -A2FDFAT::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDFAT::Read(void* buf, size_t len, size_t* pActual) { - LOGI(" FAT reading %d bytes from '%s' (offset=%ld)", + LOGD(" FAT reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); A2FileFAT* pFile = (A2FileFAT*) fpFile; @@ -428,8 +418,7 @@ A2FDFAT::Read(void* buf, size_t len, size_t* pActual) /* * Write data at the current offset. */ -DIError -A2FDFAT::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDFAT::Write(const void* buf, size_t len, size_t* pActual) { return kDIErrNotSupported; } @@ -437,8 +426,7 @@ A2FDFAT::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to a new offset. */ -DIError -A2FDFAT::Seek(di_off_t offset, DIWhence whence) +DIError A2FDFAT::Seek(di_off_t offset, DIWhence whence) { di_off_t fileLen = ((A2FileFAT*) fpFile)->fLength; @@ -473,8 +461,7 @@ A2FDFAT::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDFAT::Tell(void) +di_off_t A2FDFAT::Tell(void) { return fOffset; } @@ -482,8 +469,7 @@ A2FDFAT::Tell(void) /* * Release file state, and tell our parent to destroy us. */ -DIError -A2FDFAT::Close(void) +DIError A2FDFAT::Close(void) { fpFile->CloseDescr(this); return kDIErrNone; @@ -492,14 +478,13 @@ A2FDFAT::Close(void) /* * Return the #of sectors/blocks in the file. */ -long -A2FDFAT::GetSectorCount(void) const +long A2FDFAT::GetSectorCount(void) const { A2FileFAT* pFile = (A2FileFAT*) fpFile; return (long) ((pFile->fLength+255) / 256); } -long -A2FDFAT::GetBlockCount(void) const + +long A2FDFAT::GetBlockCount(void) const { A2FileFAT* pFile = (A2FileFAT*) fpFile; return (long) ((pFile->fLength+511) / 512); @@ -508,16 +493,15 @@ A2FDFAT::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDFAT::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDFAT::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { return kDIErrNotSupported; } + /* * Return the Nth 512-byte block in this file. */ -DIError -A2FDFAT::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDFAT::GetStorage(long blockIdx, long* pBlock) const { return kDIErrNotSupported; } diff --git a/diskimg/FDI.cpp b/diskimg/FDI.cpp index 6eb2270..12980e9 100644 --- a/diskimg/FDI.cpp +++ b/diskimg/FDI.cpp @@ -33,8 +33,7 @@ /* * Pack a disk image with FDI. */ -DIError -WrapperFDI::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD) +DIError WrapperFDI::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD) { DIError dierr = kDIErrGeneric; // not yet return dierr; @@ -57,13 +56,12 @@ WrapperFDI::PackDisk(GenericFD* pSrcGFD, GenericFD* pWrapperGFD) * * Fills in "fNibbleTrackInfo". */ -DIError -WrapperFDI::UnpackDisk525(GenericFD* pGFD, GenericFD* pNewGFD, int numCyls, - int numHeads) +DIError WrapperFDI::UnpackDisk525(GenericFD* pGFD, GenericFD* pNewGFD, + int numCyls, int numHeads) { DIError dierr = kDIErrNone; - unsigned char nibbleBuf[kNibbleBufLen]; - unsigned char* inputBuf = NULL; + uint8_t nibbleBuf[kNibbleBufLen]; + uint8_t* inputBuf = NULL; bool goodTracks[kMaxNibbleTracks525]; int inputBufLen = -1; int badTracks = 0; @@ -91,7 +89,7 @@ WrapperFDI::UnpackDisk525(GenericFD* pGFD, GenericFD* pNewGFD, int numCyls, /* allocate or increase the size of the input buffer */ delete[] inputBuf; inputBufLen = length256 * 256; - inputBuf = new unsigned char[inputBufLen]; + inputBuf = new uint8_t[inputBufLen]; if (inputBuf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -223,14 +221,13 @@ bail: * We also need to set up a "bad block" map to identify parts that we had * trouble unpacking. */ -DIError -WrapperFDI::UnpackDisk35(GenericFD* pGFD, GenericFD* pNewGFD, int numCyls, +DIError WrapperFDI::UnpackDisk35(GenericFD* pGFD, GenericFD* pNewGFD, int numCyls, int numHeads, LinearBitmap* pBadBlockMap) { DIError dierr = kDIErrNone; - unsigned char nibbleBuf[kNibbleBufLen]; - unsigned char* inputBuf = NULL; - unsigned char outputBuf[kMaxSectors35 * kBlockSize]; // 6KB + uint8_t nibbleBuf[kNibbleBufLen]; + uint8_t* inputBuf = NULL; + uint8_t outputBuf[kMaxSectors35 * kBlockSize]; // 6KB int inputBufLen = -1; int badTracks = 0; int trk, type, length256; @@ -258,7 +255,7 @@ WrapperFDI::UnpackDisk35(GenericFD* pGFD, GenericFD* pNewGFD, int numCyls, /* allocate or increase the size of the input buffer */ delete[] inputBuf; inputBufLen = length256 * 256; - inputBuf = new unsigned char[inputBufLen]; + inputBuf = new uint8_t[inputBufLen]; if (inputBuf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -344,8 +341,7 @@ bail: /* * Return the approximate bit rate for the specified cylinder, in bits/sec. */ -int -WrapperFDI::BitRate35(int cyl) +int WrapperFDI::BitRate35(int cyl) { if (cyl >= 0 && cyl <= 15) return 375000; // 394rpm @@ -374,8 +370,7 @@ WrapperFDI::BitRate35(int cyl) * (We could be more rigorous and test against valid disk bytes, but that's * probably excessive.) */ -void -WrapperFDI::FixBadNibbles(unsigned char* nibbleBuf, long nibbleLen) +void WrapperFDI::FixBadNibbles(uint8_t* nibbleBuf, long nibbleLen) { int badCount = 0; @@ -399,10 +394,9 @@ WrapperFDI::FixBadNibbles(unsigned char* nibbleBuf, long nibbleLen) * * Returns the track type and amount of data (/256). */ -void -WrapperFDI::GetTrackInfo(int trk, int* pType, int* pLength256) +void WrapperFDI::GetTrackInfo(int trk, int* pType, int* pLength256) { - unsigned short trackDescr; + uint16_t trackDescr; trackDescr = fHeaderBuf[kTrackDescrOffset + trk * 2] << 8 | fHeaderBuf[kTrackDescrOffset + trk * 2 +1]; @@ -457,15 +451,14 @@ WrapperFDI::GetTrackInfo(int trk, int* pType, int* pLength256) * * Returns "true" on success, "false" on failure. */ -bool -WrapperFDI::DecodePulseTrack(const unsigned char* inputBuf, long inputLen, - int bitRate, unsigned char* nibbleBuf, long* pNibbleLen) +bool WrapperFDI::DecodePulseTrack(const uint8_t* inputBuf, long inputLen, + int bitRate, uint8_t* nibbleBuf, long* pNibbleLen) { const int kSizeValueMask = 0x003fffff; const int kSizeCompressMask = 0x00c00000; const int kSizeCompressShift = 22; PulseIndexHeader hdr; - unsigned long val; + uint32_t val; bool result = false; memset(&hdr, 0, sizeof(hdr)); @@ -502,7 +495,7 @@ WrapperFDI::DecodePulseTrack(const unsigned char* inputBuf, long inputLen, /* * Uncompress or endian-swap the pulse streams. */ - hdr.avgStream = new unsigned long[hdr.numPulses]; + hdr.avgStream = new uint32_t[hdr.numPulses]; if (hdr.avgStream == NULL) goto bail; if (!UncompressPulseStream(inputBuf, hdr.avgStreamLen, hdr.avgStream, @@ -513,7 +506,7 @@ WrapperFDI::DecodePulseTrack(const unsigned char* inputBuf, long inputLen, inputBuf += hdr.avgStreamLen; if (hdr.minStreamLen > 0) { - hdr.minStream = new unsigned long[hdr.numPulses]; + hdr.minStream = new uint32_t[hdr.numPulses]; if (hdr.minStream == NULL) goto bail; if (!UncompressPulseStream(inputBuf, hdr.minStreamLen, hdr.minStream, @@ -524,7 +517,7 @@ WrapperFDI::DecodePulseTrack(const unsigned char* inputBuf, long inputLen, inputBuf += hdr.minStreamLen; } if (hdr.maxStreamLen > 0) { - hdr.maxStream = new unsigned long[hdr.numPulses]; + hdr.maxStream = new uint32_t[hdr.numPulses]; if (!UncompressPulseStream(inputBuf, hdr.maxStreamLen, hdr.maxStream, hdr.numPulses, hdr.maxStreamCompression, 4)) { @@ -533,7 +526,7 @@ WrapperFDI::DecodePulseTrack(const unsigned char* inputBuf, long inputLen, inputBuf += hdr.maxStreamLen; } if (hdr.idxStreamLen > 0) { - hdr.idxStream = new unsigned long[hdr.numPulses]; + hdr.idxStream = new uint32_t[hdr.numPulses]; if (!UncompressPulseStream(inputBuf, hdr.idxStreamLen, hdr.idxStream, hdr.numPulses, hdr.idxStreamCompression, 2)) { @@ -575,9 +568,8 @@ bail: * Returns "true" if all went well, "false" if we hit something that we * couldn't handle. */ -bool -WrapperFDI::UncompressPulseStream(const unsigned char* inputBuf, long inputLen, - unsigned long* outputBuf, long numPulses, int format, int bytesPerPulse) +bool WrapperFDI::UncompressPulseStream(const uint8_t* inputBuf, long inputLen, + uint32_t* outputBuf, long numPulses, int format, int bytesPerPulse) { assert(bytesPerPulse == 2 || bytesPerPulse == 4); @@ -590,7 +582,7 @@ WrapperFDI::UncompressPulseStream(const unsigned char* inputBuf, long inputLen, if (format == kCompUncompressed) { int i; - LOGI("NOT TESTED"); // remove this when we've tested it + LOGE("NOT TESTED"); // remove this when we've tested it if (inputLen != numPulses * bytesPerPulse) { LOGI(" FDI: got unc inputLen=%ld, outputLen=%ld", @@ -630,18 +622,17 @@ WrapperFDI::UncompressPulseStream(const unsigned char* inputBuf, long inputLen, * * This implementation is based on the fdi2raw code. */ -bool -WrapperFDI::ExpandHuffman(const unsigned char* inputBuf, long inputLen, - unsigned long* outputBuf, long numPulses) +bool WrapperFDI::ExpandHuffman(const uint8_t* inputBuf, long inputLen, + uint32_t* outputBuf, long numPulses) { HuffNode root; - const unsigned char* origInputBuf = inputBuf; + const uint8_t* origInputBuf = inputBuf; bool signExtend, sixteenBits; int i, subStreamShift; - unsigned char bits; - unsigned char bitMask; + uint8_t bits; + uint8_t bitMask; - memset(outputBuf, 0, numPulses * sizeof(unsigned long)); + memset(outputBuf, 0, numPulses * sizeof(uint32_t)); subStreamShift = 1; while (subStreamShift != 0) { @@ -683,7 +674,7 @@ WrapperFDI::ExpandHuffman(const unsigned char* inputBuf, long inputLen, /* decode the data over all pulses */ bitMask = 0; for (i = 0; i < numPulses; i++) { - unsigned long outVal; + uint32_t outVal; const HuffNode* pCurrent = &root; /* chase down the tree until we hit a leaf */ @@ -732,11 +723,10 @@ WrapperFDI::ExpandHuffman(const unsigned char* inputBuf, long inputLen, /* * Recursively extract the Huffman tree structure for this sub-stream. */ -const unsigned char* -WrapperFDI::HuffExtractTree(const unsigned char* inputBuf, HuffNode* pNode, - unsigned char* pBits, unsigned char* pBitMask) +const uint8_t* WrapperFDI::HuffExtractTree(const uint8_t* inputBuf, + HuffNode* pNode, uint8_t* pBits, uint8_t* pBitMask) { - unsigned char val; + uint8_t val; if (*pBitMask == 0) { *pBits = *inputBuf++; @@ -764,8 +754,8 @@ WrapperFDI::HuffExtractTree(const unsigned char* inputBuf, HuffNode* pNode, /* * Recursively get the 16-bit values for our Huffman tree from the stream. */ -const unsigned char* -WrapperFDI::HuffExtractValues16(const unsigned char* inputBuf, HuffNode* pNode) +const uint8_t* WrapperFDI::HuffExtractValues16(const uint8_t* inputBuf, + HuffNode* pNode) { if (pNode->left == NULL) { pNode->val = (*inputBuf++) << 8; @@ -780,8 +770,8 @@ WrapperFDI::HuffExtractValues16(const unsigned char* inputBuf, HuffNode* pNode) /* * Recursively get the 8-bit values for our Huffman tree from the stream. */ -const unsigned char* -WrapperFDI::HuffExtractValues8(const unsigned char* inputBuf, HuffNode* pNode) +const uint8_t* WrapperFDI::HuffExtractValues8(const uint8_t* inputBuf, + HuffNode* pNode) { if (pNode->left == NULL) { pNode->val = *inputBuf++; @@ -795,8 +785,7 @@ WrapperFDI::HuffExtractValues8(const unsigned char* inputBuf, HuffNode* pNode) /* * Recursively free up the current node and all nodes beneath it. */ -void -WrapperFDI::HuffFreeNodes(HuffNode* pNode) +void WrapperFDI::HuffFreeNodes(HuffNode* pNode) { if (pNode != NULL) { HuffFreeNodes(pNode->left); @@ -809,8 +798,7 @@ WrapperFDI::HuffFreeNodes(HuffNode* pNode) /* * Sign-extend a 16-bit value to 32 bits. */ -unsigned long -WrapperFDI::HuffSignExtend16(unsigned long val) +uint32_t WrapperFDI::HuffSignExtend16(uint32_t val) { if (val & 0x8000) val |= 0xffff0000; @@ -820,8 +808,7 @@ WrapperFDI::HuffSignExtend16(unsigned long val) /* * Sign-extend an 8-bit value to 32 bits. */ -unsigned long -WrapperFDI::HuffSignExtend8(unsigned long val) +uint32_t WrapperFDI::HuffSignExtend8(uint32_t val) { if (val & 0x80) val |= 0xffffff00; @@ -843,21 +830,20 @@ WrapperFDI::HuffSignExtend8(unsigned long val) * "*pNibbleLen" should hold the maximum size of the buffer. On success, * it will hold the actual number of bytes used. */ -bool -WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, - unsigned char* nibbleBuf, long* pNibbleLen) +bool WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, + uint8_t* nibbleBuf, long* pNibbleLen) { - unsigned long* fakeIdxStream = NULL; + uint32_t* fakeIdxStream = NULL; bool result = false; int i; /* * Stream pointers. If we don't have a stream, fake it. */ - unsigned long* avgStream; - unsigned long* minStream; - unsigned long* maxStream; - unsigned long* idxStream; + uint32_t* avgStream; + uint32_t* minStream; + uint32_t* maxStream; + uint32_t* idxStream; avgStream = pHdr->avgStream; if (pHdr->minStream != NULL && pHdr->maxStream != NULL) { @@ -885,7 +871,7 @@ WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, */ LOGI(" FDI: HEY: using fake index stream"); DebugBreak(); - fakeIdxStream = new unsigned long[pHdr->numPulses]; + fakeIdxStream = new uint32_t[pHdr->numPulses]; if (fakeIdxStream == NULL) { LOGI(" FDI: unable to alloc fake idx stream"); goto bail; @@ -900,11 +886,11 @@ WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, /* * Compute a value for maxIndex. */ - unsigned long maxIndex; + uint32_t maxIndex; maxIndex = 0; for (i = 0; i < pHdr->numPulses; i++) { - unsigned long sum; + uint32_t sum; /* add up the two single-byte values in the index stream */ sum = ZeroStateCount(idxStream[i]) + OneStateCount(idxStream[i]); @@ -946,7 +932,7 @@ WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, * Compute totalAvg and weakBits, and rewrite idxStream. * (We don't actually use weakBits.) */ - unsigned long totalAvg; + uint32_t totalAvg; int weakBits; totalAvg = weakBits = 0; @@ -968,7 +954,7 @@ WrapperFDI::ConvertPulseStreamsToNibbles(PulseIndexHeader* pHdr, int bitRate, * Take our altered stream values and the stuff we've calculated, * and convert the pulse values into bits. */ - unsigned char bitBuffer[kBitBufferSize]; + uint8_t bitBuffer[kBitBufferSize]; int bitCount; bitCount = kBitBufferSize; @@ -1013,8 +999,8 @@ bail: const int kPulseLimitVal = 15; /* "tolerance of 15%" */ typedef struct PulseSamples { - unsigned long size; - int numBits; + uint32_t size; + int numBits; } PulseSamples; class PulseSampleCollection { @@ -1041,7 +1027,7 @@ public: assert(fTotalDiv != 0); } - unsigned long GetTotal(void) const { return fTotal; } + uint32_t GetTotal(void) const { return fTotal; } int GetTotalDiv(void) const { return fTotalDiv; } void AdjustTotal(long val) { fTotal += val; } @@ -1063,7 +1049,7 @@ public: private: PulseSamples fArray[kSampleArrayMax]; int fArrayIndex; - unsigned long fTotal; + uint32_t fTotal; int fTotalDiv; }; @@ -1080,8 +1066,7 @@ private: */ #undef RAND_MAX #define RAND_MAX 32767 -int -WrapperFDI::MyRand(void) +int WrapperFDI::MyRand(void) { const int kNumStates = 31; const int kQuantum = RAND_MAX / (kNumStates+1); @@ -1108,18 +1093,17 @@ WrapperFDI::MyRand(void) * This is a fairly direct conversion from the sample code. There's a lot * here that I haven't taken the time to figure out. */ -bool -WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, - const unsigned long* minStream, const unsigned long* maxStream, - const unsigned long* idxStream, int numPulses, int maxIndex, - int indexOffset, unsigned long totalAvg, int bitRate, - unsigned char* outputBuf, int* pOutputLen) +bool WrapperFDI::ConvertPulsesToBits(const uint32_t* avgStream, + const uint32_t* minStream, const uint32_t* maxStream, + const uint32_t* idxStream, int numPulses, int maxIndex, + int indexOffset, uint32_t totalAvg, int bitRate, + uint8_t* outputBuf, int* pOutputLen) { PulseSampleCollection samples; BitOutputBuffer bitOutput(outputBuf, *pOutputLen); /* magic numbers, from somewhere */ - const unsigned long kStdMFM2BitCellSize = (totalAvg * 5) / bitRate; - const unsigned long kStdMFM8BitCellSize = (totalAvg * 20) / bitRate; + const uint32_t kStdMFM2BitCellSize = (totalAvg * 5) / bitRate; + const uint32_t kStdMFM8BitCellSize = (totalAvg * 20) / bitRate; int mfmMagic = 0; // if set to 1, decode as MFM rather than GCR bool result = false; int i; @@ -1134,15 +1118,15 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, */ i = 1; while (i < numPulses && - (idxStream[i] < (unsigned long) maxIndex || - idxStream[i-1] < (unsigned long) maxIndex || + (idxStream[i] < (uint32_t) maxIndex || + idxStream[i-1] < (uint32_t) maxIndex || minStream[i] < (kStdMFM2BitCellSize - (kStdMFM2BitCellSize / 4)) )) { i++; } if (i == numPulses) { - LOGI(" FDI: no stable and long-enough pulse in track"); + LOGW(" FDI: no stable and long-enough pulse in track"); goto bail; } @@ -1150,7 +1134,7 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, * Set up some variables. */ int nextI, endOfData, adjust, bitOffset, step; - unsigned long refPulse; + uint32_t refPulse; long jitter; samples.Create(kStdMFM2BitCellSize, 1 + mfmMagic); @@ -1174,7 +1158,7 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, * Calculates the current average bit rate from previously * decoded data. */ - unsigned long avgSize; + uint32_t avgSize; int kCell8Limit = (kPulseLimitVal * kStdMFM8BitCellSize) / 100; /* this is the new average size for one MFM bit */ @@ -1195,11 +1179,11 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, /* * Get the next long-enough pulse (may require more than one pulse). */ - unsigned long pulse; + uint32_t pulse; pulse = 0; while (pulse < ((avgSize / 4) - (avgSize / 16))) { - unsigned long avgPulse, minPulse, maxPulse; + uint32_t avgPulse, minPulse, maxPulse; /* advance i */ i++; @@ -1212,10 +1196,10 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, nextI++; if (nextI >= numPulses) nextI = 0; - } while (idxStream[nextI] < (unsigned long) maxIndex); + } while (idxStream[nextI] < (uint32_t) maxIndex); } - if (idxStream[i] >= (unsigned long) maxIndex) { + if (idxStream[i] >= (uint32_t) maxIndex) { /* stable pulse */ avgPulse = avgStream[i] - jitter; minPulse = minStream[i]; @@ -1279,7 +1263,7 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, */ if (i == endOfData) step++; - } else if ((unsigned long) rand() <= (idxStream[i] * RAND_MAX) / maxIndex) { + } else if ((uint32_t) rand() <= (idxStream[i] * RAND_MAX) / maxIndex) { /* futz with it */ int randVal; @@ -1324,7 +1308,7 @@ WrapperFDI::ConvertPulsesToBits(const unsigned long* avgStream, * "realSize" will end up holding the number of bits we're going * to output for this pulse. */ - unsigned long adjustedPulse; + uint32_t adjustedPulse; int realSize; adjustedPulse = pulse; @@ -1448,7 +1432,6 @@ bail: } - /* * Convert a stream of GCR bits into nibbles. * @@ -1463,15 +1446,14 @@ bail: * "*pNibbleLen" should hold the maximum size of the buffer. On success, * it will hold the actual number of bytes used. */ -bool -WrapperFDI::ConvertBitsToNibbles(const unsigned char* bitBuffer, int bitCount, - unsigned char* nibbleBuf, long* pNibbleLen) +bool WrapperFDI::ConvertBitsToNibbles(const uint8_t* bitBuffer, int bitCount, + uint8_t* nibbleBuf, long* pNibbleLen) { BitInputBuffer inputBuffer(bitBuffer, bitCount); - const unsigned char* nibbleBufStart = nibbleBuf; + const uint8_t* nibbleBufStart = nibbleBuf; long outputBufSize = *pNibbleLen; bool result = false; - unsigned char val; + uint8_t val; bool wrap; /* @@ -1508,11 +1490,11 @@ WrapperFDI::ConvertBitsToNibbles(const unsigned char* bitBuffer, int bitCount, if ((val & 0x80) == 0) val = (val << 1) | inputBuffer.GetBit(&wrap); if ((val & 0x80) == 0) { - LOGI(" FDI: WARNING: more than 2 consecutive zeroes (read)"); + LOGW(" FDI: WARNING: more than 2 consecutive zeroes (read)"); } if (nibbleBuf - nibbleBufStart >= outputBufSize) { - LOGI(" FDI: bits overflowed nibble buffer"); + LOGW(" FDI: bits overflowed nibble buffer"); goto bail; } *nibbleBuf++ = val; @@ -1524,7 +1506,7 @@ WrapperFDI::ConvertBitsToNibbles(const unsigned char* bitBuffer, int bitCount, if (inputBuffer.GetBitsConsumed() != bitCount) { /* we dropped some or double-counted some */ - LOGI(" FDI: WARNING: consumed %d of %d bits", + LOGW(" FDI: WARNING: consumed %d of %d bits", inputBuffer.GetBitsConsumed(), bitCount); } @@ -1538,4 +1520,3 @@ WrapperFDI::ConvertBitsToNibbles(const unsigned char* bitBuffer, int bitCount, bail: return result; } - diff --git a/diskimg/FocusDrive.cpp b/diskimg/FocusDrive.cpp index c67d8b5..7c3fdce 100644 --- a/diskimg/FocusDrive.cpp +++ b/diskimg/FocusDrive.cpp @@ -28,16 +28,16 @@ const int kSignatureLen = 14; * We also make space here for the partition names, which live on blocks 1+2. */ typedef struct DiskFSFocusDrive::PartitionMap { - unsigned char signature[kSignatureLen]; - unsigned char unknown1; - unsigned char partCount; // could be ushort, combined w/unknown1 - unsigned char unknown2[16]; + uint8_t signature[kSignatureLen]; + uint8_t unknown1; + uint8_t partCount; // could be ushort, combined w/unknown1 + uint8_t unknown2[16]; struct Entry { - unsigned long startBlock; - unsigned long blockCount; - unsigned long unknown1; - unsigned long unknown2; - unsigned char name[kPartNameLen+1]; + uint32_t startBlock; + uint32_t blockCount; + uint32_t unknown1; + uint32_t unknown2; + uint8_t name[kPartNameLen+1]; } entry[kMaxPartitions]; } PartitionMap; @@ -48,11 +48,11 @@ typedef struct DiskFSFocusDrive::PartitionMap { * The "imageOrder" parameter has no use here, because (in the current * version) embedded parent volumes are implicitly ProDOS-ordered. */ -/*static*/ DIError -DiskFSFocusDrive::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +/*static*/ DIError DiskFSFocusDrive::TestImage(DiskImg* pImg, + DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int partCount; /* @@ -83,16 +83,14 @@ bail: return dierr; } - /* * Unpack a partition map block into a partition map data structure. */ -/*static*/ void -DiskFSFocusDrive::UnpackPartitionMap(const unsigned char* buf, - const unsigned char* nameBuf, PartitionMap* pMap) +/*static*/ void DiskFSFocusDrive::UnpackPartitionMap(const uint8_t* buf, + const uint8_t* nameBuf, PartitionMap* pMap) { - const unsigned char* ptr; - const unsigned char* namePtr; + const uint8_t* ptr; + const uint8_t* namePtr; int i; memcpy(pMap->signature, &buf[0x00], kSignatureLen); @@ -121,8 +119,7 @@ DiskFSFocusDrive::UnpackPartitionMap(const unsigned char* buf, /* * Debug: dump the contents of the partition map. */ -/*static*/ void -DiskFSFocusDrive::DumpPartitionMap(const PartitionMap* pMap) +/*static*/ void DiskFSFocusDrive::DumpPartitionMap(const PartitionMap* pMap) { int i; @@ -133,12 +130,10 @@ DiskFSFocusDrive::DumpPartitionMap(const PartitionMap* pMap) } } - /* * Open up a sub-volume. */ -DIError -DiskFSFocusDrive::OpenSubVolume(long startBlock, long numBlocks, +DIError DiskFSFocusDrive::OpenSubVolume(long startBlock, long numBlocks, const char* name) { DIError dierr = kDIErrNone; @@ -248,8 +243,7 @@ bail: /* * Check to see if this is a FocusDrive volume. */ -/*static*/ DIError -DiskFSFocusDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSFocusDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumBlocks() < kMinInterestingBlocks) @@ -272,8 +266,7 @@ DiskFSFocusDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Prep the FocusDrive "container" for use. */ -DIError -DiskFSFocusDrive::Initialize(void) +DIError DiskFSFocusDrive::Initialize(void) { DIError dierr = kDIErrNone; @@ -296,12 +289,11 @@ DiskFSFocusDrive::Initialize(void) /* * Find the various sub-volumes and open them. */ -DIError -DiskFSFocusDrive::FindSubVolumes(void) +DIError DiskFSFocusDrive::FindSubVolumes(void) { DIError dierr = kDIErrNone; - unsigned char buf[kBlkSize]; - unsigned char nameBuf[kBlkSize*2]; + uint8_t buf[kBlkSize]; + uint8_t nameBuf[kBlkSize*2]; PartitionMap map; int i; @@ -332,8 +324,7 @@ bail: * Open the volume. If it fails, open a placeholder instead. (If *that* * fails, return with an error.) */ -DIError -DiskFSFocusDrive::OpenVol(int idx, long startBlock, long numBlocks, +DIError DiskFSFocusDrive::OpenVol(int idx, long startBlock, long numBlocks, const char* name) { DIError dierr; diff --git a/diskimg/GenericFD.cpp b/diskimg/GenericFD.cpp index 249740d..c0d419b 100644 --- a/diskimg/GenericFD.cpp +++ b/diskimg/GenericFD.cpp @@ -22,23 +22,22 @@ * If "pCRC" is non-NULL, this computes a CRC32 as it goes, using the zlib * library function. */ -/*static*/ DIError -GenericFD::CopyFile(GenericFD* pDst, GenericFD* pSrc, di_off_t length, - unsigned long* pCRC) +/*static*/ DIError GenericFD::CopyFile(GenericFD* pDst, GenericFD* pSrc, + di_off_t length, uint32_t* pCRC) { DIError dierr = kDIErrNone; const int kCopyBufSize = 32768; - unsigned char* copyBuf = NULL; + uint8_t* copyBuf = NULL; int copySize; - LOGI("+++ CopyFile: %ld bytes", (long) length); + LOGD("+++ CopyFile: %ld bytes", (long) length); if (pDst == NULL || pSrc == NULL || length < 0) return kDIErrInvalidArg; if (length == 0) return kDIErrNone; - copyBuf = new unsigned char[kCopyBufSize]; + copyBuf = new uint8_t[kCopyBufSize]; if (copyBuf == NULL) return kDIErrMalloc; @@ -86,11 +85,13 @@ bail: * an off_t, so we can continue to use the FILE* functions there. Under * Windows "lseek" takes a long, so we have to use their specific 64-bit * variant. + * + * TODO: Visual Studio 2005 added _fseeki64. We should be able to merge + * the bulk of the implementation now. */ #ifdef HAVE_FSEEKO -DIError -GFDFile::Open(const char* filename, bool readOnly) +DIError GFDFile::Open(const char* filename, bool readOnly) { DIError dierr = kDIErrNone; @@ -119,8 +120,7 @@ GFDFile::Open(const char* filename, bool readOnly) return dierr; } -DIError -GFDFile::Read(void* buf, size_t length, size_t* pActual) +DIError GFDFile::Read(void* buf, size_t length, size_t* pActual) { DIError dierr = kDIErrNone; size_t actual; @@ -152,8 +152,7 @@ GFDFile::Read(void* buf, size_t length, size_t* pActual) return dierr; } -DIError -GFDFile::Write(const void* buf, size_t length, size_t* pActual) +DIError GFDFile::Write(const void* buf, size_t length, size_t* pActual) { DIError dierr = kDIErrNone; @@ -170,8 +169,7 @@ GFDFile::Write(const void* buf, size_t length, size_t* pActual) return dierr; } -DIError -GFDFile::Seek(di_off_t offset, DIWhence whence) +DIError GFDFile::Seek(di_off_t offset, DIWhence whence) { DIError dierr = kDIErrNone; //static const long kOneGB = 1024*1024*1024; @@ -189,8 +187,7 @@ GFDFile::Seek(di_off_t offset, DIWhence whence) return dierr; } -di_off_t -GFDFile::Tell(void) +di_off_t GFDFile::Tell(void) { DIError dierr = kDIErrNone; di_off_t result; @@ -207,8 +204,7 @@ GFDFile::Tell(void) return result; } -DIError -GFDFile::Truncate(void) +DIError GFDFile::Truncate(void) { #if defined(HAVE_FTRUNCATE) int cc; @@ -227,8 +223,7 @@ GFDFile::Truncate(void) return kDIErrNone; } -DIError -GFDFile::Close(void) +DIError GFDFile::Close(void) { if (fFp == NULL) return kDIErrNotReady; @@ -241,8 +236,7 @@ GFDFile::Close(void) #else /*HAVE_FSEEKO*/ -DIError -GFDFile::Open(const char* filename, bool readOnly) +DIError GFDFile::Open(const char* filename, bool readOnly) { DIError dierr = kDIErrNone; @@ -271,8 +265,7 @@ GFDFile::Open(const char* filename, bool readOnly) return dierr; } -DIError -GFDFile::Read(void* buf, size_t length, size_t* pActual) +DIError GFDFile::Read(void* buf, size_t length, size_t* pActual) { DIError dierr; ssize_t actual; @@ -301,8 +294,7 @@ GFDFile::Read(void* buf, size_t length, size_t* pActual) return kDIErrNone; } -DIError -GFDFile::Write(const void* buf, size_t length, size_t* pActual) +DIError GFDFile::Write(const void* buf, size_t length, size_t* pActual) { DIError dierr; ssize_t actual; @@ -322,8 +314,7 @@ GFDFile::Write(const void* buf, size_t length, size_t* pActual) return kDIErrNone; } -DIError -GFDFile::Seek(di_off_t offset, DIWhence whence) +DIError GFDFile::Seek(di_off_t offset, DIWhence whence) { DIError dierr = kDIErrNone; if (fFd < 0) @@ -340,16 +331,15 @@ GFDFile::Seek(di_off_t offset, DIWhence whence) #endif if (newPosn == kFailure) { - assert((unsigned long) offset != 0xccccccccUL); // uninitialized data! + assert((uint32_t) offset != 0xccccccccUL); // uninitialized data! dierr = ErrnoOrGeneric(); LOGI(" GDFile Seek %ld-%lu failed (err=%d)", - (long) (offset >> 32), (unsigned long) offset, dierr); + (long) (offset >> 32), (uint32_t) offset, dierr); } return dierr; } -di_off_t -GFDFile::Tell(void) +di_off_t GFDFile::Tell(void) { DIError dierr = kDIErrNone; di_off_t result; @@ -371,8 +361,7 @@ GFDFile::Tell(void) return result; } -DIError -GFDFile::Truncate(void) +DIError GFDFile::Truncate(void) { #if defined(HAVE_FTRUNCATE) int cc; @@ -390,8 +379,7 @@ GFDFile::Truncate(void) return kDIErrNone; } -DIError -GFDFile::Close(void) +DIError GFDFile::Close(void) { if (fFd < 0) return kDIErrNotReady; @@ -410,9 +398,8 @@ GFDFile::Close(void) * =========================================================================== */ -DIError -GFDBuffer::Open(void* buffer, di_off_t length, bool doDelete, bool doExpand, - bool readOnly) +DIError GFDBuffer::Open(void* buffer, di_off_t length, bool doDelete, + bool doExpand, bool readOnly) { if (fBuffer != NULL) return kDIErrAlreadyOpen; @@ -444,8 +431,7 @@ GFDBuffer::Open(void* buffer, di_off_t length, bool doDelete, bool doExpand, return kDIErrNone; } -DIError -GFDBuffer::Read(void* buf, size_t length, size_t* pActual) +DIError GFDBuffer::Read(void* buf, size_t length, size_t* pActual) { if (fBuffer == NULL) return kDIErrNotReady; @@ -476,8 +462,7 @@ GFDBuffer::Read(void* buf, size_t length, size_t* pActual) return kDIErrNone; } -DIError -GFDBuffer::Write(const void* buf, size_t length, size_t* pActual) +DIError GFDBuffer::Write(const void* buf, size_t length, size_t* pActual) { if (fBuffer == NULL) return kDIErrNotReady; @@ -527,8 +512,7 @@ GFDBuffer::Write(const void* buf, size_t length, size_t* pActual) return kDIErrNone; } -DIError -GFDBuffer::Seek(di_off_t offset, DIWhence whence) +DIError GFDBuffer::Seek(di_off_t offset, DIWhence whence) { if (fBuffer == NULL) return kDIErrNotReady; @@ -561,16 +545,14 @@ GFDBuffer::Seek(di_off_t offset, DIWhence whence) return kDIErrNone; } -di_off_t -GFDBuffer::Tell(void) +di_off_t GFDBuffer::Tell(void) { if (fBuffer == NULL) return (di_off_t) -1; return fCurrentOffset; } -DIError -GFDBuffer::Close(void) +DIError GFDBuffer::Close(void) { if (fBuffer == NULL) return kDIErrNone; @@ -609,12 +591,11 @@ GFDBuffer::Close(void) * must have the form "N:\" for a logical volume or "80:\" for a physical * volume. */ -DIError -GFDWinVolume::Open(const char* deviceName, bool readOnly) +DIError GFDWinVolume::Open(const char* deviceName, bool readOnly) { DIError dierr = kDIErrNone; HANDLE handle = NULL; - //unsigned long kTwoGBBlocks; + //uint32_t kTwoGBBlocks; if (fVolAccess.Ready()) return kDIErrAlreadyOpen; @@ -643,7 +624,7 @@ GFDWinVolume::Open(const char* deviceName, bool readOnly) assert(fBlockSize > 0); //kTwoGBBlocks = kTwoGB / fBlockSize; - unsigned long totalBlocks; + long totalBlocks; totalBlocks = fVolAccess.GetTotalBlocks(); fVolumeEOF = (di_off_t)totalBlocks * fBlockSize; @@ -655,11 +636,10 @@ bail: return dierr; } -DIError -GFDWinVolume::Read(void* buf, size_t length, size_t* pActual) +DIError GFDWinVolume::Read(void* buf, size_t length, size_t* pActual) { DIError dierr = kDIErrNone; - unsigned char* blkBuf = NULL; + uint8_t* blkBuf = NULL; //LOGI(" GFDWinVolume: reading %ld bytes from offset %ld", length, // fCurrentOffset); @@ -680,7 +660,7 @@ GFDWinVolume::Read(void* buf, size_t length, size_t* pActual) long advanceLen = length; - blkBuf = new unsigned char[fBlockSize]; // get this off the heap?? + blkBuf = new uint8_t[fBlockSize]; // get this off the heap?? long blockIndex = (long) (fCurrentOffset / fBlockSize); int bufOffset = (int) (fCurrentOffset % fBlockSize); // req power of 2 assert(blockIndex >= 0); @@ -739,11 +719,10 @@ bail: return dierr; } -DIError -GFDWinVolume::Write(const void* buf, size_t length, size_t* pActual) +DIError GFDWinVolume::Write(const void* buf, size_t length, size_t* pActual) { DIError dierr = kDIErrNone; - unsigned char* blkBuf = NULL; + uint8_t* blkBuf = NULL; //LOGI(" GFDWinVolume: writing %ld bytes at offset %ld", length, // fCurrentOffset); @@ -766,7 +745,7 @@ GFDWinVolume::Write(const void* buf, size_t length, size_t* pActual) long advanceLen = length; - blkBuf = new unsigned char[fBlockSize]; // get this out of the heap?? + blkBuf = new uint8_t[fBlockSize]; // get this out of the heap?? long blockIndex = (long) (fCurrentOffset / fBlockSize); int bufOffset = (int) (fCurrentOffset % fBlockSize); // req power of 2 assert(blockIndex >= 0); @@ -829,8 +808,7 @@ bail: return dierr; } -DIError -GFDWinVolume::Seek(di_off_t offset, DIWhence whence) +DIError GFDWinVolume::Seek(di_off_t offset, DIWhence whence) { if (!fVolAccess.Ready()) return kDIErrNotReady; @@ -863,16 +841,14 @@ GFDWinVolume::Seek(di_off_t offset, DIWhence whence) return kDIErrNone; } -di_off_t -GFDWinVolume::Tell(void) +di_off_t GFDWinVolume::Tell(void) { if (!fVolAccess.Ready()) return (di_off_t) -1; return fCurrentOffset; } -DIError -GFDWinVolume::Close(void) +DIError GFDWinVolume::Close(void) { if (!fVolAccess.Ready()) return kDIErrNotReady; diff --git a/diskimg/GenericFD.h b/diskimg/GenericFD.h index a856625..c52d4cc 100644 --- a/diskimg/GenericFD.h +++ b/diskimg/GenericFD.h @@ -133,7 +133,7 @@ public: * be seeked to their initial positions. "length" bytes will be copied. */ static DIError CopyFile(GenericFD* pDst, GenericFD* pSrc, di_off_t length, - unsigned long* pCRC = NULL); + uint32_t* pCRC = NULL); protected: GenericFD& operator=(const GenericFD&); diff --git a/diskimg/Global.cpp b/diskimg/Global.cpp index 5e88fd3..0fcd9a3 100644 --- a/diskimg/Global.cpp +++ b/diskimg/Global.cpp @@ -21,8 +21,7 @@ const char* DiskImgLib::kASPIDev = "ASPI:"; /* * Perform one-time DLL initialization. */ -/*static*/ DIError -Global::AppInit(void) +/*static*/ DIError Global::AppInit(void) { NuError nerr; long major, minor, bug; @@ -89,8 +88,7 @@ Global::AppInit(void) /* * Perform cleanup at application shutdown time. */ -/*static*/ DIError -Global::AppCleanup(void) +/*static*/ DIError Global::AppCleanup(void) { LOGI("DiskImgLib cleanup"); delete fpASPI; @@ -125,8 +123,7 @@ Global::AppCleanup(void) /* * Return current library versions. */ -/*static*/ void -Global::GetVersion(long* pMajor, long* pMinor, long* pBug) +/*static*/ void Global::GetVersion(long* pMajor, long* pMinor, long* pBug) { if (pMajor != NULL) *pMajor = kDiskImgVersionMajor; @@ -145,8 +142,7 @@ Global::GetVersion(long* pMajor, long* pMinor, long* pBug) /* * Change the debug message handler. The previous handler is returned. */ -Global::DebugMsgHandler -Global::SetDebugMsgHandler(DebugMsgHandler handler) +Global::DebugMsgHandler Global::SetDebugMsgHandler(DebugMsgHandler handler) { DebugMsgHandler oldHandler; @@ -161,8 +157,7 @@ Global::SetDebugMsgHandler(DebugMsgHandler handler) * Even if _DEBUG_MSGS is disabled we can still get here from the NuFX error * handler. */ -/*static*/ void -Global::PrintDebugMsg(const char* file, int line, const char* fmt, ...) +/*static*/ void Global::PrintDebugMsg(const char* file, int line, const char* fmt, ...) { if (gDebugMsgHandler == NULL) { /* diff --git a/diskimg/Gutenberg.cpp b/diskimg/Gutenberg.cpp index 7396b8d..1433ede 100644 --- a/diskimg/Gutenberg.cpp +++ b/diskimg/Gutenberg.cpp @@ -35,8 +35,7 @@ const int kMaxTSIterations = 32; /* * Get a pointer to the Nth entry in a catalog sector. */ -static inline unsigned char* -GetCatalogEntryPtr(unsigned char* basePtr, int entryNum) +static inline uint8_t* GetCatalogEntryPtr(uint8_t* basePtr, int entryNum) { assert(entryNum >= 0 && entryNum < kCatalogEntriesPerSect); return basePtr + kCatalogEntryOffset + entryNum * kCatalogEntrySize; @@ -47,11 +46,11 @@ GetCatalogEntryPtr(unsigned char* basePtr, int entryNum) * Test this image for Gutenberg-ness. * */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, int* pGoodCount) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, + int* pGoodCount) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; // int numTracks, numSectors; int catTrack = kVTOCTrack; int catSect = kVTOCSector; @@ -106,8 +105,7 @@ bail: /* * Test to see if the image is a Gutenberg word processor data disk. */ -/*static*/ DIError -DiskFSGutenberg::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSGutenberg::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumTracks() > kMaxInterestingTracks) @@ -155,8 +153,7 @@ DiskFSGutenberg::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSGutenberg::Initialize(InitMode initMode) +DIError DiskFSGutenberg::Initialize(InitMode initMode) { DIError dierr = kDIErrNone; @@ -185,8 +182,7 @@ bail: /* * Get the amount of free space remaining. */ -DIError -DiskFSGutenberg::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, +DIError DiskFSGutenberg::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, int* pUnitSize) const { *pTotalUnits = fpImg->GetNumTracks() * fpImg->GetNumSectPerTrack(); @@ -195,16 +191,13 @@ DiskFSGutenberg::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, return kDIErrNone; } - /* * Read the disk's catalog. - * */ -DIError -DiskFSGutenberg::ReadCatalog(void) +DIError DiskFSGutenberg::ReadCatalog(void) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int catTrack, catSect; int iterations; @@ -222,7 +215,7 @@ DiskFSGutenberg::ReadCatalog(void) goto bail; memcpy(fDiskVolumeName, &sctBuf[6], kMaxVolNameLen); // Copy out the volume name; it should be the same on all catalog sectors. fDiskVolumeName[kMaxVolNameLen] = 0x00; - DiskFSGutenberg::LowerASCII((unsigned char*)fDiskVolumeName, kMaxVolNameLen); + DiskFSGutenberg::LowerASCII((uint8_t*)fDiskVolumeName, kMaxVolNameLen); A2FileGutenberg::TrimTrailingSpaces(fDiskVolumeName); dierr = ProcessCatalogSector(catTrack, catSect, sctBuf); @@ -253,12 +246,11 @@ bail: * Pass in the track, sector, and the contents of that track and sector. * (We only use "catTrack" and "catSect" to fill out some fields.) */ -DIError -DiskFSGutenberg::ProcessCatalogSector(int catTrack, int catSect, - const unsigned char* sctBuf) +DIError DiskFSGutenberg::ProcessCatalogSector(int catTrack, int catSect, + const uint8_t* sctBuf) { A2FileGutenberg* pFile; - const unsigned char* pEntry; + const uint8_t* pEntry; int i; pEntry = &sctBuf[kCatalogEntryOffset]; @@ -298,31 +290,27 @@ DiskFSGutenberg::ProcessCatalogSector(int catTrack, int catSect, return kDIErrNone; } - /* * Perform consistency checks on the filesystem. * * Returns "true" if disk appears to be perfect, "false" otherwise. */ -bool -DiskFSGutenberg::CheckDiskIsGood(void) +bool DiskFSGutenberg::CheckDiskIsGood(void) { bool result = true; return result; } - /* * Run through our list of files, computing the lengths and marking file * usage in the VolumeUsage object. */ -DIError -DiskFSGutenberg::GetFileLengths(void) +DIError DiskFSGutenberg::GetFileLengths(void) { A2FileGutenberg* pFile; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int tsCount = 0; - unsigned short currentTrack, currentSector; + uint16_t currentTrack, currentSector; pFile = (A2FileGutenberg*) GetNextFile(NULL); while (pFile != NULL) { @@ -352,7 +340,6 @@ bail: return kDIErrNone; } - /* * Convert high ASCII to low ASCII. * @@ -361,8 +348,7 @@ bail: * * We modify the first "len" bytes of "buf" in place. */ -/*static*/ void -DiskFSGutenberg::LowerASCII(unsigned char* buf, long len) +/*static*/ void DiskFSGutenberg::LowerASCII(uint8_t* buf, long len) { while (len--) { if (*buf & 0x80) { @@ -415,13 +401,11 @@ A2FileGutenberg::~A2FileGutenberg(void) delete fpOpenFile; } - /* * Convert the filetype enum to a ProDOS type. * */ -long -A2FileGutenberg::GetFileType(void) const +long A2FileGutenberg::GetFileType(void) const { return 0x04; // TXT; } @@ -430,10 +414,9 @@ A2FileGutenberg::GetFileType(void) const * "Fix" a filename. Convert DOS-ASCII to normal ASCII, and strip * trailing spaces. */ -void -A2FileGutenberg::FixFilename(void) +void A2FileGutenberg::FixFilename(void) { - DiskFSGutenberg::LowerASCII((unsigned char*)fFileName, kMaxFileName); + DiskFSGutenberg::LowerASCII((uint8_t*)fFileName, kMaxFileName); TrimTrailingSpaces(fFileName); } @@ -442,8 +425,7 @@ A2FileGutenberg::FixFilename(void) * * Assumes the filename has already been converted to low ASCII. */ -/*static*/ void -A2FileGutenberg::TrimTrailingSpaces(char* filename) +/*static*/ void A2FileGutenberg::TrimTrailingSpaces(char* filename) { char* lastspc = filename + strlen(filename); @@ -464,8 +446,7 @@ A2FileGutenberg::TrimTrailingSpaces(char* filename) * * "buf" must be able to hold kMaxFileName+1 chars. */ -/*static*/ void -A2FileGutenberg::MakeDOSName(char* buf, const char* name) +/*static*/ void A2FileGutenberg::MakeDOSName(char* buf, const char* name) { for (int i = 0; i < kMaxFileName; i++) { if (*name == '\0') @@ -480,8 +461,7 @@ A2FileGutenberg::MakeDOSName(char* buf, const char* name) /* * Set up state for this file. */ -DIError -A2FileGutenberg::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileGutenberg::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { DIError dierr = kDIErrNone; @@ -520,8 +500,7 @@ bail: /* * Dump the contents of an A2FileGutenberg. */ -void -A2FileGutenberg::Dump(void) const +void A2FileGutenberg::Dump(void) const { LOGI("A2FileGutenberg '%s'", fFileName); LOGI(" TS T=%-2d S=%-2d", fTrack, fSector); @@ -542,8 +521,7 @@ A2FileGutenberg::Dump(void) const * Read data from the current offset. * */ -DIError -A2FDGutenberg::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDGutenberg::Read(void* buf, size_t len, size_t* pActual) { LOGI(" Gutenberg reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -551,7 +529,7 @@ A2FDGutenberg::Read(void* buf, size_t len, size_t* pActual) A2FileGutenberg* pFile = (A2FileGutenberg*) fpFile; DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; short currentTrack, currentSector; di_off_t actualOffset = fOffset + pFile->fDataOffset; // adjust for embedded len int bufOffset = 6; @@ -587,10 +565,8 @@ A2FDGutenberg::Read(void* buf, size_t len, size_t* pActual) /* * Writing Gutenberg files isn't supported. - * */ -DIError -A2FDGutenberg::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDGutenberg::Write(const void* buf, size_t len, size_t* pActual) { return kDIErrNotSupported; } @@ -598,8 +574,7 @@ A2FDGutenberg::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to the specified offset. */ -DIError -A2FDGutenberg::Seek(di_off_t offset, DIWhence whence) +DIError A2FDGutenberg::Seek(di_off_t offset, DIWhence whence) { return kDIErrNotSupported; } @@ -607,8 +582,7 @@ A2FDGutenberg::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDGutenberg::Tell(void) +di_off_t A2FDGutenberg::Tell(void) { return kDIErrNotSupported; } @@ -627,8 +601,7 @@ A2FDGutenberg::Tell(void) * Most applications don't check the value of "Close", or call it from a * destructor, so we call CloseDescr whether we succeed or not. */ -DIError -A2FDGutenberg::Close(void) +DIError A2FDGutenberg::Close(void) { DIError dierr = kDIErrNone; @@ -636,17 +609,15 @@ A2FDGutenberg::Close(void) return dierr; } - /* * Return the #of sectors/blocks in the file. */ -long -A2FDGutenberg::GetSectorCount(void) const +long A2FDGutenberg::GetSectorCount(void) const { return fTSCount; } -long -A2FDGutenberg::GetBlockCount(void) const + +long A2FDGutenberg::GetBlockCount(void) const { return (fTSCount+1)/2; } @@ -656,16 +627,15 @@ A2FDGutenberg::GetBlockCount(void) const * * Returns (0,0) for a sparse sector. */ -DIError -A2FDGutenberg::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDGutenberg::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { return kDIErrInvalidIndex; } + /* * Unimplemented */ -DIError -A2FDGutenberg::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDGutenberg::GetStorage(long blockIdx, long* pBlock) const { return kDIErrInvalidIndex; } diff --git a/diskimg/HFS.cpp b/diskimg/HFS.cpp index c2fad17..042a0ec 100644 --- a/diskimg/HFS.cpp +++ b/diskimg/HFS.cpp @@ -30,15 +30,15 @@ const int kBlkSize = 512; const int kMasterDirBlock = 2; // also a copy in next-to-last block -const unsigned short kSignature = 0x4244; // or 0xd2d7 for MFS +const uint16_t kSignature = 0x4244; // or 0xd2d7 for MFS const int kMaxDirectoryDepth = 128; // not sure what HFS limit is //namespace DiskImgLib { /* extent descriptor */ typedef struct ExtDescriptor { - unsigned short xdrStABN; // first allocation block - unsigned short xdrNumABlks; // #of allocation blocks + uint16_t xdrStABN; // first allocation block + uint16_t xdrNumABlks; // #of allocation blocks } ExtDescriptor; /* extent data record */ typedef struct ExtDataRec { @@ -50,36 +50,36 @@ typedef struct ExtDataRec { * chapter 2 ("Data Organization on Volumes"), pages 2-60 to 2-62. */ typedef struct DiskFSHFS::MasterDirBlock { - unsigned short drSigWord; // volume signature - unsigned long drCrDate; // date/time of volume creation - unsigned long drLsMod; // date/time of last modification - unsigned short drAtrb; // volume attributes - unsigned short drNmPls; // #of files in root directory - unsigned short drVBMSt; // first block of volume bitmap - unsigned short drAllocPtr; // start of next allocation search - unsigned short drNmAlBlks; // number of allocation blocks in volume - unsigned long drAlBlkSiz; // size (bytes) of allocation blocks - unsigned long drClpSiz; // default clump size - unsigned short drAlBlSt; // first allocation block in volume - unsigned long drNxtCNID; // next unused catalog node ID - unsigned short drFreeBks; // number of unused allocation blocks - unsigned char drVN[28]; // volume name (pascal string) - unsigned long drVolBkUp; // date/time of last backup - unsigned short drVSeqNum; // volume backup sequence number - unsigned long drWrCnt; // volume write count - unsigned long drXTClpSiz; // clump size for extents overflow file - unsigned long drCTClpSiz; // clump size for catalog file - unsigned short drNmRtDirs; // #of directories in root directory - unsigned long drFilCnt; // #of files in volume - unsigned long drDirCnt; // #of directories in volume - unsigned long drFndrInfo[8]; // information used by the Finder - unsigned short drVCSize; // size (blocks) of volume cache - unsigned short drVBMCSize; // size (blocks) of volume bitmap cache - unsigned short drCtlCSize; // size (blocks) of common volume cache - unsigned long drXTFlSize; // size (bytes) of extents overflow file - ExtDataRec drXTExtRec; // extent record for extents overflow file - unsigned long drCTFlSize; // size (bytes) of catalog file - ExtDataRec drCTExtRec; // extent record for catalog file + uint16_t drSigWord; // volume signature + uint32_t drCrDate; // date/time of volume creation + uint32_t drLsMod; // date/time of last modification + uint16_t drAtrb; // volume attributes + uint16_t drNmPls; // #of files in root directory + uint16_t drVBMSt; // first block of volume bitmap + uint16_t drAllocPtr; // start of next allocation search + uint16_t drNmAlBlks; // number of allocation blocks in volume + uint32_t drAlBlkSiz; // size (bytes) of allocation blocks + uint32_t drClpSiz; // default clump size + uint16_t drAlBlSt; // first allocation block in volume + uint32_t drNxtCNID; // next unused catalog node ID + uint16_t drFreeBks; // number of unused allocation blocks + uint8_t drVN[28]; // volume name (pascal string) + uint32_t drVolBkUp; // date/time of last backup + uint16_t drVSeqNum; // volume backup sequence number + uint32_t drWrCnt; // volume write count + uint32_t drXTClpSiz; // clump size for extents overflow file + uint32_t drCTClpSiz; // clump size for catalog file + uint16_t drNmRtDirs; // #of directories in root directory + uint32_t drFilCnt; // #of files in volume + uint32_t drDirCnt; // #of directories in volume + uint32_t drFndrInfo[8]; // information used by the Finder + uint16_t drVCSize; // size (blocks) of volume cache + uint16_t drVBMCSize; // size (blocks) of volume bitmap cache + uint16_t drCtlCSize; // size (blocks) of common volume cache + uint32_t drXTFlSize; // size (bytes) of extents overflow file + ExtDataRec drXTExtRec; // extent record for extents overflow file + uint32_t drCTFlSize; // size (bytes) of catalog file + ExtDataRec drCTExtRec; // extent record for catalog file } MasterDirBlock; //}; // namespace DiskImgLib @@ -87,8 +87,7 @@ typedef struct DiskFSHFS::MasterDirBlock { /* * Extract fields from a Master Directory Block. */ -/*static*/ void -DiskFSHFS::UnpackMDB(const unsigned char* buf, MasterDirBlock* pMDB) +/*static*/ void DiskFSHFS::UnpackMDB(const uint8_t* buf, MasterDirBlock* pMDB) { pMDB->drSigWord = GetShortBE(&buf[0x00]); pMDB->drCrDate = GetLongBE(&buf[0x02]); @@ -129,12 +128,11 @@ DiskFSHFS::UnpackMDB(const unsigned char* buf, MasterDirBlock* pMDB) * * We test a few fields in the master directory block for validity. */ -/*static*/ DIError -DiskFSHFS::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +/*static*/ DIError DiskFSHFS::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; MasterDirBlock mdb; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; dierr = pImg->ReadBlockSwapped(kMasterDirBlock, blkBuf, imageOrder, DiskImg::kSectorOrderProDOS); @@ -181,8 +179,7 @@ bail: /* * Test to see if the image is an HFS disk. */ -/*static*/ DIError -DiskFSHFS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSHFS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { //return kDIErrFilesystemNotFound; // DEBUG DEBUG DEBUG @@ -209,16 +206,14 @@ DiskFSHFS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, return kDIErrFilesystemNotFound; } - /* * Load some stuff from the volume header. */ -DIError -DiskFSHFS::LoadVolHeader(void) +DIError DiskFSHFS::LoadVolHeader(void) { DIError dierr = kDIErrNone; MasterDirBlock mdb; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; if (fLocalTimeOffset == -1) { struct tm* ptm; @@ -264,7 +259,7 @@ DiskFSHFS::LoadVolHeader(void) fAllocationBlockSize = mdb.drAlBlkSiz; fTotalBlocks = fpImg->GetNumBlocks(); - unsigned long minBlocks; + uint32_t minBlocks; minBlocks = mdb.drNmAlBlks * (mdb.drAlBlkSiz / kBlkSize) + mdb.drAlBlSt + 2; assert(fTotalBlocks >= minBlocks); // verified during fs tests @@ -319,8 +314,7 @@ bail: /* * Set the volume ID based on fVolumeName. */ -void -DiskFSHFS::SetVolumeID(void) +void DiskFSHFS::SetVolumeID(void) { strcpy(fVolumeID, "HFS "); strcat(fVolumeID, fVolumeName); @@ -329,8 +323,7 @@ DiskFSHFS::SetVolumeID(void) /* * Blank out the volume usage map. The HFS volume bitmap is not yet supported. */ -void -DiskFSHFS::SetVolumeUsageMap(void) +void DiskFSHFS::SetVolumeUsageMap(void) { VolumeUsage::ChunkState cstate; long block; @@ -345,12 +338,10 @@ DiskFSHFS::SetVolumeUsageMap(void) fVolumeUsage.SetChunkState(block, &cstate); } - /* * Print some interesting fields to the debug log. */ -void -DiskFSHFS::DumpVolHeader(void) +void DiskFSHFS::DumpVolHeader(void) { LOGI("HFS volume header read:"); LOGI(" volume name = '%s'", fVolumeName); @@ -376,8 +367,7 @@ DiskFSHFS::DumpVolHeader(void) * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSHFS::Initialize(InitMode initMode) +DIError DiskFSHFS::Initialize(InitMode initMode) { DIError dierr = kDIErrNone; char msg[kMaxVolumeName + 32]; @@ -443,8 +433,7 @@ bail: * * Returns -1 on failure. */ -unsigned long -DiskFSHFS::LibHFSCB(void* vThis, int op, unsigned long arg1, void* arg2) +unsigned long DiskFSHFS::LibHFSCB(void* vThis, int op, unsigned long arg1, void* arg2) { DiskFSHFS* pThis = (DiskFSHFS*) vThis; unsigned long result = (unsigned long) -1; @@ -492,12 +481,10 @@ DiskFSHFS::LibHFSCB(void* vThis, int op, unsigned long arg1, void* arg2) return result; } - /* * Determine the amount of free space on the disk. */ -DIError -DiskFSHFS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, +DIError DiskFSHFS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, int* pUnitSize) const { assert(fHfsVol != NULL); @@ -516,8 +503,7 @@ DiskFSHFS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, /* * Recursively traverse the filesystem. */ -DIError -DiskFSHFS::RecursiveDirAdd(A2File* pParent, const char* basePath, int depth) +DIError DiskFSHFS::RecursiveDirAdd(A2File* pParent, const char* basePath, int depth) { DIError dierr = kDIErrNone; hfsdir* dir; @@ -609,14 +595,14 @@ void A2FileHFS::InitEntry(const hfsdirent* dirEntry) fDataLength = 0; fRsrcLength = -1; } else { - unsigned char* pType; + uint8_t* pType; fIsDir = false; - pType = (unsigned char*) dirEntry->u.file.type; + pType = (uint8_t*) dirEntry->u.file.type; fType = pType[0] << 24 | pType[1] << 16 | pType[2] << 8 | pType[3]; - pType = (unsigned char*) dirEntry->u.file.creator; + pType = (uint8_t*) dirEntry->u.file.creator; fCreator = pType[0] << 24 | pType[1] << 16 | pType[2] << 8 | pType[3]; fDataLength = dirEntry->u.file.dsize; @@ -641,8 +627,7 @@ void A2FileHFS::InitEntry(const hfsdirent* dirEntry) /* * Return "true" if "name" is valid for use as an HFS volume name. */ -/*static*/ bool -DiskFSHFS::IsValidVolumeName(const char* name) +/*static*/ bool DiskFSHFS::IsValidVolumeName(const char* name) { if (name == NULL) return false; @@ -663,8 +648,7 @@ DiskFSHFS::IsValidVolumeName(const char* name) /* * Return "true" if "name" is valid for use as an HFS file name. */ -/*static*/ bool -DiskFSHFS::IsValidFileName(const char* name) +/*static*/ bool DiskFSHFS::IsValidFileName(const char* name) { if (name == NULL) return false; @@ -685,8 +669,7 @@ DiskFSHFS::IsValidFileName(const char* name) /* * Format the current volume with HFS. */ -DIError -DiskFSHFS::Format(DiskImg* pDiskImg, const char* volName) +DIError DiskFSHFS::Format(DiskImg* pDiskImg, const char* volName) { assert(strlen(volName) > 0 && strlen(volName) <= kMaxVolumeName); @@ -712,7 +695,6 @@ DiskFSHFS::Format(DiskImg* pDiskImg, const char* volName) return kDIErrNone; } - /* * Normalize an HFS path. Invokes DoNormalizePath and handles the buffer * management (if the normalized path doesn't fit in "*pNormalizedBufLen" @@ -721,8 +703,7 @@ DiskFSHFS::Format(DiskImg* pDiskImg, const char* volName) * This is invoked from the generalized "add" function in CiderPress, which * doesn't want to understand the ins and outs of pathnames. */ -DIError -DiskFSHFS::NormalizePath(const char* path, char fssep, +DIError DiskFSHFS::NormalizePath(const char* path, char fssep, char* normalizedBuf, int* pNormalizedBufLen) { DIError dierr = kDIErrNone; @@ -760,8 +741,7 @@ bail: * * The caller must delete[] "*pNormalizedPath". */ -DIError -DiskFSHFS::DoNormalizePath(const char* path, char fssep, +DIError DiskFSHFS::DoNormalizePath(const char* path, char fssep, char** pNormalizedPath) { DIError dierr = kDIErrNone; @@ -876,11 +856,10 @@ bail: * Returns <0, ==0, or >0 depending on whether sstr1 is lexically less than, * equal to, or greater than sstr2. */ -/*static*/ int -DiskFSHFS::CompareMacFileNames(const char* sstr1, const char* sstr2) +/*static*/ int DiskFSHFS::CompareMacFileNames(const char* sstr1, const char* sstr2) { - const unsigned char* str1 = (const unsigned char*) sstr1; - const unsigned char* str2 = (const unsigned char*) sstr2; + const uint8_t* str1 = (const uint8_t*) sstr1; + const uint8_t* str2 = (const uint8_t*) sstr2; int diff; while (*str1 && *str2) { @@ -906,8 +885,7 @@ DiskFSHFS::CompareMacFileNames(const char* sstr1, const char* sstr2) * but may require disk reads. We use the DiskFS interface, on the assumption * that someday we'll switch the linear list to a tree structure. */ -DIError -DiskFSHFS::MakeFileNameUnique(const char* pathName, char** pUniqueName) +DIError DiskFSHFS::MakeFileNameUnique(const char* pathName, char** pUniqueName) { A2File* pFile; const int kMaxExtra = 3; @@ -984,7 +962,6 @@ DiskFSHFS::MakeFileNameUnique(const char* pathName, char** pUniqueName) return kDIErrNone; } - /* * Create a new file or directory. Automatically creates the base path * if necessary. @@ -993,8 +970,7 @@ DiskFSHFS::MakeFileNameUnique(const char* pathName, char** pUniqueName) * a stronger set of utility functions in the parent class now that we have * more than one hierarchical file system. */ -DIError -DiskFSHFS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) +DIError DiskFSHFS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) { DIError dierr = kDIErrNone; char typeStr[5], creatorStr[5]; @@ -1317,8 +1293,7 @@ bail: * * We need to use a different call for file vs. directory. */ -DIError -DiskFSHFS::DeleteFile(A2File* pGenericFile) +DIError DiskFSHFS::DeleteFile(A2File* pGenericFile) { DIError dierr = kDIErrNone; char* pathName = NULL; @@ -1373,8 +1348,7 @@ bail: * get fixed up when we copy them to a ProDOS disk, which is the only way * 8-bit AppleWorks can get at them. */ -DIError -DiskFSHFS::RenameFile(A2File* pGenericFile, const char* newName) +DIError DiskFSHFS::RenameFile(A2File* pGenericFile, const char* newName) { DIError dierr = kDIErrNone; A2FileHFS* pFile = (A2FileHFS*) pGenericFile; @@ -1474,8 +1448,7 @@ bail: * [This was lifted straight out of the ProDOS sources. It should probably * be moved into generic DiskFS.] */ -DIError -DiskFSHFS::RegeneratePathName(A2FileHFS* pFile) +DIError DiskFSHFS::RegeneratePathName(A2FileHFS* pFile) { A2FileHFS* pParent; char* buf = NULL; @@ -1532,8 +1505,7 @@ DiskFSHFS::RegeneratePathName(A2FileHFS* pFile) * Mac convention is to *not* start the volume name with a colon. In fact, * the libhfs convention is to *end* the volume names with a colon. */ -DIError -DiskFSHFS::RenameVolume(const char* newName) +DIError DiskFSHFS::RenameVolume(const char* newName) { DIError dierr = kDIErrNone; A2FileHFS* pFile; @@ -1579,8 +1551,7 @@ bail: /* * Set file attributes. */ -DIError -DiskFSHFS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, +DIError DiskFSHFS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, long accessFlags) { DIError dierr = kDIErrNone; @@ -1616,12 +1587,12 @@ DiskFSHFS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, else dirEnt.flags &= ~HFS_ISLOCKED; - LOGI(" HFS setting '%s' to fdflags=0x%04x flags=0x%04x", + LOGD(" HFS setting '%s' to fdflags=0x%04x flags=0x%04x", colonPath, dirEnt.fdflags, dirEnt.flags); - LOGI(" type=0x%08lx creator=0x%08lx", fileType, auxType); + LOGD(" type=0x%08lx creator=0x%08lx", fileType, auxType); if (hfs_setattr(fHfsVol, colonPath, &dirEnt) != 0) { - LOGI(" HFS setattr '%s' failed: %s", colonPath, hfs_error); + LOGW(" HFS setattr '%s' failed: %s", colonPath, hfs_error); dierr = kDIErrGeneric; goto bail; } @@ -1649,8 +1620,7 @@ bail: /* * Dump the contents of the A2File structure. */ -void -A2FileHFS::Dump(void) const +void A2FileHFS::Dump(void) const { LOGI("A2FileHFS '%s'", fFileName); } @@ -1701,7 +1671,7 @@ long A2FileHFS::GetFileType(void) const return digit1 << 4 | digit2; } - unsigned char flag = (unsigned char)(fType >> 24); + uint8_t flag = (uint8_t)(fType >> 24); if (flag == 0x70) { // 'p' /* type and aux embedded within */ return (fType >> 16) & 0xff; @@ -1718,7 +1688,7 @@ long A2FileHFS::GetFileType(void) const else return 0x00; } -}; +} /* * If this has a ProDOS aux type, convert it. @@ -1728,7 +1698,7 @@ long A2FileHFS::GetAuxType(void) const if (fCreator != kPdosType) return fCreator; - unsigned char flag = (unsigned char)(fType >> 24); + uint8_t flag = (uint8_t)(fType >> 24); if (flag == 0x70) { // 'p' /* type and aux embedded within */ return fType & 0xffff; @@ -1743,8 +1713,7 @@ long A2FileHFS::GetAuxType(void) const * * If we're in the volume directory, pass in "" for the base path (not NULL). */ -void -A2FileHFS::SetPathName(const char* basePath, const char* fileName) +void A2FileHFS::SetPathName(const char* basePath, const char* fileName) { assert(basePath != NULL && fileName != NULL); if (fPathName != NULL) @@ -1774,8 +1743,7 @@ A2FileHFS::SetPathName(const char* basePath, const char* fileName) * * The caller must delete[] the return value. */ -char* -A2FileHFS::GetLibHFSPathName(void) const +char* A2FileHFS::GetLibHFSPathName(void) const { char* nameBuf; @@ -1794,8 +1762,7 @@ A2FileHFS::GetLibHFSPathName(void) const * conversions discard the file's aux type and therefore are unsuitable, * and the conversion of SRC throws away its identity. */ -/*static*/ void -A2FileHFS::ConvertTypeToHFS(long fileType, long auxType, +/*static*/ void A2FileHFS::ConvertTypeToHFS(long fileType, long auxType, char* pType, char* pCreator) { if (fileType == 0x00 && auxType == 0x0000) { @@ -1808,9 +1775,9 @@ A2FileHFS::ConvertTypeToHFS(long fileType, long auxType, auxType >= 0 && auxType <= 0xffff) { pType[0] = 'p'; - pType[1] = (unsigned char) fileType; - pType[2] = (unsigned char) (auxType >> 8); - pType[3] = (unsigned char) auxType; + pType[1] = (uint8_t) fileType; + pType[2] = (uint8_t) (auxType >> 8); + pType[3] = (uint8_t) auxType; pType[4] = '\0'; pCreator[0] = 'p'; pCreator[1] = 'd'; @@ -1818,15 +1785,15 @@ A2FileHFS::ConvertTypeToHFS(long fileType, long auxType, pCreator[3] = 's'; pCreator[4] = '\0'; } else { - pType[0] = (unsigned char)(fileType >> 24); - pType[1] = (unsigned char)(fileType >> 16); - pType[2] = (unsigned char)(fileType >> 8); - pType[3] = (unsigned char) fileType; + pType[0] = (uint8_t)(fileType >> 24); + pType[1] = (uint8_t)(fileType >> 16); + pType[2] = (uint8_t)(fileType >> 8); + pType[3] = (uint8_t) fileType; pType[4] = '\0'; - pCreator[0] = (unsigned char)(auxType >> 24); - pCreator[1] = (unsigned char)(auxType >> 16); - pCreator[2] = (unsigned char)(auxType >> 8); - pCreator[3] = (unsigned char) auxType; + pCreator[0] = (uint8_t)(auxType >> 24); + pCreator[1] = (uint8_t)(auxType >> 16); + pCreator[2] = (uint8_t)(auxType >> 8); + pCreator[3] = (uint8_t) auxType; pCreator[4] = '\0'; } } @@ -1840,8 +1807,7 @@ A2FileHFS::ConvertTypeToHFS(long fileType, long auxType, * by the rest of CiderPress (and most of the civilized world), so instead * of storing the pathname that way we just tack it on here. */ -DIError -A2FileHFS::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileHFS::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { DIError dierr = kDIErrNone; @@ -1885,8 +1851,7 @@ bail: /* * Read a chunk of data from the fake file. */ -DIError -A2FDHFS::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDHFS::Read(void* buf, size_t len, size_t* pActual) { long result; @@ -1927,8 +1892,7 @@ A2FDHFS::Read(void* buf, size_t len, size_t* pActual) * one piece. This function does work correctly with multiple smaller * pieces though, because it lets libhfs do all the work.) */ -DIError -A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) { long result; @@ -1967,8 +1931,7 @@ A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to a new offset. */ -DIError -A2FDHFS::Seek(di_off_t offset, DIWhence whence) +DIError A2FDHFS::Seek(di_off_t offset, DIWhence whence) { int hfsWhence; unsigned long result; @@ -1993,8 +1956,7 @@ A2FDHFS::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDHFS::Tell(void) +di_off_t A2FDHFS::Tell(void) { di_off_t offset; @@ -2006,8 +1968,7 @@ A2FDHFS::Tell(void) /* * Release file state, and tell our parent to destroy us. */ -DIError -A2FDHFS::Close(void) +DIError A2FDHFS::Close(void) { hfsdirent dirEnt; @@ -2050,15 +2011,14 @@ A2FDHFS::Close(void) * Return the #of sectors/blocks in the file. Not supported, but since HFS * doesn't support "sparse" files we can fake it. */ -long -A2FDHFS::GetSectorCount(void) const +long A2FDHFS::GetSectorCount(void) const { A2FileHFS* pFile = (A2FileHFS*) fpFile; return (long) ((pFile->fDataLength+255) / 256 + (pFile->fRsrcLength+255) / 256); } -long -A2FDHFS::GetBlockCount(void) const + +long A2FDHFS::GetBlockCount(void) const { A2FileHFS* pFile = (A2FileHFS*) fpFile; return (long) ((pFile->fDataLength+511) / 512 + @@ -2068,16 +2028,15 @@ A2FDHFS::GetBlockCount(void) const /* * Return the Nth track/sector in this file. Not supported. */ -DIError -A2FDHFS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDHFS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { return kDIErrNotSupported; } + /* * Return the Nth 512-byte block in this file. Not supported. */ -DIError -A2FDHFS::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDHFS::GetStorage(long blockIdx, long* pBlock) const { return kDIErrNotSupported; } @@ -2094,8 +2053,7 @@ A2FDHFS::GetStorage(long blockIdx, long* pBlock) const * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSHFS::Initialize(InitMode initMode) +DIError DiskFSHFS::Initialize(InitMode initMode) { DIError dierr = kDIErrNone; @@ -2112,12 +2070,10 @@ bail: return dierr; } - /* * Fill a buffer with some interesting stuff, and add it to the file list. */ -void -DiskFSHFS::CreateFakeFile(void) +void DiskFSHFS::CreateFakeFile(void) { A2FileHFS* pFile; char buf[768]; // currently running about 475 @@ -2156,7 +2112,7 @@ DiskFSHFS::CreateFakeFile(void) dateBuf[len-1] = '\0'; memset(buf, 0, sizeof(buf)); - sprintf(buf, kFormatMsg, + snprintf(buf, NELEM(buf), kFormatMsg, fVolumeName, capacity, (double) capacity / 2048.0, @@ -2194,8 +2150,7 @@ DIError GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, /* * Not a whole lot to do. */ -DIError -A2FileHFS::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileHFS::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { A2FDHFS* pOpenFile = NULL; @@ -2224,10 +2179,9 @@ A2FileHFS::Open(A2FileDescr** ppOpenFile, bool readOnly, /* * Read a chunk of data from the fake file. */ -DIError -A2FDHFS::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDHFS::Read(void* buf, size_t len, size_t* pActual) { - LOGI(" HFS reading %d bytes from '%s' (offset=%ld)", + LOGD(" HFS reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); A2FileHFS* pFile = (A2FileHFS*) fpFile; @@ -2251,8 +2205,7 @@ A2FDHFS::Read(void* buf, size_t len, size_t* pActual) /* * Write data at the current offset. */ -DIError -A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) { return kDIErrNotSupported; } @@ -2260,8 +2213,7 @@ A2FDHFS::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to a new offset. */ -DIError -A2FDHFS::Seek(di_off_t offset, DIWhence whence) +DIError A2FDHFS::Seek(di_off_t offset, DIWhence whence) { di_off_t fileLen = ((A2FileHFS*) fpFile)->fDataLength; @@ -2296,8 +2248,7 @@ A2FDHFS::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDHFS::Tell(void) +di_off_t A2FDHFS::Tell(void) { return fOffset; } @@ -2305,8 +2256,7 @@ A2FDHFS::Tell(void) /* * Release file state, and tell our parent to destroy us. */ -DIError -A2FDHFS::Close(void) +DIError A2FDHFS::Close(void) { fpFile->CloseDescr(this); return kDIErrNone; @@ -2315,14 +2265,13 @@ A2FDHFS::Close(void) /* * Return the #of sectors/blocks in the file. */ -long -A2FDHFS::GetSectorCount(void) const +long A2FDHFS::GetSectorCount(void) const { A2FileHFS* pFile = (A2FileHFS*) fpFile; return (long) ((pFile->fDataLength+255) / 256); } -long -A2FDHFS::GetBlockCount(void) const + +long A2FDHFS::GetBlockCount(void) const { A2FileHFS* pFile = (A2FileHFS*) fpFile; return (long) ((pFile->fDataLength+511) / 512); @@ -2331,16 +2280,15 @@ A2FDHFS::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDHFS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDHFS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { return kDIErrNotSupported; } + /* * Return the Nth 512-byte block in this file. */ -DIError -A2FDHFS::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDHFS::GetStorage(long blockIdx, long* pBlock) const { return kDIErrNotSupported; } diff --git a/diskimg/ImageWrapper.cpp b/diskimg/ImageWrapper.cpp index 1ed4025..1027062 100644 --- a/diskimg/ImageWrapper.cpp +++ b/diskimg/ImageWrapper.cpp @@ -42,8 +42,7 @@ * The easiest way to do that is to open up the header and see if * it looks valid. */ -/*static*/ DIError -Wrapper2MG::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError Wrapper2MG::Test(GenericFD* pGFD, di_off_t wrappedLength) { TwoImgHeader header; @@ -62,8 +61,7 @@ Wrapper2MG::Test(GenericFD* pGFD, di_off_t wrappedLength) /* * Get the header (again) and use it to locate the data. */ -DIError -Wrapper2MG::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, +DIError Wrapper2MG::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) @@ -108,8 +106,7 @@ Wrapper2MG::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, /* * Initialize fields for a new file. */ -DIError -Wrapper2MG::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError Wrapper2MG::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -185,8 +182,7 @@ Wrapper2MG::Create(di_off_t length, DiskImg::PhysicalFormat physical, * Since there's no checksum, none of the header fields change, so we * don't even deal with that. */ -DIError -Wrapper2MG::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError Wrapper2MG::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { return kDIErrNone; @@ -207,8 +203,8 @@ Wrapper2MG::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, /* * Display error messages... or not. */ -/*static*/ NuResult -WrapperNuFX::ErrMsgHandler(NuArchive* /*pArchive*/, void* vErrorMessage) +/*static*/ NuResult WrapperNuFX::ErrMsgHandler(NuArchive* /*pArchive*/, + void* vErrorMessage) { const NuErrorMessage* pErrorMessage = (const NuErrorMessage*) vErrorMessage; @@ -229,8 +225,7 @@ WrapperNuFX::ErrMsgHandler(NuArchive* /*pArchive*/, void* vErrorMessage) * On success, the NuArchive pointer and thread idx are set, and 0 is * returned. Returns -1 on failure. */ -/*static*/ DIError -WrapperNuFX::OpenNuFX(const char* pathName, NuArchive** ppArchive, +/*static*/ DIError WrapperNuFX::OpenNuFX(const char* pathName, NuArchive** ppArchive, NuThreadIdx* pThreadIdx, long* pLength, bool readOnly) { NuError nerr = kNuErrNone; @@ -362,16 +357,15 @@ file_archive: * * Returns 0 on success, -1 on error. */ -DIError -WrapperNuFX::GetNuFXDiskImage(NuArchive* pArchive, NuThreadIdx threadIdx, +DIError WrapperNuFX::GetNuFXDiskImage(NuArchive* pArchive, NuThreadIdx threadIdx, long length, char** ppData) { NuError err; NuDataSink* pDataSink = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; assert(length > 0); - buf = new unsigned char[length]; + buf = new uint8_t[length]; if (buf == NULL) return kDIErrMalloc; @@ -417,8 +411,7 @@ bail: * Test to see if this is a single-record NuFX archive with a disk archive * in it. */ -/*static*/ DIError -WrapperNuFX::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperNuFX::Test(GenericFD* pGFD, di_off_t wrappedLength) { DIError dierr; NuArchive* pArchive = NULL; @@ -446,8 +439,7 @@ WrapperNuFX::Test(GenericFD* pGFD, di_off_t wrappedLength) /* * Open the archive, extract the disk image into a memory buffer. */ -DIError -WrapperNuFX::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, +DIError WrapperNuFX::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) @@ -511,8 +503,7 @@ bail: * * Returns a string allocated with new[]. */ -/*static*/ char* -WrapperNuFX::GenTempPath(const char* path) +/*static*/ char* WrapperNuFX::GenTempPath(const char* path) { static const char* kTmpTemplate = "DItmp_XXXXXX"; char* tmpPath; @@ -551,8 +542,7 @@ WrapperNuFX::GenTempPath(const char* path) * recreating the underlying file. (If it doesn't have an underlying * file, then we're hosed.) */ -DIError -WrapperNuFX::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperNuFX::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -563,7 +553,7 @@ WrapperNuFX::Create(di_off_t length, DiskImg::PhysicalFormat physical, NuArchive* pArchive; const char* imagePath; char* tmpPath = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; NuError nerr; /* @@ -594,7 +584,7 @@ WrapperNuFX::Create(di_off_t length, DiskImg::PhysicalFormat physical, * Create a blank chunk of memory for the image. */ assert(length > 0); - buf = new unsigned char[(int) length]; + buf = new uint8_t[(int) length]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -625,8 +615,7 @@ bail: /* * Close the NuFX archive. */ -DIError -WrapperNuFX::CloseNuFX(void) +DIError WrapperNuFX::CloseNuFX(void) { NuError nerr; @@ -650,8 +639,7 @@ WrapperNuFX::CloseNuFX(void) * pWrapperGFD, we can't have a gzip wrapper, so there's no point in * updating it. */ -DIError -WrapperNuFX::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperNuFX::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { NuError nerr = kNuErrNone; @@ -727,7 +715,7 @@ WrapperNuFX::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, * feed the data into NufxLib. */ nerr = NuCreateDataSourceForBuffer(kNuThreadFormatUncompressed, 0, - (const unsigned char*) ((GFDBuffer*) pDataGFD)->GetBuffer(), + (const uint8_t*) ((GFDBuffer*) pDataGFD)->GetBuffer(), 0, (long) dataLen, NULL, &pDataSource); if (nerr != kNuErrNone) { LOGI(" NuFX unable to create NufxLib data source (nerr=%d)", nerr); @@ -770,8 +758,7 @@ bail: /* * Common NuFX utility function. This ought to be in NufxLib. */ -void -WrapperNuFX::UNIXTimeToDateTime(const time_t* pWhen, NuDateTime *pDateTime) +void WrapperNuFX::UNIXTimeToDateTime(const time_t* pWhen, NuDateTime *pDateTime) { struct tm* ptm; @@ -802,8 +789,7 @@ WrapperNuFX::UNIXTimeToDateTime(const time_t* pWhen, NuDateTime *pDateTime) * runs of repeated bytes, which will be impossible in a DDD file because * we compress runs of repeated bytes with RLE. */ -/*static*/ DIError -WrapperDDD::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperDDD::Test(GenericFD* pGFD, di_off_t wrappedLength) { DIError dierr; GenericFD* pNewGFD = NULL; @@ -846,12 +832,11 @@ WrapperDDD::Test(GenericFD* pGFD, di_off_t wrappedLength) * bytes of the file, because DOS DDD just fills it with junk, and it's * possible that junk might have runs in it. */ -/*static*/ DIError -WrapperDDD::CheckForRuns(GenericFD* pGFD) +/*static*/ DIError WrapperDDD::CheckForRuns(GenericFD* pGFD) { DIError dierr = kDIErrNone; int kRunThreshold = 5; - unsigned char buf[8192]; + uint8_t buf[8192]; size_t bufCount; int runLen; di_off_t fileLen; @@ -904,8 +889,7 @@ bail: /* * Prepping is much the same as testing, but we fill in a few more details. */ -DIError -WrapperDDD::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, +DIError WrapperDDD::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) @@ -930,17 +914,17 @@ WrapperDDD::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, * Unpack a compressed disk image from "pGFD" to a new memory buffer * created in "*ppNewGFD". */ -/*static*/ DIError -WrapperDDD::Unpack(GenericFD* pGFD, GenericFD** ppNewGFD, short* pDiskVolNum) +/*static*/ DIError WrapperDDD::Unpack(GenericFD* pGFD, GenericFD** ppNewGFD, + short* pDiskVolNum) { DIError dierr; GFDBuffer* pNewGFD = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; short diskVolNum; pGFD->Rewind(); - buf = new unsigned char[kNumTracks * kTrackLen]; + buf = new uint8_t[kNumTracks * kTrackLen]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -975,8 +959,7 @@ bail: * Initialize stuff for a new file. There's no file header or other * goodies, so we leave "pWrapperGFD" and "pWrappedLength" alone. */ -DIError -WrapperDDD::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperDDD::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -985,12 +968,12 @@ WrapperDDD::Create(di_off_t length, DiskImg::PhysicalFormat physical, assert(order == DiskImg::kSectorOrderDOS); DIError dierr; - unsigned char* buf = NULL; + uint8_t* buf = NULL; /* * Create a blank chunk of memory for the image. */ - buf = new unsigned char[(int) length]; + buf = new uint8_t[(int) length]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1021,8 +1004,7 @@ bail: /* * Compress the disk image. */ -DIError -WrapperDDD::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperDDD::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { DIError dierr; @@ -1061,14 +1043,14 @@ const int kDC42PrivateMagic = 0x100; const int kDC42FakeTagLen = 19200; // add a "fake" tag to match Mac typedef struct DiskImgLib::DC42Header { - char diskName[kDC42NameLen+1]; // from pascal string - long dataSize; // in bytes - long tagSize; - unsigned long dataChecksum; - unsigned long tagChecksum; - unsigned char diskFormat; // should be 1 for 800K - unsigned char formatByte; // should be $24, sometimes $22 - unsigned short privateWord; // must be 0x0100 + char diskName[kDC42NameLen+1]; // from pascal string + long dataSize; // in bytes + long tagSize; + uint32_t dataChecksum; + uint32_t tagChecksum; + uint8_t diskFormat; // should be 1 for 800K + uint8_t formatByte; // should be $24, sometimes $22 + uint16_t privateWord; // must be 0x0100 // userData begins at +84 // tagData follows user data } DC42Header; @@ -1076,8 +1058,7 @@ typedef struct DiskImgLib::DC42Header { /* * Dump the contents of a DC42Header. */ -/*static*/ void -WrapperDiskCopy42::DumpHeader(const DC42Header* pHeader) +/*static*/ void WrapperDiskCopy42::DumpHeader(const DC42Header* pHeader) { LOGI("--- header contents:"); LOGI("\tdiskName = '%s'", pHeader->diskName); @@ -1094,8 +1075,7 @@ WrapperDiskCopy42::DumpHeader(const DC42Header* pHeader) /* * Init a DC42 header for an 800K ProDOS disk. */ -void -WrapperDiskCopy42::InitHeader(DC42Header* pHeader) +void WrapperDiskCopy42::InitHeader(DC42Header* pHeader) { memset(pHeader, 0, sizeof(*pHeader)); if (fStorageName == NULL || strlen(fStorageName) == 0) @@ -1116,10 +1096,9 @@ WrapperDiskCopy42::InitHeader(DC42Header* pHeader) * * Returns 0 on success, -1 on error or invalid header. */ -/*static*/ int -WrapperDiskCopy42::ReadHeader(GenericFD* pGFD, DC42Header* pHeader) +/*static*/ int WrapperDiskCopy42::ReadHeader(GenericFD* pGFD, DC42Header* pHeader) { - unsigned char hdrBuf[kDC42DataOffset]; + uint8_t hdrBuf[kDC42DataOffset]; if (pGFD->Read(hdrBuf, kDC42DataOffset) != kDIErrNone) return -1; @@ -1153,10 +1132,9 @@ WrapperDiskCopy42::ReadHeader(GenericFD* pGFD, DC42Header* pHeader) /* * Write the header for a DC42 file. */ -DIError -WrapperDiskCopy42::WriteHeader(GenericFD* pGFD, const DC42Header* pHeader) +DIError WrapperDiskCopy42::WriteHeader(GenericFD* pGFD, const DC42Header* pHeader) { - unsigned char hdrBuf[kDC42DataOffset]; + uint8_t hdrBuf[kDC42DataOffset]; pGFD->Rewind(); @@ -1190,8 +1168,7 @@ WrapperDiskCopy42::WriteHeader(GenericFD* pGFD, const DC42Header* pHeader) * about our interpretation of some of the header fields (e.g. we only * recognize 800K disks) we should be okay. */ -/*static*/ DIError -WrapperDiskCopy42::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperDiskCopy42::Test(GenericFD* pGFD, di_off_t wrappedLength) { DC42Header header; @@ -1214,14 +1191,12 @@ WrapperDiskCopy42::Test(GenericFD* pGFD, di_off_t wrappedLength) * * Position "pGFD" at the start of data. */ -/*static*/ DIError -WrapperDiskCopy42::ComputeChecksum(GenericFD* pGFD, - unsigned long* pChecksum) +/*static*/ DIError WrapperDiskCopy42::ComputeChecksum(GenericFD* pGFD, uint32_t* pChecksum) { DIError dierr = kDIErrNone; - unsigned char buf[512]; + uint8_t buf[512]; long dataRem = 800 * 1024 /*pHeader->dataSize*/; - unsigned long checksum; + uint32_t checksum; assert(dataRem % sizeof(buf) == 0); assert((sizeof(buf) & 0x01) == 0); // we take it two bytes at a time @@ -1237,7 +1212,7 @@ WrapperDiskCopy42::ComputeChecksum(GenericFD* pGFD, } for (i = 0; i < (int) sizeof(buf); i += 2) { - unsigned short val = GetShortBE(buf+i); + uint16_t val = GetShortBE(buf+i); checksum += val; if (checksum & 0x01) @@ -1257,9 +1232,8 @@ WrapperDiskCopy42::ComputeChecksum(GenericFD* pGFD, /* * Prepare a DiskCopy image for use. */ -DIError -WrapperDiskCopy42::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, - di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, +DIError WrapperDiskCopy42::Prep(GenericFD* pGFD, di_off_t wrappedLength, + bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) { @@ -1274,7 +1248,7 @@ WrapperDiskCopy42::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, /* * Verify checksum. File should already be seeked to appropriate place. */ - unsigned long checksum; + uint32_t checksum; dierr = ComputeChecksum(pGFD, &checksum); if (dierr != kDIErrNone) return dierr; @@ -1302,8 +1276,7 @@ WrapperDiskCopy42::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, /* * Initialize fields for a new file. */ -DIError -WrapperDiskCopy42::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperDiskCopy42::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -1331,12 +1304,11 @@ WrapperDiskCopy42::Create(di_off_t length, DiskImg::PhysicalFormat physical, * We only use GFDGFD, so there's no data to write. However, we do need * to update the checksum, and append our "fake" tag section. */ -DIError -WrapperDiskCopy42::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperDiskCopy42::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { DIError dierr; - unsigned long checksum; + uint32_t checksum; /* compute the data checksum */ dierr = pWrapperGFD->Seek(kDC42DataOffset, kSeekSet); @@ -1411,8 +1383,7 @@ static const char* kSim2eID = "SIMSYSTEM_HDV"; * Test for a virtual hard-drive image. This is either a "raw" unadorned * image, or one with a 15-byte "SimIIe" header on it. */ -DIError -WrapperSim2eHDV::Test(GenericFD* pGFD, di_off_t wrappedLength) +DIError WrapperSim2eHDV::Test(GenericFD* pGFD, di_off_t wrappedLength) { char buf[kSim2eHeaderLen]; @@ -1438,9 +1409,8 @@ WrapperSim2eHDV::Test(GenericFD* pGFD, di_off_t wrappedLength) /* * These are always ProDOS volumes. */ -DIError -WrapperSim2eHDV::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, - di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, +DIError WrapperSim2eHDV::Prep(GenericFD* pGFD, di_off_t wrappedLength, + bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) { @@ -1455,12 +1425,11 @@ WrapperSim2eHDV::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, /* * Initialize fields for a new file. */ -DIError -WrapperSim2eHDV::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperSim2eHDV::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { - unsigned char header[kSim2eHeaderLen]; + uint8_t header[kSim2eHeaderLen]; long blocks = (long) (length / 512); assert(physical == DiskImg::kPhysicalFormatSectors); @@ -1474,8 +1443,8 @@ WrapperSim2eHDV::Create(di_off_t length, DiskImg::PhysicalFormat physical, blocks = 65535; memcpy(header, kSim2eID, strlen(kSim2eID)); - header[13] = (unsigned char) blocks; - header[14] = (unsigned char) ((blocks & 0xff00) >> 8); + header[13] = (uint8_t) blocks; + header[14] = (uint8_t) ((blocks & 0xff00) >> 8); DIError dierr = pWrapperGFD->Write(header, kSim2eHeaderLen); if (dierr != kDIErrNone) { LOGI(" Sim2eHDV header write failed (err=%d)", dierr); @@ -1491,8 +1460,7 @@ WrapperSim2eHDV::Create(di_off_t length, DiskImg::PhysicalFormat physical, /* * We only use GFDGFD, so there's nothing to do here. */ -DIError -WrapperSim2eHDV::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperSim2eHDV::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { return kDIErrNone; @@ -1553,8 +1521,7 @@ WrapperSim2eHDV::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, * * There is currently no way for the API to set the number of tracks. */ -/*static*/ DIError -WrapperTrackStar::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperTrackStar::Test(GenericFD* pGFD, di_off_t wrappedLength) { DIError dierr = kDIErrNone; LOGI("Testing for TrackStar"); @@ -1571,7 +1538,7 @@ WrapperTrackStar::Test(GenericFD* pGFD, di_off_t wrappedLength) LOGI(" Checking for %d-track image", numTracks); /* verify each track */ - unsigned char trackBuf[kFileTrackStorageLen]; + uint8_t trackBuf[kFileTrackStorageLen]; pGFD->Rewind(); for (int trk = 0; trk < numTracks; trk++) { dierr = pGFD->Read(trackBuf, sizeof(trackBuf)); @@ -1590,8 +1557,7 @@ bail: /* * Check the format. */ -/*static*/ DIError -WrapperTrackStar::VerifyTrack(int track, const unsigned char* trackBuf) +/*static*/ DIError WrapperTrackStar::VerifyTrack(int track, const uint8_t* trackBuf) { unsigned int dataLen; @@ -1628,9 +1594,8 @@ WrapperTrackStar::VerifyTrack(int track, const unsigned char* trackBuf) /* * Fill in some details. */ -DIError -WrapperTrackStar::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, - di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, +DIError WrapperTrackStar::Prep(GenericFD* pGFD, di_off_t wrappedLength, + bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) { @@ -1659,16 +1624,15 @@ WrapperTrackStar::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, * Unpack reverse-order nibbles from "pGFD" to a new memory buffer * created in "*ppNewGFD". */ -DIError -WrapperTrackStar::Unpack(GenericFD* pGFD, GenericFD** ppNewGFD) +DIError WrapperTrackStar::Unpack(GenericFD* pGFD, GenericFD** ppNewGFD) { DIError dierr; GFDBuffer* pNewGFD = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; pGFD->Rewind(); - buf = new unsigned char[kTrackStarNumTracks * kTrackAllocSize]; + buf = new uint8_t[kTrackStarNumTracks * kTrackAllocSize]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1712,12 +1676,11 @@ bail: * * This fills out "fNibbleTrackInfo". */ -DIError -WrapperTrackStar::UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD) +DIError WrapperTrackStar::UnpackDisk(GenericFD* pGFD, GenericFD* pNewGFD) { DIError dierr = kDIErrNone; - unsigned char inBuf[kFileTrackStorageLen]; - unsigned char outBuf[kTrackAllocSize]; + uint8_t inBuf[kFileTrackStorageLen]; + uint8_t outBuf[kTrackAllocSize]; int i, trk; assert(kTrackStarNumTracks <= kMaxNibbleTracks525); @@ -1768,8 +1731,7 @@ bail: * Initialize stuff for a new file. There's no file header or other * goodies, so we leave "pWrapperGFD" and "pWrappedLength" alone. */ -DIError -WrapperTrackStar::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperTrackStar::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -1779,7 +1741,7 @@ WrapperTrackStar::Create(di_off_t length, DiskImg::PhysicalFormat physical, assert(order == DiskImg::kSectorOrderPhysical); DIError dierr; - unsigned char* buf = NULL; + uint8_t* buf = NULL; int numTracks = (int) (length / kTrackLenTrackStar525); int i; @@ -1798,7 +1760,7 @@ WrapperTrackStar::Create(di_off_t length, DiskImg::PhysicalFormat physical, /* * Create a blank chunk of memory for the image. */ - buf = new unsigned char[(int) length]; + buf = new uint8_t[(int) length]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1827,8 +1789,7 @@ bail: * The source data is in "pDataGFD" in a layout described by fNibbleTrackInfo. * We need to create the new file in "pWrapperGFD". */ -DIError -WrapperTrackStar::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperTrackStar::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { DIError dierr = kDIErrNone; @@ -1839,8 +1800,8 @@ WrapperTrackStar::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, pDataGFD->Rewind(); - unsigned char writeBuf[kFileTrackStorageLen]; - unsigned char dataBuf[kTrackLenTrackStar525]; + uint8_t writeBuf[kFileTrackStorageLen]; + uint8_t dataBuf[kTrackLenTrackStar525]; int track, trackLen; for (track = 0; track < kTrackStarNumTracks; track++) { @@ -1883,7 +1844,7 @@ WrapperTrackStar::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, if (trackLen == kMaxTrackLen) PutShortLE(writeBuf + 0x19fe, 0); else - PutShortLE(writeBuf + 0x19fe, (unsigned short) trackLen); + PutShortLE(writeBuf + 0x19fe, (uint16_t) trackLen); dierr = pWrapperGFD->Write(writeBuf, sizeof(writeBuf)); if (dierr != kDIErrNone) @@ -1897,8 +1858,7 @@ bail: return dierr; } -void -WrapperTrackStar::SetNibbleTrackLength(int track, int length) +void WrapperTrackStar::SetNibbleTrackLength(int track, int length) { assert(track >= 0); assert(length > 0 && length <= kMaxTrackLen); @@ -1930,11 +1890,10 @@ WrapperTrackStar::SetNibbleTrackLength(int track, int length) /* * Test to see if this is an FDI disk image. */ -/*static*/ DIError -WrapperFDI::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperFDI::Test(GenericFD* pGFD, di_off_t wrappedLength) { DIError dierr = kDIErrNone; - unsigned char headerBuf[kMinHeaderLen]; + uint8_t headerBuf[kMinHeaderLen]; FDIHeader hdr; LOGI("Testing for FDI"); @@ -1961,8 +1920,7 @@ bail: /* * Unpack a 512-byte buffer with the FDI header into its components. */ -/*static*/ void -WrapperFDI::UnpackHeader(const unsigned char* headerBuf, FDIHeader* pHdr) +/*static*/ void WrapperFDI::UnpackHeader(const uint8_t* headerBuf, FDIHeader* pHdr) { memcpy(pHdr->signature, &headerBuf[0], kSignatureLen); pHdr->signature[kSignatureLen] = '\0'; @@ -1985,8 +1943,7 @@ WrapperFDI::UnpackHeader(const unsigned char* headerBuf, FDIHeader* pHdr) /* * Dump the contents of an FDI header. */ -/*static*/ void -WrapperFDI::DumpHeader(const FDIHeader* pHdr) +/*static*/ void WrapperFDI::DumpHeader(const FDIHeader* pHdr) { static const char* kTypes[] = { "8\"", "5.25\"", "3.5\"", "3\"" @@ -2019,8 +1976,7 @@ WrapperFDI::DumpHeader(const FDIHeader* pHdr) /* * Unpack the disk to heap storage. */ -DIError -WrapperFDI::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, +DIError WrapperFDI::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) @@ -2113,13 +2069,12 @@ bail: /* * Unpack pulse timing values to nibbles. */ -DIError -WrapperFDI::Unpack525(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, +DIError WrapperFDI::Unpack525(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, int numHeads) { DIError dierr = kDIErrNone; GFDBuffer* pNewGFD = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; int numTracks; numTracks = numCyls * numHeads; @@ -2128,7 +2083,7 @@ WrapperFDI::Unpack525(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, pGFD->Rewind(); - buf = new unsigned char[numTracks * kTrackAllocSize]; + buf = new uint8_t[numTracks * kTrackAllocSize]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -2161,17 +2116,16 @@ bail: /* * Unpack pulse timing values to fully-decoded blocks. */ -DIError -WrapperFDI::Unpack35(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, +DIError WrapperFDI::Unpack35(GenericFD* pGFD, GenericFD** ppNewGFD, int numCyls, int numHeads, LinearBitmap** ppBadBlockMap) { DIError dierr = kDIErrNone; GFDBuffer* pNewGFD = NULL; - unsigned char* buf = NULL; + uint8_t* buf = NULL; pGFD->Rewind(); - buf = new unsigned char[800 * 1024]; + buf = new uint8_t[800 * 1024]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -2210,14 +2164,13 @@ bail: * Initialize stuff for a new file. There's no file header or other * goodies, so we leave "pWrapperGFD" and "pWrappedLength" alone. */ -DIError -WrapperFDI::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperFDI::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { DIError dierr = kDIErrGeneric; // not yet #if 0 - unsigned char* buf = NULL; + uint8_t* buf = NULL; int numTracks = (int) (length / kTrackLenTrackStar525); int i; @@ -2241,7 +2194,7 @@ WrapperFDI::Create(di_off_t length, DiskImg::PhysicalFormat physical, /* * Create a blank chunk of memory for the image. */ - buf = new unsigned char[(int) length]; + buf = new uint8_t[(int) length]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -2271,8 +2224,7 @@ bail: * The source data is in "pDataGFD" in a layout described by fNibbleTrackInfo. * We need to create the new file in "pWrapperGFD". */ -DIError -WrapperFDI::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperFDI::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { DIError dierr = kDIErrGeneric; // not yet @@ -2284,8 +2236,8 @@ WrapperFDI::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, pDataGFD->Rewind(); - unsigned char writeBuf[kFileTrackStorageLen]; - unsigned char dataBuf[kTrackLenTrackStar525]; + uint8_t writeBuf[kFileTrackStorageLen]; + uint8_t dataBuf[kTrackLenTrackStar525]; int track, trackLen; for (track = 0; track < kTrackStarNumTracks; track++) { @@ -2322,7 +2274,7 @@ WrapperFDI::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, if (trackLen == kMaxTrackLen) PutShortLE(writeBuf + 0x19fe, 0); else - PutShortLE(writeBuf + 0x19fe, (unsigned short) trackLen); + PutShortLE(writeBuf + 0x19fe, (uint16_t) trackLen); dierr = pWrapperGFD->Write(writeBuf, sizeof(writeBuf)); if (dierr != kDIErrNone) @@ -2337,8 +2289,7 @@ bail: return dierr; } -void -WrapperFDI::SetNibbleTrackLength(int track, int length) +void WrapperFDI::SetNibbleTrackLength(int track, int length) { assert(false); // not yet #if 0 @@ -2361,8 +2312,8 @@ WrapperFDI::SetNibbleTrackLength(int track, int length) /* * See if this is unadorned nibble format. */ -/*static*/ DIError -WrapperUnadornedNibble::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperUnadornedNibble::Test(GenericFD* pGFD, + di_off_t wrappedLength) { LOGI("Testing for unadorned nibble"); @@ -2375,7 +2326,7 @@ WrapperUnadornedNibble::Test(GenericFD* pGFD, di_off_t wrappedLength) /* quick scan for invalid data */ const int kScanSize = 512; - unsigned char buf[kScanSize]; + uint8_t buf[kScanSize]; pGFD->Rewind(); if (pGFD->Read(buf, sizeof(buf)) != kDIErrNone) @@ -2389,11 +2340,11 @@ WrapperUnadornedNibble::Test(GenericFD* pGFD, di_off_t wrappedLength) */ for (int i = 0; i < kScanSize; i++) { if (buf[i] < 0x80) { - LOGI(" Disqualifying len=%ld from nibble, byte=0x%02x", + LOGD(" Disqualifying len=%ld from nibble, byte=0x%02x", (long) wrappedLength, buf[i]); return kDIErrGeneric; } else if (buf[i] < 0x96) { - LOGI(" Warning: funky byte 0x%02x in file", buf[i]); + LOGD(" Warning: funky byte 0x%02x in file", buf[i]); } } @@ -2403,9 +2354,8 @@ WrapperUnadornedNibble::Test(GenericFD* pGFD, di_off_t wrappedLength) /* * Prepare unadorned nibble for use. Not much to do here. */ -DIError -WrapperUnadornedNibble::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, - di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, +DIError WrapperUnadornedNibble::Prep(GenericFD* pGFD, di_off_t wrappedLength, + bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) { @@ -2433,9 +2383,9 @@ WrapperUnadornedNibble::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readO /* * Initialize fields for a new file. */ -DIError -WrapperUnadornedNibble::Create(di_off_t length, DiskImg::PhysicalFormat physical, - DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, +DIError WrapperUnadornedNibble::Create(di_off_t length, + DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, + short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { LOGI("Create unadorned nibble"); @@ -2448,8 +2398,7 @@ WrapperUnadornedNibble::Create(di_off_t length, DiskImg::PhysicalFormat physical /* * We only use GFDGFD, so there's nothing to do here. */ -DIError -WrapperUnadornedNibble::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperUnadornedNibble::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { return kDIErrNone; @@ -2473,11 +2422,10 @@ WrapperUnadornedNibble::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, * It also holds for 35-track 6656-byte unadorned nibble images, so we need * to test for them first. */ -/*static*/ DIError -WrapperUnadornedSector::Test(GenericFD* pGFD, di_off_t wrappedLength) +/*static*/ DIError WrapperUnadornedSector::Test(GenericFD* pGFD, di_off_t wrappedLength) { LOGI("Testing for unadorned sector (wrappedLength=%ld/%lu)", - (long) (wrappedLength >> 32), (unsigned long) wrappedLength); + (long) (wrappedLength >> 32), (uint32_t) wrappedLength); if (wrappedLength >= 1536 && (wrappedLength % 512) == 0) return kDIErrNone; if (wrappedLength == kD13Length) // 13-sector image? @@ -2489,9 +2437,8 @@ WrapperUnadornedSector::Test(GenericFD* pGFD, di_off_t wrappedLength) /* * Prepare unadorned sector for use. Not much to do here. */ -DIError -WrapperUnadornedSector::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readOnly, - di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, +DIError WrapperUnadornedSector::Prep(GenericFD* pGFD, di_off_t wrappedLength, + bool readOnly, di_off_t* pLength, DiskImg::PhysicalFormat* pPhysical, DiskImg::SectorOrder* pOrder, short* pDiskVolNum, LinearBitmap** ppBadBlockMap, GenericFD** ppNewGFD) { @@ -2508,8 +2455,7 @@ WrapperUnadornedSector::Prep(GenericFD* pGFD, di_off_t wrappedLength, bool readO /* * Initialize fields for a new file. */ -DIError -WrapperUnadornedSector::Create(di_off_t length, DiskImg::PhysicalFormat physical, +DIError WrapperUnadornedSector::Create(di_off_t length, DiskImg::PhysicalFormat physical, DiskImg::SectorOrder order, short dosVolumeNum, GenericFD* pWrapperGFD, di_off_t* pWrappedLength, GenericFD** pDataFD) { @@ -2523,8 +2469,7 @@ WrapperUnadornedSector::Create(di_off_t length, DiskImg::PhysicalFormat physical /* * We only use GFDGFD, so there's nothing to do here. */ -DIError -WrapperUnadornedSector::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, +DIError WrapperUnadornedSector::Flush(GenericFD* pWrapperGFD, GenericFD* pDataGFD, di_off_t dataLen, di_off_t* pWrappedLen) { return kDIErrNone; diff --git a/diskimg/MacPart.cpp b/diskimg/MacPart.cpp index 0f793b1..e214f4d 100644 --- a/diskimg/MacPart.cpp +++ b/diskimg/MacPart.cpp @@ -21,43 +21,43 @@ const int kPartMapStart = 1; // start of partition map * Format of DDR (block 0). */ typedef struct DiskFSMacPart::DriverDescriptorRecord { - unsigned short sbSig; // {device signature} - unsigned short sbBlkSize; // {block size of the device} - unsigned long sbBlkCount; // {number of blocks on the device} - unsigned short sbDevType; // {reserved} - unsigned short sbDevId; // {reserved} - unsigned long sbData; // {reserved} - unsigned short sbDrvrCount; // {number of driver descriptor entries} - unsigned short hiddenPad; // implicit in specification - unsigned long ddBlock; // {first driver's starting block} - unsigned short ddSize; // {size of the driver, in 512-byte blocks} - unsigned short ddType; // {operating system type (MacOS = 1)} - unsigned short ddPad[242]; // {additional drivers, if any} + uint16_t sbSig; // {device signature} + uint16_t sbBlkSize; // {block size of the device} + uint32_t sbBlkCount; // {number of blocks on the device} + uint16_t sbDevType; // {reserved} + uint16_t sbDevId; // {reserved} + uint32_t sbData; // {reserved} + uint16_t sbDrvrCount; // {number of driver descriptor entries} + uint16_t hiddenPad; // implicit in specification + uint32_t ddBlock; // {first driver's starting block} + uint16_t ddSize; // {size of the driver, in 512-byte blocks} + uint16_t ddType; // {operating system type (MacOS = 1)} + uint16_t ddPad[242]; // {additional drivers, if any} } DriverDescriptorRecord; /* * Format of partition map blocks. The partition map is an array of these. */ typedef struct DiskFSMacPart::PartitionMap { - unsigned short pmSig; // {partition signature} - unsigned short pmSigPad; // {reserved} - unsigned long pmMapBlkCnt; // {number of blocks in partition map} - unsigned long pmPyPartStart; // {first physical block of partition} - unsigned long pmPartBlkCnt; // {number of blocks in partition} - unsigned char pmPartName[32]; // {partition name} - unsigned char pmParType[32]; // {partition type} - unsigned long pmLgDataStart; // {first logical block of data area} - unsigned long pmDataCnt; // {number of blocks in data area} - unsigned long pmPartStatus; // {partition status information} - unsigned long pmLgBootStart; // {first logical block of boot code} - unsigned long pmBootSize; // {size of boot code, in bytes} - unsigned long pmBootAddr; // {boot code load address} - unsigned long pmBootAddr2; // {reserved} - unsigned long pmBootEntry; // {boot code entry point} - unsigned long pmBootEntry2; // {reserved} - unsigned long pmBootCksum; // {boot code checksum} - unsigned char pmProcessor[16]; // {processor type} - unsigned short pmPad[188]; // {reserved} + uint16_t pmSig; // {partition signature} + uint16_t pmSigPad; // {reserved} + uint32_t pmMapBlkCnt; // {number of blocks in partition map} + uint32_t pmPyPartStart; // {first physical block of partition} + uint32_t pmPartBlkCnt; // {number of blocks in partition} + uint8_t pmPartName[32]; // {partition name} + uint8_t pmParType[32]; // {partition type} + uint32_t pmLgDataStart; // {first logical block of data area} + uint32_t pmDataCnt; // {number of blocks in data area} + uint32_t pmPartStatus; // {partition status information} + uint32_t pmLgBootStart; // {first logical block of boot code} + uint32_t pmBootSize; // {size of boot code, in bytes} + uint32_t pmBootAddr; // {boot code load address} + uint32_t pmBootAddr2; // {reserved} + uint32_t pmBootEntry; // {boot code entry point} + uint32_t pmBootEntry2; // {reserved} + uint32_t pmBootCksum; // {boot code checksum} + uint8_t pmProcessor[16]; // {processor type} + uint16_t pmPad[188]; // {reserved} } PartitionMap; @@ -70,11 +70,11 @@ typedef struct DiskFSMacPart::PartitionMap { * It would be difficult to guess the block order based on the partition * structure, because the partition map entries can appear in any order. */ -/*static*/ DIError -DiskFSMacPart::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +/*static*/ DIError DiskFSMacPart::TestImage(DiskImg* pImg, + DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; DriverDescriptorRecord ddr; long pmMapBlkCnt; @@ -146,8 +146,7 @@ bail: /* * Unpack a DDR disk block into a DDR data structure. */ -/*static*/ void -DiskFSMacPart::UnpackDDR(const unsigned char* buf, +/*static*/ void DiskFSMacPart::UnpackDDR(const uint8_t* buf, DriverDescriptorRecord* pDDR) { pDDR->sbSig = GetShortBE(&buf[0x00]); @@ -172,8 +171,7 @@ DiskFSMacPart::UnpackDDR(const unsigned char* buf, /* * Debug: dump the contents of the DDR. */ -/*static*/ void -DiskFSMacPart::DumpDDR(const DriverDescriptorRecord* pDDR) +/*static*/ void DiskFSMacPart::DumpDDR(const DriverDescriptorRecord* pDDR) { LOGI(" MacPart driver descriptor record"); LOGI(" sbSig=0x%04x sbBlkSize=%d sbBlkCount=%ld", @@ -187,8 +185,7 @@ DiskFSMacPart::DumpDDR(const DriverDescriptorRecord* pDDR) /* * Unpack a partition map disk block into a partition map data structure. */ -/*static*/ void -DiskFSMacPart::UnpackPartitionMap(const unsigned char* buf, +/*static*/ void DiskFSMacPart::UnpackPartitionMap(const uint8_t* buf, PartitionMap* pMap) { pMap->pmSig = GetShortBE(&buf[0x00]); @@ -223,8 +220,7 @@ DiskFSMacPart::UnpackPartitionMap(const unsigned char* buf, /* * Debug: dump the contents of the partition map. */ -/*static*/ void -DiskFSMacPart::DumpPartitionMap(long block, const PartitionMap* pMap) +/*static*/ void DiskFSMacPart::DumpPartitionMap(long block, const PartitionMap* pMap) { LOGI(" MacPart partition map: block=%ld", block); LOGI(" pmSig=0x%04x (pad=0x%04x) pmMapBlkCnt=%ld", @@ -250,8 +246,7 @@ DiskFSMacPart::DumpPartitionMap(long block, const PartitionMap* pMap) /* * Open up a sub-volume. */ -DIError -DiskFSMacPart::OpenSubVolume(const PartitionMap* pMap) +DIError DiskFSMacPart::OpenSubVolume(const PartitionMap* pMap) { DIError dierr = kDIErrNone; DiskFS* pNewFS = NULL; @@ -380,8 +375,7 @@ bail: /* * Check to see if this is a MacPart volume. */ -/*static*/ DIError -DiskFSMacPart::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSMacPart::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumBlocks() < kMinInterestingBlocks) @@ -400,12 +394,10 @@ DiskFSMacPart::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, return kDIErrFilesystemNotFound; } - /* * Prep the MacPart "container" for use. */ -DIError -DiskFSMacPart::Initialize(void) +DIError DiskFSMacPart::Initialize(void) { DIError dierr = kDIErrNone; @@ -424,18 +416,16 @@ DiskFSMacPart::Initialize(void) return dierr; } - /* * Find the various sub-volumes and open them. * * Because the partitions are explicitly typed, we don't need to probe * their contents. But we do anyway. */ -DIError -DiskFSMacPart::FindSubVolumes(void) +DIError DiskFSMacPart::FindSubVolumes(void) { DIError dierr = kDIErrNone; - unsigned char buf[kBlkSize]; + uint8_t buf[kBlkSize]; PartitionMap map; int i, numMapBlocks; diff --git a/diskimg/MicroDrive.cpp b/diskimg/MicroDrive.cpp index 35c1ef3..ad98b5e 100644 --- a/diskimg/MicroDrive.cpp +++ b/diskimg/MicroDrive.cpp @@ -15,7 +15,7 @@ const int kBlkSize = 512; const int kPartMapBlock = 0; // partition map lives here -const unsigned int kPartSizeMask = 0x00ffffff; +const uint32_t kPartSizeMask = 0x00ffffff; /* @@ -45,24 +45,24 @@ const unsigned int kPartSizeMask = 0x00ffffff; */ const int kMaxNumParts = 8; typedef struct DiskFSMicroDrive::PartitionMap { - unsigned short magic; // partition signature - unsigned short cylinders; // #of cylinders - unsigned short reserved1; // ?? - unsigned short heads; // #of heads/cylinder - unsigned short sectors; // #of sectors/track - unsigned short reserved2; // ?? - unsigned char numPart1; // #of partitions in first chunk - unsigned char numPart2; // #of partitions in second chunk - unsigned char reserved3[10]; // bytes 0x0e-0x17 - unsigned short romVersion; // IIgs ROM01 or ROM03 - unsigned char reserved4[6]; // bytes 0x1a-0x1f - unsigned long partitionStart1[kMaxNumParts]; // bytes 0x20-0x3f - unsigned long partitionLength1[kMaxNumParts]; // bytes 0x40-0x5f - unsigned char reserved5[32]; // bytes 0x60-0x7f - unsigned long partitionStart2[kMaxNumParts]; // bytes 0x80-0x9f - unsigned long partitionLength2[kMaxNumParts]; // bytes 0xa0-0xbf + uint16_t magic; // partition signature + uint16_t cylinders; // #of cylinders + uint16_t reserved1; // ?? + uint16_t heads; // #of heads/cylinder + uint16_t sectors; // #of sectors/track + uint16_t reserved2; // ?? + uint8_t numPart1; // #of partitions in first chunk + uint8_t numPart2; // #of partitions in second chunk + uint8_t reserved3[10]; // bytes 0x0e-0x17 + uint16_t romVersion; // IIgs ROM01 or ROM03 + uint8_t reserved4[6]; // bytes 0x1a-0x1f + uint32_t partitionStart1[kMaxNumParts]; // bytes 0x20-0x3f + uint32_t partitionLength1[kMaxNumParts]; // bytes 0x40-0x5f + uint8_t reserved5[32]; // bytes 0x60-0x7f + uint32_t partitionStart2[kMaxNumParts]; // bytes 0x80-0x9f + uint32_t partitionLength2[kMaxNumParts]; // bytes 0xa0-0xbf - unsigned char padding[320]; + uint8_t padding[320]; } PartitionMap; @@ -72,11 +72,11 @@ typedef struct DiskFSMicroDrive::PartitionMap { * The "imageOrder" parameter has no use here, because (in the current * version) embedded parent volumes are implicitly ProDOS-ordered. */ -/*static*/ DIError -DiskFSMicroDrive::TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +/*static*/ DIError DiskFSMicroDrive::TestImage(DiskImg* pImg, + DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int partCount1, partCount2; assert(sizeof(PartitionMap) == kBlkSize); @@ -119,8 +119,7 @@ bail: /* * Unpack a partition map block into a partition map data structure. */ -/*static*/ void -DiskFSMicroDrive::UnpackPartitionMap(const unsigned char* buf, +/*static*/ void DiskFSMicroDrive::UnpackPartitionMap(const uint8_t* buf, PartitionMap* pMap) { pMap->magic = GetShortLE(&buf[0x00]); @@ -148,8 +147,7 @@ DiskFSMicroDrive::UnpackPartitionMap(const unsigned char* buf, /* * Debug: dump the contents of the partition map. */ -/*static*/ void -DiskFSMicroDrive::DumpPartitionMap(const PartitionMap* pMap) +/*static*/ void DiskFSMicroDrive::DumpPartitionMap(const PartitionMap* pMap) { LOGI(" MicroDrive partition map:"); LOGI(" cyls=%d res1=%d heads=%d sects=%d", @@ -178,8 +176,7 @@ DiskFSMicroDrive::DumpPartitionMap(const PartitionMap* pMap) /* * Open up a sub-volume. */ -DIError -DiskFSMicroDrive::OpenSubVolume(long startBlock, long numBlocks) +DIError DiskFSMicroDrive::OpenSubVolume(long startBlock, long numBlocks) { DIError dierr = kDIErrNone; DiskFS* pNewFS = NULL; @@ -289,8 +286,7 @@ bail: /* * Check to see if this is a MicroDrive volume. */ -/*static*/ DIError -DiskFSMicroDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSMicroDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (pImg->GetNumBlocks() < kMinInterestingBlocks) @@ -313,8 +309,7 @@ DiskFSMicroDrive::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Prep the MicroDrive "container" for use. */ -DIError -DiskFSMicroDrive::Initialize(void) +DIError DiskFSMicroDrive::Initialize(void) { DIError dierr = kDIErrNone; @@ -337,11 +332,10 @@ DiskFSMicroDrive::Initialize(void) /* * Find the various sub-volumes and open them. */ -DIError -DiskFSMicroDrive::FindSubVolumes(void) +DIError DiskFSMicroDrive::FindSubVolumes(void) { DIError dierr = kDIErrNone; - unsigned char buf[kBlkSize]; + uint8_t buf[kBlkSize]; PartitionMap map; int i; @@ -375,8 +369,7 @@ bail: * Open the volume. If it fails, open a placeholder instead. (If *that* * fails, return with an error.) */ -DIError -DiskFSMicroDrive::OpenVol(int idx, long startBlock, long numBlocks) +DIError DiskFSMicroDrive::OpenVol(int idx, long startBlock, long numBlocks) { DIError dierr; @@ -387,13 +380,13 @@ DiskFSMicroDrive::OpenVol(int idx, long startBlock, long numBlocks) DiskFS* pNewFS = NULL; DiskImg* pNewImg = NULL; - LOGI(" MicroDrive failed opening sub-volume %d", idx); + LOGW(" MicroDrive failed opening sub-volume %d", idx); dierr = CreatePlaceholder(startBlock, numBlocks, NULL, NULL, &pNewImg, &pNewFS); if (dierr == kDIErrNone) { AddSubVolumeToList(pNewImg, pNewFS); } else { - LOGI(" MicroDrive unable to create placeholder (err=%d)", + LOGE(" MicroDrive unable to create placeholder (err=%d)", dierr); // fall out with error } diff --git a/diskimg/Nibble.cpp b/diskimg/Nibble.cpp index 7aa834c..5b53509 100644 --- a/diskimg/Nibble.cpp +++ b/diskimg/Nibble.cpp @@ -19,13 +19,13 @@ * =========================================================================== */ -/*static*/ unsigned char DiskImg::kDiskBytes53[32] = { +/*static*/ uint8_t DiskImg::kDiskBytes53[32] = { 0xab, 0xad, 0xae, 0xaf, 0xb5, 0xb6, 0xb7, 0xba, 0xbb, 0xbd, 0xbe, 0xbf, 0xd6, 0xd7, 0xda, 0xdb, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xed, 0xee, 0xef, 0xf5, 0xf6, 0xf7, 0xfa, 0xfb, 0xfd, 0xfe, 0xff }; -/*static*/ unsigned char DiskImg::kDiskBytes62[64] = { +/*static*/ uint8_t DiskImg::kDiskBytes62[64] = { 0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6, 0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc, @@ -35,16 +35,15 @@ 0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff }; -/*static*/ unsigned char DiskImg::kInvDiskBytes53[256]; // all values are 0-31 -/*static*/ unsigned char DiskImg::kInvDiskBytes62[256]; // all values are 0-63 +/*static*/ uint8_t DiskImg::kInvDiskBytes53[256]; // all values are 0-31 +/*static*/ uint8_t DiskImg::kInvDiskBytes62[256]; // all values are 0-63 /* * Compute tables to convert disk bytes back to values. * * Should be called once, at DLL initialization time. */ -/*static*/ void -DiskImg::CalcNibbleInvTables(void) +/*static*/ void DiskImg::CalcNibbleInvTables(void) { unsigned int i; @@ -66,8 +65,7 @@ DiskImg::CalcNibbleInvTables(void) * * Returns the index start on success or -1 on failure. */ -int -DiskImg::FindNibbleSectorStart(const CircularBufferAccess& buffer, int track, +int DiskImg::FindNibbleSectorStart(const CircularBufferAccess& buffer, int track, int sector, const NibbleDescr* pNibbleDescr, int* pVol) { const int kMaxDataReach = 48; // fairly arbitrary @@ -178,8 +176,7 @@ DiskImg::FindNibbleSectorStart(const CircularBufferAccess& buffer, int track, /* * Decode the values in the address field. */ -void -DiskImg::DecodeAddr(const CircularBufferAccess& buffer, int offset, +void DiskImg::DecodeAddr(const CircularBufferAccess& buffer, int offset, short* pVol, short* pTrack, short* pSector, short* pChksum) { //unsigned int vol, track, sector, chksum; @@ -195,9 +192,8 @@ DiskImg::DecodeAddr(const CircularBufferAccess& buffer, int offset, * This invokes the appropriate function (e.g. 5&3 or 6&2) to decode the * data into a 256-byte sector. */ -DIError -DiskImg::DecodeNibbleData(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) +DIError DiskImg::DecodeNibbleData(const CircularBufferAccess& buffer, int idx, + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) { switch (pNibbleDescr->encoding) { case kNibbleEnc62: @@ -215,9 +211,8 @@ DiskImg::DecodeNibbleData(const CircularBufferAccess& buffer, int idx, * This invokes the appropriate function (e.g. 5&3 or 6&2) to encode the * data from a 256-byte sector. */ -void -DiskImg::EncodeNibbleData(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const +void DiskImg::EncodeNibbleData(const CircularBufferAccess& buffer, int idx, + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const { switch (pNibbleDescr->encoding) { case kNibbleEnc62: @@ -235,13 +230,12 @@ DiskImg::EncodeNibbleData(const CircularBufferAccess& buffer, int idx, /* * Decode 6&2 encoding. */ -DIError -DiskImg::DecodeNibble62(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) +DIError DiskImg::DecodeNibble62(const CircularBufferAccess& buffer, int idx, + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) { - unsigned char twos[kChunkSize62 * 3]; // 258 + uint8_t twos[kChunkSize62 * 3]; // 258 int chksum = pNibbleDescr->dataChecksumSeed; - unsigned char decodedVal; + uint8_t decodedVal; int i; /* @@ -294,12 +288,11 @@ DiskImg::DecodeNibble62(const CircularBufferAccess& buffer, int idx, /* * Encode 6&2 encoding. */ -void -DiskImg::EncodeNibble62(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const +void DiskImg::EncodeNibble62(const CircularBufferAccess& buffer, int idx, + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const { - unsigned char top[256]; - unsigned char twos[kChunkSize62]; + uint8_t top[256]; + uint8_t twos[kChunkSize62]; int twoPosn, twoShift; int i; @@ -338,14 +331,13 @@ DiskImg::EncodeNibble62(const CircularBufferAccess& buffer, int idx, /* * Decode 5&3 encoding. */ -DIError -DiskImg::DecodeNibble53(const CircularBufferAccess& buffer, int idx, - unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) +DIError DiskImg::DecodeNibble53(const CircularBufferAccess& buffer, int idx, + uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) { - unsigned char base[256]; - unsigned char threes[kThreeSize]; + uint8_t base[256]; + uint8_t threes[kThreeSize]; int chksum = pNibbleDescr->dataChecksumSeed; - unsigned char decodedVal; + uint8_t decodedVal; int i; /* @@ -391,7 +383,7 @@ DiskImg::DecodeNibble53(const CircularBufferAccess& buffer, int idx, /* * Convert this pile of stuff into 256 data bytes. */ - unsigned char* bufPtr; + uint8_t* bufPtr; bufPtr = sctBuf; for (i = kChunkSize53-1; i >= 0; i--) { @@ -422,12 +414,11 @@ DiskImg::DecodeNibble53(const CircularBufferAccess& buffer, int idx, /* * Encode 5&3 encoding. */ -void -DiskImg::EncodeNibble53(const CircularBufferAccess& buffer, int idx, - const unsigned char* sctBuf, const NibbleDescr* pNibbleDescr) const +void DiskImg::EncodeNibble53(const CircularBufferAccess& buffer, int idx, + const uint8_t* sctBuf, const NibbleDescr* pNibbleDescr) const { - unsigned char top[kChunkSize53 * 5 +1]; // (255 / 0xff) +1 - unsigned char threes[kChunkSize53 * 3 +1]; // (153 / 0x99) +1 + uint8_t top[kChunkSize53 * 5 +1]; // (255 / 0xff) +1 + uint8_t threes[kChunkSize53 * 3 +1]; // (153 / 0x99) +1 int i, chunk; /* @@ -500,8 +491,7 @@ DiskImg::EncodeNibble53(const CircularBufferAccess& buffer, int idx, * * "buf" must be able to hold (num * 3) characters. */ -static void -DumpBytes(const unsigned char* bytes, unsigned int num, char* buf) +static void DumpBytes(const uint8_t* bytes, unsigned int num, char* buf) { sprintf(buf, "%02x", bytes[0]); buf += 2; @@ -514,8 +504,7 @@ DumpBytes(const unsigned char* bytes, unsigned int num, char* buf) *buf = '\0'; } -static inline const char* -VerifyStr(bool val) +static inline const char* VerifyStr(bool val) { return val ? "verify" : "ignore"; } @@ -523,8 +512,7 @@ VerifyStr(bool val) /* * Dump the contents of a NibbleDescr struct. */ -void -DiskImg::DumpNibbleDescr(const NibbleDescr* pNibDescr) const +void DiskImg::DumpNibbleDescr(const NibbleDescr* pNibDescr) const { char outBuf1[48]; char outBuf2[48]; @@ -560,8 +548,7 @@ DiskImg::DumpNibbleDescr(const NibbleDescr* pNibDescr) const /* * Load a nibble track into our track buffer. */ -DIError -DiskImg::LoadNibbleTrack(long track, long* pTrackLen) +DIError DiskImg::LoadNibbleTrack(long track, long* pTrackLen) { DIError dierr = kDIErrNone; long offset; @@ -586,7 +573,7 @@ DiskImg::LoadNibbleTrack(long track, long* pTrackLen) /* alloc track buffer if needed */ if (fNibbleTrackBuf == NULL) { - fNibbleTrackBuf = new unsigned char[kTrackAllocSize]; + fNibbleTrackBuf = new uint8_t[kTrackAllocSize]; if (fNibbleTrackBuf == NULL) return kDIErrMalloc; } @@ -606,8 +593,7 @@ DiskImg::LoadNibbleTrack(long track, long* pTrackLen) /* * Save the track buffer back to disk. */ -DIError -DiskImg::SaveNibbleTrack(void) +DIError DiskImg::SaveNibbleTrack(void) { if (fNibbleTrackLoaded < 0) { LOGI("ERROR: tried to save track without loading it first"); @@ -630,8 +616,7 @@ DiskImg::SaveNibbleTrack(void) * return it. If "pVol" is non-NULL, return the volume number from * one of the readable sectors. */ -int -DiskImg::TestNibbleTrack(int track, const NibbleDescr* pNibbleDescr, +int DiskImg::TestNibbleTrack(int track, const NibbleDescr* pNibbleDescr, int* pVol) { long trackLen; @@ -655,7 +640,7 @@ DiskImg::TestNibbleTrack(int track, const NibbleDescr* pNibbleDescr, if (pVol != NULL) *pVol = vol; - unsigned char sctBuf[256]; + uint8_t sctBuf[256]; if (DecodeNibbleData(buffer, sectorIdx, sctBuf, pNibbleDescr) == kDIErrNone) count++; } @@ -678,8 +663,7 @@ DiskImg::TestNibbleTrack(int track, const NibbleDescr* pNibbleDescr, * fDOSVolumeNum holds a volume number from one of the tracks * fNumTracks holds the number of tracks on the disk */ -DIError -DiskImg::AnalyzeNibbleData(void) +DIError DiskImg::AnalyzeNibbleData(void) { assert(IsNibbleFormat(fPhysical)); @@ -739,15 +723,13 @@ DiskImg::AnalyzeNibbleData(void) return kDIErrNone; } - /* * Read a sector from a nibble image. * * While fNumTracks is valid, fNumSectPerTrack is a little flaky, because * in theory each track could be formatted differently. */ -DIError -DiskImg::ReadNibbleSector(long track, int sector, void* buf, +DIError DiskImg::ReadNibbleSector(long track, int sector, void* buf, const NibbleDescr* pNibbleDescr) { if (pNibbleDescr == NULL) { @@ -782,7 +764,7 @@ DiskImg::ReadNibbleSector(long track, int sector, void* buf, if (sectorIdx < 0) return kDIErrSectorUnreadable; - dierr = DecodeNibbleData(buffer, sectorIdx, (unsigned char*) buf, + dierr = DecodeNibbleData(buffer, sectorIdx, (uint8_t*) buf, pNibbleDescr); return dierr; @@ -791,8 +773,7 @@ DiskImg::ReadNibbleSector(long track, int sector, void* buf, /* * Write a sector to a nibble image. */ -DIError -DiskImg::WriteNibbleSector(long track, int sector, const void* buf, +DIError DiskImg::WriteNibbleSector(long track, int sector, const void* buf, const NibbleDescr* pNibbleDescr) { assert(pNibbleDescr != NULL); @@ -817,7 +798,7 @@ DiskImg::WriteNibbleSector(long track, int sector, const void* buf, if (sectorIdx < 0) return kDIErrSectorUnreadable; - EncodeNibbleData(buffer, sectorIdx, (unsigned char*) buf, pNibbleDescr); + EncodeNibbleData(buffer, sectorIdx, (uint8_t*) buf, pNibbleDescr); dierr = SaveNibbleTrack(); if (dierr != kDIErrNone) { @@ -828,14 +809,12 @@ DiskImg::WriteNibbleSector(long track, int sector, const void* buf, return dierr; } - /* * Get the contents of the nibble track. * * "buf" must be able to hold kTrackAllocSize bytes. */ -DIError -DiskImg::ReadNibbleTrack(long track, unsigned char* buf, long* pTrackLen) +DIError DiskImg::ReadNibbleTrack(long track, uint8_t* buf, long* pTrackLen) { DIError dierr; @@ -856,8 +835,7 @@ DiskImg::ReadNibbleTrack(long track, unsigned char* buf, long* pTrackLen) * .nib. Fixed-length formats shouldn't be allowed to interact. Figure * this out someday. For now, the higher-level code prevents it. */ -DIError -DiskImg::WriteNibbleTrack(long track, const unsigned char* buf, long trackLen) +DIError DiskImg::WriteNibbleTrack(long track, const uint8_t* buf, long trackLen) { DIError dierr; long oldTrackLen; @@ -889,7 +867,6 @@ DiskImg::WriteNibbleTrack(long track, const unsigned char* buf, long trackLen) return kDIErrNone; } - /* * Create a blank nibble image, using fpNibbleDescr as the template. * Sets "fLength". @@ -909,14 +886,13 @@ DiskImg::WriteNibbleTrack(long track, const unsigned char* buf, long trackLen) * 48 + (14 + 6 + (6 + 1 + 342) + 27) * 16 = 6384 * 48 + (14 + 6 + (6 + 1 + 410) + 27) * 13 = 6080 */ -DIError -DiskImg::FormatNibbles(GenericFD* pGFD) const +DIError DiskImg::FormatNibbles(GenericFD* pGFD) const { assert(fHasNibbles); assert(GetNumTracks() > 0); DIError dierr = kDIErrNone; - unsigned char trackBuf[kTrackAllocSize]; + uint8_t trackBuf[kTrackAllocSize]; /* these should be the same except for var-len images */ long trackAllocLen = GetNibbleTrackAllocLength(); long trackLen = GetNibbleTrackFormatLength(); @@ -954,8 +930,8 @@ DiskImg::FormatNibbles(GenericFD* pGFD) const * Create a prototype sector. The data for a sector full of zeroes * is exactly the same; only the address header changes. */ - unsigned char sampleSource[256]; - unsigned char sampleBuf[512]; // must hold 5&3 and 6&2 + uint8_t sampleSource[256]; + uint8_t sampleBuf[512]; // must hold 5&3 and 6&2 CircularBufferAccess sample(sampleBuf, 512); long dataLen; @@ -973,7 +949,7 @@ DiskImg::FormatNibbles(GenericFD* pGFD) const */ for (track = 0; track < GetNumTracks(); track++) { //LOGI("Formatting track %d", track); - unsigned char* trackPtr = trackBuf; + uint8_t* trackPtr = trackBuf; /* * Fill with "self-sync" bytes. @@ -987,7 +963,7 @@ DiskImg::FormatNibbles(GenericFD* pGFD) const /* * Write address field. */ - unsigned short hdrTrack, hdrSector, hdrVol, hdrChksum; + uint16_t hdrTrack, hdrSector, hdrVol, hdrChksum; hdrTrack = track; hdrSector = sector; hdrVol = fDOSVolumeNum; @@ -1043,4 +1019,3 @@ DiskImg::FormatNibbles(GenericFD* pGFD) const return dierr; } - diff --git a/diskimg/Nibble35.cpp b/diskimg/Nibble35.cpp index 48f68b5..a0efeef 100644 --- a/diskimg/Nibble35.cpp +++ b/diskimg/Nibble35.cpp @@ -73,8 +73,7 @@ enum { * There are 12 sectors per track for the first 16 cylinders, 11 sectors * per track for the next 16, and so on until we're down to 8 per track. */ -/*static*/ int -DiskImg::SectorsPerTrack35(int cylinder) +/*static*/ int DiskImg::SectorsPerTrack35(int cylinder) { return kMaxSectorsPerTrack - (cylinder / 16); } @@ -82,8 +81,7 @@ DiskImg::SectorsPerTrack35(int cylinder) /* * Convert cylinder/head/sector to a block number on a 3.5" disk. */ -/*static*/ int -DiskImg::CylHeadSect35ToBlock(int cyl, int head, int sect) +/*static*/ int DiskImg::CylHeadSect35ToBlock(int cyl, int head, int sect) { int i, block; @@ -108,16 +106,15 @@ DiskImg::CylHeadSect35ToBlock(int cyl, int head, int sect) * * "outputBuf" must be able to hold 512 * 12 sectors of decoded sector data. */ -/*static*/ DIError -DiskImg::UnpackNibbleTrack35(const unsigned char* nibbleBuf, - long nibbleLen, unsigned char* outputBuf, int cyl, int head, +/*static*/ DIError DiskImg::UnpackNibbleTrack35(const uint8_t* nibbleBuf, + long nibbleLen, uint8_t* outputBuf, int cyl, int head, LinearBitmap* pBadBlockMap) { CircularBufferAccess buffer(nibbleBuf, nibbleLen); bool foundSector[kMaxSectorsPerTrack]; - unsigned char sectorBuf[kSectorSize35]; - unsigned char readSum[kDataChecksumLen]; - unsigned char calcSum[kDataChecksumLen]; + uint8_t sectorBuf[kSectorSize35]; + uint8_t readSum[kDataChecksumLen]; + uint8_t calcSum[kDataChecksumLen]; int i; memset(&foundSector, 0, sizeof(foundSector)); @@ -189,9 +186,8 @@ DiskImg::UnpackNibbleTrack35(const unsigned char* nibbleBuf, /* * Returns the offset of the next sector, or -1 if we went off the end. */ -/*static*/ int -DiskImg::FindNextSector35(const CircularBufferAccess& buffer, int start, - int cyl, int head, int* pSector) +/*static*/ int DiskImg::FindNextSector35(const CircularBufferAccess& buffer, + int start, int cyl, int head, int* pSector) { int end = buffer.GetSize(); int i; @@ -275,16 +271,15 @@ DiskImg::FindNextSector35(const CircularBufferAccess& buffer, int start, * not return false on a checksum mismatch -- it's up to the caller to * verify the checksum if desired. */ -/*static*/ bool -DiskImg::DecodeNibbleSector35(const CircularBufferAccess& buffer, int start, - unsigned char* sectorBuf, unsigned char* readChecksum, - unsigned char* calcChecksum) +/*static*/ bool DiskImg::DecodeNibbleSector35(const CircularBufferAccess& buffer, + int start, uint8_t* sectorBuf, uint8_t* readChecksum, + uint8_t* calcChecksum) { const int kMaxDataReach35 = 48; // fairly arbitrary - unsigned char* sectorBufStart = sectorBuf; - unsigned char part0[kChunkSize35], part1[kChunkSize35], part2[kChunkSize35]; + uint8_t* sectorBufStart = sectorBuf; + uint8_t part0[kChunkSize35], part1[kChunkSize35], part2[kChunkSize35]; unsigned int chk0, chk1, chk2; - unsigned char val, nib0, nib1, nib2, twos; + uint8_t val, nib0, nib1, nib2, twos; int i, off; /* @@ -402,7 +397,7 @@ DiskImg::DecodeNibbleSector35(const CircularBufferAccess& buffer, int start, //#define TEST_ENC_35 #ifdef TEST_ENC_35 { - unsigned char nibBuf[kNibblizedOutputLen]; + uint8_t nibBuf[kNibblizedOutputLen]; memset(nibBuf, 0xcc, sizeof(nibBuf)); /* encode what we just decoded */ @@ -416,7 +411,7 @@ DiskImg::DecodeNibbleSector35(const CircularBufferAccess& buffer, int start, * two flaky bits. */ if (i == 696) { - unsigned char val1, val2; + uint8_t val1, val2; val1 = kInvDiskBytes62[buffer[start + i]]; val2 = kInvDiskBytes62[nibBuf[i]]; if ((val1 & 0xfc) != (val2 & 0xfc)) { @@ -444,11 +439,10 @@ DiskImg::DecodeNibbleSector35(const CircularBufferAccess& buffer, int start, * * Returns "true" if all goes well, "false" otherwise. */ -/*static*/ bool -DiskImg::UnpackChecksum35(const CircularBufferAccess& buffer, int offset, - unsigned char* checksumBuf) +/*static*/ bool DiskImg::UnpackChecksum35(const CircularBufferAccess& buffer, + int offset, uint8_t* checksumBuf) { - unsigned char nib0, nib1, nib2, twos; + uint8_t nib0, nib1, nib2, twos; twos = kInvDiskBytes62[buffer[offset++]]; nib2 = kInvDiskBytes62[buffer[offset++]]; @@ -476,15 +470,14 @@ DiskImg::UnpackChecksum35(const CircularBufferAccess& buffer, int offset, * * "outBuf" must be able to hold kNibblizedOutputLen bytes. */ -/*static*/ void -DiskImg::EncodeNibbleSector35(const unsigned char* sectorData, - unsigned char* outBuf) +/*static*/ void DiskImg::EncodeNibbleSector35(const uint8_t* sectorData, + uint8_t* outBuf) { - const unsigned char* sectorDataStart = sectorData; - unsigned char* outBufStart = outBuf; - unsigned char part0[kChunkSize35], part1[kChunkSize35], part2[kChunkSize35]; + const uint8_t* sectorDataStart = sectorData; + uint8_t* outBufStart = outBuf; + uint8_t part0[kChunkSize35], part1[kChunkSize35], part2[kChunkSize35]; unsigned int chk0, chk1, chk2; - unsigned char val, twos; + uint8_t val, twos; int i; /* diff --git a/diskimg/OuterWrapper.cpp b/diskimg/OuterWrapper.cpp index e3d69e7..7f7ca9b 100644 --- a/diskimg/OuterWrapper.cpp +++ b/diskimg/OuterWrapper.cpp @@ -34,11 +34,10 @@ * to be "helpful" and reads the file whether it's in gz format or not. * Some days I could do with a little less "help". */ -/*static*/ DIError -OuterGzip::Test(GenericFD* pGFD, di_off_t outerLength) +/*static*/ DIError OuterGzip::Test(GenericFD* pGFD, di_off_t outerLength) { const int kGzipMagic = 0x8b1f; // 0x1f 0x8b - unsigned short magic, magicBuf; + uint16_t magic, magicBuf; const char* imagePath; LOGI("Testing for gzip"); @@ -54,7 +53,7 @@ OuterGzip::Test(GenericFD* pGFD, di_off_t outerLength) if (pGFD->Read(&magicBuf, 2) != kDIErrNone) return kDIErrGeneric; - magic = GetShortLE((unsigned char*) &magicBuf); + magic = GetShortLE((uint8_t*) &magicBuf); if (magic == kGzipMagic) return kDIErrNone; @@ -62,7 +61,6 @@ OuterGzip::Test(GenericFD* pGFD, di_off_t outerLength) return kDIErrGeneric; } - /* * The gzip file format has a length embedded in the footer, but * unfortunately there is no interface to access it. So, we have @@ -81,8 +79,7 @@ OuterGzip::Test(GenericFD* pGFD, di_off_t outerLength) * to a temp file, or allowing the caller to specify what the largest * size they can handle is. */ -DIError -OuterGzip::ExtractGzipImage(gzFile gzfp, char** pBuf, di_off_t* pLength) +DIError OuterGzip::ExtractGzipImage(gzFile gzfp, char** pBuf, di_off_t* pLength) { DIError dierr = kDIErrNone; const int kMinEmpty = 256 * 1024; @@ -222,8 +219,7 @@ bail: /* * Open the archive, and extract the disk image into a memory buffer. */ -DIError -OuterGzip::Load(GenericFD* pOuterGFD, di_off_t outerLength, bool readOnly, +DIError OuterGzip::Load(GenericFD* pOuterGFD, di_off_t outerLength, bool readOnly, di_off_t* pWrapperLength, GenericFD** ppWrapperGFD) { DIError dierr = kDIErrNone; @@ -285,8 +281,7 @@ bail: * "pOuterGFD" isn't disturbed (same as Load). All we want is to get the * filename and then do everything through gzio. */ -DIError -OuterGzip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, +DIError OuterGzip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, di_off_t wrapperLength) { DIError dierr = kDIErrNone; @@ -366,8 +361,7 @@ bail: /* * Test to see if this is a ZIP archive. */ -/*static*/ DIError -OuterZip::Test(GenericFD* pGFD, di_off_t outerLength) +/*static*/ DIError OuterZip::Test(GenericFD* pGFD, di_off_t outerLength) { DIError dierr = kDIErrNone; CentralDirEntry cde; @@ -410,14 +404,13 @@ bail: /* * Open the archive, and extract the disk image into a memory buffer. */ -DIError -OuterZip::Load(GenericFD* pOuterGFD, di_off_t outerLength, bool readOnly, +DIError OuterZip::Load(GenericFD* pOuterGFD, di_off_t outerLength, bool readOnly, di_off_t* pWrapperLength, GenericFD** ppWrapperGFD) { DIError dierr = kDIErrNone; GFDBuffer* pNewGFD = NULL; CentralDirEntry cde; - unsigned char* buf = NULL; + uint8_t* buf = NULL; di_off_t length = -1; const char* pExt; @@ -471,8 +464,7 @@ bail: * Save the contents of "pWrapperGFD" to the file pointed to by * "pOuterGFD". */ -DIError -OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, +DIError OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, di_off_t wrapperLength) { DIError dierr = kDIErrNone; @@ -527,7 +519,7 @@ OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, /* * Write the compressed data. */ - unsigned long crc; + uint32_t crc; di_off_t compressedLen; if (lfh.fCompressionMethod == kCompressDeflated) { dierr = DeflateGFDToGFD(pOuterGFD, pWrapperGFD, wrapperLength, @@ -556,8 +548,8 @@ OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, * local file header is easy enough. */ lfh.fCRC32 = crc; - lfh.fCompressedSize = (unsigned long) compressedLen; - lfh.fUncompressedSize = (unsigned long) wrapperLength; + lfh.fCompressedSize = (uint32_t) compressedLen; + lfh.fUncompressedSize = (uint32_t) wrapperLength; di_off_t curPos; curPos = pOuterGFD->Tell(); @@ -590,7 +582,7 @@ OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, cde.fUncompressedSize = lfh.fUncompressedSize; assert(lfh.fExtraFieldLength == 0 && cde.fExtraFieldLength == 0); cde.fExternalAttrs = 0x81b60020; // matches what WinZip does - cde.fLocalHeaderRelOffset = (unsigned long) lfhOffset; + cde.fLocalHeaderRelOffset = (uint32_t) lfhOffset; cde.SetFileName(fStoredFileName); dierr = cde.Write(pOuterGFD); if (dierr != kDIErrNone) @@ -603,8 +595,8 @@ OuterZip::Save(GenericFD* pOuterGFD, GenericFD* pWrapperGFD, */ eocd.fNumEntries = 1; eocd.fTotalNumEntries = 1; - eocd.fCentralDirSize = (unsigned long) (cdeFinish - cdeStart); - eocd.fCentralDirOffset = (unsigned long) cdeStart; + eocd.fCentralDirSize = (uint32_t) (cdeFinish - cdeStart); + eocd.fCentralDirOffset = (uint32_t) cdeStart; assert(eocd.fCentralDirSize >= EndOfCentralDir::kEOCDLen); dierr = eocd.Write(pOuterGFD); if (dierr != kDIErrNone) @@ -619,18 +611,15 @@ bail: return dierr; } - /* * Track the name of the file stored in the ZIP archive. */ -void -OuterZip::SetStoredFileName(const char* name) +void OuterZip::SetStoredFileName(const char* name) { delete[] fStoredFileName; fStoredFileName = StrcpyNew(name); } - /* * Find the central directory and read the contents. * @@ -651,13 +640,12 @@ OuterZip::SetStoredFileName(const char* name) * area, we're hosed. This appears to be the way that the Info-ZIP guys * do it though, so we're in pretty good company if this fails. */ -/*static*/ DIError -OuterZip::ReadCentralDir(GenericFD* pGFD, di_off_t outerLength, +/*static*/ DIError OuterZip::ReadCentralDir(GenericFD* pGFD, di_off_t outerLength, CentralDirEntry* pDirEntry) { DIError dierr = kDIErrNone; EndOfCentralDir eocd; - unsigned char* buf = NULL; + uint8_t* buf = NULL; di_off_t seekStart; long readAmount; int i; @@ -666,7 +654,7 @@ OuterZip::ReadCentralDir(GenericFD* pGFD, di_off_t outerLength, if (outerLength < EndOfCentralDir::kEOCDLen + 4) return kDIErrGeneric; - buf = new unsigned char[kMaxEOCDSearch]; + buf = new uint8_t[kMaxEOCDSearch]; if (buf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -745,7 +733,7 @@ OuterZip::ReadCentralDir(GenericFD* pGFD, di_off_t outerLength, pDirEntry->Dump(); { - unsigned char checkBuf[4]; + uint8_t checkBuf[4]; dierr = pGFD->Read(checkBuf, 4); if (dierr != kDIErrNone) goto bail; @@ -763,18 +751,16 @@ bail: return dierr; } - /* * The central directory tells us where to find the local header. We - * have to skip over that to get to the start of the data.s + * have to skip over that to get to the start of the data. */ -DIError -OuterZip::ExtractZipEntry(GenericFD* pOuterGFD, CentralDirEntry* pCDE, - unsigned char** pBuf, di_off_t* pLength) +DIError OuterZip::ExtractZipEntry(GenericFD* pOuterGFD, CentralDirEntry* pCDE, + uint8_t** pBuf, di_off_t* pLength) { DIError dierr = kDIErrNone; LocalFileHeader lfh; - unsigned char* buf = NULL; + uint8_t* buf = NULL; /* seek to the start of the local header */ dierr = pOuterGFD->Seek(pCDE->fLocalHeaderRelOffset, kSeekSet); @@ -795,7 +781,7 @@ OuterZip::ExtractZipEntry(GenericFD* pOuterGFD, CentralDirEntry* pCDE, /* we should now be pointing at the data */ LOGI("File offset is 0x%08lx", (long) pOuterGFD->Tell()); - buf = new unsigned char[pCDE->fUncompressedSize]; + buf = new uint8_t[pCDE->fUncompressedSize]; if (buf == NULL) { /* a very real possibility */ LOGI(" ZIP unable to allocate buffer of %lu bytes", @@ -821,7 +807,7 @@ OuterZip::ExtractZipEntry(GenericFD* pOuterGFD, CentralDirEntry* pCDE, } /* check the CRC32 */ - unsigned long crc; + uint32_t crc; crc = crc32(0L, Z_NULL, 0); crc = crc32(crc, buf, pCDE->fUncompressedSize); @@ -849,18 +835,17 @@ bail: * * "buf" must be able to hold "uncompSize" bytes. */ -DIError -OuterZip::InflateGFDToBuffer(GenericFD* pGFD, unsigned long compSize, - unsigned long uncompSize, unsigned char* buf) +DIError OuterZip::InflateGFDToBuffer(GenericFD* pGFD, unsigned long compSize, + unsigned long uncompSize, uint8_t* buf) { DIError dierr = kDIErrNone; - const unsigned long kReadBufSize = 65536; - unsigned char* readBuf = NULL; + const size_t kReadBufSize = 65536; + uint8_t* readBuf = NULL; z_stream zstream; int zerr; unsigned long compRemaining; - readBuf = new unsigned char[kReadBufSize]; + readBuf = new uint8_t[kReadBufSize]; if (readBuf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -949,12 +934,10 @@ bail: return dierr; } - /* * Get the current date/time, in MS-DOS format. */ -void -OuterZip::GetMSDOSTime(unsigned short* pDate, unsigned short* pTime) +void OuterZip::GetMSDOSTime(uint16_t* pDate, uint16_t* pTime) { #if 0 /* this gets gmtime; we want localtime */ @@ -976,8 +959,7 @@ OuterZip::GetMSDOSTime(unsigned short* pDate, unsigned short* pTime) /* * Convert a time_t to MS-DOS date and time values. */ -void -OuterZip::DOSTime(time_t when, unsigned short* pDate, unsigned short* pTime) +void OuterZip::DOSTime(time_t when, uint16_t* pDate, uint16_t* pTime) { time_t even; @@ -1000,27 +982,25 @@ OuterZip::DOSTime(time_t when, unsigned short* pDate, unsigned short* pTime) *pTime = ptm->tm_hour << 11 | ptm->tm_min << 5 | ptm->tm_sec >> 1; } - /* * Compress "length" bytes of data from "pSrc" to "pDst". */ -DIError -OuterZip::DeflateGFDToGFD(GenericFD* pDst, GenericFD* pSrc, di_off_t srcLen, - di_off_t* pCompLength, unsigned long* pCRC) +DIError OuterZip::DeflateGFDToGFD(GenericFD* pDst, GenericFD* pSrc, + di_off_t srcLen, di_off_t* pCompLength, uint32_t* pCRC) { DIError dierr = kDIErrNone; - const unsigned long kBufSize = 32768; - unsigned char* inBuf = NULL; - unsigned char* outBuf = NULL; + const size_t kBufSize = 32768; + uint8_t* inBuf = NULL; + uint8_t* outBuf = NULL; z_stream zstream; - unsigned long crc; + uint32_t crc; int zerr; /* * Create an input buffer and an output buffer. */ - inBuf = new unsigned char[kBufSize]; - outBuf = new unsigned char[kBufSize]; + inBuf = new uint8_t[kBufSize]; + outBuf = new uint8_t[kBufSize]; if (inBuf == NULL || outBuf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1126,8 +1106,7 @@ bail: /* * Set the "fExtension" field. */ -void -OuterZip::SetExtension(const char* ext) +void OuterZip::SetExtension(const char* ext) { delete[] fExtension; fExtension = StrcpyNew(ext); @@ -1146,11 +1125,10 @@ OuterZip::SetExtension(const char* ext) * On entry, "pGFD" points to the signature at the start of the header. * On exit, "pGFD" points to the start of data. */ -DIError -OuterZip::LocalFileHeader::Read(GenericFD* pGFD) +DIError OuterZip::LocalFileHeader::Read(GenericFD* pGFD) { DIError dierr = kDIErrNone; - unsigned char buf[kLFHLen]; + uint8_t buf[kLFHLen]; dierr = pGFD->Read(buf, kLFHLen); if (dierr != kDIErrNone) @@ -1176,7 +1154,7 @@ OuterZip::LocalFileHeader::Read(GenericFD* pGFD) /* grab filename */ if (fFileNameLength != 0) { assert(fFileName == NULL); - fFileName = new unsigned char[fFileNameLength+1]; + fFileName = new uint8_t[fFileNameLength+1]; if (fFileName == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1199,11 +1177,10 @@ bail: /* * Write a local file header. */ -DIError -OuterZip::LocalFileHeader::Write(GenericFD* pGFD) +DIError OuterZip::LocalFileHeader::Write(GenericFD* pGFD) { DIError dierr = kDIErrNone; - unsigned char buf[kLFHLen]; + uint8_t buf[kLFHLen]; PutLongLE(&buf[0x00], kSignature); PutShortLE(&buf[0x04], fVersionToExtract); @@ -1236,8 +1213,7 @@ bail: /* * Change the filename field. */ -void -OuterZip::LocalFileHeader::SetFileName(const char* name) +void OuterZip::LocalFileHeader::SetFileName(const char* name) { delete[] fFileName; fFileName = NULL; @@ -1245,15 +1221,15 @@ OuterZip::LocalFileHeader::SetFileName(const char* name) if (name != NULL) { fFileNameLength = strlen(name); - fFileName = new unsigned char[fFileNameLength+1]; + fFileName = new uint8_t[fFileNameLength+1]; if (fFileName == NULL) { - LOGI("Malloc failure in SetFileName %u", fFileNameLength); + LOGW("Malloc failure in SetFileName %u", fFileNameLength); fFileName = NULL; fFileNameLength = 0; } else { memcpy(fFileName, name, fFileNameLength); fFileName[fFileNameLength] = '\0'; - LOGI("+++ OuterZip LFH filename set to '%s'", fFileName); + LOGD("+++ OuterZip LFH filename set to '%s'", fFileName); } } } @@ -1261,8 +1237,7 @@ OuterZip::LocalFileHeader::SetFileName(const char* name) /* * Dump the contents of a LocalFileHeader object. */ -void -OuterZip::LocalFileHeader::Dump(void) const +void OuterZip::LocalFileHeader::Dump(void) const { LOGI(" LocalFileHeader contents:"); LOGI(" versToExt=%u gpBits=0x%04x compression=%u", @@ -1289,11 +1264,10 @@ OuterZip::LocalFileHeader::Dump(void) const * entry. On exit, "pGFD" will point at the signature word for the next * entry or for the EOCD. */ -DIError -OuterZip::CentralDirEntry::Read(GenericFD* pGFD) +DIError OuterZip::CentralDirEntry::Read(GenericFD* pGFD) { DIError dierr = kDIErrNone; - unsigned char buf[kCDELen]; + uint8_t buf[kCDELen]; dierr = pGFD->Read(buf, kCDELen); if (dierr != kDIErrNone) @@ -1325,7 +1299,7 @@ OuterZip::CentralDirEntry::Read(GenericFD* pGFD) /* grab filename */ if (fFileNameLength != 0) { assert(fFileName == NULL); - fFileName = new unsigned char[fFileNameLength+1]; + fFileName = new uint8_t[fFileNameLength+1]; if (fFileName == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1345,7 +1319,7 @@ OuterZip::CentralDirEntry::Read(GenericFD* pGFD) /* grab comment, if any */ if (fFileCommentLength != 0) { assert(fFileComment == NULL); - fFileComment = new unsigned char[fFileCommentLength+1]; + fFileComment = new uint8_t[fFileCommentLength+1]; if (fFileComment == NULL) { dierr = kDIErrMalloc; goto bail; @@ -1364,11 +1338,10 @@ bail: /* * Write a central dir entry. */ -DIError -OuterZip::CentralDirEntry::Write(GenericFD* pGFD) +DIError OuterZip::CentralDirEntry::Write(GenericFD* pGFD) { DIError dierr = kDIErrNone; - unsigned char buf[kCDELen]; + uint8_t buf[kCDELen]; PutLongLE(&buf[0x00], kSignature); PutShortLE(&buf[0x04], fVersionMadeBy); @@ -1408,8 +1381,7 @@ bail: /* * Change the filename field. */ -void -OuterZip::CentralDirEntry::SetFileName(const char* name) +void OuterZip::CentralDirEntry::SetFileName(const char* name) { delete[] fFileName; fFileName = NULL; @@ -1417,7 +1389,7 @@ OuterZip::CentralDirEntry::SetFileName(const char* name) if (name != NULL) { fFileNameLength = strlen(name); - fFileName = new unsigned char[fFileNameLength+1]; + fFileName = new uint8_t[fFileNameLength+1]; if (fFileName == NULL) { LOGI("Malloc failure in SetFileName %u", fFileNameLength); fFileName = NULL; @@ -1430,12 +1402,10 @@ OuterZip::CentralDirEntry::SetFileName(const char* name) } } - /* * Dump the contents of a CentralDirEntry object. */ -void -OuterZip::CentralDirEntry::Dump(void) const +void OuterZip::CentralDirEntry::Dump(void) const { LOGI(" CentralDirEntry contents:"); LOGI(" versMadeBy=%u versToExt=%u gpBits=0x%04x compression=%u", @@ -1470,8 +1440,7 @@ OuterZip::CentralDirEntry::Dump(void) const * * "buf" should be positioned at the EOCD signature. */ -DIError -OuterZip::EndOfCentralDir::ReadBuf(const unsigned char* buf, int len) +DIError OuterZip::EndOfCentralDir::ReadBuf(const uint8_t* buf, int len) { if (len < kEOCDLen) { /* looks like ZIP file got truncated */ @@ -1497,11 +1466,10 @@ OuterZip::EndOfCentralDir::ReadBuf(const unsigned char* buf, int len) /* * Write an end-of-central-directory section. */ -DIError -OuterZip::EndOfCentralDir::Write(GenericFD* pGFD) +DIError OuterZip::EndOfCentralDir::Write(GenericFD* pGFD) { DIError dierr = kDIErrNone; - unsigned char buf[kEOCDLen]; + uint8_t buf[kEOCDLen]; PutLongLE(&buf[0x00], kSignature); PutShortLE(&buf[0x04], fDiskNumber); @@ -1521,6 +1489,7 @@ OuterZip::EndOfCentralDir::Write(GenericFD* pGFD) bail: return dierr; } + /* * Dump the contents of an EndOfCentralDir object. */ diff --git a/diskimg/OzDOS.cpp b/diskimg/OzDOS.cpp index b83f23d..9167a40 100644 --- a/diskimg/OzDOS.cpp +++ b/diskimg/OzDOS.cpp @@ -40,9 +40,8 @@ const int kMaxCatalogIterations = 64; * Read a track/sector, adjusting for 32-sector disks being treated as * if they were 16-sector. */ -static DIError -ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, - int sectorOffset, unsigned char* buf, DiskImg::SectorOrder imageOrder) +static DIError ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, + int sectorOffset, uint8_t* buf, DiskImg::SectorOrder imageOrder) { track *= 4; sector = sector * 2 + sectorOffset; @@ -57,11 +56,11 @@ ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, /* * Test for presence of 400K OzDOS 3.3 volumes. */ -static DIError -TestImageHalf(DiskImg* pImg, int sectorOffset, DiskImg::SectorOrder imageOrder) +static DIError TestImageHalf(DiskImg* pImg, int sectorOffset, + DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int numTracks, numSectors; int catTrack, catSect; int foundGood = 0; @@ -129,8 +128,7 @@ bail: /* * Test both of the DOS partitions. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr; @@ -150,8 +148,7 @@ TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) /* * Test to see if the image is a OzDOS volume. */ -/*static*/ DIError -DiskFSOzDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSOzDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { /* only on 800K disks (at the least, insist on numTracks being even) */ @@ -189,8 +186,8 @@ DiskFSOzDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * Test to see if the image is a 'wide' (32-sector) DOS3.3 volume, i.e. * half of a OzDOS volume. */ -/*static*/ DIError -DiskFS::TestOzWideDOS33(const DiskImg* pImg, DiskImg::SectorOrder* pOrder) +/*static*/ DIError DiskFS::TestOzWideDOS33(const DiskImg* pImg, + DiskImg::SectorOrder* pOrder) { DIError dierr = kDIErrNone; @@ -224,8 +221,7 @@ DiskFS::TestOzWideDOS33(const DiskImg* pImg, DiskImg::SectorOrder* pOrder) /* * Set up our sub-volumes. */ -DIError -DiskFSOzDOS::Initialize(void) +DIError DiskFSOzDOS::Initialize(void) { DIError dierr = kDIErrNone; @@ -249,8 +245,7 @@ DiskFSOzDOS::Initialize(void) /* * Open up one of the DOS 3.3 sub-volumes. */ -DIError -DiskFSOzDOS::OpenSubVolume(int idx) +DIError DiskFSOzDOS::OpenSubVolume(int idx) { DIError dierr = kDIErrNone; DiskFS* pNewFS = NULL; diff --git a/diskimg/Pascal.cpp b/diskimg/Pascal.cpp index 0cf8ca5..f38e6b9 100644 --- a/diskimg/Pascal.cpp +++ b/diskimg/Pascal.cpp @@ -30,12 +30,11 @@ static const char* kInvalidNameChars = "$=?,[#:"; * * We test a few fields in the volume directory for validity. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[512]; - unsigned char volName[DiskFSPascal::kMaxVolumeName+1]; + uint8_t blkBuf[512]; + uint8_t volName[DiskFSPascal::kMaxVolumeName+1]; dierr = pImg->ReadBlockSwapped(kVolHeaderBlock, blkBuf, imageOrder, DiskImg::kSectorOrderProDOS); @@ -66,8 +65,7 @@ bail: /* * Test to see if the image is a Pascal disk. */ -/*static*/ DIError -DiskFSPascal::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSPascal::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { DiskImg::SectorOrder ordering[DiskImg::kSectorOrderMax]; @@ -95,8 +93,7 @@ DiskFSPascal::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSPascal::Initialize(void) +DIError DiskFSPascal::Initialize(void) { DIError dierr = kDIErrNone; @@ -138,11 +135,10 @@ bail: /* * Read some interesting fields from the volume header. */ -DIError -DiskFSPascal::LoadVolHeader(void) +DIError DiskFSPascal::LoadVolHeader(void) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int nameLen, maxFiles; dierr = fpImg->ReadBlock(kVolHeaderBlock, blkBuf); @@ -198,8 +194,7 @@ bail: /* * Set the volume ID field. */ -void -DiskFSPascal::SetVolumeID(void) +void DiskFSPascal::SetVolumeID(void) { sprintf(fVolumeID, "Pascal %s:", fVolumeName); } @@ -207,8 +202,7 @@ DiskFSPascal::SetVolumeID(void) /* * Dump what we pulled out of the volume header. */ -void -DiskFSPascal::DumpVolHeader(void) +void DiskFSPascal::DumpVolHeader(void) { time_t access, dateSet; @@ -237,11 +231,10 @@ DiskFSPascal::DumpVolHeader(void) * * Sets "fDirectory". */ -DIError -DiskFSPascal::LoadCatalog(void) +DIError DiskFSPascal::LoadCatalog(void) { DIError dierr = kDIErrNone; - unsigned char* dirPtr; + uint8_t* dirPtr; int block, numBlocks; assert(fDirectory == NULL); @@ -252,7 +245,7 @@ DiskFSPascal::LoadCatalog(void) goto bail; } - fDirectory = new unsigned char[kBlkSize * numBlocks]; + fDirectory = new uint8_t[kBlkSize * numBlocks]; if (fDirectory == NULL) { dierr = kDIErrMalloc; goto bail; @@ -280,11 +273,10 @@ bail: /* * Write our copy of the catalog back out to disk. */ -DIError -DiskFSPascal::SaveCatalog(void) +DIError DiskFSPascal::SaveCatalog(void) { DIError dierr = kDIErrNone; - unsigned char* dirPtr; + uint8_t* dirPtr; int block, numBlocks; assert(fDirectory != NULL); @@ -308,8 +300,7 @@ bail: /* * Free the catalog storage. */ -void -DiskFSPascal::FreeCatalog(void) +void DiskFSPascal::FreeCatalog(void) { delete[] fDirectory; fDirectory = NULL; @@ -319,14 +310,13 @@ DiskFSPascal::FreeCatalog(void) /* * Process the catalog into A2File structures. */ -DIError -DiskFSPascal::ProcessCatalog(void) +DIError DiskFSPascal::ProcessCatalog(void) { DIError dierr = kDIErrNone; int i, nameLen; A2FilePascal* pFile; - const unsigned char* dirPtr; - unsigned short prevNextBlock = fNextBlock; + const uint8_t* dirPtr; + uint16_t prevNextBlock = fNextBlock; dierr = LoadCatalog(); if (dierr != kDIErrNone) @@ -398,8 +388,7 @@ bail: * Create the volume usage map. Since UCSD Pascal volumes have neither * in-use maps nor index blocks, this is pretty straightforward. */ -DIError -DiskFSPascal::ScanFileUsage(void) +DIError DiskFSPascal::ScanFileUsage(void) { int block; @@ -426,8 +415,7 @@ DiskFSPascal::ScanFileUsage(void) /* * Update an entry in the volume usage map. */ -void -DiskFSPascal::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) +void DiskFSPascal::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) { VolumeUsage::ChunkState cstate; @@ -450,8 +438,7 @@ DiskFSPascal::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) * Volume names can only be 7 characters long, but otherwise obey the same * rules as file names. */ -/*static*/ bool -DiskFSPascal::IsValidVolumeName(const char* name) +/*static*/ bool DiskFSPascal::IsValidVolumeName(const char* name) { if (name == NULL) { assert(false); @@ -471,8 +458,7 @@ DiskFSPascal::IsValidVolumeName(const char* name) * (,[#:). It also converts all alpha characters to upper case, but we can * take care of that later. */ -/*static*/ bool -DiskFSPascal::IsValidFileName(const char* name) +/*static*/ bool DiskFSPascal::IsValidFileName(const char* name) { assert(name != NULL); @@ -499,11 +485,10 @@ DiskFSPascal::IsValidFileName(const char* name) /* * Put a Pascal filesystem image on the specified DiskImg. */ -DIError -DiskFSPascal::Format(DiskImg* pDiskImg, const char* volName) +DIError DiskFSPascal::Format(DiskImg* pDiskImg, const char* volName) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; long formatBlocks; if (!IsValidVolumeName(volName)) @@ -552,7 +537,7 @@ DiskFSPascal::Format(DiskImg* pDiskImg, const char* volName) PutShortLE(&blkBuf[0x04], 0); // "file" type blkBuf[0x06] = strlen(volName); memcpy(&blkBuf[0x07], volName, strlen(volName)); - PutShortLE(&blkBuf[0x0e], (unsigned short) pDiskImg->GetNumBlocks()); + PutShortLE(&blkBuf[0x0e], (uint16_t) pDiskImg->GetNumBlocks()); PutShortLE(&blkBuf[0x10], 0); // num files PutShortLE(&blkBuf[0x12], 0); // last access date PutShortLE(&blkBuf[0x14], 0xa87b); // last date set (Nov 7 1984) @@ -580,7 +565,7 @@ bail: * Blocks 0 and 1 of a 5.25" bootable Pascal disk, formatted by * APPLE3:FORMATTER from Pascal v1.3. */ -const unsigned char gPascal525Block0[] = { +const uint8_t gPascal525Block0[] = { 0x01, 0xe0, 0x70, 0xb0, 0x04, 0xe0, 0x40, 0xb0, 0x39, 0xbd, 0x88, 0xc0, 0x20, 0x20, 0x08, 0xa2, 0x00, 0xbd, 0x25, 0x08, 0x09, 0x80, 0x20, 0xfd, 0xfb, 0xe8, 0xe0, 0x1d, 0xd0, 0xf3, 0xf0, 0xfe, 0xa9, 0x0a, 0x4c, 0x24, @@ -625,7 +610,7 @@ const unsigned char gPascal525Block0[] = { 0xf4, 0xea, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0xaa, 0xd0, 0xf2, 0xa0, 0x56, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0xad }; -const unsigned char gPascal525Block1[] = { +const uint8_t gPascal525Block1[] = { 0xd0, 0xe7, 0xa9, 0x00, 0x88, 0x84, 0x26, 0xbc, 0x8c, 0xc0, 0x10, 0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x26, 0x99, 0x00, 0x03, 0xd0, 0xee, 0x84, 0x26, 0xbc, 0x8c, 0xc0, 0x10, 0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x26, 0x99, 0x00, @@ -675,7 +660,7 @@ const unsigned char gPascal525Block1[] = { * Block 0 of a 3.5" bootable Pascal disk, formatted by * APPLE3:FORMATTER from Pascal v1.3. Block 1 is zeroed out. */ -unsigned char gPascal35Block0[] = { +const uint8_t gPascal35Block0[] = { 0x01, 0xe0, 0x70, 0xb0, 0x04, 0xe0, 0x40, 0xb0, 0x39, 0xbd, 0x88, 0xc0, 0x20, 0x20, 0x08, 0xa2, 0x00, 0xbd, 0x25, 0x08, 0x09, 0x80, 0x20, 0xfd, 0xfb, 0xe8, 0xe0, 0x1d, 0xd0, 0xf3, 0xf0, 0xfe, 0xa9, 0x0a, 0x4c, 0x24, @@ -724,12 +709,11 @@ unsigned char gPascal35Block0[] = { /* * Write the Pascal boot blocks onto the disk image. */ -DIError -DiskFSPascal::WriteBootBlocks(void) +DIError DiskFSPascal::WriteBootBlocks(void) { DIError dierr; - unsigned char block0[512]; - unsigned char block1[512]; + uint8_t block0[512]; + uint8_t block1[512]; bool is525 = false; assert(fpImg->GetHasBlocks()); @@ -765,7 +749,6 @@ DiskFSPascal::WriteBootBlocks(void) return kDIErrNone; } - /* * Scan for damaged files and conflicting file allocation entries. * @@ -774,8 +757,7 @@ DiskFSPascal::WriteBootBlocks(void) * * Returns "true" if disk appears to be perfect, "false" otherwise. */ -bool -DiskFSPascal::CheckDiskIsGood(void) +bool DiskFSPascal::CheckDiskIsGood(void) { //DIError dierr; bool result = true; @@ -809,13 +791,12 @@ DiskFSPascal::CheckDiskIsGood(void) /* * Run through the list of files and count up the free blocks. */ -DIError -DiskFSPascal::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, +DIError DiskFSPascal::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, int* pUnitSize) const { A2FilePascal* pFile; long freeBlocks = 0; - unsigned short prevNextBlock = fNextBlock; + uint16_t prevNextBlock = fNextBlock; pFile = (A2FilePascal*) GetNextFile(NULL); while (pFile != NULL) { @@ -840,8 +821,7 @@ DiskFSPascal::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, * "*pNormalizedBufLen" is used to pass in the length of the buffer and * pass out the length of the string (should the buffer prove inadequate). */ -DIError -DiskFSPascal::NormalizePath(const char* path, char fssep, +DIError DiskFSPascal::NormalizePath(const char* path, char fssep, char* normalizedBuf, int* pNormalizedBufLen) { DIError dierr = kDIErrNone; @@ -866,8 +846,7 @@ DiskFSPascal::NormalizePath(const char* path, char fssep, * * "outBuf" must be able to hold kMaxFileName+1 characters. */ -void -DiskFSPascal::DoNormalizePath(const char* name, char fssep, char* outBuf) +void DiskFSPascal::DoNormalizePath(const char* name, char fssep, char* outBuf) { char* outp = outBuf; const char* cp; @@ -912,8 +891,7 @@ DiskFSPascal::DoNormalizePath(const char* name, char fssep, char* outBuf) * we create here are expected to be written to, not used as filler, so * this behavior is actually a *good* thing. */ -DIError -DiskFSPascal::CreateFile(const CreateParms* pParms, A2File** ppNewFile) +DIError DiskFSPascal::CreateFile(const CreateParms* pParms, A2File** ppNewFile) { DIError dierr = kDIErrNone; const bool createUnique = (GetParameter(kParm_CreateUnique) != 0); @@ -1015,12 +993,12 @@ DiskFSPascal::CreateFile(const CreateParms* pParms, A2File** ppNewFile) /* * Fill the hole. */ - unsigned char* dirPtr; + uint8_t* dirPtr; dirPtr = fDirectory + (prevIdx+1) * kDirectoryEntryLen; PutShortLE(&dirPtr[0x00], pNewFile->fStartBlock); PutShortLE(&dirPtr[0x02], pNewFile->fNextBlock); - PutShortLE(&dirPtr[0x04], (unsigned short) pNewFile->fFileType); - dirPtr[0x06] = (unsigned char) strlen(pNewFile->fFileName); + PutShortLE(&dirPtr[0x04], (uint16_t) pNewFile->fFileType); + dirPtr[0x06] = (uint8_t) strlen(pNewFile->fFileName); memcpy(&dirPtr[0x07], pNewFile->fFileName, A2FilePascal::kMaxFileName); PutShortLE(&dirPtr[0x16], pNewFile->fBytesRemaining); PutShortLE(&dirPtr[0x18], pNewFile->fModWhen); @@ -1065,8 +1043,7 @@ bail: * * Returns an error on failure, which should be impossible. */ -DIError -DiskFSPascal::MakeFileNameUnique(char* fileName) +DIError DiskFSPascal::MakeFileNameUnique(char* fileName) { assert(fileName != NULL); assert(strlen(fileName) <= A2FilePascal::kMaxFileName); @@ -1135,12 +1112,11 @@ DiskFSPascal::MakeFileNameUnique(char* fileName) * * If there's no free space left, returns kDIErrDiskFull. */ -DIError -DiskFSPascal::FindLargestFreeArea(int *pPrevIdx, A2FilePascal** ppPrevFile) +DIError DiskFSPascal::FindLargestFreeArea(int *pPrevIdx, A2FilePascal** ppPrevFile) { A2FilePascal* pFile; A2FilePascal* pPrevFile; - unsigned short prevNextBlock = fNextBlock; + uint16_t prevNextBlock = fNextBlock; int gapSize, maxGap, maxIndex, idx; maxIndex = -1; @@ -1181,17 +1157,15 @@ DiskFSPascal::FindLargestFreeArea(int *pPrevIdx, A2FilePascal** ppPrevFile) return kDIErrNone; } - /* * Delete a file. Because Pascal doesn't have a block allocation map, this * is a simple matter of crunching the directory entry out. */ -DIError -DiskFSPascal::DeleteFile(A2File* pGenericFile) +DIError DiskFSPascal::DeleteFile(A2File* pGenericFile) { DIError dierr = kDIErrNone; A2FilePascal* pFile = (A2FilePascal*) pGenericFile; - unsigned char* pEntry; + uint8_t* pEntry; int dirLen, offsetToNextEntry; if (pGenericFile == NULL) { @@ -1247,13 +1221,12 @@ bail: /* * Rename a file. */ -DIError -DiskFSPascal::RenameFile(A2File* pGenericFile, const char* newName) +DIError DiskFSPascal::RenameFile(A2File* pGenericFile, const char* newName) { DIError dierr = kDIErrNone; A2FilePascal* pFile = (A2FilePascal*) pGenericFile; char normalName[A2FilePascal::kMaxFileName+1]; - unsigned char* pEntry; + uint8_t* pEntry; if (pFile == NULL || newName == NULL) return kDIErrInvalidArg; @@ -1302,13 +1275,12 @@ bail: * but we don't allow the full range of ProDOS types. Attempting to change * to an unsupported type results in "PDA" being used. */ -DIError -DiskFSPascal::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, +DIError DiskFSPascal::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, long accessFlags) { DIError dierr = kDIErrNone; A2FilePascal* pFile = (A2FilePascal*) pGenericFile; - unsigned char* pEntry; + uint8_t* pEntry; if (pFile == NULL) return kDIErrInvalidArg; @@ -1334,7 +1306,7 @@ DiskFSPascal::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, A2FilePascal::FileType newType; newType = A2FilePascal::ConvertFileType(fileType); - PutShortLE(&pEntry[0x04], (unsigned short) newType); + PutShortLE(&pEntry[0x04], (uint16_t) newType); dierr = SaveCatalog(); if (dierr != kDIErrNone) @@ -1351,8 +1323,7 @@ bail: /* * Change the Pascal volume name. */ -DIError -DiskFSPascal::RenameVolume(const char* newName) +DIError DiskFSPascal::RenameVolume(const char* newName) { DIError dierr = kDIErrNone; char normalName[A2FilePascal::kMaxFileName+1]; @@ -1387,10 +1358,9 @@ bail: /* * Find "pFile" in "fDirectory". */ -unsigned char* -DiskFSPascal::FindDirEntry(A2FilePascal* pFile) +uint8_t* DiskFSPascal::FindDirEntry(A2FilePascal* pFile) { - unsigned char* ptr; + uint8_t* ptr; int i; assert(fDirectory != NULL); @@ -1423,8 +1393,7 @@ DiskFSPascal::FindDirEntry(A2FilePascal* pFile) /* * Convert Pascal file type to ProDOS file type. */ -long -A2FilePascal::GetFileType(void) const +long A2FilePascal::GetFileType(void) const { switch (fFileType) { case kTypeUntyped: return 0x00; // NON @@ -1445,8 +1414,7 @@ A2FilePascal::GetFileType(void) const /* * Convert a ProDOS file type to a Pascal file type. */ -/*static*/ A2FilePascal::FileType -A2FilePascal::ConvertFileType(long prodosType) +/*static*/ A2FilePascal::FileType A2FilePascal::ConvertFileType(long prodosType) { FileType newType; @@ -1483,8 +1451,7 @@ A2FilePascal::ConvertFileType(long prodosType) * the year 100, it will assume that the file was created shortly before the * system crashed, and will remove the file. */ -/*static*/ time_t -A2FilePascal::ConvertPascalDate(PascalDate pascalDate) +/*static*/ time_t A2FilePascal::ConvertPascalDate(PascalDate pascalDate) { int year, month, day; @@ -1524,10 +1491,9 @@ A2FilePascal::ConvertPascalDate(PascalDate pascalDate) * * CiderPress uses kDateInvalid==-1 and kDateNone==-2. */ -/*static*/ A2FilePascal::PascalDate -A2FilePascal::ConvertPascalDate(time_t unixDate) +/*static*/ A2FilePascal::PascalDate A2FilePascal::ConvertPascalDate(time_t unixDate) { - unsigned long date, year; + uint32_t date, year; struct tm* ptm; if (unixDate == 0 || unixDate == -1 || unixDate == -2) @@ -1541,7 +1507,7 @@ A2FilePascal::ConvertPascalDate(time_t unixDate) if (year >= 100) year -= 100; if (year < 0 || year >= 100) { - LOGI("WHOOPS: got year %lu from %d", year, ptm->tm_year); + LOGW("WHOOPS: got year %lu from %d", year, ptm->tm_year); year = 70; } date = year << 9 | (ptm->tm_mon+1) | ptm->tm_mday << 4; @@ -1552,8 +1518,7 @@ A2FilePascal::ConvertPascalDate(time_t unixDate) /* * Return the file modification date. */ -time_t -A2FilePascal::GetModWhen(void) const +time_t A2FilePascal::GetModWhen(void) const { return ConvertPascalDate(fModWhen); } @@ -1561,8 +1526,7 @@ A2FilePascal::GetModWhen(void) const /* * Dump the contents of the A2File structure. */ -void -A2FilePascal::Dump(void) const +void A2FilePascal::Dump(void) const { LOGI("A2FilePascal '%s'", fFileName); LOGI(" start=%d next=%d type=%d", @@ -1574,8 +1538,7 @@ A2FilePascal::Dump(void) const /* * Not a whole lot to do, since there's no fancy index blocks. */ -DIError -A2FilePascal::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FilePascal::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { A2FDPascal* pOpenFile = NULL; @@ -1614,8 +1577,7 @@ A2FilePascal::Open(A2FileDescr** ppOpenFile, bool readOnly, /* * Read a chunk of data from the current offset. */ -DIError -A2FDPascal::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDPascal::Read(void* buf, size_t len, size_t* pActual) { LOGI(" Pascal reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -1633,7 +1595,7 @@ A2FDPascal::Read(void* buf, size_t len, size_t* pActual) long incrLen = len; DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; long block = pFile->fStartBlock + (long) (fOffset / kBlkSize); int bufOffset = (long) (fOffset % kBlkSize); // (& 0x01ff) size_t thisCount; @@ -1674,13 +1636,12 @@ A2FDPascal::Read(void* buf, size_t len, size_t* pActual) * and writing all data in one shot. On a Pascal disk, that makes this * process almost embarrassingly simple. */ -DIError -A2FDPascal::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDPascal::Write(const void* buf, size_t len, size_t* pActual) { DIError dierr = kDIErrNone; A2FilePascal* pFile = (A2FilePascal*) fpFile; DiskFSPascal* pDiskFS = (DiskFSPascal*) fpFile->GetDiskFS(); - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; size_t origLen = len; LOGI(" DOS Write len=%u %s", len, pFile->GetPathName()); @@ -1726,7 +1687,7 @@ A2FDPascal::Write(const void* buf, size_t len, size_t* pActual) goto bail; len -= kBlkSize; - buf = (unsigned char*) buf + kBlkSize; + buf = (uint8_t*) buf + kBlkSize; } else { /* partial block write */ memset(blkBuf, 0, sizeof(blkBuf)); @@ -1756,8 +1717,7 @@ bail: /* * Seek to a new offset. */ -DIError -A2FDPascal::Seek(di_off_t offset, DIWhence whence) +DIError A2FDPascal::Seek(di_off_t offset, DIWhence whence) { //di_off_t fileLen = ((A2FilePascal*) fpFile)->fLength; @@ -1792,8 +1752,7 @@ A2FDPascal::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDPascal::Tell(void) +di_off_t A2FDPascal::Tell(void) { return fOffset; } @@ -1804,15 +1763,14 @@ A2FDPascal::Tell(void) * Most applications don't check the value of "Close", or call it from a * destructor, so we call CloseDescr whether we succeed or not. */ -DIError -A2FDPascal::Close(void) +DIError A2FDPascal::Close(void) { DIError dierr = kDIErrNone; DiskFSPascal* pDiskFS = (DiskFSPascal*) fpFile->GetDiskFS(); if (fModified) { A2FilePascal* pFile = (A2FilePascal*) fpFile; - unsigned char* pEntry; + uint8_t* pEntry; dierr = pDiskFS->LoadCatalog(); if (dierr != kDIErrNone) @@ -1822,7 +1780,7 @@ A2FDPascal::Close(void) * Update our internal copies of stuff. */ pFile->fLength = fOpenEOF; - pFile->fNextBlock = pFile->fStartBlock + (unsigned short) fOpenBlocksUsed; + pFile->fNextBlock = pFile->fStartBlock + (uint16_t) fOpenBlocksUsed; pFile->fModWhen = A2FilePascal::ConvertPascalDate(time(NULL)); /* @@ -1838,8 +1796,8 @@ A2FDPascal::Close(void) dierr = kDIErrInternal; goto bail; } - unsigned short bytesInLastBlock; - bytesInLastBlock = (unsigned short)pFile->fLength % kBlkSize; + uint16_t bytesInLastBlock; + bytesInLastBlock = (uint16_t)pFile->fLength % kBlkSize; if (bytesInLastBlock == 0) bytesInLastBlock = 512; // exactly filled out last block @@ -1861,14 +1819,13 @@ bail: /* * Return the #of sectors/blocks in the file. */ -long -A2FDPascal::GetSectorCount(void) const +long A2FDPascal::GetSectorCount(void) const { A2FilePascal* pFile = (A2FilePascal*) fpFile; return (pFile->fNextBlock - pFile->fStartBlock) * 2; } -long -A2FDPascal::GetBlockCount(void) const + +long A2FDPascal::GetBlockCount(void) const { A2FilePascal* pFile = (A2FilePascal*) fpFile; return pFile->fNextBlock - pFile->fStartBlock; @@ -1877,8 +1834,7 @@ A2FDPascal::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDPascal::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDPascal::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { A2FilePascal* pFile = (A2FilePascal*) fpFile; long pascalIdx = sectorIdx / 2; @@ -1890,11 +1846,11 @@ A2FDPascal::GetStorage(long sectorIdx, long* pTrack, long* pSector) const BlockToTrackSector(pascalBlock, (sectorIdx & 0x01) != 0, pTrack, pSector); return kDIErrNone; } + /* * Return the Nth 512-byte block in this file. */ -DIError -A2FDPascal::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDPascal::GetStorage(long blockIdx, long* pBlock) const { A2FilePascal* pFile = (A2FilePascal*) fpFile; long pascalBlock = pFile->fStartBlock + blockIdx; diff --git a/diskimg/ProDOS.cpp b/diskimg/ProDOS.cpp index 15a7323..33e7839 100644 --- a/diskimg/ProDOS.cpp +++ b/diskimg/ProDOS.cpp @@ -44,37 +44,32 @@ const int kTypeDIR = 0x0f; * Directory header. All fields not marked as "only for subdirs" also apply * to the volume directory header. */ -//namespace DiskImgLib { - typedef struct DiskFSProDOS::DirHeader { - unsigned char storageType; - char dirName[A2FileProDOS::kMaxFileName+1]; - DiskFSProDOS::ProDate createWhen; - unsigned char version; - unsigned char minVersion; - unsigned char access; - unsigned char entryLength; - unsigned char entriesPerBlock; - unsigned short fileCount; + uint8_t storageType; + char dirName[A2FileProDOS::kMaxFileName+1]; + DiskFSProDOS::ProDate createWhen; + uint8_t version; + uint8_t minVersion; + uint8_t access; + uint8_t entryLength; + uint8_t entriesPerBlock; + uint16_t fileCount; /* the rest are only for subdirs */ - unsigned short parentPointer; - unsigned char parentEntry; - unsigned char parentEntryLength; + uint16_t parentPointer; + uint8_t parentEntry; + uint8_t parentEntryLength; } DirHeader; -//}; // namespace DiskImgLib - /* * See if this looks like a ProDOS volume. * * We test a few fields in the volume directory header for validity. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int volDirEntryLength; int volDirEntriesPerBlock; @@ -105,8 +100,7 @@ bail: /* * Test to see if the image is a ProDOS disk. */ -/*static*/ DIError -DiskFSProDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSProDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { DiskImg::SectorOrder ordering[DiskImg::kSectorOrderMax]; @@ -134,8 +128,7 @@ DiskFSProDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk has * no files on it. */ -DIError -DiskFSProDOS::Initialize(InitMode initMode) +DIError DiskFSProDOS::Initialize(InitMode initMode) { DIError dierr = kDIErrNone; char msg[kMaxVolumeName + 32]; @@ -227,11 +220,10 @@ bail: * The "test" function verified certain things, e.g. the storage type * is $f and the volume name length is nonzero. */ -DIError -DiskFSProDOS::LoadVolHeader(void) +DIError DiskFSProDOS::LoadVolHeader(void) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int nameLen; dierr = fpImg->ReadBlock(kVolHeaderBlock, blkBuf); @@ -276,7 +268,7 @@ DiskFSProDOS::LoadVolHeader(void) * the start of the block, which is marked as "reserved" in Beneath * Apple ProDOS. */ - unsigned short lcFlags = GetShortLE(&blkBuf[0x1a]); + uint16_t lcFlags = GetShortLE(&blkBuf[0x1a]); GenerateLowerCaseName(fVolumeName, fVolumeName, lcFlags, false); } @@ -306,7 +298,7 @@ DiskFSProDOS::LoadVolHeader(void) fpImg->AddNote(DiskImg::kNoteWarning, "ProDOS filesystem blockcount (%d) exceeds disk image blocks (%ld).", fTotalBlocks, fpImg->GetNumBlocks()); - fTotalBlocks = (unsigned short) fpImg->GetNumBlocks(); + fTotalBlocks = (uint16_t) fpImg->GetNumBlocks(); fEarlyDamage = true; } } @@ -391,18 +383,15 @@ bail: /* * Set the volume ID field. */ -void -DiskFSProDOS::SetVolumeID(void) +void DiskFSProDOS::SetVolumeID(void) { sprintf(fVolumeID, "ProDOS /%s", fVolumeName); } - /* * Dump what we pulled out of the volume header. */ -void -DiskFSProDOS::DumpVolHeader(void) +void DiskFSProDOS::DumpVolHeader(void) { LOGI(" ProDOS volume header for '%s'", fVolumeName); LOGI(" CreateWhen=0x%08lx access=0x%02x bitmap=%d totalbl=%d", @@ -420,14 +409,12 @@ DiskFSProDOS::DumpVolHeader(void) //LOGI(" volume dir fileCount=%d", fFileCount); } - /* * Load the disk's volume bitmap into the object's "fBlockUseMap" pointer. * * Does not attempt to analyze the data. */ -DIError -DiskFSProDOS::LoadVolBitmap(void) +DIError DiskFSProDOS::LoadVolBitmap(void) { DIError dierr = kDIErrNone; int bitBlock, numBlocks; @@ -446,7 +433,7 @@ DiskFSProDOS::LoadVolBitmap(void) numBlocks = GetNumBitmapBlocks(); // based on fTotalBlocks assert(numBlocks > 0); - fBlockUseMap = new unsigned char[kBlkSize * numBlocks]; + fBlockUseMap = new uint8_t[kBlkSize * numBlocks]; if (fBlockUseMap == NULL) return kDIErrMalloc; @@ -466,8 +453,7 @@ DiskFSProDOS::LoadVolBitmap(void) /* * Save our copy of the volume bitmap. */ -DIError -DiskFSProDOS::SaveVolBitmap(void) +DIError DiskFSProDOS::SaveVolBitmap(void) { DIError dierr = kDIErrNone; int bitBlock, numBlocks; @@ -499,8 +485,7 @@ DiskFSProDOS::SaveVolBitmap(void) * * It's okay to call this if the bitmap isn't loaded. */ -void -DiskFSProDOS::FreeVolBitmap(void) +void DiskFSProDOS::FreeVolBitmap(void) { delete[] fBlockUseMap; fBlockUseMap = NULL; @@ -510,8 +495,7 @@ DiskFSProDOS::FreeVolBitmap(void) * Examine the volume bitmap, setting fields in the VolumeUsage map * as appropriate. */ -DIError -DiskFSProDOS::ScanVolBitmap(void) +DIError DiskFSProDOS::ScanVolBitmap(void) { DIError dierr; @@ -540,7 +524,7 @@ DiskFSProDOS::ScanVolBitmap(void) long block = 0; long numBytes = (fTotalBlocks + 7) / 8; for (i = 0; i < numBytes; i++) { - unsigned char val = fBlockUseMap[i]; + uint8_t val = fBlockUseMap[i]; for (int j = 0; j < 8; j++) { if (!(val & 0x80)) { @@ -570,8 +554,7 @@ DiskFSProDOS::ScanVolBitmap(void) /* * Generate an empty block use map. */ -DIError -DiskFSProDOS::CreateEmptyBlockMap(void) +DIError DiskFSProDOS::CreateEmptyBlockMap(void) { DIError dierr; @@ -605,14 +588,13 @@ DiskFSProDOS::CreateEmptyBlockMap(void) * * Returns "true" if it's in use, "false" otherwise. */ -bool -DiskFSProDOS::GetBlockUseEntry(long block) const +bool DiskFSProDOS::GetBlockUseEntry(long block) const { assert(block >= 0 && block < fTotalBlocks); assert(fBlockUseMap != NULL); int offset; - unsigned char mask; + uint8_t mask; offset = block / 8; mask = 0x80 >> (block & 0x07); @@ -625,8 +607,7 @@ DiskFSProDOS::GetBlockUseEntry(long block) const /* * Change the state of an entry in the block use map. */ -void -DiskFSProDOS::SetBlockUseEntry(long block, bool inUse) +void DiskFSProDOS::SetBlockUseEntry(long block, bool inUse) { assert(block >= 0 && block < fTotalBlocks); assert(fBlockUseMap != NULL); @@ -637,7 +618,7 @@ DiskFSProDOS::SetBlockUseEntry(long block, bool inUse) } int offset; - unsigned char mask; + uint8_t mask; offset = block / 8; mask = 0x80 >> (block & 0x07); @@ -652,8 +633,7 @@ DiskFSProDOS::SetBlockUseEntry(long block, bool inUse) * * Returns "true" if bogus entries were found, "false" if all is well. */ -bool -DiskFSProDOS::ScanForExtraEntries(void) const +bool DiskFSProDOS::ScanForExtraEntries(void) const { assert(fBlockUseMap != NULL); @@ -681,8 +661,7 @@ DiskFSProDOS::ScanForExtraEntries(void) const * * Returns the block number (0-65535) on success or -1 on failure. */ -long -DiskFSProDOS::AllocBlock(void) +long DiskFSProDOS::AllocBlock(void) { assert(fBlockUseMap != NULL); @@ -712,7 +691,7 @@ DiskFSProDOS::AllocBlock(void) if (fBlockUseMap[offset] != 0) { /* got one, figure out which */ int subBlock = 0; - unsigned char uch = fBlockUseMap[offset]; + uint8_t uch = fBlockUseMap[offset]; while ((uch & 0x80) == 0) { subBlock++; uch <<= 1; @@ -736,8 +715,7 @@ DiskFSProDOS::AllocBlock(void) /* * Tally up the number of free blocks. */ -DIError -DiskFSProDOS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, +DIError DiskFSProDOS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, int* pUnitSize) const { DIError dierr; @@ -761,14 +739,12 @@ DiskFSProDOS::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits, return kDIErrNone; } - /* * Update an entry in the VolumeUsage map. * * The VolumeUsage map spans the range of blocks */ -void -DiskFSProDOS::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) +void DiskFSProDOS::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) { VolumeUsage::ChunkState cstate; @@ -788,13 +764,12 @@ DiskFSProDOS::SetBlockUsage(long block, VolumeUsage::ChunkPurpose purpose) * * Start with "pParent" set to the magic entry for the volume dir. */ -DIError -DiskFSProDOS::RecursiveDirAdd(A2File* pParent, unsigned short dirBlock, +DIError DiskFSProDOS::RecursiveDirAdd(A2File* pParent, uint16_t dirBlock, const char* basePath, int depth) { DIError dierr = kDIErrNone; DirHeader header; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int numEntries, iterations, foundCount; bool first; @@ -874,14 +849,13 @@ bail: * * "*pFound" is increased by the number of valid entries found in this block. */ -DIError -DiskFSProDOS::SlurpEntries(A2File* pParent, const DirHeader* pHeader, - const unsigned char* blkBuf, bool skipFirst, int* pCount, - const char* basePath, unsigned short thisBlock, int depth) +DIError DiskFSProDOS::SlurpEntries(A2File* pParent, const DirHeader* pHeader, + const uint8_t* blkBuf, bool skipFirst, int* pCount, + const char* basePath, uint16_t thisBlock, int depth) { DIError dierr = kDIErrNone; int entriesThisBlock = pHeader->entriesPerBlock; - const unsigned char* entryBuf; + const uint8_t* entryBuf; A2FileProDOS* pFile; int idx = 0; @@ -963,12 +937,10 @@ bail: return dierr; } - /* * Pull the directory header out of the first block of a directory. */ -DIError -DiskFSProDOS::GetDirHeader(const unsigned char* blkBuf, DirHeader* pHeader) +DIError DiskFSProDOS::GetDirHeader(const uint8_t* blkBuf, DirHeader* pHeader) { int nameLen; @@ -1011,11 +983,10 @@ DiskFSProDOS::GetDirHeader(const unsigned char* blkBuf, DirHeader* pHeader) * There's some "HFS Finder information" stuffed into the key block * right after the data fork info, but I'm planning to ignore that. */ -DIError -DiskFSProDOS::ReadExtendedInfo(A2FileProDOS* pFile) +DIError DiskFSProDOS::ReadExtendedInfo(A2FileProDOS* pFile) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; dierr = fpImg->ReadBlock(pFile->fDirEntry.keyPointer, blkBuf); if (dierr != kDIErrNone) { @@ -1055,14 +1026,13 @@ bail: * * As a side-effect, we set the "sparse" length for the file. */ -DIError -DiskFSProDOS::ScanFileUsage(void) +DIError DiskFSProDOS::ScanFileUsage(void) { DIError dierr = kDIErrNone; A2FileProDOS* pFile; long blockCount, indexCount, sparseCount; - unsigned short* blockList = NULL; - unsigned short* indexList = NULL; + uint16_t* blockList = NULL; + uint16_t* indexList = NULL; pFile = (A2FileProDOS*) GetNextFile(NULL); while (pFile != NULL) { @@ -1197,9 +1167,8 @@ bail: /* * Scan a block list into the volume usage map. */ -void -DiskFSProDOS::ScanBlockList(long blockCount, unsigned short* blockList, - long indexCount, unsigned short* indexList, long* pSparseCount) +void DiskFSProDOS::ScanBlockList(long blockCount, uint16_t* blockList, + long indexCount, uint16_t* indexList, long* pSparseCount) { assert(blockList != NULL); assert(indexCount == 0 || indexList != NULL); @@ -1223,7 +1192,6 @@ DiskFSProDOS::ScanBlockList(long blockCount, unsigned short* blockList, } } - /* * ProDOS disks may contain other filesystems. The typical DOS-in-ProDOS * strategy involves marking a bunch of blocks at the end of the disc as @@ -1233,8 +1201,7 @@ DiskFSProDOS::ScanBlockList(long blockCount, unsigned short* blockList, * usage patterns and then testing those with the standard disk testing * facilities. */ -DIError -DiskFSProDOS::ScanForSubVolumes(void) +DIError DiskFSProDOS::ScanForSubVolumes(void) { DIError dierr = kDIErrNone; VolumeUsage::ChunkState cstate; @@ -1377,8 +1344,7 @@ DiskFSProDOS::ScanForSubVolumes(void) * On success, "*ppDiskImg" and "*ppDiskFS" are newly-allocated objects * of the appropriate kind. */ -DIError -DiskFSProDOS::FindSubVolume(long blockStart, long blockCount, +DIError DiskFSProDOS::FindSubVolume(long blockStart, long blockCount, DiskImg** ppDiskImg, DiskFS** ppDiskFS) { DIError dierr = kDIErrNone; @@ -1443,8 +1409,7 @@ bail: /* * Mark the blocks used by a sub-volume as in-use. */ -void -DiskFSProDOS::MarkSubVolumeBlocks(long block, long count) +void DiskFSProDOS::MarkSubVolumeBlocks(long block, long count) { VolumeUsage::ChunkState cstate; @@ -1466,16 +1431,14 @@ DiskFSProDOS::MarkSubVolumeBlocks(long block, long count) } } - /* * Put a ProDOS filesystem image on the specified DiskImg. */ -DIError -DiskFSProDOS::Format(DiskImg* pDiskImg, const char* volName) +DIError DiskFSProDOS::Format(DiskImg* pDiskImg, const char* volName) { DIError dierr = kDIErrNone; const bool allowLowerCase = (GetParameter(kParmProDOS_AllowLowerCase) != 0); - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; long formatBlocks; if (!IsValidVolumeName(volName)) @@ -1547,7 +1510,7 @@ DiskFSProDOS::Format(DiskImg* pDiskImg, const char* volName) } char upperName[A2FileProDOS::kMaxFileName+1]; - unsigned short lcFlags; + uint16_t lcFlags; time_t now; now = time(NULL); @@ -1578,7 +1541,7 @@ DiskFSProDOS::Format(DiskImg* pDiskImg, const char* volName) blkBuf[0x24] = 0x0d; // entries_per_block: always $0d /* file_count is zero - does not include volume dir */ PutShortLE(&blkBuf[0x27], kVolHeaderBlock + kVolDirExpectedNumBlocks); // bit_map_pointer - PutShortLE(&blkBuf[0x29], (unsigned short) formatBlocks); // total_blocks + PutShortLE(&blkBuf[0x29], (uint16_t) formatBlocks); // total_blocks dierr = fpImg->WriteBlock(kVolHeaderBlock, blkBuf); if (dierr != kDIErrNone) { LOGI(" Format: block %d write failed (err=%d)", @@ -1617,7 +1580,7 @@ bail: * This is block 0; block 1 is either zeroed out or filled with a repeating * pattern. */ -const unsigned char gFloppyBlock0[512] = { +const uint8_t gFloppyBlock0[512] = { 0x01, 0x38, 0xb0, 0x03, 0x4c, 0x32, 0xa1, 0x86, 0x43, 0xc9, 0x03, 0x08, 0x8a, 0x29, 0x70, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x49, 0xa0, 0xff, 0x84, 0x48, 0x28, 0xc8, 0xb1, 0x48, 0xd0, 0x3a, 0xb0, 0x0e, 0xa9, @@ -1663,7 +1626,7 @@ const unsigned char gFloppyBlock0[512] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -unsigned char gHDBlock0[] = { +const uint8_t gHDBlock0[] = { 0x01, 0x38, 0xb0, 0x03, 0x4c, 0x1c, 0x09, 0x78, 0x86, 0x43, 0xc9, 0x03, 0x08, 0x8a, 0x29, 0x70, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x49, 0xa0, 0xff, 0x84, 0x48, 0x28, 0xc8, 0xb1, 0x48, 0xd0, 0x3a, 0xb0, 0x0e, @@ -1712,12 +1675,11 @@ unsigned char gHDBlock0[] = { /* * Write the ProDOS boot blocks onto the disk image. */ -DIError -DiskFSProDOS::WriteBootBlocks(void) +DIError DiskFSProDOS::WriteBootBlocks(void) { DIError dierr; - unsigned char block0[512]; - unsigned char block1[512]; + uint8_t block0[512]; + uint8_t block1[512]; bool isHD; assert(fpImg->GetHasBlocks()); @@ -1731,7 +1693,7 @@ DiskFSProDOS::WriteBootBlocks(void) memcpy(block0, gHDBlock0, sizeof(block0)); // repeating 0x42 0x48 pattern int i; - unsigned char* ucp; + uint8_t* ucp; for (i = 0, ucp = block1; i < (int)sizeof(block1); i++) *ucp++ = 0x42 + 6 * (i & 0x01); } else { @@ -1753,7 +1715,6 @@ DiskFSProDOS::WriteBootBlocks(void) return kDIErrNone; } - /* * Create a new, empty file. There are three different kinds of files we * need to be able to handle: @@ -1779,8 +1740,7 @@ DiskFSProDOS::WriteBootBlocks(void) * * NOTE: kParm_CreateUnique does *not* apply to creating subdirectories. */ -DIError -DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) +DIError DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) { DIError dierr = kDIErrNone; char* normalizedPath = NULL; @@ -1789,7 +1749,7 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) A2FileProDOS* pSubdir = NULL; A2FileDescr* pOpenSubdir = NULL; A2FileProDOS* pNewFile = NULL; - unsigned char* subdirBuf = NULL; + uint8_t* subdirBuf = NULL; const bool allowLowerCase = (GetParameter(kParmProDOS_AllowLowerCase) != 0); const bool createUnique = (GetParameter(kParm_CreateUnique) != 0); char upperName[A2FileProDOS::kMaxFileName+1]; @@ -1940,9 +1900,9 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) if (dierr != kDIErrNone) goto bail; - unsigned char* dirEntryPtr; + uint8_t* dirEntryPtr; long dirLen; - unsigned short dirBlock, dirKeyBlock; + uint16_t dirBlock, dirKeyBlock; int dirEntrySlot; dierr = AllocDirEntry(pOpenSubdir, &subdirBuf, &dirLen, &dirEntryPtr, &dirKeyBlock, &dirEntrySlot, &dirBlock); @@ -2016,16 +1976,16 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) dirEntryPtr[0x00] = (pParms->storageType << 4) | strlen(upperName); strncpy((char*) &dirEntryPtr[0x01], upperName, A2FileProDOS::kMaxFileName); if (pParms->fileType >= 0 && pParms->fileType <= 0xff) - dirEntryPtr[0x10] = (unsigned char) pParms->fileType; + dirEntryPtr[0x10] = (uint8_t) pParms->fileType; else dirEntryPtr[0x10] = 0; // HFS long type? - PutShortLE(&dirEntryPtr[0x11], (unsigned short) keyBlock); + PutShortLE(&dirEntryPtr[0x11], (uint16_t) keyBlock); PutShortLE(&dirEntryPtr[0x13], blocksUsed); PutShortLE(&dirEntryPtr[0x15], newEOF); dirEntryPtr[0x17] = 0; // high byte of EOF PutLongLE(&dirEntryPtr[0x18], A2FileProDOS::ConvertProDate(pParms->createWhen)); if (allowLowerCase) { - unsigned short lcBits; + uint16_t lcBits; lcBits = GenerateLowerCaseBits(upperName, fileName, false); GenerateLowerCaseName(upperName, lowerName, lcBits, false); lowerName[strlen(upperName)] = '\0'; @@ -2037,7 +1997,7 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) } dirEntryPtr[0x1e] = pParms->access; if (pParms->auxType >= 0 && pParms->auxType <= 0xffff) - PutShortLE(&dirEntryPtr[0x1f], (unsigned short) pParms->auxType); + PutShortLE(&dirEntryPtr[0x1f], (uint16_t) pParms->auxType); else PutShortLE(&dirEntryPtr[0x1f], 0); PutLongLE(&dirEntryPtr[0x21], A2FileProDOS::ConvertProDate(pParms->modWhen)); @@ -2128,7 +2088,7 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) * worry too much about weirdness. The directory entry allocator always * returns the first available, so we know the previous entry is valid. */ - unsigned char* prevDirEntryPtr; + uint8_t* prevDirEntryPtr; prevDirEntryPtr = GetPrevDirEntry(subdirBuf, dirEntryPtr); if (prevDirEntryPtr == NULL) { /* previous entry is volume or subdir header */ @@ -2137,7 +2097,7 @@ DiskFSProDOS::CreateFile(const CreateParms* pParms, A2File** ppNewFile) pNewFile->GetPathName(), pNewFile->GetParent()->GetPathName()); } else { /* dig out the key block pointer and find the matching file */ - unsigned short prevKeyBlock; + uint16_t prevKeyBlock; assert((prevDirEntryPtr[0x00] & 0xf0) != 0); // verify storage type prevKeyBlock = GetShortLE(&prevDirEntryPtr[0x11]); A2File* pPrev; @@ -2174,8 +2134,7 @@ bail: * Run through the DiskFS file list, looking for an entry with a matching * key block. */ -A2File* -DiskFSProDOS::FindFileByKeyBlock(A2File* pStart, unsigned short keyBlock) +A2File* DiskFSProDOS::FindFileByKeyBlock(A2File* pStart, uint16_t keyBlock) { while (pStart != NULL) { A2FileProDOS* pPro = (A2FileProDOS*) pStart; @@ -2200,13 +2159,12 @@ DiskFSProDOS::FindFileByKeyBlock(A2File* pStart, unsigned short keyBlock) * file, and are only needed when creating a new subdir (because the first * entry in a subdir points to its entry in the parent dir). */ -DIError -DiskFSProDOS::AllocInitialFileStorage(const CreateParms* pParms, - const char* upperName, unsigned short dirBlock, int dirEntrySlot, +DIError DiskFSProDOS::AllocInitialFileStorage(const CreateParms* pParms, + const char* upperName, uint16_t dirBlock, int dirEntrySlot, long* pKeyBlock, int* pBlocksUsed, int* pNewEOF) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; long keyBlock; int blocksUsed; int newEOF; @@ -2251,8 +2209,8 @@ DiskFSProDOS::AllocInitialFileStorage(const CreateParms* pParms, /* fill in extended key block details */ blkBuf[0x00] = blkBuf[0x100] = A2FileProDOS::kStorageSeedling; - PutShortLE(&blkBuf[0x01], (unsigned short) dataBlock); - PutShortLE(&blkBuf[0x101], (unsigned short) rsrcBlock); + PutShortLE(&blkBuf[0x01], (uint16_t) dataBlock); + PutShortLE(&blkBuf[0x101], (uint16_t) rsrcBlock); blkBuf[0x03] = blkBuf[0x103] = 1; // blocks used (lo byte) /* 3 bytes at 0x05 hold EOF, currently 0 */ @@ -2282,7 +2240,7 @@ DiskFSProDOS::AllocInitialFileStorage(const CreateParms* pParms, blkBuf[0x24] = kEntriesPerBlock; PutShortLE(&blkBuf[0x25], 0); // file count PutShortLE(&blkBuf[0x27], dirBlock); - blkBuf[0x29] = (unsigned char) dirEntrySlot; + blkBuf[0x29] = (uint8_t) dirEntrySlot; blkBuf[0x2a] = kEntryLength; // the parent dir's entry length dierr = fpImg->WriteBlock(keyBlock, blkBuf); @@ -2302,7 +2260,6 @@ bail: return dierr; } - /* * Scan for damaged files and mysterious or conflicting block usage map * entries. @@ -2315,8 +2272,7 @@ bail: * * Returns "true" if disk appears to be perfect, "false" otherwise. */ -bool -DiskFSProDOS::CheckDiskIsGood(void) +bool DiskFSProDOS::CheckDiskIsGood(void) { DIError dierr; bool result = true; @@ -2425,13 +2381,11 @@ bail: return result; } - /* * Test a string for validity as a ProDOS volume name. Syntax is the same as * ProDOS file names, but we also disallow spaces. */ -/*static*/ bool -DiskFSProDOS::IsValidVolumeName(const char* name) +/*static*/ bool DiskFSProDOS::IsValidVolumeName(const char* name) { assert((int) A2FileProDOS::kMaxFileName == (int) kMaxVolumeName); if (!IsValidFileName(name)) @@ -2451,8 +2405,7 @@ DiskFSProDOS::IsValidVolumeName(const char* name) * Lower case and spaces (a/k/a lower-case '.') are accepted. Trailing * spaces are not allowed. */ -/*static*/ bool -DiskFSProDOS::IsValidFileName(const char* name) +/*static*/ bool DiskFSProDOS::IsValidFileName(const char* name) { if (name == NULL) { assert(false); @@ -2502,12 +2455,11 @@ DiskFSProDOS::IsValidFileName(const char* name) * Returns the mask to use in a ProDOS dir. If "forAppleWorks" is set to * "true", the mask is modified for use with an AppleWorks aux type. */ -/*static*/ unsigned short -DiskFSProDOS::GenerateLowerCaseBits(const char* upperName, +/*static*/ uint16_t DiskFSProDOS::GenerateLowerCaseBits(const char* upperName, const char* lowerName, bool forAppleWorks) { - unsigned short caseMask = 0x8000; - unsigned short caseBit = 0x8000; + uint16_t caseMask = 0x8000; + uint16_t caseBit = 0x8000; int len, i; char lowch; @@ -2522,7 +2474,7 @@ DiskFSProDOS::GenerateLowerCaseBits(const char* upperName, } if (forAppleWorks) { - unsigned short adjusted; + uint16_t adjusted; caseMask <<= 1; adjusted = caseMask << 8 | caseMask >> 8; return adjusted; @@ -2548,9 +2500,8 @@ DiskFSProDOS::GenerateLowerCaseBits(const char* upperName, * "lcFlags" is either ProDOS directory flags or AppleWorks aux type flags, * depending on the value of "fromAppleWorks". */ -/*static*/ void -DiskFSProDOS::GenerateLowerCaseName(const char* upperName, char* lowerName, - unsigned short lcFlags, bool fromAppleWorks) +/*static*/ void DiskFSProDOS::GenerateLowerCaseName(const char* upperName, + char* lowerName, uint16_t lcFlags, bool fromAppleWorks) { int nameLen = strlen(upperName); int bit; @@ -2558,7 +2509,7 @@ DiskFSProDOS::GenerateLowerCaseName(const char* upperName, char* lowerName, if (fromAppleWorks) { /* handle AppleWorks lower-case-in-auxtype */ - unsigned short caseMask = // swap bytes + uint16_t caseMask = // swap bytes (lcFlags << 8) | (lcFlags >> 8); for (bit = 0; bit < nameLen ; bit++) { if ((caseMask & 0x8000) != 0) @@ -2599,8 +2550,7 @@ DiskFSProDOS::GenerateLowerCaseName(const char* upperName, char* lowerName, * This is invoked from the generalized "add" function in CiderPress, which * doesn't want to understand the ins and outs of ProDOS pathnames. */ -DIError -DiskFSProDOS::NormalizePath(const char* path, char fssep, +DIError DiskFSProDOS::NormalizePath(const char* path, char fssep, char* normalizedBuf, int* pNormalizedBufLen) { DIError dierr = kDIErrNone; @@ -2646,8 +2596,7 @@ bail: * * The caller must delete[] "*pNormalizedPath". */ -DIError -DiskFSProDOS::DoNormalizePath(const char* path, char fssep, +DIError DiskFSProDOS::DoNormalizePath(const char* path, char fssep, char** pNormalizedPath) { DIError dierr = kDIErrNone; @@ -2777,8 +2726,7 @@ bail: * "upperName" must be a buffer that holds at least kMaxFileName+1 characters. * If "name" is longer than kMaxFileName, it will be truncated. */ -void -DiskFSProDOS::UpperCaseName(char* upperName, const char* name) +void DiskFSProDOS::UpperCaseName(char* upperName, const char* name) { int i; @@ -2827,10 +2775,9 @@ DiskFSProDOS::UpperCaseName(char* upperName, const char* name) * We guarantee that we will return the first available entry in the current * directory. */ -DIError -DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, - long* pDirLen, unsigned char** ppDirEntry, unsigned short* pDirKeyBlock, - int* pDirEntrySlot, unsigned short* pDirBlock) +DIError DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, uint8_t** ppDir, + long* pDirLen, uint8_t** ppDirEntry, uint16_t* pDirKeyBlock, + int* pDirEntrySlot, uint16_t* pDirBlock) { assert(pOpenSubdir != NULL); *ppDirEntry = NULL; @@ -2840,7 +2787,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, *pDirBlock = 0; DIError dierr = kDIErrNone; - unsigned char* dirBuf = NULL; + uint8_t* dirBuf = NULL; long dirLen; A2FileProDOS* pFile; long newBlock = -1; @@ -2856,7 +2803,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, dierr = kDIErrBadFile; goto bail; } - dirBuf = new unsigned char[dirLen]; + dirBuf = new uint8_t[dirLen]; if (dirBuf == NULL) { dierr = kDIErrMalloc; goto bail; @@ -2879,7 +2826,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, * step through this by blocks, because the data is block-oriented. * If we run off the end of the last block, (re)alloc a new one. */ - unsigned char* pDirEntry; + uint8_t* pDirEntry; int blockIdx; int entryIdx; @@ -2915,7 +2862,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, * in the last block at it, so that when we go to write this dir * we will know where to put it. */ - unsigned char* pBlock; + uint8_t* pBlock; pBlock = dirBuf + 512 * (blockIdx-1); if (pBlock[0x02] != 0) { LOGI(" ProDOS GLITCH: adding to block with nonzero next ptr!"); @@ -2929,12 +2876,12 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, goto bail; } - PutShortLE(&pBlock[0x02], (unsigned short) newBlock); // set "next" + PutShortLE(&pBlock[0x02], (uint16_t) newBlock); // set "next" /* * Extend our memory buffer to hold the new entry. */ - unsigned char* newSpace = new unsigned char[dirLen + 512]; + uint8_t* newSpace = new uint8_t[dirLen + 512]; if (newSpace == NULL) { dierr = kDIErrMalloc; goto bail; @@ -2954,7 +2901,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, if (dierr != kDIErrNone) goto bail; pBlock = dirBuf + 512 * blockIdx; - PutShortLE(&pBlock[0x00], (unsigned short) lastBlock); // set "prev" + PutShortLE(&pBlock[0x00], (uint16_t) lastBlock); // set "prev" assert(GetShortLE(&pBlock[0x02]) == 0); // "next" pointer /* @@ -2968,7 +2915,7 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, /* * Success. Update the file count in the header. */ - unsigned short count; + uint16_t count; count = GetShortLE(&dirBuf[0x25]); count++; PutShortLE(&dirBuf[0x25], count); @@ -2983,12 +2930,12 @@ DiskFSProDOS::AllocDirEntry(A2FileDescr* pOpenSubdir, unsigned char** ppDir, if (blockIdx == ((A2FDProDOS*)pOpenSubdir)->GetBlockCount()) { /* not yet added to block list, so can't use GetStorage */ assert(newBlock > 0); - *pDirBlock = (unsigned short) newBlock; + *pDirBlock = (uint16_t) newBlock; } else { assert(newBlock < 0); dierr = pOpenSubdir->GetStorage(blockIdx, &whichBlock); assert(dierr == kDIErrNone); - *pDirBlock = (unsigned short) whichBlock; + *pDirBlock = (uint16_t) whichBlock; } dirBuf = NULL; @@ -3011,8 +2958,7 @@ bail: * in the same block we can just return (ptr-0x27), but if it's in a previous * block we need to return the last entry in the previous. */ -unsigned char* -DiskFSProDOS::GetPrevDirEntry(unsigned char* buf, unsigned char* ptr) +uint8_t* DiskFSProDOS::GetPrevDirEntry(uint8_t* buf, uint8_t* ptr) { assert(buf != NULL); assert(ptr != NULL); @@ -3045,8 +2991,7 @@ DiskFSProDOS::GetPrevDirEntry(unsigned char* buf, unsigned char* ptr) * Returns an error on failure, which should only happen if there are a * large number of files with similar names. */ -DIError -DiskFSProDOS::MakeFileNameUnique(const unsigned char* dirBuf, long dirLen, +DIError DiskFSProDOS::MakeFileNameUnique(const uint8_t* dirBuf, long dirLen, char* fileName) { assert(dirBuf != NULL); @@ -3121,11 +3066,10 @@ DiskFSProDOS::MakeFileNameUnique(const unsigned char* dirBuf, long dirLen, * * This should be called with the upper-case-only version of the filename. */ -bool -DiskFSProDOS::NameExistsInDir(const unsigned char* dirBuf, long dirLen, +bool DiskFSProDOS::NameExistsInDir(const uint8_t* dirBuf, long dirLen, const char* fileName) { - const unsigned char* pDirEntry; + const uint8_t* pDirEntry; int blockIdx; int entryIdx; int nameLen = strlen(fileName); @@ -3154,7 +3098,6 @@ DiskFSProDOS::NameExistsInDir(const unsigned char* dirBuf, long dirLen, return false; } - /* * Delete a file. * @@ -3165,14 +3108,13 @@ DiskFSProDOS::NameExistsInDir(const unsigned char* dirBuf, long dirLen, * * We only allow deletion of a subdirectory when the subdir is empty. */ -DIError -DiskFSProDOS::DeleteFile(A2File* pGenericFile) +DIError DiskFSProDOS::DeleteFile(A2File* pGenericFile) { DIError dierr = kDIErrNone; long blockCount = -1; long indexCount = -1; - unsigned short* blockList = NULL; - unsigned short* indexList = NULL; + uint16_t* blockList = NULL; + uint16_t* indexList = NULL; if (pGenericFile == NULL) { assert(false); @@ -3223,7 +3165,7 @@ DiskFSProDOS::DeleteFile(A2File* pGenericFile) // handle the key block "manually" blockCount = 1; - blockList = new unsigned short[blockCount]; + blockList = new uint16_t[blockCount]; blockList[0] = pFile->fDirEntry.keyPointer; FreeBlocks(blockCount, blockList); delete[] blockList; @@ -3276,8 +3218,8 @@ DiskFSProDOS::DeleteFile(A2File* pGenericFile) * and write it back, but the A2FileProDOS structure has the directory * block and entry index stored in it. Makes it a little easier. */ - unsigned char blkBuf[kBlkSize]; - unsigned char* ptr; + uint8_t blkBuf[kBlkSize]; + uint8_t* ptr; assert(pFile->fParentDirBlock > 0); assert(pFile->fParentDirIdx >= 0 && pFile->fParentDirIdx < kEntriesPerBlock); @@ -3324,7 +3266,7 @@ DiskFSProDOS::DeleteFile(A2File* pGenericFile) * to fix it. */ A2FileProDOS* pParent; - unsigned short fileCount; + uint16_t fileCount; int storageType; pParent = (A2FileProDOS*) pFile->GetParent(); assert(pParent != NULL); @@ -3375,8 +3317,7 @@ bail: * * The in-use map must already be loaded. */ -DIError -DiskFSProDOS::FreeBlocks(long blockCount, unsigned short* blockList) +DIError DiskFSProDOS::FreeBlocks(long blockCount, uint16_t* blockList) { VolumeUsage::ChunkState cstate; int i; @@ -3406,7 +3347,6 @@ DiskFSProDOS::FreeBlocks(long blockCount, unsigned short* blockList) return kDIErrNone; } - /* * Rename a file. * @@ -3425,8 +3365,7 @@ DiskFSProDOS::FreeBlocks(long blockCount, unsigned short* blockList) * according to the upper/lower case flags. This holds even if the * "allow lower case" flag is disabled. */ -DIError -DiskFSProDOS::RenameFile(A2File* pGenericFile, const char* newName) +DIError DiskFSProDOS::RenameFile(A2File* pGenericFile, const char* newName) { DIError dierr = kDIErrNone; A2FileProDOS* pFile = (A2FileProDOS*) pGenericFile; @@ -3480,8 +3419,8 @@ DiskFSProDOS::RenameFile(A2File* pGenericFile, const char* newName) * minimize the chances of a partial update, we load both blocks up * front, modify both, then write them both back. */ - unsigned char parentDirBuf[kBlkSize]; - unsigned char thisDirBuf[kBlkSize]; + uint8_t parentDirBuf[kBlkSize]; + uint8_t thisDirBuf[kBlkSize]; dierr = fpImg->ReadBlock(pFile->fParentDirBlock, parentDirBuf); if (dierr != kDIErrNone) @@ -3493,11 +3432,11 @@ DiskFSProDOS::RenameFile(A2File* pGenericFile, const char* newName) } /* compute lower case flags as needed */ - unsigned short lcFlags, lcAuxType; + uint16_t lcFlags, lcAuxType; bool allowLowerCase, isAW; allowLowerCase = GetParameter(kParmProDOS_AllowLowerCase) != 0; - isAW = A2FileProDOS::UsesAppleWorksAuxType((unsigned char)pFile->GetFileType()); + isAW = A2FileProDOS::UsesAppleWorksAuxType((uint8_t)pFile->GetFileType()); if (allowLowerCase) lcFlags = GenerateLowerCaseBits(upperName, newName, false); @@ -3520,7 +3459,7 @@ DiskFSProDOS::RenameFile(A2File* pGenericFile, const char* newName) */ /* find the right entry, and copy our filename in */ - unsigned char* ptr; + uint8_t* ptr; assert(pFile->fParentDirIdx >= 0 && pFile->fParentDirIdx < kEntriesPerBlock); ptr = parentDirBuf + 4 + pFile->fParentDirIdx * kEntryLength; @@ -3606,8 +3545,7 @@ bail: * This could be implemented more efficiently, but it's only used when * renaming files, so there's not much point. */ -DIError -DiskFSProDOS::RegeneratePathName(A2FileProDOS* pFile) +DIError DiskFSProDOS::RegeneratePathName(A2FileProDOS* pFile) { A2FileProDOS* pParent; char* buf = NULL; @@ -3657,7 +3595,6 @@ DiskFSProDOS::RegeneratePathName(A2FileProDOS* pFile) return kDIErrNone; } - /* * Change the attributes of the specified file. * @@ -3670,9 +3607,8 @@ DiskFSProDOS::RegeneratePathName(A2FileProDOS* pFile) * This does, of course, mean that there's no meaning in attempts to change * the file access permissions of the volume directory. */ -DIError -DiskFSProDOS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, - long accessFlags) +DIError DiskFSProDOS::SetFileInfo(A2File* pGenericFile, long fileType, + long auxType, long accessFlags) { DIError dierr = kDIErrNone; A2FileProDOS* pFile = (A2FileProDOS*) pGenericFile; @@ -3698,13 +3634,13 @@ DiskFSProDOS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, pFile->GetPathName(), fileType, auxType, accessFlags); /* load the directory block for this file */ - unsigned char thisDirBuf[kBlkSize]; + uint8_t thisDirBuf[kBlkSize]; dierr = fpImg->ReadBlock(pFile->fParentDirBlock, thisDirBuf); if (dierr != kDIErrNone) goto bail; /* find the right entry, and set the fields */ - unsigned char* ptr; + uint8_t* ptr; assert(pFile->fParentDirIdx >= 0 && pFile->fParentDirIdx < kEntriesPerBlock); ptr = thisDirBuf + 4 + pFile->fParentDirIdx * kEntryLength; @@ -3723,24 +3659,23 @@ DiskFSProDOS::SetFileInfo(A2File* pGenericFile, long fileType, long auxType, goto bail; } - ptr[0x10] = (unsigned char) fileType; - ptr[0x1e] = (unsigned char) accessFlags; - PutShortLE(&ptr[0x1f], (unsigned short) auxType); + ptr[0x10] = (uint8_t) fileType; + ptr[0x1e] = (uint8_t) accessFlags; + PutShortLE(&ptr[0x1f], (uint16_t) auxType); dierr = fpImg->WriteBlock(pFile->fParentDirBlock, thisDirBuf); if (dierr != kDIErrNone) goto bail; /* update our local copy */ - pFile->fDirEntry.fileType = (unsigned char) fileType; - pFile->fDirEntry.auxType = (unsigned short) auxType; - pFile->fDirEntry.access = (unsigned char) accessFlags; + pFile->fDirEntry.fileType = (uint8_t) fileType; + pFile->fDirEntry.auxType = (uint16_t) auxType; + pFile->fDirEntry.access = (uint8_t) accessFlags; bail: return dierr; } - /* * Change the disk volume name. * @@ -3751,8 +3686,7 @@ bail: * Internally we need to update the "fake" entry and the cached copies in * fVolumeName and fVolumeID. */ -DIError -DiskFSProDOS::RenameVolume(const char* newName) +DIError DiskFSProDOS::RenameVolume(const char* newName) { DIError dierr = kDIErrNone; char upperName[A2FileProDOS::kMaxFileName+1]; @@ -3773,7 +3707,7 @@ DiskFSProDOS::RenameVolume(const char* newName) /* * Figure out the lower-case flags. */ - unsigned short lcFlags; + uint16_t lcFlags; bool allowLowerCase; UpperCaseName(upperName, newName); @@ -3786,8 +3720,8 @@ DiskFSProDOS::RenameVolume(const char* newName) /* * Update the volume dir header. */ - unsigned char thisDirBuf[kBlkSize]; - unsigned char* ptr; + uint8_t thisDirBuf[kBlkSize]; + uint8_t* ptr; assert(pFile->fDirEntry.keyPointer == kVolHeaderBlock); dierr = fpImg->ReadBlock(pFile->fDirEntry.keyPointer, thisDirBuf); @@ -3847,17 +3781,16 @@ bail: * be a valid date since "day" ranges from 1 to 31). If this is found then * ((time_t) 0) is returned. */ -/*static*/ time_t -A2FileProDOS::ConvertProDate(ProDate proDate) +/*static*/ time_t A2FileProDOS::ConvertProDate(ProDate proDate) { - unsigned short prodosDate, prodosTime; + uint16_t prodosDate, prodosTime; int year, month, day, hour, minute, second; if (proDate == 0) return 0; - prodosDate = (unsigned short) (proDate & 0x0000ffff); - prodosTime = (unsigned short) ((proDate >> 16) & 0x0000ffff); + prodosDate = (uint16_t) (proDate & 0x0000ffff); + prodosTime = (uint16_t) ((proDate >> 16) & 0x0000ffff); second = 0; minute = prodosTime & 0x3f; @@ -3893,11 +3826,10 @@ A2FileProDOS::ConvertProDate(ProDate proDate) * * CiderPress uses kDateInvalid==-1 and kDateNone==-2. */ -/*static*/ A2FileProDOS::ProDate -A2FileProDOS::ConvertProDate(time_t unixDate) +/*static*/ A2FileProDOS::ProDate A2FileProDOS::ConvertProDate(time_t unixDate) { ProDate proDate; - unsigned long prodosDate, prodosTime; + uint32_t prodosDate, prodosTime; struct tm* ptm; int year; @@ -3929,12 +3861,10 @@ A2FileProDOS::ConvertProDate(time_t unixDate) return proDate; } - /* * Return the file creation time as a time_t. */ -time_t -A2FileProDOS::GetCreateWhen(void) const +time_t A2FileProDOS::GetCreateWhen(void) const { return ConvertProDate(fDirEntry.createWhen); } @@ -3942,8 +3872,7 @@ A2FileProDOS::GetCreateWhen(void) const /* * Return the file modification time as a time_t. */ -time_t -A2FileProDOS::GetModWhen(void) const +time_t A2FileProDOS::GetModWhen(void) const { return ConvertProDate(fDirEntry.modWhen); } @@ -3954,8 +3883,7 @@ A2FileProDOS::GetModWhen(void) const * * If we're in the volume directory, pass in "" for the base path (not NULL). */ -void -A2FileProDOS::SetPathName(const char* basePath, const char* fileName) +void A2FileProDOS::SetPathName(const char* basePath, const char* fileName) { assert(basePath != NULL && fileName != NULL); if (fPathName != NULL) @@ -3973,15 +3901,13 @@ A2FileProDOS::SetPathName(const char* basePath, const char* fileName) strcpy(fPathName + baseLen, fileName); } - /* * Convert a character in a ProDOS name to lower case. * * This is special in that '.' is considered upper case, with ' ' as its * lower-case counterpart. */ -/*static*/ char -A2FileProDOS::NameToLower(char ch) +/*static*/ char A2FileProDOS::NameToLower(char ch) { if (ch == '.') return ' '; @@ -3995,9 +3921,8 @@ A2FileProDOS::NameToLower(char ch) * * Deals with lower case conversions on the filename. */ -/*static*/ void -A2FileProDOS::InitDirEntry(A2FileProDOS::DirEntry* pEntry, - const unsigned char* entryBuf) +/*static*/ void A2FileProDOS::InitDirEntry(A2FileProDOS::DirEntry* pEntry, + const uint8_t* entryBuf) { int nameLen; @@ -4029,14 +3954,12 @@ A2FileProDOS::InitDirEntry(A2FileProDOS::DirEntry* pEntry, pEntry->fileName[sizeof(pEntry->fileName)-1] = '\0'; } - /* * Open one fork of this file. * * I really, really dislike forked files. */ -DIError -A2FileProDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileProDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*= false*/) { DIError dierr = kDIErrNone; @@ -4127,7 +4050,6 @@ bail: return dierr; } - /* * Gather a linear, non-sparse list of file blocks into an array. * @@ -4147,10 +4069,9 @@ bail: * * The caller must delete[] "*pBlockList" and "*pIndexBlockList". */ -DIError -A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, - long eof, long* pBlockCount, unsigned short** pBlockList, - long* pIndexBlockCount, unsigned short** pIndexBlockList) +DIError A2FileProDOS::LoadBlockList(int storageType, uint16_t keyBlock, + long eof, long* pBlockCount, uint16_t** pBlockList, + long* pIndexBlockCount, uint16_t** pIndexBlockList) { if (storageType == kStorageDirectory || storageType == kStorageVolumeDirHeader) @@ -4178,14 +4099,14 @@ A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, } DIError dierr = kDIErrNone; - unsigned short* list = NULL; + uint16_t* list = NULL; long count; assert(eof < 1024*1024*16); count = (eof + kBlkSize -1) / kBlkSize; if (count == 0) count = 1; - list = new unsigned short[count+1]; + list = new uint16_t[count+1]; if (list == NULL) { dierr = kDIErrMalloc; goto bail; @@ -4197,7 +4118,7 @@ A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, } /* this should take care of trailing sparse entries */ - memset(list, 0, sizeof(unsigned short) * count); + memset(list, 0, sizeof(uint16_t) * count); list[count] = kInvalidBlockNum; // overrun check if (storageType == kStorageSeedling) { @@ -4214,13 +4135,13 @@ A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, if (pIndexBlockList != NULL) { *pIndexBlockCount = 1; - *pIndexBlockList = new unsigned short[1]; + *pIndexBlockList = new uint16_t[1]; **pIndexBlockList = keyBlock; } } else if (storageType == kStorageTree) { - unsigned char blkBuf[kBlkSize]; - unsigned short* listPtr = list; - unsigned short* outIndexPtr = NULL; + uint8_t blkBuf[kBlkSize]; + uint16_t* listPtr = list; + uint16_t* outIndexPtr = NULL; long countDown = count; int idx = 0; @@ -4231,7 +4152,7 @@ A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, if (pIndexBlockList != NULL) { int numIndices = (count + kMaxBlocksPerIndex-1) / kMaxBlocksPerIndex; numIndices++; // add one for the master index block - *pIndexBlockList = new unsigned short[numIndices]; + *pIndexBlockList = new uint16_t[numIndices]; outIndexPtr = *pIndexBlockList; *outIndexPtr++ = keyBlock; *pIndexBlockCount = 1; @@ -4241,13 +4162,13 @@ A2FileProDOS::LoadBlockList(int storageType, unsigned short keyBlock, long blockCount = countDown; if (blockCount > kMaxBlocksPerIndex) blockCount = kMaxBlocksPerIndex; - unsigned short idxBlock; + uint16_t idxBlock; - idxBlock = blkBuf[idx] | (unsigned short) blkBuf[idx+256] << 8; + idxBlock = blkBuf[idx] | (uint16_t) blkBuf[idx+256] << 8; if (idxBlock == 0) { /* fully sparse index block */ //LOGI(" ProDOS that's seriously sparse (%d)!", idx); - memset(listPtr, 0, blockCount * sizeof(unsigned short)); + memset(listPtr, 0, blockCount * sizeof(uint16_t)); if (pIndexBlockList != NULL) { *outIndexPtr++ = idxBlock; (*pIndexBlockCount)++; @@ -4313,8 +4234,7 @@ bail: * * What we really need is three states for each file: good, suspect, damaged. */ -DIError -A2FileProDOS::ValidateBlockList(const unsigned short* list, long count) +DIError A2FileProDOS::ValidateBlockList(const uint16_t* list, long count) { DiskImg* pImg = fpDiskFS->GetDiskImg(); bool foundBad = false; @@ -4344,12 +4264,11 @@ A2FileProDOS::ValidateBlockList(const unsigned short* list, long count) * Copy the entries from the index block in "block" to "list", copying * at most "maxCount" entries. */ -DIError -A2FileProDOS::LoadIndexBlock(unsigned short block, unsigned short* list, +DIError A2FileProDOS::LoadIndexBlock(uint16_t block, uint16_t* list, int maxCount) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; int i; if (maxCount > kMaxBlocksPerIndex) @@ -4361,7 +4280,7 @@ A2FileProDOS::LoadIndexBlock(unsigned short block, unsigned short* list, //LOGI("LOADING 0x%04x", block); for (i = 0; i < maxCount; i++) { - *list++ = blkBuf[i] | (unsigned short) blkBuf[i+256] << 8; + *list++ = blkBuf[i] | (uint16_t) blkBuf[i+256] << 8; } bail: @@ -4372,14 +4291,13 @@ bail: * Load the block list from a directory, which is essentially a linear * linked list. */ -DIError -A2FileProDOS::LoadDirectoryBlockList(unsigned short keyBlock, - long eof, long* pBlockCount, unsigned short** pBlockList) +DIError A2FileProDOS::LoadDirectoryBlockList(uint16_t keyBlock, + long eof, long* pBlockCount, uint16_t** pBlockList) { DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; - unsigned short* list = NULL; - unsigned short* listPtr; + uint8_t blkBuf[kBlkSize]; + uint16_t* list = NULL; + uint16_t* listPtr; int iterations; long count; @@ -4387,14 +4305,14 @@ A2FileProDOS::LoadDirectoryBlockList(unsigned short keyBlock, count = (eof + kBlkSize -1) / kBlkSize; if (count == 0) count = 1; - list = new unsigned short[count+1]; + list = new uint16_t[count+1]; if (list == NULL) { dierr = kDIErrMalloc; goto bail; } /* this should take care of trailing sparse entries */ - memset(list, 0, sizeof(unsigned short) * count); + memset(list, 0, sizeof(uint16_t) * count); list[count] = kInvalidBlockNum; // overrun check iterations = 0; @@ -4438,8 +4356,7 @@ bail: /* * Dump the contents. */ -void -A2FileProDOS::Dump(void) const +void A2FileProDOS::Dump(void) const { LOGI(" ProDOS file '%s' (path='%s')", fDirEntry.fileName, fPathName); @@ -4473,8 +4390,7 @@ A2FileProDOS::Dump(void) const /* * Read a chunk of data from whichever fork is open. */ -DIError -A2FDProDOS::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDProDOS::Read(void* buf, size_t len, size_t* pActual) { LOGI(" ProDOS reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -4492,7 +4408,7 @@ A2FDProDOS::Read(void* buf, size_t len, size_t* pActual) long incrLen = len; DIError dierr = kDIErrNone; - unsigned char blkBuf[kBlkSize]; + uint8_t blkBuf[kBlkSize]; long blockIndex = (long) (fOffset / kBlkSize); int bufOffset = (int) (fOffset % kBlkSize); // (& 0x01ff) size_t thisCount; @@ -4572,15 +4488,14 @@ A2FDProDOS::Read(void* buf, size_t len, size_t* pActual) * to read the indexes (which, at the moment, appear at the end of the file). * A bit tricky, but doable. */ -DIError -A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) { DIError dierr = kDIErrNone; A2FileProDOS* pFile = (A2FileProDOS*) fpFile; DiskFSProDOS* pDiskFS = (DiskFSProDOS*) fpFile->GetDiskFS(); bool allocSparse = (pDiskFS->GetParameter(DiskFS::kParmProDOS_AllocSparse) != 0); - unsigned char blkBuf[kBlkSize]; - unsigned short keyBlock; + uint8_t blkBuf[kBlkSize]; + uint16_t keyBlock; if (len >= 0x01000000) { // 16MB assert(false); @@ -4644,7 +4559,7 @@ A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) fBlockCount = (len + kBlkSize-1) / kBlkSize; assert(fBlockCount > 0); delete[] fBlockList; - fBlockList = new unsigned short[fBlockCount+1]; + fBlockList = new uint16_t[fBlockCount+1]; if (fBlockList == NULL) { dierr = kDIErrMalloc; goto bail; @@ -4655,14 +4570,14 @@ A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) * Write the data blocks to disk, allocating as we go. We have to treat * the last entry specially because it might not fill an entire block. */ - const unsigned char* blkPtr; + const uint8_t* blkPtr; long blockIdx; bool allZero; long progressCounter; progressCounter = 0; allZero = true; - blkPtr = (const unsigned char*) buf; + blkPtr = (const uint8_t*) buf; for (blockIdx = 0; blockIdx < fBlockCount; blockIdx++) { long newBlock; @@ -4689,7 +4604,7 @@ A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) goto bail; } - fBlockList[blockIdx] = (unsigned short) newBlock; + fBlockList[blockIdx] = (uint16_t) newBlock; if (newBlock != 0) { dierr = pDiskFS->GetDiskImg()->WriteBlock(newBlock, blkPtr); @@ -4769,7 +4684,7 @@ A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) fOpenStorageType = A2FileProDOS::kStorageSapling; } else { /* tree file, write two or more indexes and write master into key */ - unsigned char masterBlk[kBlkSize]; + uint8_t masterBlk[kBlkSize]; int idx; memset(masterBlk, 0, sizeof(masterBlk)); @@ -4797,8 +4712,8 @@ A2FDProDOS::Write(const void* buf, size_t len, size_t* pActual) goto bail; } - masterBlk[(idx-1) / 256] = (unsigned char) newBlock; - masterBlk[256 + (idx-1)/256] = (unsigned char) (newBlock >> 8); + masterBlk[(idx-1) / 256] = (uint8_t) newBlock; + masterBlk[256 + (idx-1)/256] = (uint8_t) (newBlock >> 8); } dierr = pDiskFS->GetDiskImg()->WriteBlock(keyBlock, masterBlk); @@ -4832,8 +4747,7 @@ bail: /* * Determine whether a block is filled entirely with zeroes. */ -bool -A2FDProDOS::IsEmptyBlock(const unsigned char* blk) +bool A2FDProDOS::IsEmptyBlock(const uint8_t* blk) { int i; @@ -4854,8 +4768,7 @@ A2FDProDOS::IsEmptyBlock(const unsigned char* blk) * would have to update the volume bitmap when another function is already * making lots of changes to it.) */ -DIError -A2FDProDOS::WriteDirectory(const void* buf, size_t len, size_t* pActual) +DIError A2FDProDOS::WriteDirectory(const void* buf, size_t len, size_t* pActual) { DIError dierr = kDIErrNone; @@ -4871,16 +4784,16 @@ A2FDProDOS::WriteDirectory(const void* buf, size_t len, size_t* pActual) * Extend the block list, remembering that we add an extra item * on the end to check for overruns. */ - unsigned short* newBlockList; + uint16_t* newBlockList; fBlockCount++; - newBlockList = new unsigned short[fBlockCount+1]; + newBlockList = new uint16_t[fBlockCount+1]; memcpy(newBlockList, fBlockList, - sizeof(unsigned short) * fBlockCount); + sizeof(uint16_t) * fBlockCount); newBlockList[fBlockCount] = A2FileProDOS::kInvalidBlockNum; - unsigned char* blkPtr; - blkPtr = (unsigned char*)buf + fOpenEOF - kBlkSize; + uint8_t* blkPtr; + blkPtr = (uint8_t*)buf + fOpenEOF - kBlkSize; assert(blkPtr >= buf); assert(GetShortLE(&blkPtr[0x02]) != 0); newBlockList[fBlockCount-1] = GetShortLE(&blkPtr[0x02]); @@ -4900,7 +4813,7 @@ A2FDProDOS::WriteDirectory(const void* buf, size_t len, size_t* pActual) for (idx = 0; idx < fBlockCount; idx++) { assert(fBlockList[idx] >= kVolHeaderBlock); dierr = fpFile->GetDiskFS()->GetDiskImg()->WriteBlock(fBlockList[idx], - (unsigned char*)buf + idx * kBlkSize); + (uint8_t*)buf + idx * kBlkSize); if (dierr != kDIErrNone) { LOGI(" ProDOS failed writing dir, block=%d", fBlockList[idx]); goto bail; @@ -4908,7 +4821,7 @@ A2FDProDOS::WriteDirectory(const void* buf, size_t len, size_t* pActual) } fOpenEOF = len; - fOpenBlocksUsed = (unsigned short) fBlockCount; // very simple for subdirs + fOpenBlocksUsed = (uint16_t) fBlockCount; // very simple for subdirs //fOpenStorageType fModified = true; @@ -4919,8 +4832,7 @@ bail: /* * Seek to a new position within the file. */ -DIError -A2FDProDOS::Seek(di_off_t offset, DIWhence whence) +DIError A2FDProDOS::Seek(di_off_t offset, DIWhence whence) { DIError dierr = kDIErrNone; switch (whence) { @@ -4955,8 +4867,7 @@ A2FDProDOS::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDProDOS::Tell(void) +di_off_t A2FDProDOS::Tell(void) { //if (fBlockList == NULL) // return kDIErrNotReady; @@ -4970,19 +4881,18 @@ A2FDProDOS::Tell(void) * Most applications don't check the value of "Close", or call it from a * destructor, so we call CloseDescr whether we succeed or not. */ -DIError -A2FDProDOS::Close(void) +DIError A2FDProDOS::Close(void) { DIError dierr = kDIErrNone; if (fModified) { A2FileProDOS* pFile = (A2FileProDOS*) fpFile; - unsigned char blkBuf[kBlkSize]; - unsigned char newStorageType = fOpenStorageType; - unsigned short newBlocksUsed = fOpenBlocksUsed; - unsigned long newEOF = (unsigned long) fOpenEOF; - unsigned short combinedBlocksUsed; - unsigned long combinedEOF; + uint8_t blkBuf[kBlkSize]; + uint8_t newStorageType = fOpenStorageType; + uint16_t newBlocksUsed = fOpenBlocksUsed; + uint32_t newEOF = (uint32_t) fOpenEOF; // TODO: assert range + uint16_t combinedBlocksUsed; + uint32_t combinedEOF; /* * If this is an extended file, fix the entries in the extended @@ -5004,9 +4914,9 @@ A2FDProDOS::Close(void) blkBuf[0x00 + offset] = fOpenStorageType; // key block doesn't change PutShortLE(&blkBuf[0x03 + offset], newBlocksUsed); - blkBuf[0x05 + offset] = (unsigned char) newEOF; - blkBuf[0x06 + offset] = (unsigned char) (newEOF >> 8); - blkBuf[0x07 + offset] = (unsigned char) (newEOF >> 16); + blkBuf[0x05 + offset] = (uint8_t) newEOF; + blkBuf[0x06 + offset] = (uint8_t) (newEOF >> 8); + blkBuf[0x07 + offset] = (uint8_t) (newEOF >> 16); dierr = fpFile->GetDiskFS()->GetDiskImg()->WriteBlock( pFile->fDirEntry.keyPointer, blkBuf); @@ -5032,12 +4942,12 @@ A2FDProDOS::Close(void) if (dierr != kDIErrNone) goto bail; - unsigned char* pParentPtr; + uint8_t* pParentPtr; pParentPtr = blkBuf + 0x04 + pFile->fParentDirIdx * kEntryLength; assert(pParentPtr + kEntryLength < blkBuf + kBlkSize); if (toupper(pParentPtr[0x01]) != toupper(pFile->fDirEntry.fileName[0])) { - LOGI("ProDOS ERROR: parent pointer has wrong entry??"); + LOGW("ProDOS ERROR: parent pointer has wrong entry??"); assert(false); dierr = kDIErrInternal; goto bail; @@ -5049,8 +4959,8 @@ A2FDProDOS::Close(void) PutShortLE(&pParentPtr[0x13], combinedBlocksUsed); if (pFile->fDirEntry.storageType != A2FileProDOS::kStorageExtended) { - PutShortLE(&pParentPtr[0x15], (unsigned short) newEOF); - pParentPtr[0x17] = (unsigned char) (newEOF >> 16); + PutShortLE(&pParentPtr[0x15], (uint16_t) newEOF); + pParentPtr[0x17] = (uint8_t) (newEOF >> 16); } /* don't update the mod date for now */ //PutLongLE(&pParentPtr[0x21], A2FileProDOS::ConvertProDate(time(NULL))); @@ -5116,15 +5026,14 @@ bail: /* * Return the #of sectors/blocks in the file. */ -long -A2FDProDOS::GetSectorCount(void) const +long A2FDProDOS::GetSectorCount(void) const { //if (fBlockList == NULL) // return kDIErrNotReady; return fBlockCount * 2; } -long -A2FDProDOS::GetBlockCount(void) const + +long A2FDProDOS::GetBlockCount(void) const { //if (fBlockList == NULL) // return kDIErrNotReady; @@ -5134,8 +5043,7 @@ A2FDProDOS::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDProDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDProDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { //if (fBlockList == NULL) // return kDIErrNotReady; @@ -5153,8 +5061,7 @@ A2FDProDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const /* * Return the Nth 512-byte block in this file. */ -DIError -A2FDProDOS::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDProDOS::GetStorage(long blockIdx, long* pBlock) const { //if (fBlockList == NULL) // return kDIErrNotReady; @@ -5171,8 +5078,7 @@ A2FDProDOS::GetStorage(long blockIdx, long* pBlock) const * Dump the list of blocks from an open file, skipping over * "sparsed-out" entries. */ -void -A2FDProDOS::DumpBlockList(void) const +void A2FDProDOS::DumpBlockList(void) const { long ll; diff --git a/diskimg/RDOS.cpp b/diskimg/RDOS.cpp index 705154a..3c48c8e 100644 --- a/diskimg/RDOS.cpp +++ b/diskimg/RDOS.cpp @@ -49,12 +49,11 @@ const int kNumDirEntryPerSect = (256 / kDirectoryEntryLen); // 8 * The initial value of "pFormatFound" is ignored, because we can reliably * detect which variant we're looking at. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, DiskImg::FSFormat* pFormatFound) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; if (pImg->GetNumSectPerTrack() == 13) { @@ -106,7 +105,7 @@ TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, */ { int track, sector, offset; - unsigned char orMask; + uint8_t orMask; static const char* kCompare = ""; DiskImg::SectorOrder order; @@ -133,7 +132,7 @@ TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, int i; for (i = strlen(kCompare)-1; i >= 0; i--) { - if (sctBuf[offset+i] != ((unsigned char)kCompare[i] | orMask)) + if (sctBuf[offset+i] != ((uint8_t)kCompare[i] | orMask)) break; } if (i >= 0) { @@ -153,8 +152,7 @@ bail: /* * Common RDOS test code. */ -/*static*/ DIError -DiskFSRDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSRDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { if (!pImg->GetHasSectors()) { @@ -190,8 +188,7 @@ DiskFSRDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Test to see if the image is an RDOS 3.3 disk. */ -/*static*/ DIError -DiskFSRDOS::TestFS33(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSRDOS::TestFS33(DiskImg* pImg, DiskImg::SectorOrder* pOrder, FSLeniency leniency) { DIError dierr; @@ -211,8 +208,7 @@ DiskFSRDOS::TestFS33(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Test to see if the image is an RDOS 3.2 disk. */ -/*static*/ DIError -DiskFSRDOS::TestFS32(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSRDOS::TestFS32(DiskImg* pImg, DiskImg::SectorOrder* pOrder, FSLeniency leniency) { DIError dierr; @@ -232,8 +228,7 @@ DiskFSRDOS::TestFS32(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Test to see if the image is an RDOS 3 (cracked 3.2) disk. */ -/*static*/ DIError -DiskFSRDOS::TestFS3(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSRDOS::TestFS3(DiskImg* pImg, DiskImg::SectorOrder* pOrder, FSLeniency leniency) { DIError dierr; @@ -259,8 +254,7 @@ DiskFSRDOS::TestFS3(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * on out must be handled somehow, possibly by claiming that the disk is * completely full and has no files on it. */ -DIError -DiskFSRDOS::Initialize(void) +DIError DiskFSRDOS::Initialize(void) { DIError dierr = kDIErrNone; const char* volStr; @@ -314,15 +308,14 @@ bail: * * To make life easy we slurp the whole thing into memory. */ -DIError -DiskFSRDOS::ReadCatalog(void) +DIError DiskFSRDOS::ReadCatalog(void) { DIError dierr = kDIErrNone; - unsigned char* dir = NULL; - unsigned char* dirPtr; + uint8_t* dir = NULL; + uint8_t* dirPtr; int track, sector; - dir = new unsigned char[kSctSize * kNumCatSectors]; + dir = new uint8_t[kSctSize * kNumCatSectors]; if (dir == NULL) { dierr = kDIErrMalloc; goto bail; @@ -391,8 +384,7 @@ bail: * Create the volume usage map. Since RDOS volumes have neither * in-use maps nor index blocks, this is pretty straightforward. */ -DIError -DiskFSRDOS::ScanFileUsage(void) +DIError DiskFSRDOS::ScanFileUsage(void) { int track, sector, block, count; @@ -419,8 +411,7 @@ DiskFSRDOS::ScanFileUsage(void) /* * Update an entry in the usage map. */ -void -DiskFSRDOS::SetSectorUsage(long track, long sector, +void DiskFSRDOS::SetSectorUsage(long track, long sector, VolumeUsage::ChunkPurpose purpose) { VolumeUsage::ChunkState cstate; @@ -447,8 +438,7 @@ DiskFSRDOS::SetSectorUsage(long track, long sector, /* * Convert RDOS file type to ProDOS file type. */ -long -A2FileRDOS::GetFileType(void) const +long A2FileRDOS::GetFileType(void) const { long retval; @@ -463,12 +453,10 @@ A2FileRDOS::GetFileType(void) const return retval; } - /* * Dump the contents of the A2File structure. */ -void -A2FileRDOS::Dump(void) const +void A2FileRDOS::Dump(void) const { LOGI("A2FileRDOS '%s' (type=%d)", fFileName, fFileType); LOGI(" start=%d num=%d len=%d addr=0x%04x", @@ -484,10 +472,9 @@ A2FileRDOS::Dump(void) const * low-ASCII. The inverse-mode correction turns it into punctuation, but * I don't see a good way around it. Or any particular need to fix it. */ -void -A2FileRDOS::FixFilename(void) +void A2FileRDOS::FixFilename(void) { - DiskFSDOS33::LowerASCII((unsigned char*)fFileName, kMaxFileName); + DiskFSDOS33::LowerASCII((uint8_t*)fFileName, kMaxFileName); TrimTrailingSpaces(fFileName); } @@ -496,8 +483,7 @@ A2FileRDOS::FixFilename(void) * * Assumes the filename has already been converted to low ASCII. */ -void -A2FileRDOS::TrimTrailingSpaces(char* filename) +void A2FileRDOS::TrimTrailingSpaces(char* filename) { char* lastspc = filename + strlen(filename); @@ -511,12 +497,10 @@ A2FileRDOS::TrimTrailingSpaces(char* filename) *(lastspc+1) = '\0'; } - /* * Not a whole lot to do, since there's no fancy index blocks. */ -DIError -A2FileRDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, +DIError A2FileRDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, bool rsrcFork /*=false*/) { if (fpOpenFile != NULL) @@ -547,8 +531,7 @@ A2FileRDOS::Open(A2FileDescr** ppOpenFile, bool readOnly, /* * Read a chunk of data from the current offset. */ -DIError -A2FDRDOS::Read(void* buf, size_t len, size_t* pActual) +DIError A2FDRDOS::Read(void* buf, size_t len, size_t* pActual) { LOGI(" RDOS reading %d bytes from '%s' (offset=%ld)", len, fpFile->GetPathName(), (long) fOffset); @@ -568,7 +551,7 @@ A2FDRDOS::Read(void* buf, size_t len, size_t* pActual) long incrLen = len; DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; long block = pFile->fStartSector + (long) (fOffset / kSctSize); int bufOffset = (int) (fOffset % kSctSize); // (& 0xff) int ourSectPerTrack = GetOurSectPerTrack(); @@ -611,8 +594,7 @@ A2FDRDOS::Read(void* buf, size_t len, size_t* pActual) /* * Write data at the current offset. */ -DIError -A2FDRDOS::Write(const void* buf, size_t len, size_t* pActual) +DIError A2FDRDOS::Write(const void* buf, size_t len, size_t* pActual) { //if (!fOpen) // return kDIErrNotReady; @@ -622,8 +604,7 @@ A2FDRDOS::Write(const void* buf, size_t len, size_t* pActual) /* * Seek to a new offset. */ -DIError -A2FDRDOS::Seek(di_off_t offset, DIWhence whence) +DIError A2FDRDOS::Seek(di_off_t offset, DIWhence whence) { //if (!fOpen) // return kDIErrNotReady; @@ -661,8 +642,7 @@ A2FDRDOS::Seek(di_off_t offset, DIWhence whence) /* * Return current offset. */ -di_off_t -A2FDRDOS::Tell(void) +di_off_t A2FDRDOS::Tell(void) { //if (!fOpen) // return kDIErrNotReady; @@ -673,8 +653,7 @@ A2FDRDOS::Tell(void) /* * Release file state, such as it is. */ -DIError -A2FDRDOS::Close(void) +DIError A2FDRDOS::Close(void) { fpFile->CloseDescr(this); return kDIErrNone; @@ -683,15 +662,14 @@ A2FDRDOS::Close(void) /* * Return the #of sectors/blocks in the file. */ -long -A2FDRDOS::GetSectorCount(void) const +long A2FDRDOS::GetSectorCount(void) const { //if (!fOpen) // return kDIErrNotReady; return ((A2FileRDOS*) fpFile)->fNumSectors; } -long -A2FDRDOS::GetBlockCount(void) const + +long A2FDRDOS::GetBlockCount(void) const { //if (!fOpen) // return kDIErrNotReady; @@ -701,8 +679,7 @@ A2FDRDOS::GetBlockCount(void) const /* * Return the Nth track/sector in this file. */ -DIError -A2FDRDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const +DIError A2FDRDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const { //if (!fOpen) // return kDIErrNotReady; @@ -717,11 +694,11 @@ A2FDRDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const return kDIErrNone; } + /* * Return the Nth 512-byte block in this file. */ -DIError -A2FDRDOS::GetStorage(long blockIdx, long* pBlock) const +DIError A2FDRDOS::GetStorage(long blockIdx, long* pBlock) const { //if (!fOpen) // return kDIErrNotReady; diff --git a/diskimg/SPTI.cpp b/diskimg/SPTI.cpp index 715ff04..10f962f 100644 --- a/diskimg/SPTI.cpp +++ b/diskimg/SPTI.cpp @@ -20,12 +20,11 @@ * * Returns the LBA of the last valid block and the device's block size. */ -/*static*/ DIError -SPTI::GetDeviceCapacity(HANDLE handle, unsigned long* pLastBlock, - unsigned long* pBlockSize) +/*static*/ DIError SPTI::GetDeviceCapacity(HANDLE handle, uint32_t* pLastBlock, + uint32_t* pBlockSize) { SCSI_PASS_THROUGH_DIRECT sptd; - unsigned long lba, blockLen; + uint32_t lba, blockLen; CDB_ReadCapacityData dataBuf; DWORD cb; BOOL status; @@ -54,7 +53,7 @@ SPTI::GetDeviceCapacity(HANDLE handle, unsigned long* pLastBlock, if (!status) { DWORD lastError = ::GetLastError(); - LOGI("DeviceIoControl(SCSI READ CAPACITY) failed, err=%ld", + LOGE("DeviceIoControl(SCSI READ CAPACITY) failed, err=%ld", ::GetLastError()); if (lastError == ERROR_IO_DEVICE) // no disc in drive return kDIErrDeviceNotReady; @@ -62,14 +61,14 @@ SPTI::GetDeviceCapacity(HANDLE handle, unsigned long* pLastBlock, return kDIErrSPTIFailure; } - lba = (unsigned long) dataBuf.logicalBlockAddr0 << 24 | - (unsigned long) dataBuf.logicalBlockAddr1 << 16 | - (unsigned long) dataBuf.logicalBlockAddr2 << 8 | - (unsigned long) dataBuf.logicalBlockAddr3; - blockLen = (unsigned long) dataBuf.bytesPerBlock0 << 24 | - (unsigned long) dataBuf.bytesPerBlock1 << 16 | - (unsigned long) dataBuf.bytesPerBlock2 << 8 | - (unsigned long) dataBuf.bytesPerBlock3; + lba = (uint32_t) dataBuf.logicalBlockAddr0 << 24 | + (uint32_t) dataBuf.logicalBlockAddr1 << 16 | + (uint32_t) dataBuf.logicalBlockAddr2 << 8 | + (uint32_t) dataBuf.logicalBlockAddr3; + blockLen = (uint32_t) dataBuf.bytesPerBlock0 << 24 | + (uint32_t) dataBuf.bytesPerBlock1 << 16 | + (uint32_t) dataBuf.bytesPerBlock2 << 8 | + (uint32_t) dataBuf.bytesPerBlock3; *pLastBlock = lba; *pBlockSize = blockLen; @@ -83,9 +82,8 @@ SPTI::GetDeviceCapacity(HANDLE handle, unsigned long* pLastBlock, * * "buf" must be able to hold (numBlocks * blockSize) bytes. */ -/*static*/ DIError -SPTI::ReadBlocks(HANDLE handle, long startBlock, short numBlocks, - long blockSize, void* buf) +/*static*/ DIError SPTI::ReadBlocks(HANDLE handle, long startBlock, + short numBlocks, long blockSize, void* buf) { SCSI_PASS_THROUGH_DIRECT sptd; DWORD cb; @@ -95,7 +93,7 @@ SPTI::ReadBlocks(HANDLE handle, long startBlock, short numBlocks, assert(numBlocks > 0); assert(buf != NULL); - //LOGI(" SPTI phys read block (%ld) %d", startBlock, numBlocks); + LOGD(" SPTI phys read block (%ld) %d", startBlock, numBlocks); memset(&sptd, 0, sizeof(sptd)); sptd.Length = sizeof(sptd); // size of struct (+ request-sense buffer) @@ -113,23 +111,23 @@ SPTI::ReadBlocks(HANDLE handle, long startBlock, short numBlocks, CDB10* pCdb = (CDB10*) &sptd.Cdb; pCdb->operationCode = kScsiOpRead; - pCdb->logicalBlockAddr0 = (unsigned char) (startBlock >> 24); // MSB - pCdb->logicalBlockAddr1 = (unsigned char) (startBlock >> 16); - pCdb->logicalBlockAddr2 = (unsigned char) (startBlock >> 8); - pCdb->logicalBlockAddr3 = (unsigned char) startBlock; // LSB - pCdb->transferLength0 = (unsigned char) (numBlocks >> 8); // MSB - pCdb->transferLength1 = (unsigned char) numBlocks; // LSB + pCdb->logicalBlockAddr0 = (uint8_t) (startBlock >> 24); // MSB + pCdb->logicalBlockAddr1 = (uint8_t) (startBlock >> 16); + pCdb->logicalBlockAddr2 = (uint8_t) (startBlock >> 8); + pCdb->logicalBlockAddr3 = (uint8_t) startBlock; // LSB + pCdb->transferLength0 = (uint8_t) (numBlocks >> 8); // MSB + pCdb->transferLength1 = (uint8_t) numBlocks; // LSB status = ::DeviceIoControl(handle, IOCTL_SCSI_PASS_THROUGH_DIRECT, &sptd, sizeof(sptd), NULL, 0, &cb, NULL); if (!status) { - LOGI("DeviceIoControl(SCSI READ(10)) failed, err=%ld", + LOGE("DeviceIoControl(SCSI READ(10)) failed, err=%ld", ::GetLastError()); return kDIErrReadFailed; // close enough } if (sptd.ScsiStatus != 0) { - LOGI("SCSI READ(10) failed, status=%d", sptd.ScsiStatus); + LOGE("SCSI READ(10) failed, status=%d", sptd.ScsiStatus); return kDIErrReadFailed; } diff --git a/diskimg/SPTI.h b/diskimg/SPTI.h index bda0865..0f14ef4 100644 --- a/diskimg/SPTI.h +++ b/diskimg/SPTI.h @@ -25,15 +25,15 @@ public: // Get the capacity, expressed as the highest-available LBA and the device // block size. - static DIError GetDeviceCapacity(HANDLE handle, unsigned long* pLastBlock, - unsigned long* pBlockSize); + static DIError GetDeviceCapacity(HANDLE handle, uint32_t* pLastBlock, + uint32_t* pBlockSize); private: SPTI(void) {} ~SPTI(void) {} }; -} // namespace DiskImgLib +} // namespace DiskImgLib #endif /*_WIN32*/ diff --git a/diskimg/StdAfx.h b/diskimg/StdAfx.h index 6acab18..7cfe4f6 100644 --- a/diskimg/StdAfx.h +++ b/diskimg/StdAfx.h @@ -63,6 +63,7 @@ typedef unsigned int ssize_t; #define HAVE__VSNPRINTF #define strcasecmp stricmp +#define snprintf _snprintf //{{AFX_INSERT_LOCATION}} // Microsoft Visual C++ will insert additional declarations immediately before the previous line. diff --git a/diskimg/TwoImg.cpp b/diskimg/TwoImg.cpp index 67d58d1..b05a9c5 100644 --- a/diskimg/TwoImg.cpp +++ b/diskimg/TwoImg.cpp @@ -25,10 +25,10 @@ * * Returns 0 on success, -1 if one of the arguments was bad. */ -int -TwoImgHeader::InitHeader(int imageFormat, long imageSize, long imageBlockCount) +int TwoImgHeader::InitHeader(int imageFormat, uint32_t imageSize, + uint32_t imageBlockCount) { - if (imageSize <= 0) + if (imageSize == 0) return -1; if (imageFormat < kImageFormatDOS || imageFormat > kImageFormatNibble) return -1; @@ -36,7 +36,7 @@ TwoImgHeader::InitHeader(int imageFormat, long imageSize, long imageBlockCount) if (imageFormat != kImageFormatNibble && imageSize != imageBlockCount * 512) { - LOGI("2MG InitHeader: bad sizes %d %ld %ld", imageFormat, + LOGW("2MG InitHeader: bad sizes %d %ld %ld", imageFormat, imageSize, imageBlockCount); return -1; } @@ -70,8 +70,7 @@ TwoImgHeader::InitHeader(int imageFormat, long imageSize, long imageBlockCount) * default volume number. For the way we currently make use of this, this * makes the most sense. */ -short -TwoImgHeader::GetDOSVolumeNum(void) const +int16_t TwoImgHeader::GetDOSVolumeNum(void) const { assert(fFlags & kDOSVolumeSet); return fDOSVolumeNum; @@ -80,8 +79,7 @@ TwoImgHeader::GetDOSVolumeNum(void) const /* * Set the DOS volume number. */ -void -TwoImgHeader::SetDOSVolumeNum(short dosVolumeNum) +void TwoImgHeader::SetDOSVolumeNum(short dosVolumeNum) { assert(dosVolumeNum >= 0 && dosVolumeNum < 256); fFlags |= dosVolumeNum; @@ -91,8 +89,7 @@ TwoImgHeader::SetDOSVolumeNum(short dosVolumeNum) /* * Set the comment. */ -void -TwoImgHeader::SetComment(const char* comment) +void TwoImgHeader::SetComment(const char* comment) { delete[] fComment; if (comment == NULL) { @@ -120,8 +117,7 @@ TwoImgHeader::SetComment(const char* comment) /* * Set the creator chunk. */ -void -TwoImgHeader::SetCreatorChunk(const void* chunk, long len) +void TwoImgHeader::SetCreatorChunk(const void* chunk, long len) { assert(len >= 0); @@ -155,10 +151,9 @@ TwoImgHeader::SetCreatorChunk(const void* chunk, long len) * * Returns 0 on success, nonzero on error or invalid header. */ -int -TwoImgHeader::ReadHeader(FILE* fp, long totalLength) +int TwoImgHeader::ReadHeader(FILE* fp, uint32_t totalLength) { - unsigned char buf[kOurHeaderLen]; + uint8_t buf[kOurHeaderLen]; fread(buf, kOurHeaderLen, 1, fp); if (ferror(fp)) @@ -205,11 +200,10 @@ TwoImgHeader::ReadHeader(FILE* fp, long totalLength) * * Returns 0 on success, nonzero on error or invalid header. */ -int -TwoImgHeader::ReadHeader(GenericFD* pGFD, long totalLength) +int TwoImgHeader::ReadHeader(GenericFD* pGFD, uint32_t totalLength) { DIError dierr; - unsigned char buf[kOurHeaderLen]; + uint8_t buf[kOurHeaderLen]; dierr = pGFD->Read(buf, kOurHeaderLen); if (dierr != kDIErrNone) @@ -254,8 +248,7 @@ TwoImgHeader::ReadHeader(GenericFD* pGFD, long totalLength) /* * Grab a chunk of data from a relative offset. */ -int -TwoImgHeader::GetChunk(GenericFD* pGFD, di_off_t relOffset, long len, +int TwoImgHeader::GetChunk(GenericFD* pGFD, di_off_t relOffset, long len, void** pBuf) { DIError dierr; @@ -295,8 +288,7 @@ TwoImgHeader::GetChunk(GenericFD* pGFD, di_off_t relOffset, long len, /* * Grab a chunk of data from a relative offset. */ -int -TwoImgHeader::GetChunk(FILE* fp, di_off_t relOffset, long len, +int TwoImgHeader::GetChunk(FILE* fp, di_off_t relOffset, long len, void** pBuf) { long curPos; @@ -340,8 +332,7 @@ TwoImgHeader::GetChunk(FILE* fp, di_off_t relOffset, long len, * * Performs some sanity checks. Returns 0 on success, -1 on failure. */ -int -TwoImgHeader::UnpackHeader(const unsigned char* buf, long totalLength) +int TwoImgHeader::UnpackHeader(const uint8_t* buf, uint32_t totalLength) { fMagic = GetLongBE(&buf[0x00]); fCreator = GetLongBE(&buf[0x04]); @@ -378,7 +369,7 @@ TwoImgHeader::UnpackHeader(const unsigned char* buf, long totalLength) } if (fVersion > 1) { - LOGI("ERROR: unsupported version=%d", fVersion); + LOGW("ERROR: unsupported version=%d", fVersion); return -1; // bad header until I hear otherwise } @@ -402,22 +393,22 @@ TwoImgHeader::UnpackHeader(const unsigned char* buf, long totalLength) if (fImageFormat != kImageFormatNibble && fNumBlocks * kBlockSize != fDataLen) { - LOGI("numBlocks/dataLen mismatch (%ld vs %ld)", + LOGW("numBlocks/dataLen mismatch (%ld vs %ld)", fNumBlocks * kBlockSize, fDataLen); return -1; } if (fDataLen + fDataOffset > totalLength) { - LOGI("Invalid dataLen/offset/fileLength (dl=%ld, off=%ld, tlen=%ld)", + LOGW("Invalid dataLen/offset/fileLength (dl=%ld, off=%ld, tlen=%ld)", fDataLen, fDataOffset, totalLength); return -1; } if (fImageFormat < kImageFormatDOS || fImageFormat > kImageFormatNibble) { - LOGI("Invalid image format %ld", fImageFormat); + LOGW("Invalid image format %ld", fImageFormat); return -1; } if (fCmtOffset > 0 && fCmtOffset < fDataOffset + fDataLen) { - LOGI("2MG comment is inside the data section (off=%ld, data end=%ld)", + LOGW("2MG comment is inside the data section (off=%ld, data end=%ld)", fCmtOffset, fDataOffset+fDataLen); DebugBreak(); // ignore the comment @@ -425,10 +416,10 @@ TwoImgHeader::UnpackHeader(const unsigned char* buf, long totalLength) fCmtLen = 0; } if (fCreatorOffset > 0 && fCreatorLen > 0) { - long prevEnd = fDataOffset + fDataLen + fCmtLen; + uint32_t prevEnd = fDataOffset + fDataLen + fCmtLen; if (fCreatorOffset < prevEnd) { - LOGI("2MG creator chunk is inside prev data (off=%ld, data end=%ld)", + LOGW("2MG creator chunk is inside prev data (off=%ld, data end=%ld)", fCreatorOffset, prevEnd); DebugBreak(); // ignore the creator chunk @@ -448,7 +439,7 @@ TwoImgHeader::UnpackHeader(const unsigned char* buf, long totalLength) int TwoImgHeader::WriteHeader(FILE* fp) const { - unsigned char buf[kOurHeaderLen]; + uint8_t buf[kOurHeaderLen]; PackHeader(buf); if (fwrite(buf, kOurHeaderLen, 1, fp) != 1) @@ -464,7 +455,7 @@ TwoImgHeader::WriteHeader(FILE* fp) const int TwoImgHeader::WriteHeader(GenericFD* pGFD) const { - unsigned char buf[kOurHeaderLen]; + uint8_t buf[kOurHeaderLen]; PackHeader(buf); @@ -519,7 +510,7 @@ TwoImgHeader::WriteFooter(GenericFD* pGFD) const * Pack the header values into a 64-byte buffer. */ void -TwoImgHeader::PackHeader(unsigned char* buf) const +TwoImgHeader::PackHeader(uint8_t* buf) const { if (fCmtLen > 0 && fCmtOffset == 0) { assert(false); diff --git a/diskimg/TwoImg.h b/diskimg/TwoImg.h index 175d716..0956299 100644 --- a/diskimg/TwoImg.h +++ b/diskimg/TwoImg.h @@ -42,20 +42,20 @@ public: */ //char fMagic[4]; //char fCreator[4]; - unsigned long fMagic; - unsigned long fCreator; - short fHeaderLen; - short fVersion; - long fImageFormat; - unsigned long fFlags; // may include DOS volume num - long fNumBlocks; // 512-byte blocks - long fDataOffset; - long fDataLen; - long fCmtOffset; - long fCmtLen; - long fCreatorOffset; - long fCreatorLen; - long fSpare[4]; + uint32_t fMagic; + uint32_t fCreator; + uint16_t fHeaderLen; + uint16_t fVersion; + uint32_t fImageFormat; + uint32_t fFlags; // may include DOS volume num + uint32_t fNumBlocks; // 512-byte blocks + uint32_t fDataOffset; + uint32_t fDataLen; + uint32_t fCmtOffset; + uint32_t fCmtLen; + uint32_t fCreatorOffset; + uint32_t fCreatorLen; + uint32_t fSpare[4]; /* * Related constants. @@ -93,9 +93,9 @@ public: * end of the data section. This is done in case the file has some * sort of wrapper outside the 2MG header. */ - int InitHeader(int imageFormat, long imageSize, long imageBlockCount); - int ReadHeader(FILE* fp, long totalLength); - int ReadHeader(GenericFD* pGFD, long totalLength); + int InitHeader(int imageFormat, uint32_t imageSize, uint32_t imageBlockCount); + int ReadHeader(FILE* fp, uint32_t totalLength); + int ReadHeader(GenericFD* pGFD, uint32_t totalLength); int WriteHeader(FILE* fp) const; int WriteHeader(GenericFD* pGFD) const; int WriteFooter(FILE* fp) const; @@ -108,7 +108,7 @@ public: const char* GetMagicStr(void) const { return fMagicStr; } const char* GetCreatorStr(void) const { return fCreatorStr; } - short GetDOSVolumeNum(void) const; + int16_t GetDOSVolumeNum(void) const; void SetDOSVolumeNum(short dosVolumeNum); const char* GetComment(void) const { return fComment; } void SetComment(const char* comment); @@ -116,14 +116,12 @@ public: void SetCreatorChunk(const void* creatorBlock, long len); private: - int UnpackHeader(const unsigned char* buf, long totalLength); - void PackHeader(unsigned char* buf) const; - int GetChunk(GenericFD* pGFD, di_off_t relOffset, long len, - void** pBuf); - int GetChunk(FILE* fp, di_off_t relOffset, long len, - void** pBuf); + int UnpackHeader(const uint8_t* buf, uint32_t totalLength); + void PackHeader(uint8_t* buf) const; + int GetChunk(GenericFD* pGFD, di_off_t relOffset, long len, void** pBuf); + int GetChunk(FILE* fp, di_off_t relOffset, long len, void** pBuf); - int fDOSVolumeNum; + int16_t fDOSVolumeNum; // 8-bit volume number, or -1 char fMagicStr[5]; char fCreatorStr[5]; @@ -131,6 +129,6 @@ private: char* fCreatorChunk; }; -} // namespace DiskImgLib +} // namespace DiskImgLib #endif /*DISKIMG_TWOIMG_H*/ diff --git a/diskimg/UNIDOS.cpp b/diskimg/UNIDOS.cpp index 907d309..f47dd7a 100644 --- a/diskimg/UNIDOS.cpp +++ b/diskimg/UNIDOS.cpp @@ -44,9 +44,8 @@ const int kMaxCatalogIterations = 64; * Read a track/sector, adjusting for 32-sector disks being treated as * if they were 16-sector. */ -static DIError -ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, - int trackOffset, unsigned char* buf, DiskImg::SectorOrder imageOrder) +static DIError ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, + int trackOffset, uint8_t* buf, DiskImg::SectorOrder imageOrder) { track += trackOffset; track *= 2; @@ -61,12 +60,11 @@ ReadTrackSectorAdjusted(DiskImg* pImg, int track, int sector, /* * Test for presence of 400K DOS 3.3 volumes. */ -static DIError -TestImageHalf(DiskImg* pImg, int trackOffset, DiskImg::SectorOrder imageOrder, - int* pGoodCount) +static DIError TestImageHalf(DiskImg* pImg, int trackOffset, + DiskImg::SectorOrder imageOrder, int* pGoodCount) { DIError dierr = kDIErrNone; - unsigned char sctBuf[kSctSize]; + uint8_t sctBuf[kSctSize]; int numTracks, numSectors; int catTrack, catSect; int foundGood = 0; @@ -140,8 +138,8 @@ bail: /* * Test both of the DOS partitions. */ -static DIError -TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, int* pGoodCount) +static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, + int* pGoodCount) { DIError dierr; int goodCount1, goodCount2; @@ -169,8 +167,7 @@ TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder, int* pGoodCount) /* * Test to see if the image is a UNIDOS volume. */ -/*static*/ DIError -DiskFSUNIDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSUNIDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { /* only on 800K disks (at the least, insist on numTracks being even) */ @@ -219,8 +216,7 @@ DiskFSUNIDOS::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, * swap can return a "good" value of 7 (much less than the expected 30, but * above a threshold of reasonableness). */ -/*static*/ DIError -DiskFSUNIDOS::TestWideFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, +/*static*/ DIError DiskFSUNIDOS::TestWideFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, DiskImg::FSFormat* pFormat, FSLeniency leniency) { /* only on 400K "disks" */ @@ -269,8 +265,7 @@ DiskFSUNIDOS::TestWideFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder, /* * Set up our sub-volumes. */ -DIError -DiskFSUNIDOS::Initialize(void) +DIError DiskFSUNIDOS::Initialize(void) { DIError dierr = kDIErrNone; @@ -294,8 +289,7 @@ DiskFSUNIDOS::Initialize(void) /* * Open up one of the DOS 3.3 sub-volumes. */ -DIError -DiskFSUNIDOS::OpenSubVolume(int idx) +DIError DiskFSUNIDOS::OpenSubVolume(int idx) { DIError dierr = kDIErrNone; DiskFS* pNewFS = NULL; diff --git a/diskimg/VolumeUsage.cpp b/diskimg/VolumeUsage.cpp index e9b3bfa..14d40f5 100644 --- a/diskimg/VolumeUsage.cpp +++ b/diskimg/VolumeUsage.cpp @@ -13,8 +13,7 @@ /* * Initialize structures for a block-structured disk. */ -DIError -DiskFS::VolumeUsage::Create(long numBlocks) +DIError DiskFS::VolumeUsage::Create(long numBlocks) { if (numBlocks <= 0 || numBlocks > 32*1024*1024) // 16GB return kDIErrInvalidArg; @@ -35,8 +34,7 @@ DiskFS::VolumeUsage::Create(long numBlocks) /* * Initialize structures for a track/sector-structured disk. */ -DIError -DiskFS::VolumeUsage::Create(long numTracks, long numSectors) +DIError DiskFS::VolumeUsage::Create(long numTracks, long numSectors) { long count = numTracks * numSectors; if (numTracks <= 0 || count <= 0 || count > 32*1024*1024) @@ -58,15 +56,14 @@ DiskFS::VolumeUsage::Create(long numTracks, long numSectors) /* * Return the state of a particular chunk. */ -DIError -DiskFS::VolumeUsage::GetChunkState(long block, ChunkState* pState) const +DIError DiskFS::VolumeUsage::GetChunkState(long block, ChunkState* pState) const { if (!fByBlocks) return kDIErrInvalidArg; return GetChunkStateIdx(block, pState); } -DIError -DiskFS::VolumeUsage::GetChunkState(long track, long sector, + +DIError DiskFS::VolumeUsage::GetChunkState(long track, long sector, ChunkState* pState) const { if (fByBlocks) @@ -75,8 +72,8 @@ DiskFS::VolumeUsage::GetChunkState(long track, long sector, return kDIErrInvalidArg; return GetChunkStateIdx(track * fNumSectors + sector, pState); } -DIError -DiskFS::VolumeUsage::GetChunkStateIdx(int idx, ChunkState* pState) const + +DIError DiskFS::VolumeUsage::GetChunkStateIdx(int idx, ChunkState* pState) const { if (fList == NULL || idx < 0 || idx >= fListSize) { assert(false); @@ -94,15 +91,14 @@ DiskFS::VolumeUsage::GetChunkStateIdx(int idx, ChunkState* pState) const /* * Set the state of a particular chunk. */ -DIError -DiskFS::VolumeUsage::SetChunkState(long block, const ChunkState* pState) +DIError DiskFS::VolumeUsage::SetChunkState(long block, const ChunkState* pState) { if (!fByBlocks) return kDIErrInvalidArg; return SetChunkStateIdx(block, pState); } -DIError -DiskFS::VolumeUsage::SetChunkState(long track, long sector, + +DIError DiskFS::VolumeUsage::SetChunkState(long track, long sector, const ChunkState* pState) { if (fByBlocks) @@ -111,8 +107,8 @@ DiskFS::VolumeUsage::SetChunkState(long track, long sector, return kDIErrInvalidArg; return SetChunkStateIdx(track * fNumSectors + sector, pState); } -DIError -DiskFS::VolumeUsage::SetChunkStateIdx(int idx, const ChunkState* pState) + +DIError DiskFS::VolumeUsage::SetChunkStateIdx(int idx, const ChunkState* pState) { if (fList == NULL || idx < 0 || idx >= fListSize) { assert(false); @@ -136,12 +132,10 @@ DiskFS::VolumeUsage::SetChunkStateIdx(int idx, const ChunkState* pState) return kDIErrNone; } - /* * Count up the #of free chunks. */ -long -DiskFS::VolumeUsage::GetActualFreeChunks(void) const +long DiskFS::VolumeUsage::GetActualFreeChunks(void) const { ChunkState cstate; // could probably do this bitwise... int freeCount = 0; @@ -170,7 +164,6 @@ DiskFS::VolumeUsage::GetActualFreeChunks(void) const return freeCount; } - /* * Convert a ChunkState into a single, hopefully meaningful, character. * @@ -183,8 +176,7 @@ DiskFS::VolumeUsage::GetActualFreeChunks(void) const * 'I' - inuse, marked, used by file structure (index block) * 'F' - inuse, marked, used by file */ -inline char -DiskFS::VolumeUsage::StateToChar(ChunkState* pState) const +char DiskFS::VolumeUsage::StateToChar(ChunkState* pState) const { if (!pState->isUsed && !pState->isMarkedUsed) return '.'; @@ -217,8 +209,7 @@ DiskFS::VolumeUsage::StateToChar(ChunkState* pState) const /* * Dump the list. */ -void -DiskFS::VolumeUsage::Dump(void) const +void DiskFS::VolumeUsage::Dump(void) const { #define kMapInit "--------------------------------" if (fList == NULL) { diff --git a/diskimg/Win32BlockIO.cpp b/diskimg/Win32BlockIO.cpp index 1389568..45ae6de 100644 --- a/diskimg/Win32BlockIO.cpp +++ b/diskimg/Win32BlockIO.cpp @@ -43,8 +43,7 @@ /* * Open a logical volume. */ -DIError -Win32VolumeAccess::Open(const WCHAR* deviceName, bool readOnly) +DIError Win32VolumeAccess::Open(const WCHAR* deviceName, bool readOnly) { DIError dierr = kDIErrNone; @@ -107,8 +106,7 @@ bail: /* * Close the device. */ -void -Win32VolumeAccess::Close(void) +void Win32VolumeAccess::Close(void) { if (fpBlockAccess != NULL) { DIError dierr; @@ -130,7 +128,6 @@ Win32VolumeAccess::Close(void) } } - /* * Read a range of blocks from the device. * @@ -142,8 +139,7 @@ Win32VolumeAccess::Close(void) * * Returns with an error if any of the blocks could not be read. */ -DIError -Win32VolumeAccess::ReadBlocks(long startBlock, short blockCount, +DIError Win32VolumeAccess::ReadBlocks(long startBlock, short blockCount, void* buf) { DIError dierr = kDIErrNone; @@ -192,15 +188,13 @@ bail: return dierr; } - /* * Write a range of blocks to the device. For the most part this just * writes to the cache. * * Returns with an error if any of the blocks could not be read. */ -DIError -Win32VolumeAccess::WriteBlocks(long startBlock, short blockCount, +DIError Win32VolumeAccess::WriteBlocks(long startBlock, short blockCount, const void* buf) { DIError dierr = kDIErrNone; @@ -242,7 +236,6 @@ bail: return dierr; } - /* * Write all blocks in the cache to disk if any of them are dirty. In some * ways this is wasteful -- we could be writing stuff that isn't dirty, @@ -255,8 +248,7 @@ bail: * * If "purge" is set, we discard the blocks after writing them. */ -DIError -Win32VolumeAccess::FlushCache(bool purge) +DIError Win32VolumeAccess::FlushCache(bool purge) { DIError dierr = kDIErrNone; @@ -305,8 +297,7 @@ bail: * * On success, "*pNumBlocks" gets the number of 512-byte blocks. */ -DIError -Win32VolumeAccess::BlockAccess::DetectCapacitySPTI(HANDLE handle, +DIError Win32VolumeAccess::BlockAccess::DetectCapacitySPTI(HANDLE handle, bool isCDROM, long* pNumBlocks) { #ifndef HAVE_WINDOWS_CDROM @@ -315,17 +306,17 @@ Win32VolumeAccess::BlockAccess::DetectCapacitySPTI(HANDLE handle, #endif DIError dierr = kDIErrNone; - unsigned long lba, blockLen; + uint32_t lba, blockLen; dierr = SPTI::GetDeviceCapacity(handle, &lba, &blockLen); if (dierr != kDIErrNone) goto bail; - LOGI("READ CAPACITY reports lba=%lu blockLen=%lu (total=%lu)", + LOGI("READ CAPACITY reports lba=%u blockLen=%u (total=%u)", lba, blockLen, lba*blockLen); if (isCDROM && blockLen != kCDROMSectorSize) { - LOGI("Unacceptable CD-ROM blockLen=%ld, bailing", blockLen); + LOGW("Unacceptable CD-ROM blockLen=%ld, bailing", blockLen); dierr = kDIErrReadFailed; goto bail; } @@ -351,8 +342,8 @@ bail: * This sets "*pNumBlocks" on success. The largest size this will detect * is currently 8GB. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::ScanCapacity(BlockAccess* pThis, long* pNumBlocks) +/*static*/ DIError Win32VolumeAccess::BlockAccess::ScanCapacity(BlockAccess* pThis, + long* pNumBlocks) { DIError dierr = kDIErrNone; // max out at 8GB (-1 block) @@ -441,11 +432,11 @@ bail: /* * Figure out if the block at "blockNum" exists. */ -/*static*/ bool -Win32VolumeAccess::BlockAccess::CanReadBlock(BlockAccess* pThis, long blockNum) +/*static*/ bool Win32VolumeAccess::BlockAccess::CanReadBlock(BlockAccess* pThis, + long blockNum) { DIError dierr; - unsigned char buf[BlockAccess::kBlockSize]; + uint8_t buf[BlockAccess::kBlockSize]; dierr = pThis->ReadBlocks(blockNum, 1, buf); if (dierr == kDIErrNone) { @@ -515,8 +506,8 @@ typedef struct _DRIVEMAPINFO { * * Pass in the vwin32 handle. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::GetInt13Unit(HANDLE handle, int driveNum, int* pInt13Unit) +/*static*/ DIError Win32VolumeAccess::BlockAccess::GetInt13Unit(HANDLE handle, + int driveNum, int* pInt13Unit) { DIError dierr = kDIErrNone; BOOL result; @@ -606,8 +597,7 @@ bail: * is returned, "*pNumTracks", "*pNumHeads", and "*pNumSectors" will receive * values if the pointers are non-NULL. */ -/*static*/ bool -Win32VolumeAccess::BlockAccess::LookupFloppyGeometry(long totalBlocks, +/*static*/ bool Win32VolumeAccess::BlockAccess::LookupFloppyGeometry(long totalBlocks, DiskGeometry* pGeometry) { static const struct { @@ -661,8 +651,7 @@ Win32VolumeAccess::BlockAccess::LookupFloppyGeometry(long totalBlocks, * * Returns "true" on success, "false" on failure. */ -/*static*/ bool -Win32VolumeAccess::BlockAccess::BlockToCylinderHeadSector(long blockNum, +/*static*/ bool Win32VolumeAccess::BlockAccess::BlockToCylinderHeadSector(long blockNum, const DiskGeometry* pGeometry, int* pCylinder, int* pHead, int* pSector, long* pLastBlockOnTrack) { @@ -696,9 +685,8 @@ Win32VolumeAccess::BlockAccess::BlockToCylinderHeadSector(long blockNum, /* * Get the floppy drive kind (*not* the media kind) using Int13h func 8. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::GetFloppyDriveKind(HANDLE handle, int unitNum, - FloppyKind* pKind) +/*static*/ DIError Win32VolumeAccess::BlockAccess::GetFloppyDriveKind(HANDLE handle, + int unitNum, FloppyKind* pKind) { DIOC_REGISTERS reg = {0}; DWORD cb; @@ -740,9 +728,8 @@ Win32VolumeAccess::BlockAccess::GetFloppyDriveKind(HANDLE handle, int unitNum, * Returns 0 on success, the status code from AH on failure. If the call * fails but AH is zero, -1 is returned. */ -/*static*/ int -Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, int unitNum, - int cylinder, int head, int sector, short blockCount, void* buf) +/*static*/ int Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, + int unitNum, int cylinder, int head, int sector, short blockCount, void* buf) { DIOC_REGISTERS reg = {0}; DWORD cb; @@ -787,7 +774,6 @@ Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, int unitNum, return 0; } - /* * Read one or more blocks using Int13h services. This only works on * floppy drives due to Win9x limitations. @@ -796,9 +782,8 @@ Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, int unitNum, * reasons. Because this is fairly "raw", we have to retry it 3x before * giving up. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, int unitNum, - const DiskGeometry* pGeometry, long startBlock, short blockCount, +/*static*/ DIError Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, + int unitNum, const DiskGeometry* pGeometry, long startBlock, short blockCount, void* buf) { int cylinder, head, sector; @@ -861,9 +846,8 @@ Win32VolumeAccess::BlockAccess::ReadBlocksInt13h(HANDLE handle, int unitNum, * reasons. Because this is fairly "raw", we have to retry it 3x before * giving up. */ -/*static*/ int -Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, int unitNum, - int cylinder, int head, int sector, short blockCount, +/*static*/ int Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, + int unitNum, int cylinder, int head, int sector, short blockCount, const void* buf) { DIOC_REGISTERS reg = {0}; @@ -910,9 +894,8 @@ Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, int unitNum, * * Returns "true" on success, "false" on failure. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, int unitNum, - const DiskGeometry* pGeometry, long startBlock, short blockCount, +/*static*/ DIError Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, + int unitNum, const DiskGeometry* pGeometry, long startBlock, short blockCount, const void* buf) { int cylinder, head, sector; @@ -962,16 +945,14 @@ Win32VolumeAccess::BlockAccess::WriteBlocksInt13h(HANDLE handle, int unitNum, return kDIErrNone; } - /* * Read blocks from a Win9x logical volume, using Int21h func 7305h. Pass in * a handle to vwin32 and the logical drive number (A=1, B=2, etc). * * Works on Win95 OSR2 and later. Earlier versions require Int25 or Int13. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::ReadBlocksInt21h(HANDLE handle, int driveNum, - long startBlock, short blockCount, void* buf) +/*static*/ DIError Win32VolumeAccess::BlockAccess::ReadBlocksInt21h(HANDLE handle, + int driveNum, long startBlock, short blockCount, void* buf) { #if 0 assert(false); // discouraged @@ -1040,9 +1021,8 @@ Win32VolumeAccess::BlockAccess::ReadBlocksInt21h(HANDLE handle, int driveNum, * * Works on Win95 OSR2 and later. Earlier versions require Int26 or Int13. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::WriteBlocksInt21h(HANDLE handle, int driveNum, - long startBlock, short blockCount, const void* buf) +/*static*/ DIError Win32VolumeAccess::BlockAccess::WriteBlocksInt21h(HANDLE handle, + int driveNum, long startBlock, short blockCount, const void* buf) { BOOL result; DWORD cb; @@ -1076,12 +1056,10 @@ Win32VolumeAccess::BlockAccess::WriteBlocksInt21h(HANDLE handle, int driveNum, return kDIErrNone; } - /* * Read blocks from a Win2K logical or physical volume. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::ReadBlocksWin2K(HANDLE handle, +/*static*/ DIError Win32VolumeAccess::BlockAccess::ReadBlocksWin2K(HANDLE handle, long startBlock, short blockCount, void* buf) { /* @@ -1122,12 +1100,10 @@ Win32VolumeAccess::BlockAccess::ReadBlocksWin2K(HANDLE handle, return kDIErrNone; } - /* * Write blocks to a Win2K logical or physical volume. */ -/*static*/ DIError -Win32VolumeAccess::BlockAccess::WriteBlocksWin2K(HANDLE handle, +/*static*/ DIError Win32VolumeAccess::BlockAccess::WriteBlocksWin2K(HANDLE handle, long startBlock, short blockCount, const void* buf) { DWORD posn, actual; @@ -1165,8 +1141,8 @@ Win32VolumeAccess::BlockAccess::WriteBlocksWin2K(HANDLE handle, /* * Open a logical device. The device name should be of the form "A:\". */ -DIError -Win32VolumeAccess::LogicalBlockAccess::Open(const WCHAR* deviceName, bool readOnly) +DIError Win32VolumeAccess::LogicalBlockAccess::Open(const WCHAR* deviceName, + bool readOnly) { DIError dierr = kDIErrNone; const bool kPreferASPI = true; @@ -1307,8 +1283,7 @@ bail: /* * Close the device handle. */ -DIError -Win32VolumeAccess::LogicalBlockAccess::Close(void) +DIError Win32VolumeAccess::LogicalBlockAccess::Close(void) { if (fHandle != NULL) { ::CloseHandle(fHandle); @@ -1317,12 +1292,10 @@ Win32VolumeAccess::LogicalBlockAccess::Close(void) return kDIErrNone; } - /* * Read 512-byte blocks from CD-ROM media using SPTI calls. */ -DIError -Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, +DIError Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, long startBlock, short blockCount, void* buf) { #ifdef HAVE_WINDOWS_CDROM @@ -1337,7 +1310,7 @@ Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, /* alloc sector buffer on first use */ if (fLastSectorCache == NULL) { - fLastSectorCache = new unsigned char[kCDROMSectorSize]; + fLastSectorCache = new uint8_t[kCDROMSectorSize]; if (fLastSectorCache == NULL) return kDIErrMalloc; assert(fLastSectorNum == -1); @@ -1384,7 +1357,7 @@ Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, thisNumBlocks * kBlockSize); blockCount -= thisNumBlocks; - buf = (unsigned char*) buf + (thisNumBlocks * kBlockSize); + buf = (uint8_t*) buf + (thisNumBlocks * kBlockSize); sectorOffset = 0; sectorIndex++; @@ -1402,7 +1375,7 @@ Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, return dierr; blockCount -= numSectors * kFactor; - buf = (unsigned char*) buf + (numSectors * kCDROMSectorSize); + buf = (uint8_t*) buf + (numSectors * kCDROMSectorSize); sectorIndex += numSectors; } @@ -1425,8 +1398,8 @@ Win32VolumeAccess::LogicalBlockAccess::ReadBlocksCDROM(HANDLE handle, /* * Open a physical device. The device name should be of the form "80:\". */ -DIError -Win32VolumeAccess::PhysicalBlockAccess::Open(const WCHAR* deviceName, bool readOnly) +DIError Win32VolumeAccess::PhysicalBlockAccess::Open(const WCHAR* deviceName, + bool readOnly) { DIError dierr = kDIErrNone; @@ -1537,8 +1510,7 @@ bail: * * Sets "fFloppyKind" and "fGeometry". */ -DIError -Win32VolumeAccess::PhysicalBlockAccess::DetectFloppyGeometry(void) +DIError Win32VolumeAccess::PhysicalBlockAccess::DetectFloppyGeometry(void) { DIError dierr = kDIErrNone; static const struct { @@ -1552,7 +1524,7 @@ Win32VolumeAccess::PhysicalBlockAccess::DetectFloppyGeometry(void) { kFloppy35_1440, { 80, 2, 18, 1440*2 } }, { kFloppy35_2880, { 80, 2, 36, 2880*2 } } }; - unsigned char buf[kBlockSize]; + uint8_t buf[kBlockSize]; FloppyKind driveKind; int status; @@ -1631,8 +1603,7 @@ bail: /* * Flush the system disk cache. */ -DIError -Win32VolumeAccess::PhysicalBlockAccess::FlushBlockDevice(void) +DIError Win32VolumeAccess::PhysicalBlockAccess::FlushBlockDevice(void) { DIError dierr = kDIErrNone; @@ -1649,8 +1620,7 @@ Win32VolumeAccess::PhysicalBlockAccess::FlushBlockDevice(void) /* * Close the device handle. */ -DIError -Win32VolumeAccess::PhysicalBlockAccess::Close(void) +DIError Win32VolumeAccess::PhysicalBlockAccess::Close(void) { if (fHandle != NULL) { ::CloseHandle(fHandle); @@ -1671,8 +1641,8 @@ Win32VolumeAccess::PhysicalBlockAccess::Close(void) * Unpack device name and verify that the device is a CD-ROM drive or * direct-access storage device. */ -DIError -Win32VolumeAccess::ASPIBlockAccess::Open(const char* deviceName, bool readOnly) +DIError Win32VolumeAccess::ASPIBlockAccess::Open(const char* deviceName, + bool readOnly) { DIError dierr = kDIErrNone; @@ -1708,7 +1678,7 @@ Win32VolumeAccess::ASPIBlockAccess::Open(const char* deviceName, bool readOnly) fTarget = target; fLun = lun; - unsigned char deviceType; + uint8_t deviceType; dierr = fpASPI->GetDeviceType(fAdapter, fTarget, fLun, &deviceType); if (dierr != kDIErrNone || (deviceType != kScsiDevTypeCDROM && deviceType != kScsiDevTypeDASD)) @@ -1738,8 +1708,7 @@ bail: * * Returns 0 on success, -1 on failure. */ -int -Win32VolumeAccess::ASPIBlockAccess::ExtractInt(const char** pStr, int* pResult) +int Win32VolumeAccess::ASPIBlockAccess::ExtractInt(const char** pStr, int* pResult) { char* end = NULL; @@ -1763,8 +1732,7 @@ Win32VolumeAccess::ASPIBlockAccess::ExtractInt(const char** pStr, int* pResult) * * Sets fChunkSize as a side-effect. */ -DIError -Win32VolumeAccess::ASPIBlockAccess::DetectCapacity(long* pNumBlocks) +DIError Win32VolumeAccess::ASPIBlockAccess::DetectCapacity(long* pNumBlocks) { DIError dierr = kDIErrNone; unsigned long lba, blockLen; @@ -1801,9 +1769,8 @@ bail: * SCSI doesn't promise it'll be in a chunk size we like, but it's pretty * safe to assume that it'll be at least 512 bytes, and divisible by 512. */ -DIError -Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, short blockCount, - void* buf) +DIError Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, + short blockCount, void* buf) { DIError dierr; @@ -1813,7 +1780,7 @@ Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, short blockCount /* alloc chunk buffer on first use */ if (fLastChunkCache == NULL) { - fLastChunkCache = new unsigned char[fChunkSize]; + fLastChunkCache = new uint8_t[fChunkSize]; if (fLastChunkCache == NULL) return kDIErrMalloc; assert(fLastChunkNum == -1); @@ -1859,7 +1826,7 @@ Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, short blockCount thisNumBlocks * kBlockSize); blockCount -= thisNumBlocks; - buf = (unsigned char*) buf + (thisNumBlocks * kBlockSize); + buf = (uint8_t*) buf + (thisNumBlocks * kBlockSize); chunkOffset = 0; chunkIndex++; @@ -1877,7 +1844,7 @@ Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, short blockCount return dierr; blockCount -= numChunks * kFactor; - buf = (unsigned char*) buf + (numChunks * fChunkSize); + buf = (uint8_t*) buf + (numChunks * fChunkSize); chunkIndex += numChunks; } @@ -1892,9 +1859,8 @@ Win32VolumeAccess::ASPIBlockAccess::ReadBlocks(long startBlock, short blockCount * SCSI doesn't promise it'll be in a chunk size we like, but it's pretty * safe to assume that it'll be at least 512 bytes, and divisible by 512. */ -DIError -Win32VolumeAccess::ASPIBlockAccess::WriteBlocks(long startBlock, short blockCount, - const void* buf) +DIError Win32VolumeAccess::ASPIBlockAccess::WriteBlocks(long startBlock, + short blockCount, const void* buf) { DIError dierr; @@ -1942,7 +1908,7 @@ Win32VolumeAccess::ASPIBlockAccess::WriteBlocks(long startBlock, short blockCoun thisNumBlocks * kBlockSize); blockCount -= thisNumBlocks; - buf = (const unsigned char*) buf + (thisNumBlocks * kBlockSize); + buf = (const uint8_t*) buf + (thisNumBlocks * kBlockSize); chunkOffset = 0; chunkIndex++; @@ -1958,7 +1924,7 @@ Win32VolumeAccess::ASPIBlockAccess::WriteBlocks(long startBlock, short blockCoun return dierr; blockCount -= numChunks * kFactor; - buf = (const unsigned char*) buf + (numChunks * fChunkSize); + buf = (const uint8_t*) buf + (numChunks * fChunkSize); chunkIndex += numChunks; } @@ -1988,8 +1954,7 @@ Win32VolumeAccess::ASPIBlockAccess::Close(void) /* * Determine whether we're holding a block in the cache. */ -bool -CBCache::IsBlockInCache(long blockNum) const +bool CBCache::IsBlockInCache(long blockNum) const { if (fFirstBlock == kEmpty) return false; @@ -2004,8 +1969,7 @@ CBCache::IsBlockInCache(long blockNum) const /* * Retrieve a single block from the cache. */ -DIError -CBCache::GetFromCache(long blockNum, void* buf) +DIError CBCache::GetFromCache(long blockNum, void* buf) { if (!IsBlockInCache(blockNum)) { assert(false); @@ -2025,8 +1989,7 @@ CBCache::GetFromCache(long blockNum, void* buf) * criteria: (1) there must actually be room at the end, and (2) the * block in question must be the next consecutive block. */ -bool -CBCache::IsRoomInCache(long blockNum) const +bool CBCache::IsRoomInCache(long blockNum) const { if (fFirstBlock == kEmpty) return true; @@ -2055,8 +2018,7 @@ CBCache::IsRoomInCache(long blockNum) const * they're trying to overwrite dirty cached data with the result of a new * read, which is a bug. Trap it here. */ -DIError -CBCache::PutInCache(long blockNum, const void* buf, bool isDirty) +DIError CBCache::PutInCache(long blockNum, const void* buf, bool isDirty) { int blockOffset = -1; if (!IsRoomInCache(blockNum)) { @@ -2101,8 +2063,7 @@ CBCache::PutInCache(long blockNum, const void* buf, bool isDirty) /* * Determine whether there are any dirty blocks in the cache. */ -bool -CBCache::IsDirty(void) const +bool CBCache::IsDirty(void) const { if (fFirstBlock == kEmpty) return false; @@ -2123,8 +2084,7 @@ CBCache::IsDirty(void) const * Return a pointer to the cache goodies, so that the object sitting * on the disk hardware can write our stuff. */ -void -CBCache::GetCachePointer(long* pFirstBlock, int* pNumBlocks, void** pBuf) const +void CBCache::GetCachePointer(long* pFirstBlock, int* pNumBlocks, void** pBuf) const { assert(fFirstBlock != kEmpty); // not essential, but why call here if not? @@ -2136,8 +2096,7 @@ CBCache::GetCachePointer(long* pFirstBlock, int* pNumBlocks, void** pBuf) const /* * Clear all the dirty flags. */ -void -CBCache::Scrub(void) +void CBCache::Scrub(void) { if (fFirstBlock == kEmpty) return; @@ -2149,15 +2108,14 @@ CBCache::Scrub(void) /* * Trash all of our entries. If any are dirty, scream bloody murder. */ -void -CBCache::Purge(void) +void CBCache::Purge(void) { if (fFirstBlock == kEmpty) return; if (IsDirty()) { // Should only happen after a write failure causes us to clean up. - LOGI("HEY: CBCache purging dirty blocks!"); + LOGE("HEY: CBCache purging dirty blocks!"); //assert(false); } Scrub(); @@ -2166,5 +2124,4 @@ CBCache::Purge(void) fNumBlocks = 0; } - #endif /*_WIN32*/ diff --git a/diskimg/diskimg.vcxproj b/diskimg/diskimg.vcxproj index b5c3dbe..b83ef68 100644 --- a/diskimg/diskimg.vcxproj +++ b/diskimg/diskimg.vcxproj @@ -45,13 +45,13 @@ $(SolutionDir)$(Configuration)\ $(Configuration)\ false - diskimg4 + diskimg5 $(SolutionDir)$(Configuration)\ $(Configuration)\ true - diskimg4 + diskimg5 diff --git a/mdc/Main.cpp b/mdc/Main.cpp index 106451a..418115b 100644 --- a/mdc/Main.cpp +++ b/mdc/Main.cpp @@ -599,7 +599,8 @@ MainWindow::ScanDiskImage(const WCHAR* pathName, ScanOpts* pScanOpts) ext.Delete(0, 1); } - dierr = diskImg.OpenImage(pathName, '\\', true); + CStringA pathNameA(pathName); + dierr = diskImg.OpenImage(pathNameA, '\\', true); if (dierr != kDIErrNone) { errMsg.Format(L"Unable to open '%ls': %hs", pathName, DiskImgLib::DIStrError(dierr));