Save-state: Renamed YamlLoadHelper load-type functions to be more consistent with YamlSaveHelper functions

This commit is contained in:
tomcw 2016-02-24 22:38:59 +00:00
parent 6b07fd665f
commit 11789c9023
17 changed files with 288 additions and 278 deletions

View File

@ -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

View File

@ -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();
}

View File

@ -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++)

View File

@ -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++)

View File

@ -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();
}

View File

@ -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();
}

View File

@ -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();
}

View File

@ -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();

View File

@ -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;
}

View File

@ -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;
}

View File

@ -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);

View File

@ -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;

View File

@ -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();
}

View File

@ -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();
}

View File

@ -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);

View File

@ -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)
{

View File

@ -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;