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_INT(m, &currbank) < 0) || (SMR_BA(m, roml_banks, 0x2000 * 64) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return magicdesk_common_attach(); }
int riotcore_snapshot_write_module(riot_context_t *riot_context, snapshot_t *p) { snapshot_module_t *m; m = snapshot_module_create(p, riot_context->myname, RIOT_DUMP_VER_MAJOR, RIOT_DUMP_VER_MINOR); if (m == NULL) { return -1; } update_timer(riot_context); if (0 || SMW_B(m, riot_context->riot_io[0]) < 0 || SMW_B(m, riot_context->riot_io[1]) < 0 || SMW_B(m, riot_context->riot_io[2]) < 0 || SMW_B(m, riot_context->riot_io[3]) < 0 || SMW_B(m, riot_context->r_edgectrl) < 0 || SMW_B(m, (BYTE)(riot_context->r_irqfl | (riot_context->r_irqline ? 1 : 0))) < 0 || SMW_B(m, (BYTE)(riot_context->r_N - (*(riot_context->clk_ptr) - riot_context->r_write_clk) / riot_context->r_divider)) < 0 || SMW_W(m, (WORD)(riot_context->r_divider)) < 0 || SMW_W(m, (BYTE)((*(riot_context->clk_ptr) - riot_context->r_write_clk) % riot_context->r_divider)) < 0 || SMW_B(m, (BYTE)(riot_context->r_irqen ? 1 : 0)) < 0) { snapshot_module_close(m); return -1; } return snapshot_module_close(m); }
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(); }
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 sid_snapshot_write_module_simple(snapshot_t *s) { int sound, sid_engine; snapshot_module_t *m; m = snapshot_module_create(s, snap_module_name_simple, SNAP_MAJOR_SIMPLE, SNAP_MINOR_SIMPLE); if (m == NULL) { return -1; } resources_get_int("Sound", &sound); if (SMW_B(m, (BYTE)sound) < 0) { snapshot_module_close(m); return -1; } if (sound) { resources_get_int("SidEngine", &sid_engine); if (SMW_B(m, (BYTE)sid_engine) < 0) { snapshot_module_close(m); return -1; } /* FIXME: Only data for first SID stored. */ if (SMW_BA(m, sid_get_siddata(0), 32) < 0) { snapshot_module_close(m); return -1; } } snapshot_module_close(m); return 0; }
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(); }
int easyflash_snapshot_write_module(snapshot_t *s) { snapshot_module_t *m; m = snapshot_module_create(s, SNAP_MODULE_NAME, CART_DUMP_VER_MAJOR, CART_DUMP_VER_MINOR); if (m == NULL) { return -1; } if (0 || (SMW_B(m, (BYTE)easyflash_jumper) < 0) || (SMW_B(m, easyflash_register_00) < 0) || (SMW_B(m, easyflash_register_02) < 0) || (SMW_BA(m, easyflash_ram, 256) < 0) || (SMW_BA(m, roml_banks, 0x80000) < 0) || (SMW_BA(m, romh_banks, 0x80000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); if (0 || (flash040core_snapshot_write_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0) || (flash040core_snapshot_write_module(s, easyflash_state_high, FLASH_SNAP_MODULE_NAME) < 0)) { return -1; } return 0; }
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 finalexpansion_snapshot_write_module(snapshot_t *s) { snapshot_module_t *m; m = snapshot_module_create(s, SNAP_MODULE_NAME, VIC20CART_DUMP_VER_MAJOR, VIC20CART_DUMP_VER_MINOR); if (m == NULL) { return -1; } if (0 || (SMW_B(m, register_a) < 0) || (SMW_B(m, register_b) < 0) || (SMW_B(m, lock_bit) < 0) || (SMW_BA(m, cart_ram, CART_RAM_SIZE) < 0) || (SMW_BA(m, flash_state.flash_data, CART_ROM_SIZE) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); if ((flash040core_snapshot_write_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) { return -1; } return 0; }
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 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 vic_fp_snapshot_write_module(snapshot_t *s) { snapshot_module_t *m; m = snapshot_module_create(s, SNAP_MODULE_NAME, VIC20CART_DUMP_VER_MAJOR, VIC20CART_DUMP_VER_MINOR); if (m == NULL) { return -1; } if (0 || (SMW_B(m, cart_bank_reg) < 0) || (SMW_B(m, cart_cfg_reg) < 0) || (SMW_BA(m, cart_ram, CART_RAM_SIZE) < 0) || (SMW_BA(m, cart_rom, CART_ROM_SIZE) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); if ((flash040core_snapshot_write_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) { return -1; } return 0; }
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) { goto fail; } return snapshot_module_close(m); fail: snapshot_module_close(m); return -1; }
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 }
int digimax_snapshot_write_module(snapshot_t *s) { snapshot_module_t *m; m = snapshot_module_create(s, SNAP_MODULE_NAME, CART_DUMP_VER_MAJOR, CART_DUMP_VER_MINOR); if (m == NULL) { return -1; } if (0 || (SMW_DW(m, (DWORD)digimax_address) < 0) /* FIXME: implement userport part in userport_digimax.c */ #if 0 || (SMW_B(m, digimax_userport_address) < 0) || (SMW_B(m, digimax_userport_direction_A) < 0) || (SMW_B(m, digimax_userport_direction_B) < 0) #endif || (SMW_BA(m, digimax_sound_data, 4) < 0) || (SMW_B(m, snd.voice0) < 0) || (SMW_B(m, snd.voice1) < 0) || (SMW_B(m, snd.voice2) < 0) || (SMW_B(m, snd.voice3) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return 0; }
int warpspeed_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, 0x2000) < 0) || (SMR_BA(m, romh_banks, 0x2000) < 0)) { snapshot_module_close(m); return -1; } snapshot_module_close(m); return warpspeed_common_attach(); }
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; }
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 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; }
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 drive_snapshot_write_image_module(snapshot_t *s, unsigned int dnr) { char snap_module_name[10]; snapshot_module_t *m; BYTE sector_data[0x100]; WORD word; disk_addr_t dadr; int rc; drive_t *drive; drive = drive_context[dnr]->drive; if (drive->image == NULL) { sprintf(snap_module_name, "NOIMAGE%i", dnr); } else { sprintf(snap_module_name, "IMAGE%i", dnr); } m = snapshot_module_create(s, snap_module_name, IMAGE_SNAP_MAJOR, IMAGE_SNAP_MINOR); if (m == NULL) { return -1; } if (drive->image == NULL) { if (snapshot_module_close(m) < 0) { return -1; } return 0; } word = drive->image->type; SMW_W(m, word); /* we use the return code to step through the tracks. So we do not need any geometry info. */ for (dadr.track = 1;; dadr.track++) { rc = 0; for (dadr.sector = 0;; dadr.sector++) { rc = disk_image_read_sector(drive->image, sector_data, &dadr); if (rc == 0) { SMW_BA(m, sector_data, 0x100); } else { break; } } if (dadr.sector == 0) { break; } } if (snapshot_module_close(m) < 0) { return -1; } 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 vic_snapshot_write_module(snapshot_t *s) { int i; snapshot_module_t *m; m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR); if (m == NULL) { return -1; } if (SMW_B(m, (BYTE)VIC_RASTER_CYCLE(maincpu_clk)) < 0 || SMW_W(m, (WORD)VIC_RASTER_Y(maincpu_clk)) < 0) { goto fail; } if (0 || (SMW_W(m, (WORD)vic.area) < 0) || (SMW_W(m, (WORD)vic.fetch_state) < 0) || (SMW_DW(m, (DWORD)vic.raster_line) < 0) || (SMW_DW(m, (DWORD)vic.text_cols) < 0) || (SMW_DW(m, (DWORD)vic.text_lines) < 0) || (SMW_DW(m, (DWORD)vic.pending_text_cols) < 0) || (SMW_DW(m, (DWORD)vic.line_was_blank) < 0) || (SMW_DW(m, (DWORD)vic.memptr) < 0) || (SMW_DW(m, (DWORD)vic.memptr_inc) < 0) || (SMW_DW(m, (DWORD)vic.row_counter) < 0) || (SMW_DW(m, (DWORD)vic.buf_offset) < 0) || SMW_B(m, (BYTE)vic.light_pen.state) < 0 || SMW_B(m, (BYTE)vic.light_pen.triggered) < 0 || SMW_DW(m, (DWORD)vic.light_pen.x) < 0 || SMW_DW(m, (DWORD)vic.light_pen.y) < 0 || SMW_DW(m, (DWORD)vic.light_pen.x_extra_bits) < 0 || SMW_DW(m, (DWORD)vic.light_pen.trigger_cycle) < 0 || (SMW_B(m, vic.vbuf) < 0)) { goto fail; } /* Color RAM. */ if (SMW_BA(m, mem_ram + 0x9400, 0x400) < 0) { goto fail; } for (i = 0; i < 0x10; i++) { if (SMW_B(m, (BYTE)vic.regs[i]) < 0) { goto fail; } } return snapshot_module_close(m); fail: if (m != NULL) 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 ds1216e_write_snapshot(rtc_ds1216e_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; snapshot_module_t *m; /* time_t can be either 32bit or 64bit, so we save as 64bit */ #if (SIZE_OF_TIME_T == 8) latch_hi = (DWORD)(context->latch >> 32); latch_lo = (DWORD)(context->latch & 0xffffffff); offset_hi = (DWORD)(context->offset >> 32); offset_lo = (DWORD)(context->offset & 0xffffffff); old_offset_hi = (DWORD)(context->old_offset >> 32); old_offset_lo = (DWORD)(context->old_offset & 0xffffffff); #else latch_lo = (DWORD)context->latch; offset_lo = (DWORD)context->offset; old_offset_lo = (DWORD)context->old_offset; #endif m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR); if (m == NULL) { return -1; } if (0 || SMW_B(m, (BYTE)context->reset) < 0 || SMW_B(m, (BYTE)context->inactive) < 0 || SMW_B(m, (BYTE)context->hours12) < 0 || SMW_B(m, (BYTE)context->pattern_pos) < 0 || SMW_B(m, (BYTE)context->pattern_ignore) < 0 || SMW_B(m, (BYTE)context->output) < 0 || SMW_B(m, (BYTE)context->output_pos) < 0 || SMW_DW(m, latch_hi) < 0 || SMW_DW(m, latch_lo) < 0 || SMW_DW(m, offset_hi) < 0 || SMW_DW(m, offset_lo) < 0 || SMW_DW(m, old_offset_hi) < 0 || SMW_DW(m, old_offset_lo) < 0 || SMW_BA(m, context->clock_regs, DS1216E_REG_SIZE) < 0 || SMW_BA(m, context->old_clock_regs, DS1216E_REG_SIZE) < 0 || SMW_BA(m, context->clock_regs_changed, DS1216E_REG_SIZE) < 0 || SMW_STR(m, context->device) < 0) { snapshot_module_close(m); return -1; } return snapshot_module_close(m); }
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; }