mirror of
https://github.com/AppleWin/AppleWin.git
synced 2024-06-18 03:29:30 +00:00
Save-state: Renamed YamlLoadHelper load-type functions to be more consistent with YamlSaveHelper functions
This commit is contained in:
tomcw
parent
6b07fd665f
commit
11789c9023
|
|
@ -1053,51 +1053,51 @@ bool CAY8910::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, std::string& suffix)
|
|||
if (!yamlLoadHelper.GetSubMap(unit))
|
||||
throw std::string("Card: Expected key: ") + unit;
|
||||
|
||||
ay_tone_tick[0] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE0_TICK);
|
||||
ay_tone_tick[1] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE1_TICK);
|
||||
ay_tone_tick[2] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE2_TICK);
|
||||
ay_tone_high[0] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE0_HIGH);
|
||||
ay_tone_high[1] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE1_HIGH);
|
||||
ay_tone_high[2] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE2_HIGH);
|
||||
ay_noise_tick = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_NOISE_TICK);
|
||||
ay_tone_subcycles = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE_SUBCYCLES);
|
||||
ay_env_subcycles = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_SUBCYCLES);
|
||||
ay_env_internal_tick = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_INTERNAL_TICK);
|
||||
ay_env_tick = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_TICK);
|
||||
ay_tick_incr = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TICK_INCR);
|
||||
ay_tone_period[0] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE0_PERIOD);
|
||||
ay_tone_period[1] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE1_PERIOD);
|
||||
ay_tone_period[2] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TONE2_PERIOD);
|
||||
ay_noise_period = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_NOISE_PERIOD);
|
||||
rng = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_RNG);
|
||||
noise_toggle = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_NOISE_TOGGLE);
|
||||
env_first = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_FIRST);
|
||||
env_rev = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_REV);
|
||||
env_counter = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENV_COUNTER);
|
||||
ay_tone_tick[0] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE0_TICK);
|
||||
ay_tone_tick[1] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE1_TICK);
|
||||
ay_tone_tick[2] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE2_TICK);
|
||||
ay_tone_high[0] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE0_HIGH);
|
||||
ay_tone_high[1] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE1_HIGH);
|
||||
ay_tone_high[2] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE2_HIGH);
|
||||
ay_noise_tick = yamlLoadHelper.LoadUint(SS_YAML_KEY_NOISE_TICK);
|
||||
ay_tone_subcycles = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE_SUBCYCLES);
|
||||
ay_env_subcycles = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_SUBCYCLES);
|
||||
ay_env_internal_tick = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_INTERNAL_TICK);
|
||||
ay_env_tick = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_TICK);
|
||||
ay_tick_incr = yamlLoadHelper.LoadUint(SS_YAML_KEY_TICK_INCR);
|
||||
ay_tone_period[0] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE0_PERIOD);
|
||||
ay_tone_period[1] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE1_PERIOD);
|
||||
ay_tone_period[2] = yamlLoadHelper.LoadUint(SS_YAML_KEY_TONE2_PERIOD);
|
||||
ay_noise_period = yamlLoadHelper.LoadUint(SS_YAML_KEY_NOISE_PERIOD);
|
||||
rng = yamlLoadHelper.LoadUint(SS_YAML_KEY_RNG);
|
||||
noise_toggle = yamlLoadHelper.LoadUint(SS_YAML_KEY_NOISE_TOGGLE);
|
||||
env_first = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_FIRST);
|
||||
env_rev = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_REV);
|
||||
env_counter = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENV_COUNTER);
|
||||
|
||||
if (!yamlLoadHelper.GetSubMap(SS_YAML_KEY_REGISTERS))
|
||||
throw std::string("Card: Expected key: ") + SS_YAML_KEY_REGISTERS;
|
||||
|
||||
USHORT period = (USHORT) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_TONE0_PERIOD);
|
||||
USHORT period = (USHORT) yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_TONE0_PERIOD);
|
||||
sound_ay_registers[0] = period & 0xff;
|
||||
sound_ay_registers[1] = (period >> 8) & 0xf;
|
||||
period = (USHORT) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_TONE1_PERIOD);
|
||||
period = (USHORT) yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_TONE1_PERIOD);
|
||||
sound_ay_registers[2] = period & 0xff;
|
||||
sound_ay_registers[3] = (period >> 8) & 0xf;
|
||||
period = (USHORT) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_TONE2_PERIOD);
|
||||
period = (USHORT) yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_TONE2_PERIOD);
|
||||
sound_ay_registers[4] = period & 0xff;
|
||||
sound_ay_registers[5] = (period >> 8) & 0xf;
|
||||
sound_ay_registers[6] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_NOISE_PERIOD);
|
||||
sound_ay_registers[7] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_MIXER);
|
||||
sound_ay_registers[8] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_VOL0);
|
||||
sound_ay_registers[9] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_VOL1);
|
||||
sound_ay_registers[10] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_VOL2);
|
||||
period = (USHORT) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_ENV_PERIOD);
|
||||
sound_ay_registers[6] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_NOISE_PERIOD);
|
||||
sound_ay_registers[7] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_MIXER);
|
||||
sound_ay_registers[8] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_VOL0);
|
||||
sound_ay_registers[9] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_VOL1);
|
||||
sound_ay_registers[10] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_VOL2);
|
||||
period = (USHORT) yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_ENV_PERIOD);
|
||||
sound_ay_registers[11] = period & 0xff;
|
||||
sound_ay_registers[12] = period >> 8;
|
||||
sound_ay_registers[13] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_ENV_SHAPE);
|
||||
sound_ay_registers[14] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_PORTA);
|
||||
sound_ay_registers[15] = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REG_PORTB);
|
||||
sound_ay_registers[13] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_ENV_SHAPE);
|
||||
sound_ay_registers[14] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_PORTA);
|
||||
sound_ay_registers[15] = yamlLoadHelper.LoadUint(SS_YAML_KEY_REG_PORTB);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
||||
|
|
@ -1110,7 +1110,7 @@ bool CAY8910::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, std::string& suffix)
|
|||
sprintf_s(szIndex, sizeof(szIndex), "0x%04X", ay_change_count);
|
||||
|
||||
bool bFound;
|
||||
std::string value = yamlLoadHelper.GetMapValueSTRING_NoThrow(szIndex, bFound);
|
||||
std::string value = yamlLoadHelper.LoadString_NoThrow(szIndex, bFound);
|
||||
if (!bFound)
|
||||
break; // done
|
||||
|
||||
|
|
|
|||
|
|
@ -744,23 +744,23 @@ void CpuLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(CpuGetSnapshotStructName()))
|
||||
return;
|
||||
|
||||
std::string cpuType = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_CPU_TYPE);
|
||||
std::string cpuType = yamlLoadHelper.LoadString(SS_YAML_KEY_CPU_TYPE);
|
||||
eCpuType cpu;
|
||||
if (cpuType == SS_YAML_VALUE_6502) cpu = CPU_6502;
|
||||
else if (cpuType == SS_YAML_VALUE_65C02) cpu = CPU_65C02;
|
||||
else throw std::string("Load: Unknown main CPU type");
|
||||
SetMainCpu(cpu);
|
||||
|
||||
regs.a = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGA);
|
||||
regs.x = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGX);
|
||||
regs.y = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGY);
|
||||
regs.ps = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGP) | (AF_RESERVED | AF_BREAK);
|
||||
regs.sp = (USHORT) ((yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGS) & 0xff) | 0x100);
|
||||
regs.pc = (USHORT) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGPC);
|
||||
regs.a = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_REGA);
|
||||
regs.x = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_REGX);
|
||||
regs.y = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_REGY);
|
||||
regs.ps = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_REGP) | (AF_RESERVED | AF_BREAK);
|
||||
regs.sp = (USHORT) ((yamlLoadHelper.LoadUint(SS_YAML_KEY_REGS) & 0xff) | 0x100);
|
||||
regs.pc = (USHORT) yamlLoadHelper.LoadUint(SS_YAML_KEY_REGPC);
|
||||
|
||||
CpuIrqReset();
|
||||
CpuNmiReset();
|
||||
g_nCumulativeCycles = yamlLoadHelper.GetMapValueUINT64(SS_YAML_KEY_CUMULATIVECYCLES);
|
||||
g_nCumulativeCycles = yamlLoadHelper.LoadUint64(SS_YAML_KEY_CUMULATIVECYCLES);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1249,7 +1249,7 @@ static void DiskLoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper, UINT unit)
|
|||
g_aFloppyDisk[unit].imagename[0] = 0;
|
||||
g_aFloppyDisk[unit].bWriteProtected = false; // Default to false (until image is successfully loaded below)
|
||||
|
||||
std::string filename = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_FILENAME).c_str();
|
||||
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
|
||||
if (!filename.empty())
|
||||
{
|
||||
DWORD dwAttributes = GetFileAttributes(filename.c_str());
|
||||
|
|
@ -1274,21 +1274,21 @@ static void DiskLoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper, UINT unit)
|
|||
}
|
||||
}
|
||||
|
||||
g_aFloppyDisk[unit].track = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TRACK);
|
||||
g_aFloppyDisk[unit].phase = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PHASE);
|
||||
g_aFloppyDisk[unit].byte = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BYTE);
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_WRITE_PROTECTED); // Consume
|
||||
g_aFloppyDisk[unit].spinning = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SPINNING);
|
||||
g_aFloppyDisk[unit].writelight = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_WRITE_LIGHT);
|
||||
g_aFloppyDisk[unit].nibbles = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_NIBBLES);
|
||||
g_aFloppyDisk[unit].trackimagedata = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TRACK_IMAGE_DATA);
|
||||
g_aFloppyDisk[unit].trackimagedirty = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TRACK_IMAGE_DIRTY);
|
||||
g_aFloppyDisk[unit].track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK);
|
||||
g_aFloppyDisk[unit].phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE);
|
||||
g_aFloppyDisk[unit].byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE);
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_PROTECTED); // Consume
|
||||
g_aFloppyDisk[unit].spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING);
|
||||
g_aFloppyDisk[unit].writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT);
|
||||
g_aFloppyDisk[unit].nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES);
|
||||
g_aFloppyDisk[unit].trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA);
|
||||
g_aFloppyDisk[unit].trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY);
|
||||
|
||||
std::auto_ptr<BYTE> pTrack( new BYTE [NIBBLES_PER_TRACK] );
|
||||
memset(pTrack.get(), 0, NIBBLES_PER_TRACK);
|
||||
if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE))
|
||||
{
|
||||
yamlLoadHelper.GetMapValueMemory(pTrack.get(), NIBBLES_PER_TRACK);
|
||||
yamlLoadHelper.LoadMemory(pTrack.get(), NIBBLES_PER_TRACK);
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
||||
|
|
@ -1323,13 +1323,13 @@ bool DiskLoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT slot, UINT vers
|
|||
if (version != 1)
|
||||
throw std::string("Card: wrong version");
|
||||
|
||||
phases = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PHASES);
|
||||
currdrive = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CURRENT_DRIVE);
|
||||
diskaccessed = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_DISK_ACCESSED);
|
||||
enhancedisk = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ENHANCE_DISK);
|
||||
floppylatch = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_FLOPPY_LATCH);
|
||||
floppymotoron = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_FLOPPY_MOTOR_ON);
|
||||
floppywritemode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_FLOPPY_WRITE_MODE);
|
||||
phases = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASES);
|
||||
currdrive = yamlLoadHelper.LoadUint(SS_YAML_KEY_CURRENT_DRIVE);
|
||||
diskaccessed = yamlLoadHelper.LoadUint(SS_YAML_KEY_DISK_ACCESSED);
|
||||
enhancedisk = yamlLoadHelper.LoadUint(SS_YAML_KEY_ENHANCE_DISK);
|
||||
floppylatch = yamlLoadHelper.LoadUint(SS_YAML_KEY_FLOPPY_LATCH);
|
||||
floppymotoron = yamlLoadHelper.LoadUint(SS_YAML_KEY_FLOPPY_MOTOR_ON);
|
||||
floppywritemode = yamlLoadHelper.LoadUint(SS_YAML_KEY_FLOPPY_WRITE_MODE);
|
||||
|
||||
// Eject all disks first in case Drive-2 contains disk to be inserted into Drive-1
|
||||
for(UINT i=0; i<NUM_DRIVES; i++)
|
||||
|
|
|
|||
|
|
@ -731,18 +731,18 @@ static bool HD_LoadSnapshotHDDUnit(YamlLoadHelper& yamlLoadHelper, UINT unit)
|
|||
g_HardDisk[unit].hd_status_next = DISK_STATUS_OFF;
|
||||
g_HardDisk[unit].hd_status_prev = DISK_STATUS_OFF;
|
||||
|
||||
std::string filename = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_FILENAME).c_str();
|
||||
g_HardDisk[unit].hd_error = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ERROR);
|
||||
g_HardDisk[unit].hd_memblock = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_MEMBLOCK);
|
||||
g_HardDisk[unit].hd_diskblock = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_DISKBLOCK);
|
||||
yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_IMAGELOADED); // Consume
|
||||
Disk_Status_e diskStatusNext = (Disk_Status_e) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_STATUS_NEXT);
|
||||
Disk_Status_e diskStatusPrev = (Disk_Status_e) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_STATUS_PREV);
|
||||
g_HardDisk[unit].hd_buf_ptr = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BUF_PTR);
|
||||
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
|
||||
g_HardDisk[unit].hd_error = yamlLoadHelper.LoadUint(SS_YAML_KEY_ERROR);
|
||||
g_HardDisk[unit].hd_memblock = yamlLoadHelper.LoadUint(SS_YAML_KEY_MEMBLOCK);
|
||||
g_HardDisk[unit].hd_diskblock = yamlLoadHelper.LoadUint(SS_YAML_KEY_DISKBLOCK);
|
||||
yamlLoadHelper.LoadBool(SS_YAML_KEY_IMAGELOADED); // Consume
|
||||
Disk_Status_e diskStatusNext = (Disk_Status_e) yamlLoadHelper.LoadUint(SS_YAML_KEY_STATUS_NEXT);
|
||||
Disk_Status_e diskStatusPrev = (Disk_Status_e) yamlLoadHelper.LoadUint(SS_YAML_KEY_STATUS_PREV);
|
||||
g_HardDisk[unit].hd_buf_ptr = yamlLoadHelper.LoadUint(SS_YAML_KEY_BUF_PTR);
|
||||
|
||||
if (!yamlLoadHelper.GetSubMap(SS_YAML_KEY_BUF))
|
||||
throw hddUnitName + std::string(": Missing: ") + std::string(SS_YAML_KEY_BUF);
|
||||
yamlLoadHelper.GetMapValueMemory(g_HardDisk[unit].hd_buf, HD_BLOCK_SIZE);
|
||||
yamlLoadHelper.LoadMemory(g_HardDisk[unit].hd_buf, HD_BLOCK_SIZE);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
yamlLoadHelper.PopMap();
|
||||
|
|
@ -791,8 +791,8 @@ bool HD_LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT slot, UINT version, co
|
|||
if (version != 1)
|
||||
throw std::string("Card: wrong version");
|
||||
|
||||
g_nHD_UnitNum = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CURRENT_UNIT); // b7=unit
|
||||
g_nHD_Command = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_COMMAND);
|
||||
g_nHD_UnitNum = yamlLoadHelper.LoadUint(SS_YAML_KEY_CURRENT_UNIT); // b7=unit
|
||||
g_nHD_Command = yamlLoadHelper.LoadUint(SS_YAML_KEY_COMMAND);
|
||||
|
||||
// Unplug all HDDs first in case HDD-2 is to be plugged in as HDD-1
|
||||
for (UINT i=0; i<NUM_HARDDISKS; i++)
|
||||
|
|
|
|||
|
|
@ -883,11 +883,11 @@ void JoyLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(JoyGetSnapshotStructName()))
|
||||
return;
|
||||
|
||||
g_nJoyCntrResetCycle = yamlLoadHelper.GetMapValueUINT64(SS_YAML_KEY_COUNTERRESETCYCLE);
|
||||
JoySetTrim(yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_JOY0TRIMX), true);
|
||||
JoySetTrim(yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_JOY0TRIMY), false);
|
||||
yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_JOY1TRIMX); // dump value
|
||||
yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_JOY1TRIMY); // dump value
|
||||
g_nJoyCntrResetCycle = yamlLoadHelper.LoadUint64(SS_YAML_KEY_COUNTERRESETCYCLE);
|
||||
JoySetTrim(yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMX), true);
|
||||
JoySetTrim(yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMY), false);
|
||||
yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMX); // dump value
|
||||
yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMY); // dump value
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -527,7 +527,7 @@ void KeybLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(KeybGetSnapshotStructName()))
|
||||
return;
|
||||
|
||||
g_nLastKey = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_LASTKEY);
|
||||
g_nLastKey = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_LASTKEY);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1761,12 +1761,12 @@ bool MemLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(MemGetSnapshotStructName()))
|
||||
return false;
|
||||
|
||||
SetMemMode( yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_MEMORYMODE) );
|
||||
lastwriteram = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_LASTRAMWRITE) ? TRUE : FALSE;
|
||||
IO_SELECT = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IOSELECT);
|
||||
IO_SELECT_InternalROM = (BYTE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IOSELECT_INT);
|
||||
g_eExpansionRomType = (eExpansionRomType) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_EXPANSIONROMTYPE);
|
||||
g_uPeripheralRomSlot = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PERIPHERALROMSLOT);
|
||||
SetMemMode( yamlLoadHelper.LoadUint(SS_YAML_KEY_MEMORYMODE) );
|
||||
lastwriteram = yamlLoadHelper.LoadUint(SS_YAML_KEY_LASTRAMWRITE) ? TRUE : FALSE;
|
||||
IO_SELECT = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_IOSELECT);
|
||||
IO_SELECT_InternalROM = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_IOSELECT_INT);
|
||||
g_eExpansionRomType = (eExpansionRomType) yamlLoadHelper.LoadUint(SS_YAML_KEY_EXPANSIONROMTYPE);
|
||||
g_uPeripheralRomSlot = yamlLoadHelper.LoadUint(SS_YAML_KEY_PERIPHERALROMSLOT);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
||||
|
|
@ -1775,7 +1775,7 @@ bool MemLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap( MemGetSnapshotMainMemStructName() ))
|
||||
throw std::string("Card: Expected key: ") + MemGetSnapshotMainMemStructName();
|
||||
|
||||
yamlLoadHelper.GetMapValueMemory(memmain, _6502_MEM_END+1);
|
||||
yamlLoadHelper.LoadMemory(memmain, _6502_MEM_END+1);
|
||||
memset(memdirty, 0, 0x100);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
|
@ -1823,10 +1823,10 @@ bool MemLoadSnapshotAux(YamlLoadHelper& yamlLoadHelper, UINT version)
|
|||
throw std::string(SS_YAML_KEY_UNIT ": AuxSlot: Version mismatch");
|
||||
|
||||
// "State"
|
||||
UINT numAuxBanks = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_NUMAUXBANKS);
|
||||
UINT activeAuxBank = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ACTIVEAUXBANK);
|
||||
UINT numAuxBanks = yamlLoadHelper.LoadUint(SS_YAML_KEY_NUMAUXBANKS);
|
||||
UINT activeAuxBank = yamlLoadHelper.LoadUint(SS_YAML_KEY_ACTIVEAUXBANK);
|
||||
|
||||
std::string card = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_CARD);
|
||||
std::string card = yamlLoadHelper.LoadString(SS_YAML_KEY_CARD);
|
||||
if (card == SS_YAML_VALUE_CARD_80COL)
|
||||
{
|
||||
if (numAuxBanks != 0 || activeAuxBank != 0)
|
||||
|
|
@ -1871,7 +1871,7 @@ bool MemLoadSnapshotAux(YamlLoadHelper& yamlLoadHelper, UINT version)
|
|||
if (!yamlLoadHelper.GetSubMap(auxMemName))
|
||||
throw std::string("Memory: Missing map name: " + auxMemName);
|
||||
|
||||
yamlLoadHelper.GetMapValueMemory(pBank, _6502_MEM_END+1);
|
||||
yamlLoadHelper.LoadMemory(pBank, _6502_MEM_END+1);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2001,19 +2001,19 @@ static void LoadSnapshotSY6522(YamlLoadHelper& yamlLoadHelper, SY6522& sy6522)
|
|||
if (!yamlLoadHelper.GetSubMap(SS_YAML_KEY_SY6522))
|
||||
throw std::string("Card: Expected key: ") + std::string(SS_YAML_KEY_SY6522);
|
||||
|
||||
sy6522.ORB = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_ORB);
|
||||
sy6522.ORA = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_ORA);
|
||||
sy6522.DDRB = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_DDRB);
|
||||
sy6522.DDRA = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_DDRA);
|
||||
sy6522.TIMER1_COUNTER.w = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_T1_COUNTER);
|
||||
sy6522.TIMER1_LATCH.w = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_T1_LATCH);
|
||||
sy6522.TIMER2_COUNTER.w = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_T2_COUNTER);
|
||||
sy6522.TIMER2_LATCH.w = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_T2_LATCH);
|
||||
sy6522.SERIAL_SHIFT = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_SERIAL_SHIFT);
|
||||
sy6522.ACR = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_ACR);
|
||||
sy6522.PCR = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_PCR);
|
||||
sy6522.IFR = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_IFR);
|
||||
sy6522.IER = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SY6522_REG_IER);
|
||||
sy6522.ORB = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_ORB);
|
||||
sy6522.ORA = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_ORA);
|
||||
sy6522.DDRB = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_DDRB);
|
||||
sy6522.DDRA = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_DDRA);
|
||||
sy6522.TIMER1_COUNTER.w = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_T1_COUNTER);
|
||||
sy6522.TIMER1_LATCH.w = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_T1_LATCH);
|
||||
sy6522.TIMER2_COUNTER.w = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_T2_COUNTER);
|
||||
sy6522.TIMER2_LATCH.w = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_T2_LATCH);
|
||||
sy6522.SERIAL_SHIFT = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_SERIAL_SHIFT);
|
||||
sy6522.ACR = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_ACR);
|
||||
sy6522.PCR = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_PCR);
|
||||
sy6522.IFR = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_IFR);
|
||||
sy6522.IER = yamlLoadHelper.LoadUint(SS_YAML_KEY_SY6522_REG_IER);
|
||||
sy6522.ORA_NO_HS = 0; // Not saved
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
|
@ -2024,12 +2024,12 @@ static void LoadSnapshotSSI263(YamlLoadHelper& yamlLoadHelper, SSI263A& ssi263)
|
|||
if (!yamlLoadHelper.GetSubMap(SS_YAML_KEY_SSI263))
|
||||
throw std::string("Card: Expected key: ") + std::string(SS_YAML_KEY_SSI263);
|
||||
|
||||
ssi263.DurationPhoneme = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_DUR_PHON);
|
||||
ssi263.Inflection = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_INF);
|
||||
ssi263.RateInflection = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_RATE_INF);
|
||||
ssi263.CtrlArtAmp = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_CTRL_ART_AMP);
|
||||
ssi263.FilterFreq = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_FILTER_FREQ);
|
||||
ssi263.CurrentMode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SSI263_REG_CURRENT_MODE);
|
||||
ssi263.DurationPhoneme = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_DUR_PHON);
|
||||
ssi263.Inflection = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_INF);
|
||||
ssi263.RateInflection = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_RATE_INF);
|
||||
ssi263.CtrlArtAmp = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_CTRL_ART_AMP);
|
||||
ssi263.FilterFreq = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_FILTER_FREQ);
|
||||
ssi263.CurrentMode = yamlLoadHelper.LoadUint(SS_YAML_KEY_SSI263_REG_CURRENT_MODE);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
@ -2062,10 +2062,10 @@ bool MB_LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT slot, UINT version)
|
|||
AY8910_LoadSnapshot(yamlLoadHelper, nDeviceNum, std::string(""));
|
||||
LoadSnapshotSSI263(yamlLoadHelper, pMB->SpeechChip);
|
||||
|
||||
pMB->nAYCurrentRegister = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_AY_CURR_REG);
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TIMER1_IRQ); // Consume
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TIMER2_IRQ); // Consume
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SPEECH_IRQ); // Consume
|
||||
pMB->nAYCurrentRegister = yamlLoadHelper.LoadUint(SS_YAML_KEY_AY_CURR_REG);
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_TIMER1_IRQ); // Consume
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_TIMER2_IRQ); // Consume
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_SPEECH_IRQ); // Consume
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
||||
|
|
@ -2144,8 +2144,8 @@ bool Phasor_LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT slot, UINT version
|
|||
if (version != 1)
|
||||
throw std::string("Card: wrong version");
|
||||
|
||||
g_PhasorClockScaleFactor = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PHASOR_CLOCK_SCALE_FACTOR);
|
||||
g_nPhasorMode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PHASOR_MODE);
|
||||
g_PhasorClockScaleFactor = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASOR_CLOCK_SCALE_FACTOR);
|
||||
g_nPhasorMode = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASOR_MODE);
|
||||
|
||||
AY8910UpdateSetCycles();
|
||||
|
||||
|
|
@ -2167,10 +2167,10 @@ bool Phasor_LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT slot, UINT version
|
|||
AY8910_LoadSnapshot(yamlLoadHelper, nDeviceNum+1, std::string("-B"));
|
||||
LoadSnapshotSSI263(yamlLoadHelper, pMB->SpeechChip);
|
||||
|
||||
pMB->nAYCurrentRegister = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_AY_CURR_REG);
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TIMER1_IRQ); // Consume
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_TIMER2_IRQ); // Consume
|
||||
yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_SPEECH_IRQ); // Consume
|
||||
pMB->nAYCurrentRegister = yamlLoadHelper.LoadUint(SS_YAML_KEY_AY_CURR_REG);
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_TIMER1_IRQ); // Consume
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_TIMER2_IRQ); // Consume
|
||||
yamlLoadHelper.LoadUint(SS_YAML_KEY_SPEECH_IRQ); // Consume
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
|
||||
|
|
|
|||
|
|
@ -700,15 +700,15 @@ void CMouseInterface::LoadSnapshotMC6821(YamlLoadHelper& yamlLoadHelper, std::st
|
|||
throw std::string("Card: Expected key: ") + key;
|
||||
|
||||
mc6821_t mc6821;
|
||||
mc6821.pra = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PRA);
|
||||
mc6821.ddra = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_DDRA);
|
||||
mc6821.cra = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CRA);
|
||||
mc6821.prb = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PRB);
|
||||
mc6821.ddrb = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_DDRB);
|
||||
mc6821.crb = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CRB);
|
||||
mc6821.pra = yamlLoadHelper.LoadUint(SS_YAML_KEY_PRA);
|
||||
mc6821.ddra = yamlLoadHelper.LoadUint(SS_YAML_KEY_DDRA);
|
||||
mc6821.cra = yamlLoadHelper.LoadUint(SS_YAML_KEY_CRA);
|
||||
mc6821.prb = yamlLoadHelper.LoadUint(SS_YAML_KEY_PRB);
|
||||
mc6821.ddrb = yamlLoadHelper.LoadUint(SS_YAML_KEY_DDRB);
|
||||
mc6821.crb = yamlLoadHelper.LoadUint(SS_YAML_KEY_CRB);
|
||||
|
||||
BYTE byIA = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IA);
|
||||
BYTE byIB = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IB);
|
||||
BYTE byIA = yamlLoadHelper.LoadUint(SS_YAML_KEY_IA);
|
||||
BYTE byIB = yamlLoadHelper.LoadUint(SS_YAML_KEY_IB);
|
||||
|
||||
m_6821.Set6821(mc6821, byIA, byIB);
|
||||
|
||||
|
|
@ -725,32 +725,32 @@ bool CMouseInterface::LoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT sl
|
|||
|
||||
LoadSnapshotMC6821(yamlLoadHelper, SS_YAML_KEY_MC6821);
|
||||
|
||||
m_nDataLen = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_DATALEN);
|
||||
m_byMode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_MODE);
|
||||
m_by6821B = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_6821B);
|
||||
m_by6821A = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_6821A);
|
||||
m_nDataLen = yamlLoadHelper.LoadUint(SS_YAML_KEY_DATALEN);
|
||||
m_byMode = yamlLoadHelper.LoadUint(SS_YAML_KEY_MODE);
|
||||
m_by6821B = yamlLoadHelper.LoadUint(SS_YAML_KEY_6821B);
|
||||
m_by6821A = yamlLoadHelper.LoadUint(SS_YAML_KEY_6821A);
|
||||
|
||||
if (!yamlLoadHelper.GetSubMap(SS_YAML_KEY_BUFF))
|
||||
throw std::string("Card: Expected key: "SS_YAML_KEY_BUFF);
|
||||
yamlLoadHelper.GetMapValueMemory(m_byBuff, sizeof(m_byBuff));
|
||||
yamlLoadHelper.LoadMemory(m_byBuff, sizeof(m_byBuff));
|
||||
yamlLoadHelper.PopMap();
|
||||
|
||||
m_nBuffPos = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BUFFPOS);
|
||||
m_byState = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_MOUSESTATE);
|
||||
m_nX = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_X);
|
||||
m_nY = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_Y);
|
||||
m_bBtn0 = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_BTN0);
|
||||
m_bBtn1 = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_BTN1);
|
||||
m_bVBL = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_VBL);
|
||||
m_iX = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IX);
|
||||
m_iMinX = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IMINX);
|
||||
m_iMaxX = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IMAXX);
|
||||
m_iY = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IY);
|
||||
m_iMinY = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IMINY);
|
||||
m_iMaxY = yamlLoadHelper.GetMapValueINT(SS_YAML_KEY_IMAXY);
|
||||
m_bButtons[0] = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_BUTTON0);
|
||||
m_bButtons[1] = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_BUTTON1);
|
||||
m_bEnabled = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_ENABLED); // MemInitializeIO() calls Initialize() which sets true
|
||||
m_nBuffPos = yamlLoadHelper.LoadUint(SS_YAML_KEY_BUFFPOS);
|
||||
m_byState = yamlLoadHelper.LoadUint(SS_YAML_KEY_MOUSESTATE);
|
||||
m_nX = yamlLoadHelper.LoadInt(SS_YAML_KEY_X);
|
||||
m_nY = yamlLoadHelper.LoadInt(SS_YAML_KEY_Y);
|
||||
m_bBtn0 = yamlLoadHelper.LoadBool(SS_YAML_KEY_BTN0);
|
||||
m_bBtn1 = yamlLoadHelper.LoadBool(SS_YAML_KEY_BTN1);
|
||||
m_bVBL = yamlLoadHelper.LoadBool(SS_YAML_KEY_VBL);
|
||||
m_iX = yamlLoadHelper.LoadInt(SS_YAML_KEY_IX);
|
||||
m_iMinX = yamlLoadHelper.LoadInt(SS_YAML_KEY_IMINX);
|
||||
m_iMaxX = yamlLoadHelper.LoadInt(SS_YAML_KEY_IMAXX);
|
||||
m_iY = yamlLoadHelper.LoadInt(SS_YAML_KEY_IY);
|
||||
m_iMinY = yamlLoadHelper.LoadInt(SS_YAML_KEY_IMINY);
|
||||
m_iMaxY = yamlLoadHelper.LoadInt(SS_YAML_KEY_IMAXY);
|
||||
m_bButtons[0] = yamlLoadHelper.LoadBool(SS_YAML_KEY_BUTTON0);
|
||||
m_bButtons[1] = yamlLoadHelper.LoadBool(SS_YAML_KEY_BUTTON1);
|
||||
m_bEnabled = yamlLoadHelper.LoadBool(SS_YAML_KEY_ENABLED); // MemInitializeIO() calls Initialize() which sets true
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -298,13 +298,13 @@ bool Printer_LoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT slot, UINT
|
|||
if (version != 1)
|
||||
throw std::string("Card: wrong version");
|
||||
|
||||
inactivity = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_INACTIVITY);
|
||||
g_PrinterIdleLimit = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IDLELIMIT);
|
||||
strncpy(g_szPrintFilename, yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_FILENAME).c_str(), sizeof(g_szPrintFilename));
|
||||
inactivity = yamlLoadHelper.LoadUint(SS_YAML_KEY_INACTIVITY);
|
||||
g_PrinterIdleLimit = yamlLoadHelper.LoadUint(SS_YAML_KEY_IDLELIMIT);
|
||||
strncpy(g_szPrintFilename, yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME).c_str(), sizeof(g_szPrintFilename));
|
||||
|
||||
if (yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_FILEOPEN))
|
||||
if (yamlLoadHelper.LoadBool(SS_YAML_KEY_FILEOPEN))
|
||||
{
|
||||
yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_APPEND); // Consume
|
||||
yamlLoadHelper.LoadBool(SS_YAML_KEY_APPEND); // Consume
|
||||
g_bPrinterAppend = true; // Re-open print-file in append mode
|
||||
BOOL bRes = CheckPrint();
|
||||
if (!bRes)
|
||||
|
|
@ -312,13 +312,13 @@ bool Printer_LoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT slot, UINT
|
|||
}
|
||||
else
|
||||
{
|
||||
g_bPrinterAppend = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_APPEND);
|
||||
g_bPrinterAppend = yamlLoadHelper.LoadBool(SS_YAML_KEY_APPEND);
|
||||
}
|
||||
|
||||
g_bDumpToPrinter = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_DUMPTOPRINTER);
|
||||
g_bConvertEncoding = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_CONVERTENCODING);
|
||||
g_bFilterUnprintable = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_FILTERUNPRINTABLE);
|
||||
g_bEnableDumpToRealPrinter = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_DUMPTOREALPRINTER);
|
||||
g_bDumpToPrinter = yamlLoadHelper.LoadBool(SS_YAML_KEY_DUMPTOPRINTER);
|
||||
g_bConvertEncoding = yamlLoadHelper.LoadBool(SS_YAML_KEY_CONVERTENCODING);
|
||||
g_bFilterUnprintable = yamlLoadHelper.LoadBool(SS_YAML_KEY_FILTERUNPRINTABLE);
|
||||
g_bEnableDumpToRealPrinter = yamlLoadHelper.LoadBool(SS_YAML_KEY_DUMPTOREALPRINTER);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -300,14 +300,14 @@ static UINT ParseFileHdr(void)
|
|||
|
||||
//
|
||||
|
||||
std::string value = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_TAG);
|
||||
std::string value = yamlLoadHelper.LoadString(SS_YAML_KEY_TAG);
|
||||
if (value != SS_YAML_VALUE_AWSS)
|
||||
{
|
||||
//printf("%s: Bad tag (%s) - expected %s\n", SS_YAML_KEY_FILEHDR, value.c_str(), SS_YAML_VALUE_AWSS);
|
||||
throw std::string(SS_YAML_KEY_FILEHDR ": Bad tag");
|
||||
}
|
||||
|
||||
return yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_VERSION);
|
||||
return yamlLoadHelper.LoadUint(SS_YAML_KEY_VERSION);
|
||||
}
|
||||
|
||||
//---
|
||||
|
|
@ -317,7 +317,7 @@ static void ParseUnitApple2(YamlLoadHelper& yamlLoadHelper, UINT version)
|
|||
if (version != UNIT_APPLE2_VER)
|
||||
throw std::string(SS_YAML_KEY_UNIT ": Apple2: Version mismatch");
|
||||
|
||||
std::string model = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_MODEL);
|
||||
std::string model = yamlLoadHelper.LoadString(SS_YAML_KEY_MODEL);
|
||||
SetApple2Type( ParseApple2Type(model) ); // NB. Sets default main CPU type
|
||||
m_ConfigNew.m_Apple2Type = GetApple2Type();
|
||||
|
||||
|
|
@ -350,8 +350,8 @@ static void ParseSlots(YamlLoadHelper& yamlLoadHelper, UINT version)
|
|||
|
||||
yamlLoadHelper.GetSubMap(scalar);
|
||||
|
||||
std::string card = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_CARD);
|
||||
UINT version = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_VERSION);
|
||||
std::string card = yamlLoadHelper.LoadString(SS_YAML_KEY_CARD);
|
||||
UINT version = yamlLoadHelper.LoadUint(SS_YAML_KEY_VERSION);
|
||||
|
||||
if (!yamlLoadHelper.GetSubMap(std::string(SS_YAML_KEY_STATE)))
|
||||
throw std::string(SS_YAML_KEY_UNIT ": Expected sub-map name: " SS_YAML_KEY_STATE);
|
||||
|
|
@ -425,8 +425,8 @@ static void ParseUnit(void)
|
|||
|
||||
YamlLoadHelper yamlLoadHelper(yamlHelper);
|
||||
|
||||
std::string unit = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_TYPE);
|
||||
UINT version = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_VERSION);
|
||||
std::string unit = yamlLoadHelper.LoadString(SS_YAML_KEY_TYPE);
|
||||
UINT version = yamlLoadHelper.LoadUint(SS_YAML_KEY_VERSION);
|
||||
|
||||
if (!yamlLoadHelper.GetSubMap(std::string(SS_YAML_KEY_STATE)))
|
||||
throw std::string(SS_YAML_KEY_UNIT ": Expected sub-map name: " SS_YAML_KEY_STATE);
|
||||
|
|
|
|||
|
|
@ -1385,13 +1385,13 @@ void CSuperSerialCard::LoadSnapshotDIPSW(YamlLoadHelper& yamlLoadHelper, std::st
|
|||
if (!yamlLoadHelper.GetSubMap(key))
|
||||
throw std::string("Card: Expected key: " + key);
|
||||
|
||||
dipsw.uBaudRate = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BAUDRATE);
|
||||
dipsw.eFirmwareMode = (eFWMODE) yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_FWMODE);
|
||||
dipsw.uStopBits = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_STOPBITS);
|
||||
dipsw.uByteSize = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BYTESIZE);
|
||||
dipsw.uParity = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PARITY);
|
||||
dipsw.bLinefeed = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_LINEFEED);
|
||||
dipsw.bInterrupts = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_INTERRUPTS);
|
||||
dipsw.uBaudRate = yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE);
|
||||
dipsw.eFirmwareMode = (eFWMODE) yamlLoadHelper.LoadUint(SS_YAML_KEY_FWMODE);
|
||||
dipsw.uStopBits = yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS);
|
||||
dipsw.uByteSize = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE);
|
||||
dipsw.uParity = yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);
|
||||
dipsw.bLinefeed = yamlLoadHelper.LoadBool(SS_YAML_KEY_LINEFEED);
|
||||
dipsw.bInterrupts = yamlLoadHelper.LoadBool(SS_YAML_KEY_INTERRUPTS);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
@ -1407,20 +1407,20 @@ bool CSuperSerialCard::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT slot, U
|
|||
LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWDEFAULT, m_DIPSWDefault);
|
||||
LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWCURRENT, m_DIPSWCurrent);
|
||||
|
||||
m_uBaudRate = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BAUDRATE);
|
||||
m_uStopBits = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_STOPBITS);
|
||||
m_uByteSize = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_BYTESIZE);
|
||||
m_uParity = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_PARITY);
|
||||
m_uControlByte = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CONTROL);
|
||||
m_uCommandByte = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_COMMAND);
|
||||
m_dwCommInactivity = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_INACTIVITY);
|
||||
m_bTxIrqEnabled = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_TXIRQENABLED);
|
||||
m_bRxIrqEnabled = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_RXIRQENABLED);
|
||||
m_vbTxIrqPending = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_TXIRQPENDING);
|
||||
m_vbRxIrqPending = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_RXIRQPENDING);
|
||||
m_bWrittenTx = yamlLoadHelper.GetMapValueBool(SS_YAML_KEY_WRITTENTX);
|
||||
m_uBaudRate = yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE);
|
||||
m_uStopBits = yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS);
|
||||
m_uByteSize = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE);
|
||||
m_uParity = yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);
|
||||
m_uControlByte = yamlLoadHelper.LoadUint(SS_YAML_KEY_CONTROL);
|
||||
m_uCommandByte = yamlLoadHelper.LoadUint(SS_YAML_KEY_COMMAND);
|
||||
m_dwCommInactivity = yamlLoadHelper.LoadUint(SS_YAML_KEY_INACTIVITY);
|
||||
m_bTxIrqEnabled = yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQENABLED);
|
||||
m_bRxIrqEnabled = yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQENABLED);
|
||||
m_vbTxIrqPending = yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQPENDING);
|
||||
m_vbRxIrqPending = yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQPENDING);
|
||||
m_bWrittenTx = yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITTENTX);
|
||||
|
||||
std::string serialPortName = yamlLoadHelper.GetMapValueSTRING(SS_YAML_KEY_SERIALPORTNAME);
|
||||
std::string serialPortName = yamlLoadHelper.LoadString(SS_YAML_KEY_SERIALPORTNAME);
|
||||
SetSerialPortName(serialPortName.c_str());
|
||||
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -1119,7 +1119,7 @@ void SpkrLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(SpkrGetSnapshotStructName()))
|
||||
return;
|
||||
|
||||
g_nSpkrLastCycle = yamlLoadHelper.GetMapValueUINT64(SS_YAML_KEY_LASTCYCLE);
|
||||
g_nSpkrLastCycle = yamlLoadHelper.LoadUint64(SS_YAML_KEY_LASTCYCLE);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2973,9 +2973,9 @@ void VideoLoadSnapshot(YamlLoadHelper& yamlLoadHelper)
|
|||
if (!yamlLoadHelper.GetSubMap(VideoGetSnapshotStructName()))
|
||||
return;
|
||||
|
||||
g_nAltCharSetOffset = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ALTCHARSET) ? 256 : 0;
|
||||
g_uVideoMode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_VIDEOMODE);
|
||||
g_dwCyclesThisFrame = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_CYCLESTHISFRAME);
|
||||
g_nAltCharSetOffset = yamlLoadHelper.LoadUint(SS_YAML_KEY_ALTCHARSET) ? 256 : 0;
|
||||
g_uVideoMode = yamlLoadHelper.LoadUint(SS_YAML_KEY_VIDEOMODE);
|
||||
g_dwCyclesThisFrame = yamlLoadHelper.LoadUint(SS_YAML_KEY_CYCLESTHISFRAME);
|
||||
|
||||
yamlLoadHelper.PopMap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -236,7 +236,7 @@ void YamlHelper::MakeAsciiToHexTable(void)
|
|||
m_AsciiToHex[i] = i - 'a' + 0xA;
|
||||
}
|
||||
|
||||
void YamlHelper::GetMapValueMemory(MapYaml& mapYaml, const LPBYTE pMemBase, const size_t kAddrSpaceSize)
|
||||
void YamlHelper::LoadMemory(MapYaml& mapYaml, const LPBYTE pMemBase, const size_t kAddrSpaceSize)
|
||||
{
|
||||
for (MapYaml::iterator it = mapYaml.begin(); it != mapYaml.end(); ++it)
|
||||
{
|
||||
|
|
@ -275,6 +275,72 @@ void YamlHelper::GetMapValueMemory(MapYaml& mapYaml, const LPBYTE pMemBase, cons
|
|||
|
||||
//-------------------------------------
|
||||
|
||||
INT YamlLoadHelper::LoadInt(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return strtol(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
UINT YamlLoadHelper::LoadUint(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return strtoul(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
UINT64 YamlLoadHelper::LoadUint64(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return _strtoui64(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
bool YamlLoadHelper::LoadBool(const std::string key)
|
||||
{
|
||||
return LoadUint(key) ? true : false;
|
||||
}
|
||||
|
||||
std::string YamlLoadHelper::LoadString_NoThrow(const std::string& key, bool& bFound)
|
||||
{
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
return value;
|
||||
}
|
||||
|
||||
std::string YamlLoadHelper::LoadString(const std::string& key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = LoadString_NoThrow(key, bFound);
|
||||
if (!bFound)
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
void YamlLoadHelper::LoadMemory(const LPBYTE pMemBase, const size_t size)
|
||||
{
|
||||
m_yamlHelper.LoadMemory(*m_pMapYaml, pMemBase, size);
|
||||
}
|
||||
|
||||
//-------------------------------------
|
||||
|
||||
void YamlSaveHelper::Save(const char* format, ...)
|
||||
{
|
||||
fwrite(m_szIndent, 1, m_indent, m_hFile);
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ private:
|
|||
void GetNextEvent(bool bInMap = false);
|
||||
int ParseMap(MapYaml& mapYaml);
|
||||
std::string GetMapValue(MapYaml& mapYaml, const std::string key, bool& bFound);
|
||||
void GetMapValueMemory(MapYaml& mapYaml, const LPBYTE pMemBase, const size_t kAddrSpaceSize);
|
||||
void LoadMemory(MapYaml& mapYaml, const LPBYTE pMemBase, const size_t kAddrSpaceSize);
|
||||
bool GetSubMap(MapYaml** mapYaml, const std::string key);
|
||||
void GetMapRemainder(std::string& mapName, MapYaml& mapYaml);
|
||||
|
||||
|
|
@ -91,69 +91,13 @@ public:
|
|||
m_yamlHelper.GetMapRemainder(m_topLevelMapName, m_yamlHelper.m_mapYaml);
|
||||
}
|
||||
|
||||
INT GetMapValueINT(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return strtol(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
UINT GetMapValueUINT(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return strtoul(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
UINT64 GetMapValueUINT64(const std::string key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
if (value == "")
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return _strtoui64(value.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
bool GetMapValueBool(const std::string key)
|
||||
{
|
||||
return GetMapValueUINT(key) ? true : false;
|
||||
}
|
||||
|
||||
std::string GetMapValueSTRING_NoThrow(const std::string& key, bool& bFound)
|
||||
{
|
||||
std::string value = m_yamlHelper.GetMapValue(*m_pMapYaml, key, bFound);
|
||||
return value;
|
||||
}
|
||||
|
||||
std::string GetMapValueSTRING(const std::string& key)
|
||||
{
|
||||
bool bFound;
|
||||
std::string value = GetMapValueSTRING_NoThrow(key, bFound);
|
||||
if (!bFound)
|
||||
{
|
||||
m_bDoGetMapRemainder = false;
|
||||
throw std::string(m_currentMapName + ": Missing: " + key);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
void GetMapValueMemory(const LPBYTE pMemBase, const size_t size)
|
||||
{
|
||||
m_yamlHelper.GetMapValueMemory(*m_pMapYaml, pMemBase, size);
|
||||
}
|
||||
INT LoadInt(const std::string key);
|
||||
UINT LoadUint(const std::string key);
|
||||
UINT64 LoadUint64(const std::string key);
|
||||
bool LoadBool(const std::string key);
|
||||
std::string LoadString_NoThrow(const std::string& key, bool& bFound);
|
||||
std::string LoadString(const std::string& key);
|
||||
void LoadMemory(const LPBYTE pMemBase, const size_t size);
|
||||
|
||||
bool GetSubMap(const std::string key)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6528,41 +6528,41 @@ bool Z80_LoadSnapshot(class YamlLoadHelper& yamlLoadHelper, UINT uSlot, UINT ver
|
|||
if (version != 1)
|
||||
throw std::string("Card: wrong version");
|
||||
|
||||
reg_a = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGA);
|
||||
reg_b = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGB);
|
||||
reg_c = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGC);
|
||||
reg_d = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGD);
|
||||
reg_e = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGE);
|
||||
reg_f = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGF);
|
||||
reg_h = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGH);
|
||||
reg_l = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGL);
|
||||
USHORT IX = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGIX);
|
||||
reg_a = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGA);
|
||||
reg_b = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGB);
|
||||
reg_c = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGC);
|
||||
reg_d = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGD);
|
||||
reg_e = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGE);
|
||||
reg_f = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGF);
|
||||
reg_h = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGH);
|
||||
reg_l = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGL);
|
||||
USHORT IX = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGIX);
|
||||
reg_ixh = IX >> 8;
|
||||
reg_ixl = IX & 0xFF;
|
||||
USHORT IY = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGIY);
|
||||
USHORT IY = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGIY);
|
||||
reg_iyh = IY >> 8;
|
||||
reg_iyl = IY & 0xFF;
|
||||
reg_sp = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGSP);
|
||||
z80_reg_pc = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGPC);
|
||||
reg_i = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGI);
|
||||
reg_r = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGR);
|
||||
reg_sp = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGSP);
|
||||
z80_reg_pc = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGPC);
|
||||
reg_i = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGI);
|
||||
reg_r = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGR);
|
||||
|
||||
iff1 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IFF1);
|
||||
iff2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IFF2);
|
||||
im_mode = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_IM_MODE);
|
||||
iff1 = yamlLoadHelper.LoadUint(SS_YAML_KEY_IFF1);
|
||||
iff2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_IFF2);
|
||||
im_mode = yamlLoadHelper.LoadUint(SS_YAML_KEY_IM_MODE);
|
||||
|
||||
reg_a2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGA2);
|
||||
reg_b2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGB2);
|
||||
reg_c2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGC2);
|
||||
reg_d2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGD2);
|
||||
reg_e2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGE2);
|
||||
reg_f2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGF2);
|
||||
reg_h2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGH2);
|
||||
reg_l2 = yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_REGL2);
|
||||
reg_a2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGA2);
|
||||
reg_b2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGB2);
|
||||
reg_c2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGC2);
|
||||
reg_d2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGD2);
|
||||
reg_e2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGE2);
|
||||
reg_f2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGF2);
|
||||
reg_h2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGH2);
|
||||
reg_l2 = yamlLoadHelper.LoadUint(SS_YAML_KEY_REGL2);
|
||||
|
||||
export_registers();
|
||||
|
||||
if ( yamlLoadHelper.GetMapValueUINT(SS_YAML_KEY_ACTIVE) )
|
||||
if ( yamlLoadHelper.LoadUint(SS_YAML_KEY_ACTIVE) )
|
||||
SetActiveCpu(CPU_Z80); // Support MS SoftCard in multiple slots (only one Z80 can be active at any one time)
|
||||
|
||||
return true;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user