diff --git a/source/AY8910.cpp b/source/AY8910.cpp index fc4328ac..bc41cfe5 100644 --- a/source/AY8910.cpp +++ b/source/AY8910.cpp @@ -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 diff --git a/source/CPU.cpp b/source/CPU.cpp index 9422d378..c0cfed32 100644 --- a/source/CPU.cpp +++ b/source/CPU.cpp @@ -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(); } diff --git a/source/Disk.cpp b/source/Disk.cpp index 7d2a49f5..8c7cef97 100644 --- a/source/Disk.cpp +++ b/source/Disk.cpp @@ -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 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; iSpeechChip); - 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(); diff --git a/source/MouseInterface.cpp b/source/MouseInterface.cpp index 5c33d03d..009f8494 100644 --- a/source/MouseInterface.cpp +++ b/source/MouseInterface.cpp @@ -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; } diff --git a/source/ParallelPrinter.cpp b/source/ParallelPrinter.cpp index 0dcf5846..f295c958 100644 --- a/source/ParallelPrinter.cpp +++ b/source/ParallelPrinter.cpp @@ -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; } diff --git a/source/SaveState.cpp b/source/SaveState.cpp index 2dd77a3b..3a771cd8 100644 --- a/source/SaveState.cpp +++ b/source/SaveState.cpp @@ -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); diff --git a/source/SerialComms.cpp b/source/SerialComms.cpp index 4e4e8a87..83660262 100644 --- a/source/SerialComms.cpp +++ b/source/SerialComms.cpp @@ -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; diff --git a/source/Speaker.cpp b/source/Speaker.cpp index 327c33d6..0a90f963 100644 --- a/source/Speaker.cpp +++ b/source/Speaker.cpp @@ -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(); } diff --git a/source/Video.cpp b/source/Video.cpp index f3ab19b7..e391ae0c 100644 --- a/source/Video.cpp +++ b/source/Video.cpp @@ -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(); } diff --git a/source/YamlHelper.cpp b/source/YamlHelper.cpp index 1b947d15..5679d44d 100644 --- a/source/YamlHelper.cpp +++ b/source/YamlHelper.cpp @@ -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); diff --git a/source/YamlHelper.h b/source/YamlHelper.h index ce5752c0..463c1608 100644 --- a/source/YamlHelper.h +++ b/source/YamlHelper.h @@ -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) { diff --git a/source/Z80VICE/z80.cpp b/source/Z80VICE/z80.cpp index a91440ec..c84d51e0 100644 --- a/source/Z80VICE/z80.cpp +++ b/source/Z80VICE/z80.cpp @@ -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;