Apple-2-Tools/AppleWin
1
0
Fork 0
mirror of https://github.com/AppleWin/AppleWin.git synced 2024-06-26 01:29:30 +00:00
Code Issues Projects Releases Wiki Activity

Rename Disk_t to FloppyDisk; and prefix members

Browse Source
This commit is contained in:
tomcw 2019-04-14 16:58:49 +01:00
parent cd62b82af4
commit 1f846fa26f
5 changed files with 145 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

216
source/Disk.cpp
View File

@ -84,12 +84,12 @@ void DiskIIInterfaceCard::SetEnhanceDisk(bool bEnhanceDisk) { m_enhanceDisk = bE
int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; } int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; }
int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].m_track; } int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].m_track; }
int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].m_phase; } int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].m_phase; }
int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].m_disk.byte; } int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].m_disk.m_byte; }
int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].m_track; } int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].m_track; }
LPCTSTR DiskIIInterfaceCard::GetCurrentState(void) LPCTSTR DiskIIInterfaceCard::GetCurrentState(void)
{ {
if (m_floppyDrive[m_currDrive].m_disk.imagehandle == NULL) if (m_floppyDrive[m_currDrive].m_disk.m_imagehandle == NULL)
return "Empty"; return "Empty";
if (!m_floppyMotorOn) if (!m_floppyMotorOn)
@ -101,7 +101,7 @@ LPCTSTR DiskIIInterfaceCard::GetCurrentState(void)
} }
else if (m_floppyWriteMode) else if (m_floppyWriteMode)
{ {
if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected) if (m_floppyDrive[m_currDrive].m_disk.m_bWriteProtected)
return "Writing (write protected)"; return "Writing (write protected)";
else else
return "Writing"; return "Writing";
@ -153,7 +153,7 @@ void DiskIIInterfaceCard::SaveLastDiskImage(const int drive)
if (!m_saveDiskImage) if (!m_saveDiskImage)
return; return;
const char *pFileName = m_floppyDrive[drive].m_disk.fullname; const char *pFileName = m_floppyDrive[drive].m_disk.m_fullname;
if (drive == DRIVE_1) if (drive == DRIVE_1)
RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName); RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName);
@ -203,7 +203,7 @@ Disk_Status_e DiskIIInterfaceCard::GetDriveLightStatus(const int drive)
if (pDrive->m_spinning) if (pDrive->m_spinning)
{ {
if (pDrive->m_disk.bWriteProtected) if (pDrive->m_disk.m_bWriteProtected)
return DISK_STATUS_PROT; return DISK_STATUS_PROT;
if (pDrive->m_writelight) if (pDrive->m_writelight)
@ -231,8 +231,8 @@ bool DiskIIInterfaceCard::IsDriveValid(const int drive)
void DiskIIInterfaceCard::AllocTrack(const int drive) void DiskIIInterfaceCard::AllocTrack(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk; FloppyDisk* pFloppy = &m_floppyDrive[drive].m_disk;
pFloppy->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE); pFloppy->m_trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE);
} }
//=========================================================================== //===========================================================================
@ -243,32 +243,32 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
return; return;
FloppyDrive* pDrive = &m_floppyDrive[ drive ]; FloppyDrive* pDrive = &m_floppyDrive[ drive ];
Disk_t* pFloppy = &pDrive->m_disk; FloppyDisk* pFloppy = &pDrive->m_disk;
if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle)) if (pDrive->m_track >= ImageGetNumTracks(pFloppy->m_imagehandle))
{ {
pFloppy->trackimagedata = false; pFloppy->m_trackimagedata = false;
return; return;
} }
if (!pFloppy->trackimage) if (!pFloppy->m_trackimage)
AllocTrack( drive ); AllocTrack( drive );
if (pFloppy->trackimage && pFloppy->imagehandle) if (pFloppy->m_trackimage && pFloppy->m_imagehandle)
{ {
#if LOG_DISK_TRACKS #if LOG_DISK_TRACKS
LOG_DISK("track $%02X%s read\r\n", pDrive->track, (pDrive->phase & 1) ? ".5" : " "); LOG_DISK("track $%02X%s read\r\n", pDrive->track, (pDrive->phase & 1) ? ".5" : " ");
#endif #endif
ImageReadTrack( ImageReadTrack(
pFloppy->imagehandle, pFloppy->m_imagehandle,
pDrive->m_track, pDrive->m_track,
pDrive->m_phase, pDrive->m_phase,
pFloppy->trackimage, pFloppy->m_trackimage,
&pFloppy->nibbles, &pFloppy->m_nibbles,
m_enhanceDisk); m_enhanceDisk);
pFloppy->byte = 0; pFloppy->m_byte = 0;
pFloppy->trackimagedata = (pFloppy->nibbles != 0); pFloppy->m_trackimagedata = (pFloppy->m_nibbles != 0);
} }
} }
@ -276,26 +276,26 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
void DiskIIInterfaceCard::RemoveDisk(const int drive) void DiskIIInterfaceCard::RemoveDisk(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk; FloppyDisk* pFloppy = &m_floppyDrive[drive].m_disk;
if (pFloppy->imagehandle) if (pFloppy->m_imagehandle)
{ {
FlushCurrentTrack(drive); FlushCurrentTrack(drive);
ImageClose(pFloppy->imagehandle); ImageClose(pFloppy->m_imagehandle);
pFloppy->imagehandle = NULL; pFloppy->m_imagehandle = NULL;
} }
if (pFloppy->trackimage) if (pFloppy->m_trackimage)
{ {
VirtualFree(pFloppy->trackimage, 0, MEM_RELEASE); VirtualFree(pFloppy->m_trackimage, 0, MEM_RELEASE);
pFloppy->trackimage = NULL; pFloppy->m_trackimage = NULL;
pFloppy->trackimagedata = false; pFloppy->m_trackimagedata = false;
} }
memset( pFloppy->imagename, 0, MAX_DISK_IMAGE_NAME+1 ); memset( pFloppy->m_imagename, 0, MAX_DISK_IMAGE_NAME+1 );
memset( pFloppy->fullname , 0, MAX_DISK_FULL_NAME +1 ); memset( pFloppy->m_fullname , 0, MAX_DISK_FULL_NAME +1 );
pFloppy->strFilenameInZip = ""; pFloppy->m_strFilenameInZip = "";
SaveLastDiskImage( drive ); SaveLastDiskImage( drive );
Video_ResetScreenshotCounter( NULL ); Video_ResetScreenshotCounter( NULL );
@ -306,35 +306,35 @@ void DiskIIInterfaceCard::RemoveDisk(const int drive)
void DiskIIInterfaceCard::WriteTrack(const int drive) void DiskIIInterfaceCard::WriteTrack(const int drive)
{ {
FloppyDrive* pDrive = &m_floppyDrive[ drive ]; FloppyDrive* pDrive = &m_floppyDrive[ drive ];
Disk_t* pFloppy = &pDrive->m_disk; FloppyDisk* pFloppy = &pDrive->m_disk;
if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle)) if (pDrive->m_track >= ImageGetNumTracks(pFloppy->m_imagehandle))
return; return;
if (pFloppy->bWriteProtected) if (pFloppy->m_bWriteProtected)
return; return;
if (pFloppy->trackimage && pFloppy->imagehandle) if (pFloppy->m_trackimage && pFloppy->m_imagehandle)
{ {
#if LOG_DISK_TRACKS #if LOG_DISK_TRACKS
LOG_DISK("track $%02X%s write\r\n", pDrive->track, (pDrive->phase & 0) ? ".5" : " "); // TODO: hard-coded to whole tracks - see below (nickw) LOG_DISK("track $%02X%s write\r\n", pDrive->m_track, (pDrive->m_phase & 0) ? ".5" : " "); // TODO: hard-coded to whole tracks - see below (nickw)
#endif #endif
ImageWriteTrack( ImageWriteTrack(
pFloppy->imagehandle, pFloppy->m_imagehandle,
pDrive->m_track, pDrive->m_track,
pDrive->m_phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw) pDrive->m_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->m_trackimage,
pFloppy->nibbles); pFloppy->m_nibbles);
} }
pFloppy->trackimagedirty = false; pFloppy->m_trackimagedirty = false;
} }
void DiskIIInterfaceCard::FlushCurrentTrack(const int drive) void DiskIIInterfaceCard::FlushCurrentTrack(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk; FloppyDisk* pFloppy = &m_floppyDrive[drive].m_disk;
if (pFloppy->trackimage && pFloppy->trackimagedirty) if (pFloppy->m_trackimage && pFloppy->m_trackimagedirty)
WriteTrack(drive); WriteTrack(drive);
} }
@ -344,7 +344,7 @@ void DiskIIInterfaceCard::Boot(void)
{ {
// THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE. // 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 A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING.
if (m_floppyDrive[0].m_disk.imagehandle && ImageBoot(m_floppyDrive[0].m_disk.imagehandle)) if (m_floppyDrive[0].m_disk.m_imagehandle && ImageBoot(m_floppyDrive[0].m_disk.m_imagehandle))
m_floppyMotorOn = 0; m_floppyMotorOn = 0;
} }
@ -371,7 +371,7 @@ void __stdcall DiskIIInterfaceCard::ControlMotor(WORD, WORD address, BYTE, BYTE,
void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles) void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles)
{ {
FloppyDrive* pDrive = &m_floppyDrive[m_currDrive]; FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
Disk_t* pFloppy = &pDrive->m_disk; FloppyDisk* pFloppy = &pDrive->m_disk;
if (!m_floppyMotorOn) // GH#525 if (!m_floppyMotorOn) // GH#525
{ {
@ -419,14 +419,14 @@ void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYT
if (direction) if (direction)
{ {
pDrive->m_phase = MAX(0, MIN(79, pDrive->m_phase + direction)); pDrive->m_phase = MAX(0, MIN(79, pDrive->m_phase + direction));
const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle); const int nNumTracksInImage = ImageGetNumTracks(pFloppy->m_imagehandle);
const int newtrack = (nNumTracksInImage == 0) ? 0 const int newtrack = (nNumTracksInImage == 0) ? 0
: MIN(nNumTracksInImage-1, pDrive->m_phase >> 1); // (round half tracks down) : MIN(nNumTracksInImage-1, pDrive->m_phase >> 1); // (round half tracks down)
if (newtrack != pDrive->m_track) if (newtrack != pDrive->m_track)
{ {
FlushCurrentTrack(m_currDrive); FlushCurrentTrack(m_currDrive);
pDrive->m_track = newtrack; pDrive->m_track = newtrack;
pFloppy->trackimagedata = false; pFloppy->m_trackimagedata = false;
m_formatTrack.DriveNotWritingTrack(); m_formatTrack.DriveNotWritingTrack();
} }
@ -495,8 +495,8 @@ void DiskIIInterfaceCard::EjectDisk(const int drive)
// . Used by Drive Buttons' tooltips // . Used by Drive Buttons' tooltips
LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive) LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
{ {
if (!m_floppyDrive[drive].m_disk.strFilenameInZip.empty()) if (!m_floppyDrive[drive].m_disk.m_strFilenameInZip.empty())
return m_floppyDrive[drive].m_disk.strFilenameInZip.c_str(); return m_floppyDrive[drive].m_disk.m_strFilenameInZip.c_str();
return GetFullName(drive); return GetFullName(drive);
} }
@ -505,19 +505,19 @@ LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
// . Used by Property Sheet Page (Disk) // . Used by Property Sheet Page (Disk)
LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive) LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive)
{ {
return m_floppyDrive[drive].m_disk.fullname; return m_floppyDrive[drive].m_disk.m_fullname;
} }
// Return the imagename // Return the imagename
// . Used by Drive Button's icons & Property Sheet Page (Save snapshot) // . Used by Drive Button's icons & Property Sheet Page (Save snapshot)
LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive) LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive)
{ {
return m_floppyDrive[drive].m_disk.imagename; return m_floppyDrive[drive].m_disk.m_imagename;
} }
LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive) LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive)
{ {
return ImageGetPathname(m_floppyDrive[drive].m_disk.imagehandle); return ImageGetPathname(m_floppyDrive[drive].m_disk.m_imagehandle);
} }
//=========================================================================== //===========================================================================
@ -536,9 +536,9 @@ void DiskIIInterfaceCard::GetLightStatus(Disk_Status_e *pDisk1Status, Disk_Statu
ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary) ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary)
{ {
FloppyDrive* pDrive = &m_floppyDrive[drive]; FloppyDrive* pDrive = &m_floppyDrive[drive];
Disk_t* pFloppy = &pDrive->m_disk; FloppyDisk* pFloppy = &pDrive->m_disk;
if (pFloppy->imagehandle) if (pFloppy->m_imagehandle)
RemoveDisk(drive); RemoveDisk(drive);
// Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon) // Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon)
@ -553,9 +553,9 @@ ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFi
const DWORD dwAttributes = GetFileAttributes(pszImageFilename); const DWORD dwAttributes = GetFileAttributes(pszImageFilename);
if(dwAttributes == INVALID_FILE_ATTRIBUTES) if(dwAttributes == INVALID_FILE_ATTRIBUTES)
pFloppy->bWriteProtected = false; // Assume this is a new file to create pFloppy->m_bWriteProtected = false; // Assume this is a new file to create
else else
pFloppy->bWriteProtected = bForceWriteProtected ? true : (dwAttributes & FILE_ATTRIBUTE_READONLY); pFloppy->m_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 // Check if image is being used by the other drive, and if so remove it in order so it can be swapped
{ {
@ -574,16 +574,16 @@ ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFi
} }
ImageError_e Error = ImageOpen(pszImageFilename, ImageError_e Error = ImageOpen(pszImageFilename,
&pFloppy->imagehandle, &pFloppy->m_imagehandle,
&pFloppy->bWriteProtected, &pFloppy->m_bWriteProtected,
bCreateIfNecessary, bCreateIfNecessary,
pFloppy->strFilenameInZip); pFloppy->m_strFilenameInZip);
if (Error == eIMAGE_ERROR_NONE && ImageIsMultiFileZip(pFloppy->imagehandle)) if (Error == eIMAGE_ERROR_NONE && ImageIsMultiFileZip(pFloppy->m_imagehandle))
{ {
TCHAR szText[100+MAX_PATH]; TCHAR szText[100+MAX_PATH];
szText[sizeof(szText)-1] = 0; 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' ?", pFloppy->strFilenameInZip.c_str()); _snprintf(szText, sizeof(szText)-1, "Only the first file in a multi-file zip is supported\nUse disk image '%s' ?", pFloppy->m_strFilenameInZip.c_str());
int nRes = MessageBox(g_hFrameWindow, szText, TEXT("Multi-Zip Warning"), MB_ICONWARNING | MB_YESNO | MB_SETFOREGROUND); int nRes = MessageBox(g_hFrameWindow, szText, TEXT("Multi-Zip Warning"), MB_ICONWARNING | MB_YESNO | MB_SETFOREGROUND);
if (nRes == IDNO) if (nRes == IDNO)
{ {
@ -594,8 +594,8 @@ ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFi
if (Error == eIMAGE_ERROR_NONE) if (Error == eIMAGE_ERROR_NONE)
{ {
GetImageTitle(pszImageFilename, pFloppy->imagename, pFloppy->fullname); GetImageTitle(pszImageFilename, pFloppy->m_imagename, pFloppy->m_fullname);
Video_ResetScreenshotCounter(pFloppy->imagename); Video_ResetScreenshotCounter(pFloppy->m_imagename);
} }
else else
{ {
@ -683,7 +683,7 @@ void DiskIIInterfaceCard::NotifyInvalidImage(const int drive, LPCTSTR pszImageFi
TEXT("first file (%s) in this multi-zip archive is not recognized.\n") TEXT("first file (%s) in this multi-zip archive is not recognized.\n")
TEXT("Try unzipping and using the disk images directly.\n"), TEXT("Try unzipping and using the disk images directly.\n"),
pszImageFilename, pszImageFilename,
m_floppyDrive[drive].m_disk.strFilenameInZip.c_str()); m_floppyDrive[drive].m_disk.m_strFilenameInZip.c_str());
break; break;
case eIMAGE_ERROR_GZ: case eIMAGE_ERROR_GZ:
@ -738,7 +738,7 @@ bool DiskIIInterfaceCard::GetProtect(const int drive)
{ {
if (IsDriveValid(drive)) if (IsDriveValid(drive))
{ {
if (m_floppyDrive[drive].m_disk.bWriteProtected) if (m_floppyDrive[drive].m_disk.m_bWriteProtected)
return true; return true;
} }
@ -751,7 +751,7 @@ void DiskIIInterfaceCard::SetProtect(const int drive, const bool bWriteProtect)
{ {
if (IsDriveValid( drive )) if (IsDriveValid( drive ))
{ {
m_floppyDrive[drive].m_disk.bWriteProtected = bWriteProtect; m_floppyDrive[drive].m_disk.m_bWriteProtected = bWriteProtect;
} }
} }
@ -762,7 +762,7 @@ bool DiskIIInterfaceCard::IsDiskImageWriteProtected(const int drive)
if (!IsDriveValid(drive)) if (!IsDriveValid(drive))
return true; return true;
return ImageIsWriteProtected(m_floppyDrive[drive].m_disk.imagehandle); return ImageIsWriteProtected(m_floppyDrive[drive].m_disk.m_imagehandle);
} }
//=========================================================================== //===========================================================================
@ -772,7 +772,7 @@ bool DiskIIInterfaceCard::IsDriveEmpty(const int drive)
if (!IsDriveValid(drive)) if (!IsDriveValid(drive))
return true; return true;
return m_floppyDrive[drive].m_disk.imagehandle == NULL; return m_floppyDrive[drive].m_disk.m_imagehandle == NULL;
} }
//=========================================================================== //===========================================================================
@ -812,12 +812,12 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
{ {
/* m_floppyLoadMode = 0; */ /* m_floppyLoadMode = 0; */
FloppyDrive* pDrive = &m_floppyDrive[m_currDrive]; FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
Disk_t* pFloppy = &pDrive->m_disk; FloppyDisk* pFloppy = &pDrive->m_disk;
if (!pFloppy->trackimagedata && pFloppy->imagehandle) if (!pFloppy->m_trackimagedata && pFloppy->m_imagehandle)
ReadTrack(m_currDrive); ReadTrack(m_currDrive);
if (!pFloppy->trackimagedata) if (!pFloppy->m_trackimagedata)
{ {
m_floppyLatch = 0xFF; m_floppyLatch = 0xFF;
return; return;
@ -837,13 +837,13 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
// 40 cycles for a write of a 10-bit 0xFF sync byte // 40 cycles for a write of a 10-bit 0xFF sync byte
uSpinNibbleCount = nCycleDiff >> 5; // ...but divide by 32 (not 40) uSpinNibbleCount = nCycleDiff >> 5; // ...but divide by 32 (not 40)
ULONG uWrapOffset = uSpinNibbleCount % pFloppy->nibbles; ULONG uWrapOffset = uSpinNibbleCount % pFloppy->m_nibbles;
pFloppy->byte += uWrapOffset; pFloppy->m_byte += uWrapOffset;
if (pFloppy->byte >= pFloppy->nibbles) if (pFloppy->m_byte >= pFloppy->m_nibbles)
pFloppy->byte -= pFloppy->nibbles; pFloppy->m_byte -= pFloppy->m_nibbles;
#if LOG_DISK_NIBBLES_SPIN #if LOG_DISK_NIBBLES_SPIN
UINT uCompleteRevolutions = uSpinNibbleCount / pFloppy->nibbles; UINT uCompleteRevolutions = uSpinNibbleCount / pFloppy->m_nibbles;
LOG_DISK("spin: revs=%d, nibbles=%d\r\n", uCompleteRevolutions, uWrapOffset); LOG_DISK("spin: revs=%d, nibbles=%d\r\n", uCompleteRevolutions, uWrapOffset);
#endif #endif
} }
@ -868,11 +868,11 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
if (nReadCycleDiff <= kReadAccessThreshold) if (nReadCycleDiff <= kReadAccessThreshold)
{ {
UINT invalidBits = 8 - (nReadCycleDiff / 4); // 4 cycles per bit-cell UINT invalidBits = 8 - (nReadCycleDiff / 4); // 4 cycles per bit-cell
m_floppyLatch = *(pFloppy->trackimage + pFloppy->byte) >> invalidBits; m_floppyLatch = *(pFloppy->m_trackimage + pFloppy->m_byte) >> invalidBits;
return; // Early return so don't update: m_diskLastReadLatchCycle & pFloppy->byte return; // Early return so don't update: m_diskLastReadLatchCycle & pFloppy->byte
} }
m_floppyLatch = *(pFloppy->trackimage + pFloppy->byte); m_floppyLatch = *(pFloppy->m_trackimage + pFloppy->m_byte);
m_diskLastReadLatchCycle = g_nCumulativeCycles; m_diskLastReadLatchCycle = g_nCumulativeCycles;
#if LOG_DISK_NIBBLES_READ #if LOG_DISK_NIBBLES_READ
@ -880,16 +880,16 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
if (m_bLogDisk_NibblesRW) if (m_bLogDisk_NibblesRW)
#endif #endif
{ {
LOG_DISK("read %04X = %02X\r\n", pFloppy->byte, m_floppyLatch); LOG_DISK("read %04X = %02X\r\n", pFloppy->m_byte, m_floppyLatch);
} }
m_formatTrack.DecodeLatchNibbleRead(m_floppyLatch); m_formatTrack.DecodeLatchNibbleRead(m_floppyLatch);
#endif #endif
} }
else if (!pFloppy->bWriteProtected) // && m_floppyWriteMode else if (!pFloppy->m_bWriteProtected) // && m_floppyWriteMode
{ {
*(pFloppy->trackimage + pFloppy->byte) = m_floppyLatch; *(pFloppy->m_trackimage + pFloppy->m_byte) = m_floppyLatch;
pFloppy->trackimagedirty = true; pFloppy->m_trackimagedirty = true;
bool bIsSyncFF = false; bool bIsSyncFF = false;
#if LOG_DISK_NIBBLES_WRITE #if LOG_DISK_NIBBLES_WRITE
@ -905,18 +905,18 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
#endif #endif
{ {
if (!bIsSyncFF) if (!bIsSyncFF)
LOG_DISK("write %04X = %02X (cy=+%d)\r\n", pFloppy->byte, m_floppyLatch, uCycleDelta); LOG_DISK("write %04X = %02X (cy=+%d)\r\n", pFloppy->m_byte, m_floppyLatch, uCycleDelta);
else else
LOG_DISK("write %04X = %02X (cy=+%d) sync #%d\r\n", pFloppy->byte, m_floppyLatch, uCycleDelta, m_uSyncFFCount); LOG_DISK("write %04X = %02X (cy=+%d) sync #%d\r\n", pFloppy->m_byte, m_floppyLatch, uCycleDelta, m_uSyncFFCount);
} }
#endif #endif
} }
if (++pFloppy->byte >= pFloppy->nibbles) if (++pFloppy->m_byte >= pFloppy->m_nibbles)
pFloppy->byte = 0; pFloppy->m_byte = 0;
// Show track status (GH#201) - NB. Prevent flooding of forcing UI to redraw!!! // Show track status (GH#201) - NB. Prevent flooding of forcing UI to redraw!!!
if ((pFloppy->byte & 0xFF) == 0) if ((pFloppy->m_byte & 0xFF) == 0)
FrameDrawDiskStatus( (HDC)0 ); FrameDrawDiskStatus( (HDC)0 );
} }
@ -1018,7 +1018,7 @@ void __stdcall DiskIIInterfaceCard::LoadWriteProtect(WORD, WORD, BYTE write, BYT
// . write mode doesn't prevent reading write protect (GH#537): // . 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, // "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) // the write protect switch would still be read correctly" (UTAIIe page 9-21)
if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected) if (m_floppyDrive[m_currDrive].m_disk.m_bWriteProtected)
m_floppyLatch |= 0x80; m_floppyLatch |= 0x80;
else else
m_floppyLatch &= 0x7F; m_floppyLatch &= 0x7F;
@ -1044,7 +1044,7 @@ void __stdcall DiskIIInterfaceCard::SetWriteMode(WORD, WORD, BYTE, BYTE, ULONG u
{ {
m_floppyWriteMode = 1; m_floppyWriteMode = 1;
m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].m_disk.byte); m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].m_disk.m_byte);
BOOL modechange = !m_floppyDrive[m_currDrive].m_writelight; BOOL modechange = !m_floppyDrive[m_currDrive].m_writelight;
#if LOG_DISK_RW_MODE #if LOG_DISK_RW_MODE
@ -1137,8 +1137,8 @@ bool DiskIIInterfaceCard::DriveSwap(void)
std::swap(m_floppyDrive[DRIVE_1].m_disk, m_floppyDrive[DRIVE_2].m_disk); std::swap(m_floppyDrive[DRIVE_1].m_disk, m_floppyDrive[DRIVE_2].m_disk);
// Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543) // Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543)
m_floppyDrive[DRIVE_1].m_disk.trackimagedata = false; m_floppyDrive[DRIVE_1].m_disk.m_trackimagedata = false;
m_floppyDrive[DRIVE_2].m_disk.trackimagedata = false; m_floppyDrive[DRIVE_2].m_disk.m_trackimagedata = false;
SaveLastDiskImage(DRIVE_1); SaveLastDiskImage(DRIVE_1);
SaveLastDiskImage(DRIVE_2); SaveLastDiskImage(DRIVE_2);
@ -1293,21 +1293,21 @@ std::string DiskIIInterfaceCard::GetSnapshotCardName(void)
void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit) void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit)
{ {
YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit); YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit);
yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].m_disk.fullname); yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].m_disk.m_fullname);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].m_track); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].m_track);
yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].m_phase); yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].m_phase);
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].m_disk.byte); yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].m_disk.m_byte);
yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].m_disk.bWriteProtected); yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].m_disk.m_bWriteProtected);
yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].m_spinning); yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].m_spinning);
yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].m_writelight); yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].m_writelight);
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].m_disk.nibbles); yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].m_disk.m_nibbles);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].m_disk.trackimagedata); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].m_disk.m_trackimagedata);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].m_disk.trackimagedirty); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].m_disk.m_trackimagedirty);
if (m_floppyDrive[unit].m_disk.trackimage) if (m_floppyDrive[unit].m_disk.m_trackimage)
{ {
YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE); YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE);
yamlSaveHelper.SaveMemory(m_floppyDrive[unit].m_disk.trackimage, NIBBLES_PER_TRACK); yamlSaveHelper.SaveMemory(m_floppyDrive[unit].m_disk.m_trackimage, NIBBLES_PER_TRACK);
} }
} }
@ -1339,9 +1339,9 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
bool bImageError = false; bool bImageError = false;
m_floppyDrive[unit].m_disk.fullname[0] = 0; m_floppyDrive[unit].m_disk.m_fullname[0] = 0;
m_floppyDrive[unit].m_disk.imagename[0] = 0; m_floppyDrive[unit].m_disk.m_imagename[0] = 0;
m_floppyDrive[unit].m_disk.bWriteProtected = false; // Default to false (until image is successfully loaded below) m_floppyDrive[unit].m_disk.m_bWriteProtected = false; // Default to false (until image is successfully loaded below)
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME); std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
if (!filename.empty()) if (!filename.empty())
@ -1370,13 +1370,13 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
m_floppyDrive[unit].m_track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK); m_floppyDrive[unit].m_track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK);
m_floppyDrive[unit].m_phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE); m_floppyDrive[unit].m_phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE);
m_floppyDrive[unit].m_disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE); m_floppyDrive[unit].m_disk.m_byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE);
yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume
m_floppyDrive[unit].m_spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING); m_floppyDrive[unit].m_spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING);
m_floppyDrive[unit].m_writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT); m_floppyDrive[unit].m_writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT);
m_floppyDrive[unit].m_disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES); m_floppyDrive[unit].m_disk.m_nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES);
m_floppyDrive[unit].m_disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false; m_floppyDrive[unit].m_disk.m_trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false;
m_floppyDrive[unit].m_disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false; m_floppyDrive[unit].m_disk.m_trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false;
std::vector<BYTE> track(NIBBLES_PER_TRACK); std::vector<BYTE> track(NIBBLES_PER_TRACK);
if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE)) if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE))
@ -1391,20 +1391,20 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
if (!filename.empty() && !bImageError) if (!filename.empty() && !bImageError)
{ {
if ((m_floppyDrive[unit].m_disk.trackimage == NULL) && m_floppyDrive[unit].m_disk.nibbles) if ((m_floppyDrive[unit].m_disk.m_trackimage == NULL) && m_floppyDrive[unit].m_disk.m_nibbles)
AllocTrack(unit); AllocTrack(unit);
if (m_floppyDrive[unit].m_disk.trackimage == NULL) if (m_floppyDrive[unit].m_disk.m_trackimage == NULL)
bImageError = true; bImageError = true;
else else
memcpy(m_floppyDrive[unit].m_disk.trackimage, &track[0], NIBBLES_PER_TRACK); memcpy(m_floppyDrive[unit].m_disk.m_trackimage, &track[0], NIBBLES_PER_TRACK);
} }
if (bImageError) if (bImageError)
{ {
m_floppyDrive[unit].m_disk.trackimagedata = false; m_floppyDrive[unit].m_disk.m_trackimagedata = false;
m_floppyDrive[unit].m_disk.trackimagedirty = false; m_floppyDrive[unit].m_disk.m_trackimagedirty = false;
m_floppyDrive[unit].m_disk.nibbles = 0; m_floppyDrive[unit].m_disk.m_nibbles = 0;
} }
} }

46
source/Disk.h
View File

@ -43,38 +43,38 @@ const bool IMAGE_FORCE_WRITE_PROTECTED = true;
const bool IMAGE_DONT_CREATE = false; const bool IMAGE_DONT_CREATE = false;
const bool IMAGE_CREATE = true; const bool IMAGE_CREATE = true;
struct Disk_t struct FloppyDisk
{ {
TCHAR imagename[ MAX_DISK_IMAGE_NAME + 1 ]; // <FILENAME> (ie. no extension) TCHAR m_imagename[ MAX_DISK_IMAGE_NAME + 1 ]; // <FILENAME> (ie. no extension)
TCHAR fullname [ MAX_DISK_FULL_NAME + 1 ]; // <FILENAME.EXT> or <FILENAME.zip> : This is persisted to the snapshot file TCHAR m_fullname [ MAX_DISK_FULL_NAME + 1 ]; // <FILENAME.EXT> or <FILENAME.zip> : This is persisted to the snapshot file
std::string strFilenameInZip; // "" or <FILENAME.EXT> std::string m_strFilenameInZip; // "" or <FILENAME.EXT>
ImageInfo* imagehandle; // Init'd by DiskInsert() -> ImageOpen() ImageInfo* m_imagehandle; // Init'd by DiskInsert() -> ImageOpen()
bool bWriteProtected; bool m_bWriteProtected;
// //
int byte; int m_byte;
int nibbles; // Init'd by ReadTrack() -> ImageReadTrack() int m_nibbles; // Init'd by ReadTrack() -> ImageReadTrack()
LPBYTE trackimage; LPBYTE m_trackimage;
bool trackimagedata; bool m_trackimagedata;
bool trackimagedirty; bool m_trackimagedirty;
Disk_t() FloppyDisk()
{ {
clear(); clear();
} }
void clear() void clear()
{ {
ZeroMemory(imagename, sizeof(imagename)); ZeroMemory(m_imagename, sizeof(m_imagename));
ZeroMemory(fullname, sizeof(fullname)); ZeroMemory(m_fullname, sizeof(m_fullname));
strFilenameInZip.clear(); m_strFilenameInZip.clear();
imagehandle = NULL; m_imagehandle = NULL;
bWriteProtected = false; m_bWriteProtected = false;
// //
byte = 0; m_byte = 0;
nibbles = 0; m_nibbles = 0;
trackimage = NULL; m_trackimage = NULL;
trackimagedata = false; m_trackimagedata = false;
trackimagedirty = false; m_trackimagedirty = false;
} }
}; };
@ -84,7 +84,7 @@ struct FloppyDrive
int m_track; int m_track;
DWORD m_spinning; DWORD m_spinning;
DWORD m_writelight; DWORD m_writelight;
Disk_t m_disk; FloppyDisk m_disk;
FloppyDrive() FloppyDrive()
{ {

20
source/DiskFormatTrack.cpp
View File

@ -82,15 +82,15 @@ void FormatTrack::DriveNotWritingTrack(void)
#endif #endif
} }
void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const pFloppy) void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const FloppyDisk* const pFloppy)
{ {
if (pFloppy->bWriteProtected) if (pFloppy->m_bWriteProtected)
return; return;
if (m_bmWrittenSectorAddrFields == 0x0000) if (m_bmWrittenSectorAddrFields == 0x0000)
{ {
if (m_WriteTrackStartIndex == (UINT)-1) // waiting for 1st write? if (m_WriteTrackStartIndex == (UINT)-1) // waiting for 1st write?
m_WriteTrackStartIndex = pFloppy->byte; m_WriteTrackStartIndex = pFloppy->m_byte;
return; return;
} }
@ -106,8 +106,8 @@ void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const
return; return;
} }
UINT uTrackIndex = pFloppy->byte; UINT uTrackIndex = pFloppy->m_byte;
const UINT& kTrackMaxNibbles = pFloppy->nibbles; const UINT& kTrackMaxNibbles = pFloppy->m_nibbles;
// NB. spin in write mode is only max 1-2 bytes // NB. spin in write mode is only max 1-2 bytes
do do
@ -126,7 +126,7 @@ void FormatTrack::UpdateOnWriteLatch(UINT uSpinNibbleCount, const Disk_t* const
while (uSpinNibbleCount--); while (uSpinNibbleCount--);
} }
void FormatTrack::DriveSwitchedToReadMode(Disk_t* const pFloppy) void FormatTrack::DriveSwitchedToReadMode(FloppyDisk* const pFloppy)
{ {
if (m_bAddressPrologueIsDOS3_2) if (m_bAddressPrologueIsDOS3_2)
{ {
@ -152,10 +152,10 @@ void FormatTrack::DriveSwitchedToReadMode(Disk_t* const pFloppy)
// So need a track size between 0x18B0 (rounding down) and 0x182F // So need a track size between 0x18B0 (rounding down) and 0x182F
const UINT kShortTrackLen = 0x18B0; const UINT kShortTrackLen = 0x18B0;
LPBYTE TrackBuffer = pFloppy->trackimage; LPBYTE TrackBuffer = pFloppy->m_trackimage;
const UINT kLongTrackLen = pFloppy->nibbles; const UINT kLongTrackLen = pFloppy->m_nibbles;
UINT uWriteTrackEndIndex = pFloppy->byte; UINT uWriteTrackEndIndex = pFloppy->m_byte;
UINT uWrittenTrackSize = m_WriteTrackHasWrapped ? kLongTrackLen : 0; UINT uWrittenTrackSize = m_WriteTrackHasWrapped ? kLongTrackLen : 0;
if (m_WriteTrackStartIndex <= uWriteTrackEndIndex) if (m_WriteTrackStartIndex <= uWriteTrackEndIndex)
@ -214,7 +214,7 @@ void FormatTrack::DecodeLatchNibbleRead(BYTE floppylatch)
DecodeLatchNibble(floppylatch, false, false); DecodeLatchNibble(floppylatch, false, false);
} }
void FormatTrack::DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const Disk_t* const pFloppy, bool bIsSyncFF) void FormatTrack::DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const FloppyDisk* const pFloppy, bool bIsSyncFF)
{ {
DecodeLatchNibble(floppylatch, true, bIsSyncFF); DecodeLatchNibble(floppylatch, true, bIsSyncFF);
UpdateOnWriteLatch(uSpinNibbleCount, pFloppy); UpdateOnWriteLatch(uSpinNibbleCount, pFloppy);

6
source/DiskFormatTrack.h
View File

@ -35,15 +35,15 @@ public:
void Reset(void); void Reset(void);
void DriveNotWritingTrack(void); void DriveNotWritingTrack(void);
void DriveSwitchedToReadMode(struct Disk_t* const pFloppy); void DriveSwitchedToReadMode(struct FloppyDisk* const pFloppy);
void DriveSwitchedToWriteMode(UINT uTrackIndex); void DriveSwitchedToWriteMode(UINT uTrackIndex);
void DecodeLatchNibbleRead(BYTE floppylatch); void DecodeLatchNibbleRead(BYTE floppylatch);
void DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const struct Disk_t* const pFloppy, bool bIsSyncFF); void DecodeLatchNibbleWrite(BYTE floppylatch, UINT uSpinNibbleCount, const struct FloppyDisk* const pFloppy, bool bIsSyncFF);
void SaveSnapshot(class YamlSaveHelper& yamlSaveHelper); void SaveSnapshot(class YamlSaveHelper& yamlSaveHelper);
void LoadSnapshot(class YamlLoadHelper& yamlLoadHelper); void LoadSnapshot(class YamlLoadHelper& yamlLoadHelper);
private: private:
void UpdateOnWriteLatch(UINT uSpinNibbleCount, const struct Disk_t* const pFloppy); void UpdateOnWriteLatch(UINT uSpinNibbleCount, const struct FloppyDisk* const pFloppy);
void DecodeLatchNibble(BYTE floppylatch, bool bIsWrite, bool bIsSyncFF); void DecodeLatchNibble(BYTE floppylatch, bool bIsWrite, bool bIsSyncFF);
BYTE m_VolTrkSecChk[4]; BYTE m_VolTrkSecChk[4];

2
source/Harddisk.cpp
View File

@ -140,7 +140,7 @@ struct HDD
#endif #endif
} }
// From Disk_t // From FloppyDisk
TCHAR imagename[ MAX_DISK_IMAGE_NAME + 1 ]; // <FILENAME> (ie. no extension) [not used] TCHAR imagename[ MAX_DISK_IMAGE_NAME + 1 ]; // <FILENAME> (ie. no extension) [not used]
TCHAR fullname[ MAX_DISK_FULL_NAME + 1 ]; // <FILENAME.EXT> or <FILENAME.zip> TCHAR fullname[ MAX_DISK_FULL_NAME + 1 ]; // <FILENAME.EXT> or <FILENAME.zip>
std::string strFilenameInZip; // "" or <FILENAME.EXT> [not used] std::string strFilenameInZip; // "" or <FILENAME.EXT> [not used]