diff --git a/source/Disk.cpp b/source/Disk.cpp index 87c43e15..3b78ddb1 100644 --- a/source/Disk.cpp +++ b/source/Disk.cpp @@ -57,8 +57,31 @@ BOOL enhancedisk = 1; // TODO: Make static & add accessor funcs // Private ________________________________________________________________________________________ +struct Drive_t +{ + int phase; + int track; + DWORD spinning; + DWORD writelight; + Disk_t disk; + + Drive_t() + { + clear(); + } + + void clear() + { + phase = 0; + track = 0; + spinning = 0; + writelight = 0; + disk.clear(); + } +}; + static WORD currdrive = 0; -static Disk_t g_aFloppyDisk[NUM_DRIVES]; +static Drive_t g_aFloppyDrive[NUM_DRIVES]; static BYTE floppylatch = 0; static BOOL floppymotoron = 0; static BOOL floppyloadmode = 0; // for efficiency this is not used; it's extremely unlikely to affect emulation (nickw) @@ -82,31 +105,31 @@ static LPCTSTR DiskGetFullPathName(const int iDrive); //=========================================================================== int DiskGetCurrentDrive(void) { return currdrive; } -int DiskGetCurrentTrack(void) { return g_aFloppyDisk[currdrive].track; } -int DiskGetCurrentPhase(void) { return g_aFloppyDisk[currdrive].phase; } -int DiskGetCurrentOffset(void) { return g_aFloppyDisk[currdrive].byte; } -int DiskGetTrack( int drive ) { return g_aFloppyDisk[ drive ].track; } +int DiskGetCurrentTrack(void) { return g_aFloppyDrive[currdrive].track; } +int DiskGetCurrentPhase(void) { return g_aFloppyDrive[currdrive].phase; } +int DiskGetCurrentOffset(void) { return g_aFloppyDrive[currdrive].disk.byte; } +int DiskGetTrack( int drive ) { return g_aFloppyDrive[ drive ].track; } const char* DiskGetDiskPathFilename(const int iDrive) { - return g_aFloppyDisk[iDrive].fullname; + return g_aFloppyDrive[iDrive].disk.fullname; } const char* DiskGetCurrentState(void) { - if (g_aFloppyDisk[currdrive].imagehandle == NULL) + if (g_aFloppyDrive[currdrive].disk.imagehandle == NULL) return "Empty"; if (!floppymotoron) { - if (g_aFloppyDisk[currdrive].spinning > 0) + if (g_aFloppyDrive[currdrive].spinning > 0) return "Off (spinning)"; else return "Off"; } else if (floppywritemode) { - if (g_aFloppyDisk[currdrive].bWriteProtected) + if (g_aFloppyDrive[currdrive].disk.bWriteProtected) return "Writing (write protected)"; else return "Writing"; @@ -115,7 +138,7 @@ const char* DiskGetCurrentState(void) { /*if (floppyloadmode) { - if (g_aFloppyDisk[currdrive].bWriteProtected) + if (g_aFloppyDrive[currdrive].bWriteProtected) return "Reading write protect state (write protected)"; else return "Reading write protect state (not write protected)"; @@ -158,7 +181,7 @@ void Disk_SaveLastDiskImage(const int iDrive) if (!g_bSaveDiskImage) return; - const char *pFileName = g_aFloppyDisk[iDrive].fullname; + const char *pFileName = g_aFloppyDrive[iDrive].disk.fullname; if (iDrive == DRIVE_1) RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName); @@ -182,10 +205,10 @@ void Disk_SaveLastDiskImage(const int iDrive) // Called by DiskControlMotor() & DiskEnable() static void CheckSpinning(const ULONG nCyclesLeft) { - DWORD modechange = (floppymotoron && !g_aFloppyDisk[currdrive].spinning); + DWORD modechange = (floppymotoron && !g_aFloppyDrive[currdrive].spinning); if (floppymotoron) - g_aFloppyDisk[currdrive].spinning = SPINNING_CYCLES; + g_aFloppyDrive[currdrive].spinning = SPINNING_CYCLES; if (modechange) FrameDrawDiskLEDS( (HDC)0 ); @@ -204,20 +227,22 @@ static Disk_Status_e GetDriveLightStatus(const int iDrive) { if (IsDriveValid( iDrive )) { - Disk_t *pFloppy = & g_aFloppyDisk[ iDrive ]; + Drive_t* pDrive = &g_aFloppyDrive[ iDrive ]; - if (pFloppy->spinning) + if (pDrive->spinning) { - if (pFloppy->bWriteProtected) + if (pDrive->disk.bWriteProtected) return DISK_STATUS_PROT; - if (pFloppy->writelight) + if (pDrive->writelight) return DISK_STATUS_WRITE; else return DISK_STATUS_READ; } else + { return DISK_STATUS_OFF; + } } return DISK_STATUS_OFF; @@ -234,8 +259,8 @@ static bool IsDriveValid(const int iDrive) static void AllocTrack(const int iDrive) { - Disk_t * fptr = &g_aFloppyDisk[iDrive]; - fptr->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE); + Drive_t* pDrive = &g_aFloppyDrive[iDrive]; + pDrive->disk.trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE); } //=========================================================================== @@ -245,26 +270,27 @@ static void ReadTrack(const int iDrive) if (! IsDriveValid( iDrive )) return; - Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ]; + Drive_t* pDrive = &g_aFloppyDrive[ iDrive ]; + Disk_t* pFloppy = &pDrive->disk; - if (pFloppy->track >= ImageGetNumTracks(pFloppy->imagehandle)) + if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle)) { pFloppy->trackimagedata = 0; return; } - if (! pFloppy->trackimage) + if (!pFloppy->trackimage) AllocTrack( iDrive ); if (pFloppy->trackimage && pFloppy->imagehandle) { #if LOG_DISK_TRACKS - LOG_DISK("track $%02X%s read\r\n", pFloppy->track, (pFloppy->phase & 1) ? ".5" : " "); + LOG_DISK("track $%02X%s read\r\n", pDrive->track, (pDrive->phase & 1) ? ".5" : " "); #endif ImageReadTrack( pFloppy->imagehandle, - pFloppy->track, - pFloppy->phase, + pDrive->track, + pDrive->phase, pFloppy->trackimage, &pFloppy->nibbles); @@ -277,7 +303,7 @@ static void ReadTrack(const int iDrive) void DiskFlushCurrentTrack(const int iDrive) { - Disk_t *pFloppy = &g_aFloppyDisk[iDrive]; + Disk_t* pFloppy = &g_aFloppyDrive[iDrive].disk; if (pFloppy->trackimage && pFloppy->trackimagedirty) WriteTrack(iDrive); @@ -287,7 +313,7 @@ void DiskFlushCurrentTrack(const int iDrive) static void RemoveDisk(const int iDrive) { - Disk_t *pFloppy = &g_aFloppyDisk[iDrive]; + Disk_t* pFloppy = &g_aFloppyDrive[iDrive].disk; if (pFloppy->imagehandle) { @@ -299,7 +325,7 @@ static void RemoveDisk(const int iDrive) if (pFloppy->trackimage) { - VirtualFree(pFloppy->trackimage,0,MEM_RELEASE); + VirtualFree(pFloppy->trackimage, 0, MEM_RELEASE); pFloppy->trackimage = NULL; pFloppy->trackimagedata = 0; } @@ -316,9 +342,10 @@ static void RemoveDisk(const int iDrive) static void WriteTrack(const int iDrive) { - Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ]; + Drive_t* pDrive = &g_aFloppyDrive[ iDrive ]; + Disk_t* pFloppy = &pDrive->disk; - if (pFloppy->track >= ImageGetNumTracks(pFloppy->imagehandle)) + if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle)) return; if (pFloppy->bWriteProtected) @@ -327,12 +354,12 @@ static void WriteTrack(const int iDrive) if (pFloppy->trackimage && pFloppy->imagehandle) { #if LOG_DISK_TRACKS - LOG_DISK("track $%02X%s write\r\n", pFloppy->track, (pFloppy->phase & 0) ? ".5" : " "); // TODO: hard-coded to whole tracks - see below (nickw) + LOG_DISK("track $%02X%s write\r\n", pDrive->track, (pDrive->phase & 0) ? ".5" : " "); // TODO: hard-coded to whole tracks - see below (nickw) #endif ImageWriteTrack( pFloppy->imagehandle, - pFloppy->track, - pFloppy->phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw) + pDrive->track, + pDrive->phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw) pFloppy->trackimage, pFloppy->nibbles); } @@ -350,7 +377,7 @@ void DiskBoot(void) { // THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE. // IF A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING. - if (g_aFloppyDisk[0].imagehandle && ImageBoot(g_aFloppyDisk[0].imagehandle)) + if (g_aFloppyDrive[0].disk.imagehandle && ImageBoot(g_aFloppyDrive[0].disk.imagehandle)) floppymotoron = 0; } @@ -376,11 +403,12 @@ static void __stdcall DiskControlMotor(WORD, WORD address, BYTE, BYTE, ULONG uEx static void __stdcall DiskControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles) { - Disk_t * fptr = &g_aFloppyDisk[currdrive]; + Drive_t* pDrive = &g_aFloppyDrive[currdrive]; + Disk_t* pFloppy = &pDrive->disk; if (!floppymotoron) // GH#525 { - if (!fptr->spinning) + if (!pDrive->spinning) { #if LOG_DISK_PHASES LOG_DISK("stepper accessed whilst motor is off and not spinning\r\n"); @@ -415,23 +443,23 @@ static void __stdcall DiskControlStepper(WORD, WORD address, BYTE, BYTE, ULONG u // - do not move if both adjacent magnets are on // momentum and timing are not accounted for ... maybe one day! int direction = 0; - if (phases & (1 << ((fptr->phase + 1) & 3))) + if (phases & (1 << ((pDrive->phase + 1) & 3))) direction += 1; - if (phases & (1 << ((fptr->phase + 3) & 3))) + if (phases & (1 << ((pDrive->phase + 3) & 3))) direction -= 1; // apply magnet step, if any if (direction) { - fptr->phase = MAX(0, MIN(79, fptr->phase + direction)); - const int nNumTracksInImage = ImageGetNumTracks(fptr->imagehandle); + pDrive->phase = MAX(0, MIN(79, pDrive->phase + direction)); + const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle); const int newtrack = (nNumTracksInImage == 0) ? 0 - : MIN(nNumTracksInImage-1, fptr->phase >> 1); // (round half tracks down) - if (newtrack != fptr->track) + : MIN(nNumTracksInImage-1, pDrive->phase >> 1); // (round half tracks down) + if (newtrack != pDrive->track) { DiskFlushCurrentTrack(currdrive); - fptr->track = newtrack; - fptr->trackimagedata = 0; + pDrive->track = newtrack; + pFloppy->trackimagedata = 0; g_formatTrack.DriveNotWritingTrack(); } @@ -446,8 +474,8 @@ static void __stdcall DiskControlStepper(WORD, WORD address, BYTE, BYTE, ULONG u #if LOG_DISK_PHASES LOG_DISK("track $%02X%s phases %d%d%d%d phase %d %s address $%4X\r\n", - fptr->phase >> 1, - (fptr->phase & 1) ? ".5" : " ", + pDrive->phase >> 1, + (pDrive->phase & 1) ? ".5" : " ", (phases >> 3) & 1, (phases >> 2) & 1, (phases >> 1) & 1, @@ -479,8 +507,8 @@ static void __stdcall DiskEnable(WORD, WORD address, BYTE, BYTE, ULONG uExecuted #if LOG_DISK_ENABLE_DRIVE LOG_DISK("enable drive: %d\r\n", currdrive); #endif - g_aFloppyDisk[!currdrive].spinning = 0; - g_aFloppyDisk[!currdrive].writelight = 0; + g_aFloppyDrive[!currdrive].spinning = 0; + g_aFloppyDrive[!currdrive].writelight = 0; CheckSpinning(uExecutedCycles); } @@ -500,39 +528,39 @@ void DiskEject(const int iDrive) // . Used by Property Sheet Page (Disk) LPCTSTR DiskGetFullName(const int iDrive) { - return g_aFloppyDisk[iDrive].fullname; + return g_aFloppyDrive[iDrive].disk.fullname; } // Return the filename // . Used by Drive Buttons' tooltips LPCTSTR DiskGetFullDiskFilename(const int iDrive) { - if (!g_aFloppyDisk[iDrive].strFilenameInZip.empty()) - return g_aFloppyDisk[iDrive].strFilenameInZip.c_str(); + if (!g_aFloppyDrive[iDrive].disk.strFilenameInZip.empty()) + return g_aFloppyDrive[iDrive].disk.strFilenameInZip.c_str(); return DiskGetFullName(iDrive); } static LPCTSTR DiskGetFullPathName(const int iDrive) { - return ImageGetPathname(g_aFloppyDisk[iDrive].imagehandle); + return ImageGetPathname(g_aFloppyDrive[iDrive].disk.imagehandle); } // Return the imagename // . Used by Drive Button's icons & Property Sheet Page (Save snapshot) LPCTSTR DiskGetBaseName(const int iDrive) { - return g_aFloppyDisk[iDrive].imagename; + return g_aFloppyDrive[iDrive].disk.imagename; } //=========================================================================== -void DiskGetLightStatus(Disk_Status_e *pDisk1Status_, Disk_Status_e *pDisk2Status_) +void DiskGetLightStatus(Disk_Status_e *pDisk1Status, Disk_Status_e *pDisk2Status) { - if (pDisk1Status_) - *pDisk1Status_ = GetDriveLightStatus( 0 ); + if (pDisk1Status) + *pDisk1Status = GetDriveLightStatus(DRIVE_1); - if (pDisk2Status_) - *pDisk2Status_ = GetDriveLightStatus( 1 ); + if (pDisk2Status) + *pDisk2Status = GetDriveLightStatus(DRIVE_2); } //=========================================================================== @@ -541,32 +569,34 @@ void DiskInitialize(void) { int loop = NUM_DRIVES; while (loop--) - g_aFloppyDisk[loop].clear(); + g_aFloppyDrive[loop].clear(); } //=========================================================================== ImageError_e DiskInsert(const int iDrive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary) { - Disk_t * fptr = &g_aFloppyDisk[iDrive]; - if (fptr->imagehandle) + Drive_t* pDrive = &g_aFloppyDrive[iDrive]; + Disk_t* pFloppy = &pDrive->disk; + + if (pFloppy->imagehandle) RemoveDisk(iDrive); // Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon) // . Changing the disk (in the drive) doesn't affect the drive's head etc. { - int track = fptr->track; - int phase = fptr->phase; - fptr->clear(); - fptr->track = track; - fptr->phase = phase; + int track = pDrive->track; + int phase = pDrive->phase; + pDrive->clear(); + pDrive->track = track; + pDrive->phase = phase; } const DWORD dwAttributes = GetFileAttributes(pszImageFilename); if(dwAttributes == INVALID_FILE_ATTRIBUTES) - fptr->bWriteProtected = false; // Assume this is a new file to create + pFloppy->bWriteProtected = false; // Assume this is a new file to create else - fptr->bWriteProtected = bForceWriteProtected ? true : (dwAttributes & FILE_ATTRIBUTE_READONLY); + pFloppy->bWriteProtected = bForceWriteProtected ? true : (dwAttributes & FILE_ATTRIBUTE_READONLY); // Check if image is being used by the other drive, and if so remove it in order so it can be swapped { @@ -585,16 +615,16 @@ ImageError_e DiskInsert(const int iDrive, LPCTSTR pszImageFilename, const bool b } ImageError_e Error = ImageOpen(pszImageFilename, - &fptr->imagehandle, - &fptr->bWriteProtected, + &pFloppy->imagehandle, + &pFloppy->bWriteProtected, bCreateIfNecessary, - fptr->strFilenameInZip); + pFloppy->strFilenameInZip); - if (Error == eIMAGE_ERROR_NONE && ImageIsMultiFileZip(fptr->imagehandle)) + if (Error == eIMAGE_ERROR_NONE && ImageIsMultiFileZip(pFloppy->imagehandle)) { TCHAR szText[100+MAX_PATH]; szText[sizeof(szText)-1] = 0; - _snprintf(szText, sizeof(szText)-1, "Only the first file in a multi-file zip is supported\nUse disk image '%s' ?", fptr->strFilenameInZip.c_str()); + _snprintf(szText, sizeof(szText)-1, "Only the first file in a multi-file zip is supported\nUse disk image '%s' ?", pFloppy->strFilenameInZip.c_str()); int nRes = MessageBox(g_hFrameWindow, szText, TEXT("Multi-Zip Warning"), MB_ICONWARNING | MB_YESNO | MB_SETFOREGROUND); if (nRes == IDNO) { @@ -605,8 +635,8 @@ ImageError_e DiskInsert(const int iDrive, LPCTSTR pszImageFilename, const bool b if (Error == eIMAGE_ERROR_NONE) { - GetImageTitle(pszImageFilename, fptr->imagename, fptr->fullname); - Video_ResetScreenshotCounter(fptr->imagename); + GetImageTitle(pszImageFilename, pFloppy->imagename, pFloppy->fullname); + Video_ResetScreenshotCounter(pFloppy->imagename); } else { @@ -689,7 +719,7 @@ void DiskNotifyInvalidImage(const int iDrive, LPCTSTR pszImageFilename, const Im TEXT("first file (%s) in this multi-zip archive is not recognized.\n") TEXT("Try unzipping and using the disk images directly.\n"), pszImageFilename, - g_aFloppyDisk[iDrive].strFilenameInZip.c_str()); + g_aFloppyDrive[iDrive].disk.strFilenameInZip.c_str()); break; case eIMAGE_ERROR_GZ: @@ -745,10 +775,10 @@ bool DiskGetProtect(const int iDrive) { if (IsDriveValid(iDrive)) { - Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ]; - if (pFloppy->bWriteProtected) + if (g_aFloppyDrive[iDrive].disk.bWriteProtected) return true; } + return false; } @@ -759,8 +789,7 @@ void DiskSetProtect(const int iDrive, const bool bWriteProtect) { if (IsDriveValid( iDrive )) { - Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ]; - pFloppy->bWriteProtected = bWriteProtect; + g_aFloppyDrive[iDrive].disk.bWriteProtected = bWriteProtect; } } @@ -772,8 +801,7 @@ bool Disk_ImageIsWriteProtected(const int iDrive) if (!IsDriveValid(iDrive)) return true; - Disk_t *pFloppy = &g_aFloppyDisk[iDrive]; - return ImageIsWriteProtected(pFloppy->imagehandle); + return ImageIsWriteProtected(g_aFloppyDrive[iDrive].disk.imagehandle); } //=========================================================================== @@ -783,8 +811,7 @@ bool Disk_IsDriveEmpty(const int iDrive) if (!IsDriveValid(iDrive)) return true; - Disk_t *pFloppy = &g_aFloppyDisk[iDrive]; - return pFloppy->imagehandle == NULL; + return g_aFloppyDrive[iDrive].disk.imagehandle == NULL; } //=========================================================================== @@ -826,12 +853,13 @@ static bool LogWriteCheckSyncFF(ULONG& uCycleDelta) static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft) { /* floppyloadmode = 0; */ - Disk_t * fptr = &g_aFloppyDisk[currdrive]; + Drive_t* pDrive = &g_aFloppyDrive[currdrive]; + Disk_t* pFloppy = &pDrive->disk; - if (!fptr->trackimagedata && fptr->imagehandle) + if (!pFloppy->trackimagedata && pFloppy->imagehandle) ReadTrack(currdrive); - if (!fptr->trackimagedata) + if (!pFloppy->trackimagedata) { floppylatch = 0xFF; return; @@ -841,7 +869,7 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO UINT uSpinNibbleCount = 0; CpuCalcCycles(nCyclesLeft); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF() - if (!enhancedisk && fptr->spinning) + if (!enhancedisk && pDrive->spinning) { const ULONG nCycleDiff = (ULONG) (g_nCumulativeCycles - g_uDiskLastCycle); g_uDiskLastCycle = g_nCumulativeCycles; @@ -851,13 +879,13 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO // 40 cycles for a write of a 10-bit 0xFF sync byte uSpinNibbleCount = nCycleDiff >> 5; // ...but divide by 32 (not 40) - ULONG uWrapOffset = uSpinNibbleCount % fptr->nibbles; - fptr->byte += uWrapOffset; - if (fptr->byte >= fptr->nibbles) - fptr->byte -= fptr->nibbles; + ULONG uWrapOffset = uSpinNibbleCount % pFloppy->nibbles; + pFloppy->byte += uWrapOffset; + if (pFloppy->byte >= pFloppy->nibbles) + pFloppy->byte -= pFloppy->nibbles; #if LOG_DISK_NIBBLES_SPIN - UINT uCompleteRevolutions = uSpinNibbleCount / fptr->nibbles; + UINT uCompleteRevolutions = uSpinNibbleCount / pFloppy->nibbles; LOG_DISK("spin: revs=%d, nibbles=%d\r\n", uCompleteRevolutions, uWrapOffset); #endif } @@ -867,23 +895,23 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO // but Sherwood Forest sets shift mode and reads with the drive off, so don't check for now if (!floppywritemode) { - floppylatch = *(fptr->trackimage + fptr->byte); + floppylatch = *(pFloppy->trackimage + pFloppy->byte); #if LOG_DISK_NIBBLES_READ #if LOG_DISK_NIBBLES_USE_RUNTIME_VAR if (g_bLogDisk_NibblesRW) #endif { - LOG_DISK("read %04X = %02X\r\n", fptr->byte, floppylatch); + LOG_DISK("read %04X = %02X\r\n", pFloppy->byte, floppylatch); } g_formatTrack.DecodeLatchNibbleRead(floppylatch); #endif } - else if (!fptr->bWriteProtected) // && floppywritemode + else if (!pFloppy->bWriteProtected) // && floppywritemode { - *(fptr->trackimage + fptr->byte) = floppylatch; - fptr->trackimagedirty = 1; + *(pFloppy->trackimage + pFloppy->byte) = floppylatch; + pFloppy->trackimagedirty = 1; bool bIsSyncFF = false; #if LOG_DISK_NIBBLES_WRITE @@ -891,7 +919,7 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO bIsSyncFF = LogWriteCheckSyncFF(uCycleDelta); #endif - g_formatTrack.DecodeLatchNibbleWrite(floppylatch, uSpinNibbleCount, fptr, bIsSyncFF); // GH#125 + g_formatTrack.DecodeLatchNibbleWrite(floppylatch, uSpinNibbleCount, pFloppy, bIsSyncFF); // GH#125 #if LOG_DISK_NIBBLES_WRITE #if LOG_DISK_NIBBLES_USE_RUNTIME_VAR @@ -899,20 +927,20 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO #endif { if (!bIsSyncFF) - LOG_DISK("write %04X = %02X (cy=+%d)\r\n", fptr->byte, floppylatch, uCycleDelta); + LOG_DISK("write %04X = %02X (cy=+%d)\r\n", pFloppy->byte, floppylatch, uCycleDelta); else - LOG_DISK("write %04X = %02X (cy=+%d) sync #%d\r\n", fptr->byte, floppylatch, uCycleDelta, g_uSyncFFCount); + LOG_DISK("write %04X = %02X (cy=+%d) sync #%d\r\n", pFloppy->byte, floppylatch, uCycleDelta, g_uSyncFFCount); } #endif } - if (++fptr->byte >= fptr->nibbles) - fptr->byte = 0; + if (++pFloppy->byte >= pFloppy->nibbles) + pFloppy->byte = 0; // Feature Request #201 Show track status // https://github.com/AppleWin/AppleWin/issues/201 // NB. Prevent flooding of forcing UI to redraw!!! - if( ((fptr->byte) & 0xFF) == 0 ) + if( ((pFloppy->byte) & 0xFF) == 0 ) FrameDrawDiskStatus( (HDC)0 ); } @@ -931,10 +959,10 @@ void DiskReset(const bool bIsPowerCycle/*=false*/) if (bIsPowerCycle) // GH#460 { - g_aFloppyDisk[DRIVE_1].spinning = 0; - g_aFloppyDisk[DRIVE_1].writelight = 0; - g_aFloppyDisk[DRIVE_2].spinning = 0; - g_aFloppyDisk[DRIVE_2].writelight = 0; + g_aFloppyDrive[DRIVE_1].spinning = 0; + g_aFloppyDrive[DRIVE_1].writelight = 0; + g_aFloppyDrive[DRIVE_2].spinning = 0; + g_aFloppyDrive[DRIVE_2].writelight = 0; FrameRefreshStatus(DRAW_LEDS, false); } @@ -1012,7 +1040,7 @@ static void __stdcall DiskLoadWriteProtect(WORD, WORD, BYTE write, BYTE value, U // . write mode doesn't prevent reading write protect (GH#537): // "If for some reason the above write protect check were entered with the READ/WRITE switch in WRITE, // the write protect switch would still be read correctly" (UTAIIe page 9-21) - if (g_aFloppyDisk[currdrive].bWriteProtected) + if (g_aFloppyDrive[currdrive].disk.bWriteProtected) floppylatch |= 0x80; else floppylatch &= 0x7F; @@ -1025,7 +1053,7 @@ static void __stdcall DiskSetReadMode(WORD, WORD, BYTE, BYTE, ULONG) { floppywritemode = 0; - g_formatTrack.DriveSwitchedToReadMode(&g_aFloppyDisk[currdrive]); + g_formatTrack.DriveSwitchedToReadMode(&g_aFloppyDrive[currdrive].disk); #if LOG_DISK_RW_MODE LOG_DISK("rw mode: read\r\n"); @@ -1038,9 +1066,9 @@ static void __stdcall DiskSetWriteMode(WORD, WORD, BYTE, BYTE, ULONG uExecutedCy { floppywritemode = 1; - g_formatTrack.DriveSwitchedToWriteMode(g_aFloppyDisk[currdrive].byte); + g_formatTrack.DriveSwitchedToWriteMode(g_aFloppyDrive[currdrive].disk.byte); - BOOL modechange = !g_aFloppyDisk[currdrive].writelight; + BOOL modechange = !g_aFloppyDrive[currdrive].writelight; #if LOG_DISK_RW_MODE LOG_DISK("rw mode: write (mode changed=%d)\r\n", modechange ? 1 : 0); #endif @@ -1048,7 +1076,7 @@ static void __stdcall DiskSetWriteMode(WORD, WORD, BYTE, BYTE, ULONG uExecutedCy g_uWriteLastCycle = 0; #endif - g_aFloppyDisk[currdrive].writelight = WRITELIGHT_CYCLES; + g_aFloppyDrive[currdrive].writelight = WRITELIGHT_CYCLES; if (modechange) FrameDrawDiskLEDS( (HDC)0 ); @@ -1061,24 +1089,24 @@ void DiskUpdateDriveState(DWORD cycles) int loop = NUM_DRIVES; while (loop--) { - Disk_t * fptr = &g_aFloppyDisk[loop]; + Drive_t* pDrive = &g_aFloppyDrive[loop]; - if (fptr->spinning && !floppymotoron) + if (pDrive->spinning && !floppymotoron) { - if (!(fptr->spinning -= MIN(fptr->spinning, cycles))) + if (!(pDrive->spinning -= MIN(pDrive->spinning, cycles))) { FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskStatus( (HDC)0 ); } } - if (floppywritemode && (currdrive == loop) && fptr->spinning) + if (floppywritemode && (currdrive == loop) && pDrive->spinning) { - fptr->writelight = WRITELIGHT_CYCLES; + pDrive->writelight = WRITELIGHT_CYCLES; } - else if (fptr->writelight) + else if (pDrive->writelight) { - if (!(fptr->writelight -= MIN(fptr->writelight, cycles))) + if (!(pDrive->writelight -= MIN(pDrive->writelight, cycles))) { FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskStatus( (HDC)0 ); @@ -1093,7 +1121,7 @@ bool DiskDriveSwap(void) { // Refuse to swap if either Disk][ is active // TODO: if Shift-Click then FORCE drive swap to bypass message - if(g_aFloppyDisk[0].spinning || g_aFloppyDisk[1].spinning) + if (g_aFloppyDrive[0].spinning || g_aFloppyDrive[1].spinning) { // 1.26.2.4 Prompt when trying to swap disks while drive is on instead of silently failing int status = MessageBox( @@ -1126,7 +1154,7 @@ bool DiskDriveSwap(void) // Swap disks between drives // . NB. We swap trackimage ptrs (so don't need to swap the buffers' data) // . TODO: Consider array of Pointers: Disk_t* g_aDrive[] - std::swap(g_aFloppyDisk[0], g_aFloppyDisk[1]); + std::swap(g_aFloppyDrive[0], g_aFloppyDrive[1]); Disk_SaveLastDiskImage(DRIVE_1); Disk_SaveLastDiskImage(DRIVE_2); @@ -1256,7 +1284,7 @@ int DiskSetSnapshot_v1(const SS_CARD_DISK2* const pSS) for(UINT i=0; iUnit[i].szFileName); - g_aFloppyDisk[i].track = pSS->Unit[i].track; - g_aFloppyDisk[i].phase = pSS->Unit[i].phase; - g_aFloppyDisk[i].byte = pSS->Unit[i].byte; -// g_aFloppyDisk[i].writeprotected = pSS->Unit[i].writeprotected; - g_aFloppyDisk[i].trackimagedata = pSS->Unit[i].trackimagedata; - g_aFloppyDisk[i].trackimagedirty = pSS->Unit[i].trackimagedirty; - g_aFloppyDisk[i].spinning = pSS->Unit[i].spinning; - g_aFloppyDisk[i].writelight = pSS->Unit[i].writelight; - g_aFloppyDisk[i].nibbles = pSS->Unit[i].nibbles; +// strcpy(g_aFloppyDrive[i].fullname, pSS->Unit[i].szFileName); + g_aFloppyDrive[i].track = pSS->Unit[i].track; + g_aFloppyDrive[i].phase = pSS->Unit[i].phase; + g_aFloppyDrive[i].spinning = pSS->Unit[i].spinning; + g_aFloppyDrive[i].writelight = pSS->Unit[i].writelight; + + g_aFloppyDrive[i].disk.byte = pSS->Unit[i].byte; +// g_aFloppyDrive[i].disk.writeprotected = pSS->Unit[i].writeprotected; + g_aFloppyDrive[i].disk.trackimagedata = pSS->Unit[i].trackimagedata ? true : false; + g_aFloppyDrive[i].disk.trackimagedirty = pSS->Unit[i].trackimagedirty ? true : false; + g_aFloppyDrive[i].disk.nibbles = pSS->Unit[i].nibbles; // if(!bImageError) { - if((g_aFloppyDisk[i].trackimage == NULL) && g_aFloppyDisk[i].nibbles) + if((g_aFloppyDrive[i].disk.trackimage == NULL) && g_aFloppyDrive[i].disk.nibbles) AllocTrack(i); - if(g_aFloppyDisk[i].trackimage == NULL) + if(g_aFloppyDrive[i].disk.trackimage == NULL) bImageError = true; else - memcpy(g_aFloppyDisk[i].trackimage, pSS->Unit[i].nTrack, NIBBLES_PER_TRACK); + memcpy(g_aFloppyDrive[i].disk.trackimage, pSS->Unit[i].nTrack, NIBBLES_PER_TRACK); } if(bImageError) { - g_aFloppyDisk[i].trackimagedata = 0; - g_aFloppyDisk[i].trackimagedirty = 0; - g_aFloppyDisk[i].nibbles = 0; + g_aFloppyDrive[i].disk.trackimagedata = 0; + g_aFloppyDrive[i].disk.trackimagedirty = 0; + g_aFloppyDrive[i].disk.nibbles = 0; } } @@ -1363,21 +1392,21 @@ std::string DiskGetSnapshotCardName(void) static void DiskSaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit) { YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit); - yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, g_aFloppyDisk[unit].fullname); - yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, g_aFloppyDisk[unit].track); - yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, g_aFloppyDisk[unit].phase); - yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, g_aFloppyDisk[unit].byte); - yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, g_aFloppyDisk[unit].bWriteProtected); - yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, g_aFloppyDisk[unit].spinning); - yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, g_aFloppyDisk[unit].writelight); - yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, g_aFloppyDisk[unit].nibbles); - yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, g_aFloppyDisk[unit].trackimagedata); - yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, g_aFloppyDisk[unit].trackimagedirty); + yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, g_aFloppyDrive[unit].disk.fullname); + yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, g_aFloppyDrive[unit].track); + yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, g_aFloppyDrive[unit].phase); + yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, g_aFloppyDrive[unit].disk.byte); + yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, g_aFloppyDrive[unit].disk.bWriteProtected); + yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, g_aFloppyDrive[unit].spinning); + yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, g_aFloppyDrive[unit].writelight); + yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, g_aFloppyDrive[unit].disk.nibbles); + yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, g_aFloppyDrive[unit].disk.trackimagedata); + yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, g_aFloppyDrive[unit].disk.trackimagedirty); - if (g_aFloppyDisk[unit].trackimage) + if (g_aFloppyDrive[unit].disk.trackimage) { YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE); - yamlSaveHelper.SaveMemory(g_aFloppyDisk[unit].trackimage, NIBBLES_PER_TRACK); + yamlSaveHelper.SaveMemory(g_aFloppyDrive[unit].disk.trackimage, NIBBLES_PER_TRACK); } } @@ -1408,9 +1437,9 @@ static void DiskLoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper, UINT unit) bool bImageError = false; - g_aFloppyDisk[unit].fullname[0] = 0; - g_aFloppyDisk[unit].imagename[0] = 0; - g_aFloppyDisk[unit].bWriteProtected = false; // Default to false (until image is successfully loaded below) + g_aFloppyDrive[unit].disk.fullname[0] = 0; + g_aFloppyDrive[unit].disk.imagename[0] = 0; + g_aFloppyDrive[unit].disk.bWriteProtected = false; // Default to false (until image is successfully loaded below) std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME); if (!filename.empty()) @@ -1430,22 +1459,22 @@ static void DiskLoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper, UINT unit) if(DiskInsert(unit, filename.c_str(), dwAttributes & FILE_ATTRIBUTE_READONLY, IMAGE_DONT_CREATE) != eIMAGE_ERROR_NONE) bImageError = true; - // DiskInsert() zeros g_aFloppyDisk[unit], then sets up: + // DiskInsert() zeros g_aFloppyDrive[unit], then sets up: // . imagename // . fullname // . writeprotected } } - g_aFloppyDisk[unit].track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK); - g_aFloppyDisk[unit].phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE); - g_aFloppyDisk[unit].byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE); + g_aFloppyDrive[unit].track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK); + g_aFloppyDrive[unit].phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE); + g_aFloppyDrive[unit].disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE); yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume - g_aFloppyDisk[unit].spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING); - g_aFloppyDisk[unit].writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT); - g_aFloppyDisk[unit].nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES); - g_aFloppyDisk[unit].trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA); - g_aFloppyDisk[unit].trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY); + g_aFloppyDrive[unit].spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING); + g_aFloppyDrive[unit].writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT); + g_aFloppyDrive[unit].disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES); + g_aFloppyDrive[unit].disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false; + g_aFloppyDrive[unit].disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false; std::vector track(NIBBLES_PER_TRACK); if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE)) @@ -1460,20 +1489,20 @@ static void DiskLoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper, UINT unit) if (!filename.empty() && !bImageError) { - if ((g_aFloppyDisk[unit].trackimage == NULL) && g_aFloppyDisk[unit].nibbles) + if ((g_aFloppyDrive[unit].disk.trackimage == NULL) && g_aFloppyDrive[unit].disk.nibbles) AllocTrack(unit); - if (g_aFloppyDisk[unit].trackimage == NULL) + if (g_aFloppyDrive[unit].disk.trackimage == NULL) bImageError = true; else - memcpy(g_aFloppyDisk[unit].trackimage, &track[0], NIBBLES_PER_TRACK); + memcpy(g_aFloppyDrive[unit].disk.trackimage, &track[0], NIBBLES_PER_TRACK); } if (bImageError) { - g_aFloppyDisk[unit].trackimagedata = 0; - g_aFloppyDisk[unit].trackimagedirty = 0; - g_aFloppyDisk[unit].nibbles = 0; + g_aFloppyDrive[unit].disk.trackimagedata = 0; + g_aFloppyDrive[unit].disk.trackimagedirty = 0; + g_aFloppyDrive[unit].disk.nibbles = 0; } } @@ -1503,7 +1532,7 @@ bool DiskLoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT slot, UINT vers for(UINT i=0; i (ie. no extension) - TCHAR fullname [ MAX_DISK_FULL_NAME + 1 ]; // or : This is persisted to the snapshot file + TCHAR imagename[ MAX_DISK_IMAGE_NAME + 1 ]; // (ie. no extension) + TCHAR fullname [ MAX_DISK_FULL_NAME + 1 ]; // or : This is persisted to the snapshot file std::string strFilenameInZip; // "" or ImageInfo* imagehandle; // Init'd by DiskInsert() -> ImageOpen() - bool bWriteProtected; + bool bWriteProtected; // - int track; - LPBYTE trackimage; - int phase; - int byte; - BOOL trackimagedata; - BOOL trackimagedirty; - DWORD spinning; - DWORD writelight; - int nibbles; // Init'd by ReadTrack() -> ImageReadTrack() + int byte; + int nibbles; // Init'd by ReadTrack() -> ImageReadTrack() + LPBYTE trackimage; + bool trackimagedata; + bool trackimagedirty; Disk_t() { @@ -116,14 +112,11 @@ struct Disk_t strFilenameInZip.clear(); imagehandle = NULL; bWriteProtected = false; - track = 0; - trackimage = NULL; - phase = 0; + // byte = 0; - trackimagedata = FALSE; - trackimagedirty = FALSE; - spinning = 0; - writelight = 0; nibbles = 0; + trackimage = NULL; + trackimagedata = false; + trackimagedirty = false; } }; diff --git a/source/DiskFormatTrack.cpp b/source/DiskFormatTrack.cpp index 25e0069d..6f8f05c0 100644 --- a/source/DiskFormatTrack.cpp +++ b/source/DiskFormatTrack.cpp @@ -84,15 +84,15 @@ void FormatTrack::DriveNotWritingTrack(void) #endif } -void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const fptr) +void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const pFloppy) { - if (fptr->bWriteProtected) + if (pFloppy->bWriteProtected) return; if (m_bmWrittenSectorAddrFields == 0x0000) { if (m_WriteTrackStartIndex == (UINT)-1) // waiting for 1st write? - m_WriteTrackStartIndex = fptr->byte; + m_WriteTrackStartIndex = pFloppy->byte; return; } @@ -108,8 +108,8 @@ void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const return; } - UINT uTrackIndex = fptr->byte; - const UINT& kTrackMaxNibbles = fptr->nibbles; + UINT uTrackIndex = pFloppy->byte; + const UINT& kTrackMaxNibbles = pFloppy->nibbles; // NB. spin in write mode is only max 1-2 bytes do @@ -128,7 +128,7 @@ void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const while (uSpinNibbleCount--); } -void FormatTrack::DriveSwitchedToReadMode(Disk_t* const fptr) +void FormatTrack::DriveSwitchedToReadMode(Disk_t* const pFloppy) { if (m_bAddressPrologueIsDOS3_2) { @@ -154,10 +154,10 @@ void FormatTrack::DriveSwitchedToReadMode(Disk_t* const fptr) // So need a track size between 0x18B0 (rounding down) and 0x182F const UINT kShortTrackLen = 0x18B0; - LPBYTE TrackBuffer = fptr->trackimage; - const UINT kLongTrackLen = fptr->nibbles; + LPBYTE TrackBuffer = pFloppy->trackimage; + const UINT kLongTrackLen = pFloppy->nibbles; - UINT uWriteTrackEndIndex = fptr->byte; + UINT uWriteTrackEndIndex = pFloppy->byte; UINT uWrittenTrackSize = m_WriteTrackHasWrapped ? kLongTrackLen : 0; if (m_WriteTrackStartIndex <= uWriteTrackEndIndex) @@ -216,10 +216,10 @@ void FormatTrack::DecodeLatchNibbleRead(BYTE floppylatch) DecodeLatchNibble(floppylatch, false, false); } -void FormatTrack::DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const Disk_t* const fptr, bool bIsSyncFF) +void FormatTrack::DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const Disk_t* const pFloppy, bool bIsSyncFF) { DecodeLatchNibble(floppylatch, true, bIsSyncFF); - UpdateOnWriteLatch(uSpinNibbleCount, fptr); + UpdateOnWriteLatch(uSpinNibbleCount, pFloppy); } void FormatTrack::DecodeLatchNibble(BYTE floppylatch, bool bIsWrite, bool bIsSyncFF) diff --git a/source/DiskFormatTrack.h b/source/DiskFormatTrack.h index 68a1e87e..ad67c0b4 100644 --- a/source/DiskFormatTrack.h +++ b/source/DiskFormatTrack.h @@ -35,15 +35,15 @@ public: void Reset(void); void DriveNotWritingTrack(void); - void DriveSwitchedToReadMode(Disk_t* const fptr); + void DriveSwitchedToReadMode(Disk_t* const pFloppy); void DriveSwitchedToWriteMode(UINT uTrackIndex); void DecodeLatchNibbleRead(BYTE floppylatch); - void DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const Disk_t* const fptr, bool bIsSyncFF); + void DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const Disk_t* const pFloppy, bool bIsSyncFF); void SaveSnapshot(class YamlSaveHelper& yamlSaveHelper); void LoadSnapshot(class YamlLoadHelper& yamlLoadHelper); private: - void UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const fptr); + void UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const pFloppy); void DecodeLatchNibble(BYTE floppylatch, bool bIsWrite, bool bIsSyncFF); BYTE m_VolTrkSecChk[4];