static int paperclip64_read_snapshot(struct snapshot_s *s, int port) { BYTE major_version, minor_version; snapshot_module_t *m; m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (0 || SMR_DW_INT(m, &counter) < 0 || SMR_B(m, &command) < 0 || SMR_B_INT(m, &state) < 0) { goto fail; } return snapshot_module_close(m); fail: snapshot_module_close(m); return -1; }
int magicdesk_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B(m, ®val) < 0) || (SMR_BA(m, roml_banks, 0x2000 * MAXBANKS) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); if (magicdesk_common_attach() == -1) { return -1; } magicdesk_io1_store(0xde00, regval); return 0; }
int sfx_soundsampler_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B(m, &sfx_soundsampler_sound_data) < 0)) { snapshot_module_close(m); return -1; } if (!sfx_soundsampler_sound_chip.chip_enabled) { set_sfx_soundsampler_enabled(1, NULL); } sound_store(sfx_soundsampler_sound_chip_offset, sfx_soundsampler_sound_data, 0); snapshot_module_close(m); return 0; }
int se5_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_BA(m, roml_banks, SE5_CART_SIZE) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return se5_common_attach(); }
int ds12c887rtc_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; int temp_ds12c887rtc_address; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } /* FIXME: Implement the RTC snapshot part */ if (0 || (SMR_DW_INT(m, &temp_ds12c887rtc_address) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); /* HACK set address to an invalid value, then use the function */ ds12c887rtc_base_address = -1; set_ds12c887rtc_base(temp_ds12c887rtc_address, NULL); return ds12c887rtc_enable(); }
static int dtlbasic_read_snapshot(struct snapshot_s *s) { BYTE major_version, minor_version; snapshot_module_t *m; /* enable device */ set_dtlbasic_dongle_enabled(1, NULL); m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (0 || SMR_DW_INT(m, &dtlbasic_counter) < 0 || SMR_DW_INT(m, &write_status) < 0 || SMR_DW_INT(m, &sense_status) < 0 || SMR_DW_INT(m, &dtlbasic_state) < 0) { goto fail; } return snapshot_module_close(m); fail: snapshot_module_close(m); return -1; }
static int userport_rtc_read_snapshot_module(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; /* enable device */ set_userport_rtc_enabled(1, NULL); m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (SMR_B_INT(m, &read_line_active) < 0) { goto fail; } snapshot_module_close(m); return rtc58321a_read_snapshot(rtc58321a_context, s); fail: snapshot_module_close(m); return -1; }
int freezemachine_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B_INT(m, &rom_A14) < 0) || (SMR_B_INT(m, &roml_toggle) < 0) || (SMR_B_INT(m, &allow_toggle) < 0) || (SMR_BA(m, roml_banks, 0x4000) < 0) || (SMR_BA(m, romh_banks, 0x4000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return freezemachine_common_attach(); }
int mmc_snapshot_read_module(snapshot_t *s) { return -1; #if 0 BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return 0; #endif }
static int userport_digimax_read_snapshot_module(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; /* enable device */ set_digimax_enabled(1, NULL); m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (0 || (SMR_B(m, &userport_digimax_address) < 0) || (SMR_BA(m, digimax_sound_data, 4) < 0) || (SMR_B(m, &snd.voice0) < 0) || (SMR_B(m, &snd.voice1) < 0) || (SMR_B(m, &snd.voice2) < 0) || (SMR_B(m, &snd.voice3) < 0)) { goto fail; } return snapshot_module_close(m); fail: snapshot_module_close(m); return -1; }
int actionreplay2_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B_INT(m, &ar_enabled) < 0) || (SMR_DW_INT(m, &ar_cap_enable) < 0) || (SMR_DW_INT(m, &ar_cap_disable) < 0) || (SMR_BA(m, roml_banks, 0x4000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return actionreplay2_common_attach(); }
int kcs_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B_INT(m, &freeze_flag) < 0) || (SMR_B_INT(m, &config) < 0) || (SMR_BA(m, roml_banks, 0x2000) < 0) || (SMR_BA(m, romh_banks, 0x2000) < 0) || (SMR_BA(m, export_ram0, 0x2000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return kcs_common_attach(); }
int dinamic_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B_INT(m, &currbank) < 0) || (SMR_BA(m, roml_banks, 0x2000 * 16) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return dinamic_common_attach(); }
int freezeframe_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_BA(m, roml_banks, FREEZE_FRAME_CART_SIZE) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); memcpy(romh_banks, roml_banks, FREEZE_FRAME_CART_SIZE); return freezeframe_common_attach(); }
static int mem_read_rom_snapshot_module(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; int trapfl; /* Main memory module. */ m = snapshot_module_open(s, snap_rom_module_name, &major_version, &minor_version); /* This module is optional. */ if (m == NULL) return 0; /* disable traps before loading the ROM */ resources_get_int("VirtualDevices", &trapfl); resources_set_int("VirtualDevices", 0); if (major_version > SNAP_ROM_MAJOR || minor_version > SNAP_ROM_MINOR) { log_error(c128_snapshot_log, "MEM: Snapshot module version (%d.%d) newer than %d.%d.", major_version, minor_version, SNAP_ROM_MAJOR, SNAP_ROM_MINOR); goto fail; } if (0 || SMR_BA(m, c128memrom_kernal_rom, C128_KERNAL_ROM_SIZE) < 0 || SMR_BA(m, c128memrom_basic_rom, C128_BASIC_ROM_SIZE) < 0 || SMR_BA(m, c128memrom_basic_rom + C128_BASIC_ROM_SIZE, C128_EDITOR_ROM_SIZE) < 0 || SMR_BA(m, mem_chargen_rom, C128_CHARGEN_ROM_SIZE) < 0) goto fail; log_warning(c128_snapshot_log,"Dumped Romset files and saved settings will " "represent\nthe state before loading the snapshot!"); memcpy(c128memrom_kernal_trap_rom, c128memrom_kernal_rom, C128_KERNAL_ROM_SIZE); c128rom_basic_checksum(); c128rom_kernal_checksum(); /* enable traps again when necessary */ resources_set_int("VirtualDevices", trapfl); /* to get all the checkmarks right */ ui_update_menus(); return 0; fail: /* enable traps again when necessary */ resources_set_int("VirtualDevices", trapfl); if (m != NULL) snapshot_module_close(m); return -1; }
int fdc_snapshot_read_module(snapshot_t *p, int fnum) { BYTE vmajor, vminor; BYTE byte, ndrv; DWORD dword; snapshot_module_t *m; char *name; name = lib_msprintf("FDC%d", fnum); m = snapshot_module_open(p, name, &vmajor, &vminor); lib_free(name); if (m == NULL) { log_message(fdc_log, "Could not find snapshot module %s", name); return -1; } if (vmajor != FDC_DUMP_VER_MAJOR) { log_error(fdc_log, "Snapshot module version (%d.%d) newer than %d.%d.", vmajor, vminor, FDC_DUMP_VER_MAJOR, FDC_DUMP_VER_MINOR); snapshot_module_close(m); return -1; } SMR_B(m, &byte); if (byte > FDC_LAST_STATE) { snapshot_module_close(m); return -1; } fdc[fnum].fdc_state = byte; /* clk till next invocation */ SMR_DW(m, &dword); fdc[fnum].alarm_clk = drive_clk[fnum] + dword; alarm_set(fdc[fnum].fdc_alarm, fdc[fnum].alarm_clk); /* number of drives - so far 1 only */ SMR_B(m, &ndrv); /* last accessed track/sector */ SMR_B(m, &byte); fdc[fnum].last_track = byte; SMR_B(m, &byte); fdc[fnum].last_sector = byte; if (ndrv > 1) { /* ignore drv 0 values */ SMR_B(m, &byte); SMR_B(m, &byte); } if (snapshot_module_close(m) < 0) return -1; return 0; }
int finalexpansion_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; BYTE *cart_flash = NULL; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if (vmajor != VIC20CART_DUMP_VER_MAJOR) { snapshot_module_close(m); return -1; } if (!cart_ram) { cart_ram = lib_malloc(CART_RAM_SIZE); } if (!cart_flash) { cart_flash = lib_malloc(CART_ROM_SIZE); } flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_B, cart_flash); if (0 || (SMR_B(m, ®ister_a) < 0) || (SMR_B(m, ®ister_b) < 0) || (SMR_B(m, &lock_bit) < 0) || (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0) || (SMR_BA(m, flash_state.flash_data, CART_ROM_SIZE) < 0)) { snapshot_module_close(m); flash040core_shutdown(&flash_state); lib_free(cart_ram); lib_free(cart_flash); cart_ram = NULL; cart_flash = NULL; return -1; } snapshot_module_close(m); if ((flash040core_snapshot_read_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) { flash040core_shutdown(&flash_state); lib_free(cart_ram); lib_free(cart_flash); cart_ram = NULL; cart_flash = NULL; return -1; } mem_cart_blocks = VIC_CART_RAM123 | VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO2 | VIC_CART_IO3; mem_initialize_memory(); return 0; }
static int sid_snapshot_read_module_simple(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; BYTE tmp[34]; m = snapshot_module_open(s, snap_module_name_simple, &major_version, &minor_version); if (m == NULL) { goto fail; } if (major_version > SNAP_MAJOR_SIMPLE || minor_version > SNAP_MINOR_SIMPLE) { log_error(LOG_DEFAULT, "SID: Snapshot module version (%d.%d) newer than %d.%d.\n", major_version, minor_version, SNAP_MAJOR_SIMPLE, SNAP_MINOR_SIMPLE); snapshot_module_close(m); goto fail; } /* If more than 32 bytes are present then the resource "Sound" and "SidEngine" come first! If there is only one byte present, then sound is disabled. */ if (SMR_BA(m, tmp, 34) < 0) { if (SMR_BA(m, tmp, 32) < 0) { if (SMR_BA(m, tmp, 1) < 0) { snapshot_module_close(m); goto fail; } else { sound_close(); } } else { memcpy(sid_get_siddata(0), &tmp[0], 32); } } else { int res_sound = (int)(tmp[0]); int res_engine = (int)(tmp[1]); screenshot_prepare_reopen(); sound_close(); screenshot_try_reopen(); resources_set_int("Sound", res_sound); if (res_sound) { resources_set_int("SidEngine", res_engine); /* FIXME: Only data for first SID read. */ memcpy(sid_get_siddata(0), &tmp[2], 32); sound_open(); } } return snapshot_module_close(m); fail: log_error(LOG_DEFAULT, "Failed reading SID snapshot"); return -1; }
int megacart_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if (vmajor != VIC20CART_DUMP_VER_MAJOR) { snapshot_module_close(m); return -1; } if (!cart_ram) { cart_ram = lib_malloc(CART_RAM_SIZE); } if (!cart_nvram) { cart_nvram = lib_malloc(CART_NVRAM_SIZE); } if (!cart_rom) { cart_rom = lib_malloc(CART_ROM_SIZE); } if (0 || (SMR_B(m, &bank_low_reg) < 0) || (SMR_B(m, &bank_high_reg) < 0) || (SMR_B_INT(m, &oe_flop) < 0) || (SMR_B_INT(m, &nvram_en_flop) < 0) || (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0) || (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0) || (SMR_BA(m, cart_nvram, CART_NVRAM_SIZE) < 0)) { snapshot_module_close(m); lib_free(cart_ram); lib_free(cart_nvram); lib_free(cart_rom); cart_ram = NULL; cart_nvram = NULL; cart_rom = NULL; return -1; } snapshot_module_close(m); cart_rom_low = cart_rom; cart_rom_high = cart_rom + 0x100000; reset_mode = BUTTON_RESET; mem_cart_blocks = VIC_CART_RAM123 | VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO2 | VIC_CART_IO3; mem_initialize_memory(); return 0; }
int vic_fp_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if (vmajor != VIC20CART_DUMP_VER_MAJOR) { snapshot_module_close(m); return -1; } if (!cart_ram) { cart_ram = lib_malloc(CART_RAM_SIZE); } if (!cart_rom) { cart_rom = lib_malloc(CART_ROM_SIZE); } flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_032B_A0_1_SWAP, cart_rom); if (0 || (SMR_B(m, &cart_bank_reg) < 0) || (SMR_B(m, &cart_cfg_reg) < 0) || (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0) || (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0)) { snapshot_module_close(m); lib_free(cart_ram); lib_free(cart_rom); cart_ram = NULL; cart_rom = NULL; return -1; } snapshot_module_close(m); if ((flash040core_snapshot_read_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) { flash040core_shutdown(&flash_state); lib_free(cart_ram); lib_free(cart_rom); cart_ram = NULL; cart_rom = NULL; return -1; } CART_CFG_INIT(cart_cfg_reg); mem_cart_blocks = VIC_CART_RAM123 | VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO2; mem_initialize_memory(); return 0; }
static int tape_snapshot_read_tapimage_module(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; char *filename = NULL; FILE *ftap; BYTE *buffer; long tap_size; m = snapshot_module_open(s, "TAPIMAGE", &major_version, &minor_version); if (m == NULL) return 0; if (major_version > TAPIMAGE_SNAP_MAJOR || minor_version > TAPIMAGE_SNAP_MINOR) { log_error(tape_snapshot_log, "Snapshot module version (%d.%d) newer than %d.%d.", major_version, minor_version, TAPIMAGE_SNAP_MAJOR, TAPIMAGE_SNAP_MINOR); } /* create temporary file */ /* FIXME: Were is this file deleted? */ ftap = archdep_mkstemp_fd(&filename, MODE_WRITE); if (ftap == NULL) { log_error(tape_snapshot_log, "Could not create temporary file!"); snapshot_module_close(m); goto fail; } SMR_DW_UL(m, (unsigned long *)&tap_size); buffer = lib_malloc(tap_size); SMR_BA(m, buffer, tap_size); if (fwrite(buffer, tap_size, 1, ftap) != 1) { log_error(tape_snapshot_log, "Could not create temporary file"); log_error(tape_snapshot_log, "filename=%s", filename); snapshot_module_close(m); fclose(ftap); goto fail; } lib_free(buffer); fclose(ftap); tape_image_attach(1, filename); lib_free(filename); snapshot_module_close(m); return 0; fail: lib_free(filename); return -1; }
int rtc72421_read_snapshot(rtc_72421_t *context, snapshot_t *s) { DWORD latch_lo = 0; DWORD latch_hi = 0; DWORD offset_lo = 0; DWORD offset_hi = 0; DWORD old_offset_lo = 0; DWORD old_offset_hi = 0; BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (0 || SMR_B_INT(m, &context->stop) < 0 || SMR_B_INT(m, &context->hour24) < 0 || SMR_DW(m, &latch_hi) < 0 || SMR_DW(m, &latch_lo) < 0 || SMR_DW(m, &offset_hi) < 0 || SMR_DW(m, &offset_lo) < 0 || SMR_DW(m, &old_offset_hi) < 0 || SMR_DW(m, &old_offset_lo) < 0 || SMR_STR(m, &context->device) < 0) { goto fail; } #if (SIZE_OF_TIME_T == 8) context->latch = (time_t)(latch_hi) << 32; context->latch |= latch_lo; context->offset = (time_t)(offset_hi) << 32; context->offset |= offset_lo; context->old_offset = (time_t)(old_offset_hi) << 32; context->old_offset |= old_offset_lo; #else context->latch = latch_lo; context->offset = offset_lo; context->old_offset = old_offset_lo; #endif return snapshot_module_close(m); fail: snapshot_module_close(m); return -1; }
int c128_snapshot_read_module(snapshot_t *s) { BYTE major_version, minor_version; snapshot_module_t *m; WORD i; BYTE byte; /* Main memory module. */ m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) return -1; if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { log_error(c128_snapshot_log, "MEM: Snapshot module version (%d.%d) newer than %d.%d.", major_version, minor_version, SNAP_MAJOR, SNAP_MINOR); goto fail; } for (i = 0; i < 11; i++) { if (SMR_B(m, &byte) < 0) goto fail; mmu_store(i, byte); /* Assuming no side-effects */ } if (0 || SMR_BA(m, mem_ram, C128_RAM_SIZE) < 0) goto fail; /* pla_config_changed(); */ if (snapshot_module_close(m) < 0) goto fail; m = NULL; if (mem_read_rom_snapshot_module(s) < 0) goto fail; if (cartridge_snapshot_read_modules(s) < 0) { goto fail; } ui_update_menus(); return 0; fail: if (m != NULL) snapshot_module_close(m); return -1; }
int easyflash_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } if (0 || (SMR_B_INT(m, &easyflash_jumper) < 0) || (SMR_B(m, &easyflash_register_00) < 0) || (SMR_B(m, &easyflash_register_02) < 0) || (SMR_BA(m, easyflash_ram, 256) < 0) || (SMR_BA(m, roml_banks, 0x80000) < 0) || (SMR_BA(m, romh_banks, 0x80000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); easyflash_state_low = lib_malloc(sizeof(flash040_context_t)); easyflash_state_high = lib_malloc(sizeof(flash040_context_t)); flash040core_init(easyflash_state_low, maincpu_alarm_context, FLASH040_TYPE_B, roml_banks); flash040core_init(easyflash_state_high, maincpu_alarm_context, FLASH040_TYPE_B, romh_banks); if (0 || (flash040core_snapshot_read_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0) || (flash040core_snapshot_read_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0)) { flash040core_shutdown(easyflash_state_low); flash040core_shutdown(easyflash_state_high); lib_free(easyflash_state_low); lib_free(easyflash_state_high); return -1; } easyflash_common_attach("dummy"); /* remove dummy filename, set filetype to none */ lib_free(easyflash_filename); easyflash_filename = NULL; easyflash_filetype = 0; return 0; }
int c64_glue_snapshot_read_module(snapshot_t *s) { BYTE major_version, minor_version; int snap_type, snap_alarm_active; snapshot_module_t *m; m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { log_error(LOG_ERR, "GlueLogic: Snapshot module version (%d.%d) newer than %d.%d.", major_version, minor_version, SNAP_MAJOR, SNAP_MINOR); goto fail; } if (0 || SMR_B_INT(m, &snap_type) < 0 || SMR_B_INT(m, &old_vbank) < 0 || SMR_B_INT(m, &snap_alarm_active) < 0) { goto fail; } if (snap_type != glue_logic_type) { log_warning(LOG_DEFAULT, "GlueLogic: Snapshot type %i differs from selected type %i, changing.", snap_type, glue_logic_type); glue_logic_type = snap_type; } if (glue_alarm_active) { glue_alarm_unset(); } glue_alarm_active = snap_alarm_active; if (glue_alarm_active && (glue_logic_type == 1)) { glue_alarm_set(); } snapshot_module_close(m); return 0; fail: if (m != NULL) { snapshot_module_close(m); } return -1; }
int maincpu_snapshot_read_module(snapshot_t *s) { BYTE a, x, y, sp, status; WORD pc; BYTE major, minor; snapshot_module_t *m; m = snapshot_module_open(s, snap_module_name, &major, &minor); if (m == NULL) { return -1; } /* FIXME: This is a mighty kludge to prevent VIC-II from stealing the wrong number of cycles. */ maincpu_rmw_flag = 0; /* XXX: Assumes `CLOCK' is the same size as a `DWORD'. */ if (0 || SMR_DW(m, &maincpu_clk) < 0 || SMR_B(m, &a) < 0 || SMR_B(m, &x) < 0 || SMR_B(m, &y) < 0 || SMR_B(m, &sp) < 0 || SMR_W(m, &pc) < 0 || SMR_B(m, &status) < 0 || SMR_DW_UINT(m, &last_opcode_info) < 0) { goto fail; } MOS6510_REGS_SET_A(&maincpu_regs, a); MOS6510_REGS_SET_X(&maincpu_regs, x); MOS6510_REGS_SET_Y(&maincpu_regs, y); MOS6510_REGS_SET_SP(&maincpu_regs, sp); MOS6510_REGS_SET_PC(&maincpu_regs, pc); MOS6510_REGS_SET_STATUS(&maincpu_regs, status); if (interrupt_read_snapshot(maincpu_int_status, m) < 0) { goto fail; } if (interrupt_read_new_snapshot(maincpu_int_status, m) < 0) { goto fail; } return snapshot_module_close(m); fail: if (m != NULL) { snapshot_module_close(m); } return -1; }
static int mem_read_ram_snapshot_module(snapshot_t *p) { BYTE vmajor, vminor; snapshot_module_t *m; BYTE config; m = snapshot_module_open(p, SNAP_MEM_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if (vmajor != VIC20MEM_DUMP_VER_MAJOR) { snapshot_module_close(m); return -1; } SMR_B(m, &config); SMR_B(m, &vic20_cpu_last_data); SMR_B(m, &vic20_v_bus_last_data); SMR_B(m, &vic20_v_bus_last_high); SMR_BA(m, mem_ram, 0x0400); SMR_BA(m, mem_ram + 0x1000, 0x1000); resources_set_int("RAMBlock0", (config & 1) ? 1 : 0 ); if (config & 1) { SMR_BA(m, mem_ram + 0x0400, 0x0c00); } resources_set_int("RAMBlock1", (config & 2) ? 1 : 0 ); if (config & 2) { SMR_BA(m, mem_ram + 0x2000, 0x2000); } resources_set_int("RAMBlock2", (config & 4) ? 1 : 0 ); if (config & 4) { SMR_BA(m, mem_ram + 0x4000, 0x2000); } resources_set_int("RAMBlock3", (config & 8) ? 1 : 0 ); if (config & 8) { SMR_BA(m, mem_ram + 0x6000, 0x2000); } resources_set_int("RAMBlock5", (config & 32) ? 1 : 0 ); if (config & 32) { SMR_BA(m, mem_ram + 0xA000, 0x2000); } snapshot_module_close(m); mem_initialize_memory(); return 0; }
int c64_glue_snapshot_read_module(snapshot_t *s) { BYTE major_version, minor_version; int snap_type, snap_alarm_active; snapshot_module_t *m; m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version); if (m == NULL) { return -1; } /* Do not accept versions higher than current */ if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) { snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION); goto fail; } if (0 || SMR_B_INT(m, &snap_type) < 0 || SMR_B_INT(m, &old_vbank) < 0 || SMR_B_INT(m, &snap_alarm_active) < 0) { goto fail; } if (snap_type != glue_logic_type) { log_warning(LOG_DEFAULT, "GlueLogic: Snapshot type %i differs from selected type %i, changing.", snap_type, glue_logic_type); glue_logic_type = snap_type; } if (glue_alarm_active) { glue_alarm_unset(); } glue_alarm_active = snap_alarm_active; if (glue_alarm_active && (glue_logic_type == 1)) { glue_alarm_set(); } snapshot_module_close(m); return 0; fail: if (m != NULL) { snapshot_module_close(m); } return -1; }
int mypia_snapshot_read_module(snapshot_t * p) { BYTE vmajor, vminor; BYTE byte; snapshot_module_t *m; my_restore_int(pia_int_num, 0); /* just in case */ m = snapshot_module_open(p, snap_module_name, &vmajor, &vminor); if (m == NULL) return -1; if (vmajor != PIA_DUMP_VER_MAJOR) { snapshot_module_close(m); return -1; } SMR_B(m, &mypia.port_a); SMR_B(m, &mypia.ddr_a); SMR_B(m, &mypia.ctrl_a); SMR_B(m, &mypia.port_b); SMR_B(m, &mypia.ddr_b); SMR_B(m, &mypia.ctrl_b); SMR_B(m, &byte); mypia.ca_state = (byte & 0x80) ? 1 : 0; mypia.cb_state = (byte & 0x80) ? 1 : 0; pia_set_ca2(mypia.ca_state); pia_set_cb2(mypia.cb_state); byte = mypia.port_a | ~mypia.ddr_a; undump_pa(byte); byte = mypia.port_b | ~mypia.ddr_b; undump_pb(byte); if (0 || ((mypia.ctrl_a & 0x81) == 0x81) || ((mypia.ctrl_a & 0x68) == 0x48) || ((mypia.ctrl_b & 0x81) == 0x81) || ((mypia.ctrl_b & 0x68) == 0x48) ) { my_restore_int(pia_int_num, 1); } return snapshot_module_close(m); }
int expert_snapshot_read_module(snapshot_t *s) { BYTE vmajor, vminor; snapshot_module_t *m; m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor); if (m == NULL) { return -1; } if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) { snapshot_module_close(m); return -1; } expert_ram = lib_malloc(EXPERT_RAM_SIZE); if (0 || (SMR_B_INT(m, &cartmode) < 0) || (SMR_B_INT(m, &expert_register_enabled) < 0) || (SMR_B_INT(m, &expert_ram_writeable) < 0) || (SMR_B_INT(m, &expert_ramh_enabled) < 0) || (SMR_BA(m, expert_ram, EXPERT_RAM_SIZE) < 0)) { snapshot_module_close(m); lib_free(expert_ram); expert_ram = NULL; return -1; } snapshot_module_close(m); expert_filetype = 0; expert_write_image = 0; expert_enabled = 1; /* FIXME: ugly code duplication to avoid cart_config_changed calls */ expert_io1_list_item = io_source_register(&expert_io1_device); if (c64export_add(&export_res) < 0) { lib_free(expert_ram); expert_ram = NULL; io_source_unregister(expert_io1_list_item); expert_io1_list_item = NULL; expert_enabled = 0; return -1; } return 0; }