empathicqubit/AppleWin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor codebase by renaming nCyclesLeft to uExecutedCycles (#540)

Browse source
This commit is contained in:
tomcw 2018-03-03 21:27:50 +00:00
parent 93f57c0970
commit d9accc82c5
18 changed files with 278 additions and 280 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
source/Disk.cpp
View file

@ -88,7 +88,6 @@ static UINT g_uSlot = 0;
static unsigned __int64 g_uDiskLastCycle = 0;
static FormatTrack g_formatTrack;
static void CheckSpinning(const ULONG nCyclesLeft);
static bool IsDriveValid( const int iDrive );
static void ReadTrack (int drive);
static void RemoveDisk (int drive);
@ -204,7 +203,7 @@ void Disk_SaveLastDiskImage(const int iDrive)
//===========================================================================
// Called by DiskControlMotor() & DiskEnable()
static void CheckSpinning(const ULONG nCyclesLeft)
static void CheckSpinning(const ULONG nExecutedCycles)
{
DWORD modechange = (floppymotoron && !g_aFloppyDrive[currdrive].spinning);
@ -217,7 +216,7 @@ static void CheckSpinning(const ULONG nCyclesLeft)
if (modechange)
{
// Set g_uDiskLastCycle when motor changes: not spinning (ie. off for 1 sec) -> on
CpuCalcCycles(nCyclesLeft);
CpuCalcCycles(nExecutedCycles);
g_uDiskLastCycle = g_nCumulativeCycles;
}
}
@ -856,7 +855,7 @@ static bool LogWriteCheckSyncFF(ULONG& uCycleDelta)
//===========================================================================
static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
/* floppyloadmode = 0; */
Drive_t* pDrive = &g_aFloppyDrive[currdrive];
@ -873,7 +872,7 @@ static void __stdcall DiskReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULO
// Improve precision of "authentic" drive mode - GH#125
UINT uSpinNibbleCount = 0;
CpuCalcCycles(nCyclesLeft); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF()
CpuCalcCycles(nExecutedCycles); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF()
if (!enhancedisk && pDrive->spinning)
{
@ -1171,8 +1170,8 @@ bool DiskDriveSwap(void)
//===========================================================================
static BYTE __stdcall Disk_IORead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
static BYTE __stdcall Disk_IOWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
static BYTE __stdcall Disk_IORead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
static BYTE __stdcall Disk_IOWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
// TODO: LoadRom_Disk_Floppy()
void DiskLoadRom(LPBYTE pCxRomPeripheral, UINT uSlot)
@ -1211,55 +1210,55 @@ void DiskLoadRom(LPBYTE pCxRomPeripheral, UINT uSlot)
//===========================================================================
static BYTE __stdcall Disk_IORead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall Disk_IORead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xF)
{
case 0x0: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x1: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x2: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x3: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x4: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x5: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x6: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x7: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x8: DiskControlMotor(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x9: DiskControlMotor(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xA: DiskEnable(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xB: DiskEnable(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xC: DiskReadWrite(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xD: DiskLoadWriteProtect(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xE: DiskSetReadMode(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xF: DiskSetWriteMode(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x0: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x1: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x2: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x3: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x4: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x5: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x6: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x7: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x8: DiskControlMotor(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x9: DiskControlMotor(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xA: DiskEnable(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xB: DiskEnable(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xC: DiskReadWrite(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xD: DiskLoadWriteProtect(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xE: DiskSetReadMode(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xF: DiskSetWriteMode(pc, addr, bWrite, d, nExecutedCycles); break;
}
// only even addresses return the latch (UTAIIe Table 9.1)
if (!(addr & 1))
return floppylatch;
else
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
static BYTE __stdcall Disk_IOWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall Disk_IOWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xF)
{
case 0x0: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x1: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x2: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x3: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x4: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x5: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x6: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x7: DiskControlStepper(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x8: DiskControlMotor(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x9: DiskControlMotor(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xA: DiskEnable(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xB: DiskEnable(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xC: DiskReadWrite(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xD: DiskLoadWriteProtect(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xE: DiskSetReadMode(pc, addr, bWrite, d, nCyclesLeft); break;
case 0xF: DiskSetWriteMode(pc, addr, bWrite, d, nCyclesLeft); break;
case 0x0: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x1: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x2: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x3: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x4: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x5: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x6: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x7: DiskControlStepper(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x8: DiskControlMotor(pc, addr, bWrite, d, nExecutedCycles); break;
case 0x9: DiskControlMotor(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xA: DiskEnable(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xB: DiskEnable(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xC: DiskReadWrite(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xD: DiskLoadWriteProtect(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xE: DiskSetReadMode(pc, addr, bWrite, d, nExecutedCycles); break;
case 0xF: DiskSetWriteMode(pc, addr, bWrite, d, nExecutedCycles); break;
}
// any address writes the latch via sequencer LD command (74LS323 datasheet)

8
source/Harddisk.cpp
View file

@ -260,7 +260,7 @@ static void HD_SaveLastDiskImage(const int iDrive)
// (Nearly) everything below is global
static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
static const DWORD HDDRVR_SIZE = APPLE_SLOT_SIZE;
@ -486,7 +486,7 @@ bool HD_IsDriveUnplugged(const int iDrive)
#define DEVICE_UNKNOWN_ERROR 0x28
#define DEVICE_IO_ERROR 0x27
static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
BYTE r = DEVICE_OK;
addr &= 0xFF;
@ -629,7 +629,7 @@ static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG
#if HD_LED
pHDD->hd_status_next = DISK_STATUS_OFF;
#endif
return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
}
}
else // write to registers
@ -664,7 +664,7 @@ static BYTE __stdcall HD_IO_EMUL(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG
#if HD_LED
pHDD->hd_status_next = DISK_STATUS_OFF;
#endif
return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
}
}

22
source/Joystick.cpp
View file

@ -481,7 +481,7 @@ static void DoAutofire(UINT uButton, BOOL& pressed)
lastPressed[uButton] = nowPressed;
}
BYTE __stdcall JoyportReadButton(WORD address, ULONG nCyclesLeft)
BYTE __stdcall JoyportReadButton(WORD address, ULONG nExecutedCycles)
{
BOOL pressed = 0;
@ -529,10 +529,10 @@ BYTE __stdcall JoyportReadButton(WORD address, ULONG nCyclesLeft)
pressed = pressed ? 0 : 1; // Invert as Joyport signals are active low
return MemReadFloatingBus(pressed, nCyclesLeft);
return MemReadFloatingBus(pressed, nExecutedCycles);
}
BYTE __stdcall JoyReadButton(WORD pc, WORD address, BYTE, BYTE, ULONG nCyclesLeft)
BYTE __stdcall JoyReadButton(WORD pc, WORD address, BYTE, BYTE, ULONG nExecutedCycles)
{
address &= 0xFF;
@ -545,7 +545,7 @@ BYTE __stdcall JoyReadButton(WORD pc, WORD address, BYTE, BYTE, ULONG nCyclesLef
{
// Some extra logic to stop the Joyport forcing a self-test at CTRL+RESET
if ((address != 0x62) || (address == 0x62 && pc != 0xC242 && pc != 0xC2BE)) // Original //e ($C242), Enhanced //e ($C2BE)
return JoyportReadButton(address, nCyclesLeft);
return JoyportReadButton(address, nExecutedCycles);
}
BOOL pressed = 0;
@ -583,7 +583,7 @@ BYTE __stdcall JoyReadButton(WORD pc, WORD address, BYTE, BYTE, ULONG nCyclesLef
break;
}
return MemReadFloatingBus(pressed, nCyclesLeft);
return MemReadFloatingBus(pressed, nExecutedCycles);
}
//===========================================================================
@ -605,11 +605,11 @@ BYTE __stdcall JoyReadButton(WORD pc, WORD address, BYTE, BYTE, ULONG nCyclesLef
static const double PDL_CNTR_INTERVAL = 2816.0 / 255.0; // 11.04 (From KEGS)
BYTE __stdcall JoyReadPosition(WORD programcounter, WORD address, BYTE, BYTE, ULONG nCyclesLeft)
BYTE __stdcall JoyReadPosition(WORD programcounter, WORD address, BYTE, BYTE, ULONG nExecutedCycles)
{
int nJoyNum = (address & 2) ? 1 : 0; // $C064..$C067
CpuCalcCycles(nCyclesLeft);
CpuCalcCycles(nExecutedCycles);
ULONG nPdlPos = (address & 1) ? ypos[nJoyNum] : xpos[nJoyNum];
@ -619,7 +619,7 @@ BYTE __stdcall JoyReadPosition(WORD programcounter, WORD address, BYTE, BYTE, UL
BOOL nPdlCntrActive = g_nCumulativeCycles <= (g_nJoyCntrResetCycle + (unsigned __int64) ((double)nPdlPos * PDL_CNTR_INTERVAL));
return MemReadFloatingBus(nPdlCntrActive, nCyclesLeft);
return MemReadFloatingBus(nPdlCntrActive, nExecutedCycles);
}
//===========================================================================
@ -631,9 +631,9 @@ void JoyReset()
}
//===========================================================================
BYTE __stdcall JoyResetPosition(WORD, WORD, BYTE, BYTE, ULONG nCyclesLeft)
BYTE __stdcall JoyResetPosition(WORD, WORD, BYTE, BYTE, ULONG nExecutedCycles)
{
CpuCalcCycles(nCyclesLeft);
CpuCalcCycles(nExecutedCycles);
g_nJoyCntrResetCycle = g_nCumulativeCycles;
if(joyinfo[joytype[0]] == DEVICE_JOYSTICK)
@ -641,7 +641,7 @@ BYTE __stdcall JoyResetPosition(WORD, WORD, BYTE, BYTE, ULONG nCyclesLeft)
if((joyinfo[joytype[1]] == DEVICE_JOYSTICK) || (joyinfo[joytype[1]] == DEVICE_JOYSTICK_THUMBSTICK2))
CheckJoystick1();
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
//===========================================================================

6
source/Joystick.h
View file

@ -28,6 +28,6 @@ void JoySetSnapshot_v1(const unsigned __int64 JoyCntrResetCycle);
void JoySaveSnapshot(class YamlSaveHelper& yamlSaveHelper);
void JoyLoadSnapshot(class YamlLoadHelper& yamlLoadHelper);
BYTE __stdcall JoyReadButton(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall JoyReadPosition(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall JoyResetPosition(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall JoyReadButton(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall JoyReadPosition(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall JoyResetPosition(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);

6
source/Keyboard.h
View file

@ -18,9 +18,9 @@ void KeybSetSnapshot_v1(const BYTE LastKey);
void KeybSaveSnapshot(class YamlSaveHelper& yamlSaveHelper);
void KeybLoadSnapshot(class YamlLoadHelper& yamlLoadHelper);
BYTE __stdcall KeybReadData (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall KeybReadFlag (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall KbdAllow8Bit (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft); //For Pravets A/C only
BYTE __stdcall KeybReadData (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall KeybReadFlag (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall KbdAllow8Bit (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles); //For Pravets A/C only
extern bool g_bShiftKey;
extern bool g_bCtrlKey;

270
source/Memory.cpp
View file

@ -202,134 +202,134 @@ BYTE __stdcall IO_Annunciator(WORD programcounter, WORD address, BYTE write, BYT
//=============================================================================
static BYTE __stdcall IORead_C00x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C00x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return KeybReadData(pc, addr, bWrite, d, nCyclesLeft);
return KeybReadData(pc, addr, bWrite, d, nExecutedCycles);
}
static BYTE __stdcall IOWrite_C00x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C00x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
if ((addr & 0xf) <= 0xB)
return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
else
return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
}
//-------------------------------------
static BYTE __stdcall IORead_C01x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C01x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0: return KeybReadFlag(pc, addr, bWrite, d, nCyclesLeft);
case 0x1: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x2: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x4: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x5: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x6: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x7: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x8: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x9: return VideoCheckVbl(nCyclesLeft);
case 0xA: return VideoCheckMode(pc, addr, bWrite, d, nCyclesLeft);
case 0xB: return VideoCheckMode(pc, addr, bWrite, d, nCyclesLeft);
case 0xC: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0xD: return MemCheckPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0xE: return VideoCheckMode(pc, addr, bWrite, d, nCyclesLeft);
case 0xF: return VideoCheckMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x0: return KeybReadFlag(pc, addr, bWrite, d, nExecutedCycles);
case 0x1: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x2: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x4: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x5: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x6: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x7: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x8: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x9: return VideoCheckVbl(nExecutedCycles);
case 0xA: return VideoCheckMode(pc, addr, bWrite, d, nExecutedCycles);
case 0xB: return VideoCheckMode(pc, addr, bWrite, d, nExecutedCycles);
case 0xC: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0xD: return MemCheckPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0xE: return VideoCheckMode(pc, addr, bWrite, d, nExecutedCycles);
case 0xF: return VideoCheckMode(pc, addr, bWrite, d, nExecutedCycles);
}
return 0;
}
static BYTE __stdcall IOWrite_C01x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C01x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return KeybReadFlag(pc, addr, bWrite, d, nCyclesLeft);
return KeybReadFlag(pc, addr, bWrite, d, nExecutedCycles);
}
//-------------------------------------
static BYTE __stdcall IORead_C02x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C02x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
}
static BYTE __stdcall IOWrite_C02x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C02x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return IO_Null(pc, addr, bWrite, d, nCyclesLeft); // $C020 TAPEOUT
return IO_Null(pc, addr, bWrite, d, nExecutedCycles); // $C020 TAPEOUT
}
//-------------------------------------
static BYTE __stdcall IORead_C03x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C03x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return SpkrToggle(pc, addr, bWrite, d, nCyclesLeft);
return SpkrToggle(pc, addr, bWrite, d, nExecutedCycles);
}
static BYTE __stdcall IOWrite_C03x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C03x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return SpkrToggle(pc, addr, bWrite, d, nCyclesLeft);
return SpkrToggle(pc, addr, bWrite, d, nExecutedCycles);
}
//-------------------------------------
static BYTE __stdcall IORead_C04x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C04x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
}
static BYTE __stdcall IOWrite_C04x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C04x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
}
//-------------------------------------
static BYTE __stdcall IORead_C05x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C05x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x1: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x2: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x4: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x5: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x6: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x7: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x8: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0x9: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xA: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xB: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xC: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xD: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xE: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0xF: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x0: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x1: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x2: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x4: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x5: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x6: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x7: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x8: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0x9: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xA: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xB: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xC: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xD: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xE: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0xF: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
}
return 0;
}
static BYTE __stdcall IOWrite_C05x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C05x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x1: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x2: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x4: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x5: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x6: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x7: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft);
case 0x8: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0x9: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xA: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xB: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xC: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xD: return IO_Annunciator(pc, addr, bWrite, d, nCyclesLeft);
case 0xE: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0xF: return VideoSetMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x0: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x1: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x2: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0x4: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x5: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x6: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x7: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles);
case 0x8: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0x9: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xA: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xB: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xC: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xD: return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
case 0xE: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
case 0xF: return VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
}
return 0;
@ -337,7 +337,7 @@ static BYTE __stdcall IOWrite_C05x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULON
//-------------------------------------
static BYTE __stdcall IORead_C06x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C06x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
static byte CurrentKestroke = 0;
CurrentKestroke = KeybGetKeycode();
@ -347,83 +347,83 @@ static BYTE __stdcall IORead_C06x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG
//If (CAPS lOCK of Pravets8A/C is on or Shift is pressed) and (MODE is enabled), bit7 in $C000 is 1; Else it is 0
//Writing into $C060 sets MODE on and off. If bit 0 is 0 the the MODE is set 0, if bit 0 is 1 then MODE is set to 1 (8-bit)
case 0x0: return TapeRead(pc, addr, bWrite, d, nCyclesLeft); // $C060 TAPEIN
case 0x1: return JoyReadButton(pc, addr, bWrite, d, nCyclesLeft); //$C061 Digital input 0 (If bit 7=1 then JoyButton 0 or OpenApple is pressed)
case 0x2: return JoyReadButton(pc, addr, bWrite, d, nCyclesLeft); //$C062 Digital input 1 (If bit 7=1 then JoyButton 1 or ClosedApple is pressed)
case 0x3: return JoyReadButton(pc, addr, bWrite, d, nCyclesLeft); //$C063 Digital input 2
case 0x4: return JoyReadPosition(pc, addr, bWrite, d, nCyclesLeft); //$C064 Analog input 0
case 0x5: return JoyReadPosition(pc, addr, bWrite, d, nCyclesLeft); //$C065 Analog input 1
case 0x6: return JoyReadPosition(pc, addr, bWrite, d, nCyclesLeft); //$C066 Analog input 2
case 0x7: return JoyReadPosition(pc, addr, bWrite, d, nCyclesLeft); //$C067 Analog input 3
case 0x0: return TapeRead(pc, addr, bWrite, d, nExecutedCycles); // $C060 TAPEIN
case 0x1: return JoyReadButton(pc, addr, bWrite, d, nExecutedCycles); //$C061 Digital input 0 (If bit 7=1 then JoyButton 0 or OpenApple is pressed)
case 0x2: return JoyReadButton(pc, addr, bWrite, d, nExecutedCycles); //$C062 Digital input 1 (If bit 7=1 then JoyButton 1 or ClosedApple is pressed)
case 0x3: return JoyReadButton(pc, addr, bWrite, d, nExecutedCycles); //$C063 Digital input 2
case 0x4: return JoyReadPosition(pc, addr, bWrite, d, nExecutedCycles); //$C064 Analog input 0
case 0x5: return JoyReadPosition(pc, addr, bWrite, d, nExecutedCycles); //$C065 Analog input 1
case 0x6: return JoyReadPosition(pc, addr, bWrite, d, nExecutedCycles); //$C066 Analog input 2
case 0x7: return JoyReadPosition(pc, addr, bWrite, d, nExecutedCycles); //$C067 Analog input 3
}
return 0;
}
static BYTE __stdcall IOWrite_C06x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C06x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0:
if (g_Apple2Type == A2TYPE_PRAVETS8A)
return TapeWrite (pc, addr, bWrite, d, nCyclesLeft);
return TapeWrite (pc, addr, bWrite, d, nExecutedCycles);
else
return IO_Null(pc, addr, bWrite, d, nCyclesLeft); //Apple2 value
return IO_Null(pc, addr, bWrite, d, nExecutedCycles); //Apple2 value
}
return IO_Null(pc, addr, bWrite, d, nCyclesLeft); //Apple2 value
return IO_Null(pc, addr, bWrite, d, nExecutedCycles); //Apple2 value
}
//-------------------------------------
static BYTE __stdcall IORead_C07x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IORead_C07x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0: return JoyResetPosition(pc, addr, bWrite, d, nCyclesLeft); //$C070 Analog input reset
case 0x1: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x2: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x4: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x5: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x6: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x7: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x8: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x9: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xA: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xB: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xC: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xD: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xE: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xF: return VideoCheckMode(pc, addr, bWrite, d, nCyclesLeft);
case 0x0: return JoyResetPosition(pc, addr, bWrite, d, nExecutedCycles); //$C070 Analog input reset
case 0x1: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x2: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x4: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x5: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x6: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x7: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x8: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x9: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xA: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xB: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xC: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xD: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xE: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xF: return VideoCheckMode(pc, addr, bWrite, d, nExecutedCycles);
}
return 0;
}
static BYTE __stdcall IOWrite_C07x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_C07x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
switch (addr & 0xf)
{
case 0x0: return JoyResetPosition(pc, addr, bWrite, d, nCyclesLeft);
case 0x0: return JoyResetPosition(pc, addr, bWrite, d, nExecutedCycles);
#ifdef RAMWORKS
case 0x1: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft); // extended memory card set page
case 0x2: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return MemSetPaging(pc, addr, bWrite, d, nCyclesLeft); // Ramworks III set page
case 0x1: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles); // extended memory card set page
case 0x2: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return MemSetPaging(pc, addr, bWrite, d, nExecutedCycles); // Ramworks III set page
#else
case 0x1: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x2: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x3: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x1: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x2: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x3: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
#endif
case 0x4: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x5: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x6: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x7: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x8: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x9: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xA: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xB: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xC: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0xD: return IO_Null(pc, addr, bWrite, d, nCyclesLeft);
case 0x4: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x5: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x6: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x7: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x8: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0x9: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xA: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xB: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xC: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
case 0xD: return IO_Null(pc, addr, bWrite, d, nExecutedCycles);
//http://www.kreativekorp.com/miscpages/a2info/iomemory.shtml
//- Apparently Apple//e & //c (but maybe enhanced//e not //e?)
@ -431,8 +431,8 @@ static BYTE __stdcall IOWrite_C07x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULON
//IOUDISOFF (W): $C07F Enable IOU
//RDIOUDIS (R7): $C07E Status of IOU Disabling
//RDDHIRES (R7): $C07F Status of Double HiRes
case 0xE: return IO_Null(pc, addr, bWrite, d, nCyclesLeft); // TODO: IOUDIS
case 0xF: return IO_Null(pc, addr, bWrite, d, nCyclesLeft); // TODO: IOUDIS
case 0xE: return IO_Null(pc, addr, bWrite, d, nExecutedCycles); // TODO: IOUDIS
case 0xF: return IO_Null(pc, addr, bWrite, d, nExecutedCycles); // TODO: IOUDIS
}
return 0;
@ -475,15 +475,15 @@ static UINT g_uPeripheralRomSlot = 0;
//=============================================================================
BYTE __stdcall IO_Null(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCyclesLeft)
BYTE __stdcall IO_Null(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nExecutedCycles)
{
if (!write)
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
else
return 0;
}
BYTE __stdcall IO_Annunciator(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCyclesLeft)
BYTE __stdcall IO_Annunciator(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nExecutedCycles)
{
// Apple//e ROM:
// . PC=FA6F: LDA $C058 (SETAN0)
@ -498,7 +498,7 @@ BYTE __stdcall IO_Annunciator(WORD programcounter, WORD address, BYTE write, BYT
}
if (!write)
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
else
return 0;
}
@ -547,7 +547,7 @@ static bool IsCardInSlot(const UINT uSlot);
// . Reset: On access to $CFFF or an MMU reset
//
static BYTE __stdcall IO_Cxxx(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCyclesLeft)
static BYTE __stdcall IO_Cxxx(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nExecutedCycles)
{
if (address == 0xCFFF)
{
@ -682,12 +682,12 @@ static BYTE __stdcall IO_Cxxx(WORD programcounter, WORD address, BYTE write, BYT
// Fix for GH#149 and GH#164
if (bPeripheralSlotRomEnabled && !IsCardInSlot(uSlot)) // Slot is empty
{
return IO_Null(programcounter, address, write, value, nCyclesLeft);
return IO_Null(programcounter, address, write, value, nExecutedCycles);
}
}
if ((g_eExpansionRomType == eExpRomNull) && (address >= FIRMWARE_EXPANSION_BEGIN))
return IO_Null(programcounter, address, write, value, nCyclesLeft);
return IO_Null(programcounter, address, write, value, nExecutedCycles);
return mem[address];
}
@ -1647,7 +1647,7 @@ BYTE MemReadFloatingBus(const BYTE highbit, const ULONG uExecutedCycles)
//#define DEBUG_FLIP_TIMINGS
#if defined(_DEBUG) && defined(DEBUG_FLIP_TIMINGS)
static void DebugFlip(WORD address, ULONG nCyclesLeft)
static void DebugFlip(WORD address, ULONG nExecutedCycles)
{
static unsigned __int64 uLastFlipCycle = 0;
static unsigned int uLastPage = -1;
@ -1660,7 +1660,7 @@ static void DebugFlip(WORD address, ULONG nCyclesLeft)
return;
uLastPage = uNewPage;
CpuCalcCycles(nCyclesLeft); // Update g_nCumulativeCycles
CpuCalcCycles(nExecutedCycles); // Update g_nCumulativeCycles
const unsigned int uCyclesBetweenFlips = (unsigned int) (uLastFlipCycle ? g_nCumulativeCycles - uLastFlipCycle : 0);
uLastFlipCycle = g_nCumulativeCycles;
@ -1676,12 +1676,12 @@ static void DebugFlip(WORD address, ULONG nCyclesLeft)
}
#endif
BYTE __stdcall MemSetPaging(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCyclesLeft)
BYTE __stdcall MemSetPaging(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nExecutedCycles)
{
address &= 0xFF;
DWORD lastmemmode = memmode;
#if defined(_DEBUG) && defined(DEBUG_FLIP_TIMINGS)
DebugFlip(address, nCyclesLeft);
DebugFlip(address, nExecutedCycles);
#endif
// DETERMINE THE NEW MEMORY PAGING MODE.
@ -1798,13 +1798,13 @@ _done_saturn:
if ((address >= 4) && (address <= 5) &&
((*(LPDWORD)(mem+programcounter) & 0x00FFFEFF) == 0x00C0028D)) {
modechanging = 1;
return write ? 0 : MemReadFloatingBus(1, nCyclesLeft);
return write ? 0 : MemReadFloatingBus(1, nExecutedCycles);
}
if ((address >= 0x80) && (address <= 0x8F) && (programcounter < 0xC000) &&
(((*(LPDWORD)(mem+programcounter) & 0x00FFFEFF) == 0x00C0048D) ||
((*(LPDWORD)(mem+programcounter) & 0x00FFFEFF) == 0x00C0028D))) {
modechanging = 1;
return write ? 0 : MemReadFloatingBus(1, nCyclesLeft);
return write ? 0 : MemReadFloatingBus(1, nExecutedCycles);
}
// IF THE MEMORY PAGING MODE HAS CHANGED, UPDATE OUR MEMORY IMAGES AND
@ -1844,9 +1844,9 @@ _done_saturn:
}
if ((address <= 1) || ((address >= 0x54) && (address <= 0x57)))
return VideoSetMode(programcounter,address,write,value,nCyclesLeft);
return VideoSetMode(programcounter,address,write,value,nExecutedCycles);
return write ? 0 : MemReadFloatingBus(nCyclesLeft);
return write ? 0 : MemReadFloatingBus(nExecutedCycles);
}
//===========================================================================

7
source/Memory.h
View file

@ -47,8 +47,7 @@ enum MemoryType_e
NUM_MEM_TYPE = 3
};
// TODO-TC: Refactor codebase by renaming /nCyclesLeft/ to /uExecutedCycles/
typedef BYTE (__stdcall *iofunction)(WORD nPC, WORD nAddr, BYTE nWriteFlag, BYTE nWriteValue, ULONG nCyclesLeft);
typedef BYTE (__stdcall *iofunction)(WORD nPC, WORD nAddr, BYTE nWriteFlag, BYTE nWriteValue, ULONG nExecutedCycles);
extern MemoryType_e g_eMemType;
@ -100,5 +99,5 @@ bool MemLoadSnapshotAux(class YamlLoadHelper& yamlLoadHelper, UINT version);
BYTE __stdcall IO_Null(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCycles);
BYTE __stdcall MemCheckPaging (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall MemSetPaging(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall MemCheckPaging (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall MemSetPaging(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);

22
source/Mockingboard.cpp
View file

@ -1476,9 +1476,9 @@ void MB_Reset()
//-----------------------------------------------------------------------------
static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nCyclesLeft)
static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nExecutedCycles)
{
MB_UpdateCycles(nCyclesLeft);
MB_UpdateCycles(nExecutedCycles);
#ifdef _DEBUG
if(!IS_APPLE2 && !MemCheckSLOTCXROM())
@ -1490,7 +1490,7 @@ static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULO
if(g_SoundcardType == CT_Empty)
{
_ASSERT(0); // Card unplugged, so IO_Cxxx() returns the floating bus
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
#endif
@ -1500,7 +1500,7 @@ static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULO
if(g_bPhasorEnable)
{
if(nMB != 0) // Slot4 only
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
int CS;
if(g_nPhasorMode & 1)
@ -1524,7 +1524,7 @@ static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULO
bAccessedDevice = true;
}
return bAccessedDevice ? nRes : MemReadFloatingBus(nCyclesLeft);
return bAccessedDevice ? nRes : MemReadFloatingBus(nExecutedCycles);
}
if(nOffset <= (SY6522A_Offset+0x0F))
@ -1534,14 +1534,14 @@ static BYTE __stdcall MB_Read(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULO
else if((nOffset >= SSI263_Offset) && (nOffset <= (SSI263_Offset+0x05)))
return SSI263_Read(nMB, nAddr&0xf);
else
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
//-----------------------------------------------------------------------------
static BYTE __stdcall MB_Write(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nCyclesLeft)
static BYTE __stdcall MB_Write(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nExecutedCycles)
{
MB_UpdateCycles(nCyclesLeft);
MB_UpdateCycles(nExecutedCycles);
#ifdef _DEBUG
if(!IS_APPLE2 && !MemCheckSLOTCXROM())
@ -1596,10 +1596,10 @@ static BYTE __stdcall MB_Write(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, UL
//-----------------------------------------------------------------------------
static BYTE __stdcall PhasorIO(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nCyclesLeft)
static BYTE __stdcall PhasorIO(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, ULONG nExecutedCycles)
{
if(!g_bPhasorEnable)
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
if(g_nPhasorMode < 2)
g_nPhasorMode = nAddr & 1;
@ -1608,7 +1608,7 @@ static BYTE __stdcall PhasorIO(WORD PC, WORD nAddr, BYTE bWrite, BYTE nValue, UL
AY8910_InitClock((int)(CLK_6502 * g_PhasorClockScaleFactor));
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
//-----------------------------------------------------------------------------

4
source/MouseInterface.cpp
View file

@ -236,7 +236,7 @@ void CMouseInterface::SetSlotRom()
//===========================================================================
BYTE __stdcall CMouseInterface::IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CMouseInterface::IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
UINT uSlot = ((uAddr & 0xff) >> 4) - 8;
CMouseInterface* pMouseIF = (CMouseInterface*) MemGetSlotParameters(uSlot);
@ -246,7 +246,7 @@ BYTE __stdcall CMouseInterface::IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uV
return pMouseIF->m_6821.Read( byRS );
}
BYTE __stdcall CMouseInterface::IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CMouseInterface::IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
UINT uSlot = ((uAddr & 0xff) >> 4) - 8;
CMouseInterface* pMouseIF = (CMouseInterface*) MemGetSlotParameters(uSlot);

4
source/MouseInterface.h
View file

@ -12,8 +12,8 @@ public:
void Initialize(LPBYTE pCxRomPeripheral, UINT uSlot);
void Uninitialize();
void Reset();
static BYTE __stdcall IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft);
static BYTE __stdcall IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft);
static BYTE __stdcall IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles);
static BYTE __stdcall IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles);
void SetPositionRel(long dx, long dy, int* pOutOfBoundsX, int* pOutOfBoundsY);
void SetButton(eBUTTON Button, eBUTTONSTATE State);

6
source/SAM.cpp
View file

@ -42,7 +42,7 @@
//
static BYTE __stdcall IOWrite_SAM(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
static BYTE __stdcall IOWrite_SAM(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{
// Emulate audio from a SAM / 8 bit DAC card
// Only supportable if AppleWin is using WAVE output
@ -59,10 +59,10 @@ static BYTE __stdcall IOWrite_SAM(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG
// silence.
if (soundtype != SOUND_WAVE)
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
// use existing speaker code to bring timing up to date
BYTE res = SpkrToggle(pc, addr, bWrite, d, nCyclesLeft);
BYTE res = SpkrToggle(pc, addr, bWrite, d, nExecutedCycles);
// The DAC in the SAM uses unsigned 8 bit samples
// The WAV data that g_nSpeakerData is loaded into is a signed short

68
source/SerialComms.cpp
View file

@ -408,57 +408,57 @@ void CSuperSerialCard::CommTcpSerialReceive()
//===========================================================================
BYTE __stdcall CSuperSerialCard::SSC_IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CSuperSerialCard::SSC_IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
UINT uSlot = ((uAddr & 0xff) >> 4) - 8;
CSuperSerialCard* pSSC = (CSuperSerialCard*) MemGetSlotParameters(uSlot);
switch (uAddr & 0xf)
{
case 0x0: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x1: return pSSC->CommDipSw(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x2: return pSSC->CommDipSw(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x3: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x4: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x5: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x6: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x7: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x8: return pSSC->CommReceive(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x9: return pSSC->CommStatus(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xA: return pSSC->CommCommand(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xB: return pSSC->CommControl(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xC: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xD: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xE: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xF: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x0: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x1: return pSSC->CommDipSw(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x2: return pSSC->CommDipSw(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x3: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x4: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x5: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x6: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x7: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x8: return pSSC->CommReceive(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x9: return pSSC->CommStatus(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xA: return pSSC->CommCommand(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xB: return pSSC->CommControl(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xC: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xD: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xE: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xF: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
}
return 0;
}
BYTE __stdcall CSuperSerialCard::SSC_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CSuperSerialCard::SSC_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
UINT uSlot = ((uAddr & 0xff) >> 4) - 8;
CSuperSerialCard* pSSC = (CSuperSerialCard*) MemGetSlotParameters(uSlot);
switch (uAddr & 0xf)
{
case 0x0: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x1: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x2: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x3: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x4: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x5: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x6: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x7: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x8: return pSSC->CommTransmit(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x9: return pSSC->CommStatus(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xA: return pSSC->CommCommand(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xB: return pSSC->CommControl(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xC: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xD: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xE: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0xF: return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
case 0x0: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x1: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x2: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x3: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x4: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x5: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x6: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x7: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x8: return pSSC->CommTransmit(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0x9: return pSSC->CommStatus(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xA: return pSSC->CommCommand(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xB: return pSSC->CommControl(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xC: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xD: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xE: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
case 0xF: return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
}
return 0;

16
source/SerialComms.h
View file

@ -52,16 +52,16 @@ public:
void CommTcpSerialClose();
void CommTcpSerialCleanup();
static BYTE __stdcall SSC_IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft);
static BYTE __stdcall SSC_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft);
static BYTE __stdcall SSC_IORead(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles);
static BYTE __stdcall SSC_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles);
private:
BYTE __stdcall CommCommand(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommControl(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommDipSw(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommReceive(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommStatus(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommTransmit(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall CommCommand(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall CommControl(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall CommDipSw(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall CommReceive(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall CommStatus(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
BYTE __stdcall CommTransmit(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
void InternalReset();
void GetDIPSW();

6
source/Speaker.cpp
View file

@ -372,7 +372,7 @@ static void UpdateSpkr()
// Called by emulation code when Speaker I/O reg is accessed
//
BYTE __stdcall SpkrToggle (WORD, WORD, BYTE, BYTE, ULONG nCyclesLeft)
BYTE __stdcall SpkrToggle (WORD, WORD, BYTE, BYTE, ULONG nExecutedCycles)
{
g_bSpkrToggleFlag = true;
@ -390,7 +390,7 @@ BYTE __stdcall SpkrToggle (WORD, WORD, BYTE, BYTE, ULONG nCyclesLeft)
if (soundtype == SOUND_WAVE)
{
CpuCalcCycles(nCyclesLeft);
CpuCalcCycles(nExecutedCycles);
UpdateSpkr();
@ -406,7 +406,7 @@ BYTE __stdcall SpkrToggle (WORD, WORD, BYTE, BYTE, ULONG nCyclesLeft)
g_nSpeakerData = speakerDriveLevel;
}
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
//=============================================================================

2
source/Speaker.h
View file

@ -37,4 +37,4 @@ void SpkrSetSnapshot_v1(const unsigned __int64 SpkrLastCycle);
void SpkrSaveSnapshot(class YamlSaveHelper& yamlSaveHelper);
void SpkrLoadSnapshot(class YamlLoadHelper& yamlLoadHelper);
BYTE __stdcall SpkrToggle (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
BYTE __stdcall SpkrToggle (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);

14
source/Tape.cpp
View file

@ -40,19 +40,19 @@ static bool g_CapsLockAllowed = false;
//---------------------------------------------------------------------------
BYTE __stdcall TapeRead(WORD, WORD address, BYTE, BYTE, ULONG nCyclesLeft)
BYTE __stdcall TapeRead(WORD, WORD address, BYTE, BYTE, ULONG nExecutedCycles)
{
/*
If retrieving KeybGetKeycode(); causes problems uCurrentKeystroke shall be added
in the submission variables and it shall be added by the TapeRead caller
i.e. BYTE __stdcall TapeRead (WORD, WORD address, BYTE, BYTE, ULONG nCyclesLeft) shall become
BYTE __stdcall TapeRead (WORD, WORD address, BYTE, BYTE, ULONG nCyclesLeft, BYTE uCurrentKeystroke)
i.e. BYTE __stdcall TapeRead (WORD, WORD address, BYTE, BYTE, ULONG nExecutedCycles) shall become
BYTE __stdcall TapeRead (WORD, WORD address, BYTE, BYTE, ULONG nExecutedCycles, BYTE uCurrentKeystroke)
*/
if (g_Apple2Type == A2TYPE_PRAVETS8A)
{
const BYTE uCurrentKeystroke = KeybGetKeycode();
BYTE C060 = MemReadFloatingBus(nCyclesLeft);
BYTE C060 = MemReadFloatingBus(nExecutedCycles);
if (g_CapsLockAllowed) //8bit keyboard mode
{
@ -78,14 +78,14 @@ BYTE __stdcall TapeRead(WORD, WORD address, BYTE, BYTE, ULONG nCyclesLeft)
return C060;
}
return MemReadFloatingBus(1, nCyclesLeft); // TAPEIN has high bit 1 when input is low or not connected (UTAIIe page 7-5, 7-6)
return MemReadFloatingBus(1, nExecutedCycles); // TAPEIN has high bit 1 when input is low or not connected (UTAIIe page 7-5, 7-6)
}
/*
In case s.o. decides to develop tape device emulation, this function may be renamed,
because tape is not written in $C060
*/
BYTE __stdcall TapeWrite(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nCyclesLeft)
BYTE __stdcall TapeWrite(WORD programcounter, WORD address, BYTE write, BYTE value, ULONG nExecutedCycles)
{
if (g_Apple2Type == A2TYPE_PRAVETS8A)
{
@ -99,7 +99,7 @@ BYTE __stdcall TapeWrite(WORD programcounter, WORD address, BYTE write, BYTE val
return 0;
}
return MemReadFloatingBus(nCyclesLeft);
return MemReadFloatingBus(nExecutedCycles);
}
bool GetCapsLockAllowed(void)

4
source/Tape.h
View file

@ -1,5 +1,5 @@
#pragma once
extern BYTE __stdcall TapeRead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
extern BYTE __stdcall TapeWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft);
extern BYTE __stdcall TapeRead(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
extern BYTE __stdcall TapeWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles);
extern bool GetCapsLockAllowed(void);

8
source/z80emu.cpp
View file

@ -23,17 +23,17 @@
// Variaveis
static int g_uCPMZ80Slot = 0;
BYTE __stdcall CPMZ80_IONull(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CPMZ80_IONull(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
}
BYTE __stdcall CPMZ80_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nCyclesLeft)
BYTE __stdcall CPMZ80_IOWrite(WORD PC, WORD uAddr, BYTE bWrite, BYTE uValue, ULONG nExecutedCycles)
{
if ((uAddr & 0xFF00) == (0xC000 + (g_uCPMZ80Slot << 8)))
SetActiveCpu( GetActiveCpu() == CPU_Z80 ? GetMainCpu() : CPU_Z80 );
return IO_Null(PC, uAddr, bWrite, uValue, nCyclesLeft);
return IO_Null(PC, uAddr, bWrite, uValue, nExecutedCycles);
}
//===========================================================================