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 simon_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 simon_common_attach();
}
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();
}
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 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 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;
}
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 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 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 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;
}
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 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 *p)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
BYTE config;
int trapfl;
m = snapshot_module_open(p, SNAP_ROM_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return 0; /* optional */
}
if (vmajor != VIC20ROM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
/* disable traps before loading the ROM */
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
/* old cart system ROMs (ignored) */
SMR_B(m, &config);
/* read kernal */
SMR_BA(m, vic20memrom_kernal_rom, 0x2000);
/* read basic */
SMR_BA(m, vic20memrom_basic_rom, 0x2000);
SMR_BA(m, vic20memrom_chargen_rom, 0x1000);
vic20rom_kernal_checksum();
vic20rom_basic_checksum();
log_warning(vic20_snapshot_log,
"Dumped Romset files and saved settings will "
"represent\nthe state before loading the snapshot!");
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
snapshot_module_close(m);
mem_initialize_memory();
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;
}
/* 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, &rom_A14) < 0
|| SMR_B_INT(m, &roml_toggle) < 0) {
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (SMR_B_INT(m, &allow_toggle) < 0) {
goto fail;
}
} else {
allow_toggle = 0;
}
if (0
|| SMR_BA(m, roml_banks, 0x4000) < 0
|| SMR_BA(m, romh_banks, 0x4000) < 0) {
goto fail;
}
snapshot_module_close(m);
return freezemachine_common_attach();
fail:
snapshot_module_close(m);
return -1;
}
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 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;
}
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 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;
}
int joystick_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
m = snapshot_module_open(s, "JOYSTICK",
&major_version, &minor_version);
if (m == NULL) {
return 0;
}
if (SMR_BA(m, joystick_value, (JOYSTICK_NUM + 1)) < 0) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
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;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (0
|| SMR_B_INT(m, &freezeframe_rom_8000) < 0
|| SMR_B_INT(m, &freezeframe_rom_e000) < 0) {
goto fail;
}
} else {
freezeframe_rom_8000 = 0;
freezeframe_rom_e000 = 0;
}
if (SMR_BA(m, roml_banks, FREEZE_FRAME_CART_SIZE) < 0) {
goto fail;
}
snapshot_module_close(m);
memcpy(romh_banks, roml_banks, FREEZE_FRAME_CART_SIZE);
return freezeframe_common_attach();
fail:
snapshot_module_close(m);
return -1;
}
int digimax_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int temp_digimax_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;
}
if (0
|| (SMR_DW_INT(m, &temp_digimax_address) < 0)
/* FIXME: Implement the userport part in userport_digimax.c */
#if 0
|| (SMR_B(m, &digimax_userport_address) < 0)
|| (SMR_B(m, &digimax_userport_direction_A) < 0)
|| (SMR_B(m, &digimax_userport_direction_B) < 0)
#endif
|| (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)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
/* HACK set address to an invalid value, then use the function */
digimax_address = -1;
set_digimax_base(temp_digimax_address, NULL);
return digimax_enable();
}
int rex_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;
}
/* Do not accept versions higher than current */
if ((vmajor != SNAP_MAJOR) || (vminor != SNAP_MINOR)) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (SMR_B_INT(m, &rex_active) < 0) {
goto fail;
}
} else {
rex_active = 0;
}
if (SMR_BA(m, roml_banks, 0x2000 * 64) < 0) {
goto fail;
}
snapshot_module_close(m);
return rex_common_attach();
fail:
snapshot_module_close(m);
return -1;
}
int epyxfastload_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
CLOCK temp_clk;
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_DW(m, &temp_clk) < 0)
|| (SMR_BA(m, roml_banks, 0x2000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
if (epyxfastload_common_attach() < 0) {
return -1;
}
if (temp_clk < CLOCK_MAX) {
epyxrom_alarm_time = temp_clk;
alarm_set(epyxrom_alarm, epyxrom_alarm_time);
}
return 0;
}
int behrbonz_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_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
if (0
|| (SMR_B(m, &bank_reg) < 0)
|| (SMR_B(m, &reset_mode) < 0)
|| (SMR_B(m, &write_once) < 0)
|| (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
lib_free(cart_rom);
cart_rom = NULL;
return -1;
}
snapshot_module_close(m);
mem_cart_blocks = VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO3;
mem_initialize_memory();
return 0;
}
int vic_snapshot_read_module(snapshot_t *s)
{
WORD i;
snapshot_module_t *m;
BYTE major_version, minor_version;
WORD w;
BYTE b;
sound_close();
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(vic.log, "Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
if (SMR_B(m, &b) < 0) {
goto fail;
}
if (b != VIC_RASTER_CYCLE(maincpu_clk)) {
log_error(vic.log, "Cycle value (%d) incorrect; should be %d.",
(int)b, VIC_RASTER_CYCLE(maincpu_clk));
goto fail;
}
vic.raster_cycle = (unsigned int)b;
if (SMR_W(m, &w) < 0) {
goto fail;
}
if (w != VIC_RASTER_Y(maincpu_clk)) {
log_error(vic.log, "Raster line value (%d) incorrect; should be %d.",
(int)w, VIC_RASTER_Y(maincpu_clk));
goto fail;
}
if (SMR_W(m, &w) < 0) {
goto fail;
}
vic.area = (vic_area_state_t)w;
if (SMR_W(m, &w) < 0) {
goto fail;
}
vic.fetch_state = (vic_fetch_state_t)w;
if (0
|| (SMR_DW_UINT(m, &vic.raster_line) < 0)
|| (SMR_DW_UINT(m, &vic.text_cols) < 0)
|| (SMR_DW_UINT(m, &vic.text_lines) < 0)
|| (SMR_DW_UINT(m, &vic.pending_text_cols) < 0)
|| (SMR_DW_UINT(m, &vic.line_was_blank) < 0)
|| (SMR_DW_UINT(m, &vic.memptr) < 0)
|| (SMR_DW_UINT(m, &vic.memptr_inc) < 0)
|| (SMR_DW_UINT(m, &vic.row_counter) < 0)
|| (SMR_DW_UINT(m, &vic.buf_offset) < 0)
|| SMR_B_INT(m, &vic.light_pen.state) < 0
|| SMR_B_INT(m, &vic.light_pen.triggered) < 0
|| SMR_DW_INT(m, &vic.light_pen.x) < 0
|| SMR_DW_INT(m, &vic.light_pen.y) < 0
|| SMR_DW_INT(m, &vic.light_pen.x_extra_bits) < 0
|| SMR_DW(m, &vic.light_pen.trigger_cycle) < 0
|| (SMR_B(m, &vic.vbuf) < 0)) {
goto fail;
}
/* Color RAM. */
if (SMR_BA(m, mem_ram + 0x9400, 0x400) < 0) {
goto fail;
}
for (i = 0; i < 0x10; i++) {
if (SMR_B(m, &b) < 0) {
goto fail;
}
/* XXX: This assumes that there are no side effects. */
vic_store(i, b);
}
raster_force_repaint(&vic.raster);
return snapshot_module_close(m);
fail:
if (m != NULL)
snapshot_module_close(m);
return -1;
}
static int mem_read_rom_snapshot_module(snapshot_t *p)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
BYTE config;
int i, trapfl;
m = snapshot_module_open(p, module_rom_name, &vmajor, &vminor);
if (m == NULL)
return 0; /* optional */
if (vmajor != CBM2ROM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
/* disable traps before loading the ROM */
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
SMR_B(m, &config);
/* kernal */
SMR_BA(m, mem_rom + 0xe000, 0x2000);
/* basic */
SMR_BA(m, mem_rom + 0x8000, 0x4000);
/* chargen */
if (config & 32) {
SMR_BA(m, mem_chargen_rom, 0x1000);
} else {
SMR_BA(m, mem_chargen_rom, 0x0800);
SMR_BA(m, mem_chargen_rom + 0x1000, 0x0800);
/* Inverted chargen into second half. This is a hardware feature. */
for (i = 0; i < 2048; i++) {
mem_chargen_rom[i + 2048] = mem_chargen_rom[i] ^ 0xff;
mem_chargen_rom[i + 6144] = mem_chargen_rom[i + 4096] ^ 0xff;
}
}
if (config & 2) {
SMR_BA(m, mem_rom + 0x1000, 0x1000);
}
if (config & 4) {
SMR_BA(m, mem_rom + 0x2000, 0x2000);
}
if (config & 8) {
SMR_BA(m, mem_rom + 0x4000, 0x2000);
}
if (config & 16) {
SMR_BA(m, mem_rom + 0x6000, 0x2000);
}
log_warning(cbm2_snapshot_log,
"Dumped Romset files and saved settings will "
"represent\nthe state before loading the snapshot!");
cbm2rom_checksum();
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
snapshot_module_close(m);
return 0;
}
static int mem_read_ram_snapshot_module(snapshot_t *p)
{
BYTE byte, vmajor, vminor;
snapshot_module_t *m;
BYTE config, hwconfig;
int memsize;
int effective_ramsize, effective_start;
int bank0;
m = snapshot_module_open(p, module_name, &vmajor, &vminor);
if (m == NULL)
return -1;
if (vmajor != CBM2MEM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
SMR_B(m, &byte);
memsize = ((int)byte) & 0xff;
SMR_B(m, &config);
SMR_B(m, &hwconfig);
resources_set_int("ModelLine", hwconfig & 3);
SMR_B(m, &byte);
cbm2mem_set_bank_exec(byte);
SMR_B(m, &byte);
cbm2mem_set_bank_ind(byte);
SMR_BA(m, mem_ram + 0xf0000, 0x0800);
SMR_BA(m, mem_rom + 0xd000, 0x0800);
/* calculate start and size of RAM to load */
/* ramsize starts counting at 0x10000 if less than 512k */
bank0 = config & 64;
effective_ramsize = memsize << 7;
effective_start = 0x10000;
if (bank0 || effective_ramsize >= 512) {
effective_start = 0;
}
if (bank0 && effective_ramsize < 512) {
effective_ramsize -= 64;
}
SMR_BA(m, mem_ram + effective_start, memsize << 17);
ramsize = effective_ramsize;
cart08_ram = config & 1;
cart1_ram = config & 2;
cart2_ram = config & 4;
cart4_ram = config & 8;
cart6_ram = config & 16;
cartC_ram = config & 32;
if (memsize < 4) {
SMR_BA(m, mem_ram + 0x10000, memsize << 17);
} else {
SMR_BA(m, mem_ram, memsize << 17);
}
if (memsize < 4) { /* if 1M memory, bank 15 is included */
if (config & 1) {
SMR_BA(m, mem_ram + 0xf0800, 0x0800);
}
if (config & 2) {
SMR_BA(m, mem_ram + 0xf1000, 0x1000);
}
if (config & 4) {
SMR_BA(m, mem_ram + 0xf2000, 0x2000);
}
if (config & 8) {
SMR_BA(m, mem_ram + 0xf4000, 0x2000);
}
if (config & 16) {
SMR_BA(m, mem_ram + 0xf6000, 0x2000);
}
if (config & 32) {
SMR_BA(m, mem_ram + 0xfc000, 0x1000);
}
}
mem_initialize_memory();
snapshot_module_close(m);
return 0;
}
static int drive_snapshot_read_gcrimage_module(snapshot_t *s, unsigned int dnr)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char snap_module_name[10];
BYTE *data;
unsigned int i;
drive_t *drive;
DWORD num_half_tracks, track_size;
drive = drive_context[dnr]->drive;
sprintf(snap_module_name, "GCRIMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
return 0;
}
if (major_version != GCRIMAGE_SNAP_MAJOR
|| minor_version != GCRIMAGE_SNAP_MINOR) {
log_error(drive_snapshot_log,
"Snapshot module version (%d.%d) not supported.",
major_version, minor_version);
snapshot_module_close(m);
return -1;
}
if (0
|| SMR_DW(m, &num_half_tracks) < 0
|| num_half_tracks > MAX_GCR_TRACKS) {
snapshot_module_close(m);
return -1;
}
for (i = 0; i < num_half_tracks; i++) {
if (SMR_DW(m, &track_size) < 0
|| track_size > NUM_MAX_MEM_BYTES_TRACK) {
snapshot_module_close(m);
return -1;
}
if (track_size) {
if (drive->gcr->tracks[i].data == NULL) {
drive->gcr->tracks[i].data = lib_calloc(1, track_size);
} else if (drive->gcr->tracks[i].size != (int)track_size) {
drive->gcr->tracks[i].data = lib_realloc(drive->gcr->tracks[i].data, track_size);
}
memset(drive->gcr->tracks[i].data, 0, track_size);
} else {
if (drive->gcr->tracks[i].data) {
lib_free(drive->gcr->tracks[i].data);
drive->gcr->tracks[i].data = NULL;
}
}
data = drive->gcr->tracks[i].data;
drive->gcr->tracks[i].size = track_size;
if (track_size && SMR_BA(m, data, track_size) < 0) {
snapshot_module_close(m);
return -1;
}
}
for (; i < MAX_GCR_TRACKS; i++) {
if (drive->gcr->tracks[i].data) {
lib_free(drive->gcr->tracks[i].data);
drive->gcr->tracks[i].data = NULL;
drive->gcr->tracks[i].size = 0;
}
}
snapshot_module_close(m);
drive->GCR_image_loaded = 1;
drive->complicated_image_loaded = 1; /* TODO: verify if it's really like this */
drive->image = NULL;
return 0;
}
static int drive_snapshot_read_image_module(snapshot_t *s, unsigned int dnr)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char snap_module_name[10];
WORD word;
char *filename = NULL;
char *request_str;
int len = 0;
FILE *fp;
BYTE sector_data[0x100];
disk_addr_t dadr;
int rc;
drive_t *drive;
drive = drive_context[dnr]->drive;
sprintf(snap_module_name, "NOIMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m != NULL) {
file_system_detach_disk(dnr + 8);
snapshot_module_close(m);
return 0;
}
sprintf(snap_module_name, "IMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
return 0;
}
if (major_version > IMAGE_SNAP_MAJOR || minor_version > IMAGE_SNAP_MINOR) {
log_error(drive_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
IMAGE_SNAP_MAJOR, IMAGE_SNAP_MINOR);
}
if (SMR_W(m, &word) < 0) {
snapshot_module_close(m);
return -1;
}
switch (word) {
case 1581:
len = D81_FILE_SIZE;
break;
case 8050:
len = D80_FILE_SIZE;
break;
case 8250:
len = D82_FILE_SIZE;
break;
default:
log_error(drive_snapshot_log,
"Snapshot of disk image unknown (type %d)",
(int)word);
snapshot_module_close(m);
return -1;
}
/* create temporary file of the right size */
fp = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (fp == NULL) {
log_error(drive_snapshot_log, "Could not create temporary file!");
snapshot_module_close(m);
return -1;
}
/* blow up the file to needed size */
if (fseek(fp, len - 1, SEEK_SET) < 0
|| (fputc(0, fp) == EOF)) {
log_error(drive_snapshot_log, "Could not create large temporary file");
fclose(fp);
lib_free(filename);
snapshot_module_close(m);
return -1;
}
fclose(fp);
lib_free(filename);
if (file_system_attach_disk(dnr + 8, filename) < 0) {
log_error(drive_snapshot_log, "Invalid Disk Image");
lib_free(filename);
snapshot_module_close(m);
return -1;
}
request_str = lib_msprintf("Disk image unit #%d imported from snapshot",
dnr + 8);
zfile_close_action(filename, ZFILE_REQUEST, request_str);
lib_free(request_str);
/* we use the return code to step through the tracks. So we do not
need any geometry info. */
SMR_BA(m, sector_data, 0x100);
for (dadr.track = 1;; dadr.track++) {
rc = 0;
for (dadr.sector = 0;; dadr.sector++) {
rc = disk_image_write_sector(drive->image, sector_data, &dadr);
if (rc == 0) {
SMR_BA(m, sector_data, 0x100);
} else {
break;
}
}
if (dadr.sector == 0) {
break;
}
}
vdrive_bam_reread_bam(dnr + 8);
snapshot_module_close(m);
m = NULL;
return 0;
}