static int tape_snapshot_write_tapimage_module(snapshot_t *s)
{
snapshot_module_t *m;
FILE *ftap;
long pos, tap_size;
BYTE buffer[256];
int i;
m = snapshot_module_create(s, "TAPIMAGE", TAPIMAGE_SNAP_MAJOR,
TAPIMAGE_SNAP_MINOR);
if (m == NULL)
return -1;
/* get the file descriptor */
ftap = ((tap_t*)tape_image_dev1->data)->fd;
if (!ftap) {
log_error(tape_snapshot_log, "Cannot open tapfile for reading");
return -1;
}
/* remeber current position */
pos = ftell(ftap);
/* move to end and get size of file */
if (fseek(ftap, 0, SEEK_END) != 0) {
log_error(tape_snapshot_log, "Cannot move to end of tapfile");
return -1;
}
tap_size = ftell(ftap);
if (SMW_DW(m, tap_size)) {
fseek(ftap, pos, SEEK_SET);
log_error(tape_snapshot_log, "Cannot write size of tap image");
}
/* move to beginning */
if (fseek(ftap, 0, SEEK_SET) != 0) {
log_error(tape_snapshot_log, "Cannot move to beginning of tapfile");
return -1;
}
/* read every BYTE and write to snapshot module */
while (tap_size > 0) {
i = fread(buffer, 1, 256, ftap);
if (SMW_BA(m, buffer, i) < 0) {
log_error(tape_snapshot_log, "Cannot write tap image");
fseek(ftap, pos, SEEK_SET);
return -1;
}
tap_size -= i;
}
/* restore position */
fseek(ftap, pos, SEEK_SET);
if (snapshot_module_close(m) < 0)
return -1;
return 0;
}
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;
}
static int mem_write_rom_snapshot_module(snapshot_t *p, int save_roms)
{
snapshot_module_t *m;
if (!save_roms) {
return 0;
}
m = snapshot_module_create(p, SNAP_ROM_MODULE_NAME, VIC20MEM_DUMP_VER_MAJOR, VIC20MEM_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
/* old cart system config bits. all zero = no roms */
SMW_B(m, 0x00);
/* save kernal */
SMW_BA(m, vic20memrom_kernal_rom, 0x2000);
/* save basic */
SMW_BA(m, vic20memrom_basic_rom, 0x2000);
SMW_BA(m, vic20memrom_chargen_rom, 0x1000);
snapshot_module_close(m);
return 0;
}
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 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;
}
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);
SMW_B(m, riot_context->riot_io[0]);
SMW_B(m, riot_context->riot_io[1]);
SMW_B(m, riot_context->riot_io[2]);
SMW_B(m, riot_context->riot_io[3]);
SMW_B(m, riot_context->r_edgectrl);
SMW_B(m, (BYTE)(riot_context->r_irqfl | (riot_context->r_irqline ? 1 : 0)));
SMW_B(m, (BYTE)(riot_context->r_N - (*(riot_context->clk_ptr)
- riot_context->r_write_clk)
/ riot_context->r_divider));
SMW_W(m, (WORD)(riot_context->r_divider));
SMW_W(m, (BYTE)((*(riot_context->clk_ptr) - riot_context->r_write_clk)
% riot_context->r_divider));
SMW_B(m, (BYTE)(riot_context->r_irqen ? 1 : 0));
snapshot_module_close(m);
return 0;
}
/*! \brief Write the snapshot module for the ACIA
\param p
Pointer to the snapshot data
\return
0 on success, -1 on error
\remark
Is it sensible to put the ACIA into a snapshot? It is unlikely
the "other side" of the connection will be able to handle this
case if a transfer was under way, anyway.
\todo FIXME!!! Error check.
\todo FIXME!!! If no connection, emulate carrier lost or so.
*/
int myacia_snapshot_write_module(snapshot_t *p)
{
snapshot_module_t *m;
m = snapshot_module_create(p, module_name, (BYTE)ACIA_DUMP_VER_MAJOR,
(BYTE)ACIA_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
SMW_B(m, acia.txdata);
SMW_B(m, acia.rxdata);
SMW_B(m, (BYTE)(acia_get_status() | (acia.irq ? ACIA_SR_BITS_IRQ : 0)));
SMW_B(m, acia.cmd);
SMW_B(m, acia.ctrl);
SMW_B(m, (BYTE)(acia.in_tx));
if (acia.alarm_active_tx) {
SMW_DW(m, (acia.alarm_clk_tx - myclk));
} else {
SMW_DW(m, 0);
}
/* new with VICE 2.0.9 */
if (acia.alarm_active_rx) {
SMW_DW(m, (acia.alarm_clk_rx - myclk));
} else {
SMW_DW(m, 0);
}
snapshot_module_close(m);
return 0;
}
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 fdc_snapshot_write_module(snapshot_t *p, int fnum)
{
snapshot_module_t *m;
char *name;
if (fdc[fnum].fdc_state == FDC_UNUSED) {
return 0;
}
name = lib_msprintf("FDC%i", fnum);
m = snapshot_module_create(p, name,
FDC_DUMP_VER_MAJOR, FDC_DUMP_VER_MINOR);
lib_free(name);
if (m == NULL)
return -1;
SMW_B(m, (BYTE)(fdc[fnum].fdc_state));
/* clk till next invocation */
SMW_DW(m,
(DWORD)(fdc[fnum].alarm_clk - drive_clk[fnum]));
/* number of drives - so far 1 only */
SMW_B(m, 1);
/* last accessed track/sector */
SMW_B(m, ((BYTE)(fdc[fnum].last_track)));
SMW_B(m, ((BYTE)(fdc[fnum].last_sector)));
snapshot_module_close(m);
return 0;
}
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 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;
}
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 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);
}
static int drive_snapshot_write_p64image_module(snapshot_t *s, unsigned int dnr)
{
char snap_module_name[10];
snapshot_module_t *m;
drive_t *drive;
TP64MemoryStream P64MemoryStreamInstance;
PP64Image P64Image;
drive = drive_context[dnr]->drive;
sprintf(snap_module_name, "P64IMAGE%i", dnr);
m = snapshot_module_create(s, snap_module_name, GCRIMAGE_SNAP_MAJOR,
GCRIMAGE_SNAP_MINOR);
if (m == NULL) {
return -1;
}
P64Image = (void*)drive->p64;
if (P64Image == NULL) {
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
P64MemoryStreamCreate(&P64MemoryStreamInstance);
P64MemoryStreamClear(&P64MemoryStreamInstance);
if (!P64ImageWriteToStream(P64Image, &P64MemoryStreamInstance)) {
P64MemoryStreamDestroy(&P64MemoryStreamInstance);
return -1;
}
if (SMW_DW(m, P64MemoryStreamInstance.Size) < 0 ||
SMW_BA(m, P64MemoryStreamInstance.Data, P64MemoryStreamInstance.Size) < 0) {
if (m != NULL) {
snapshot_module_close(m);
}
P64MemoryStreamDestroy(&P64MemoryStreamInstance);
return -1;
}
P64MemoryStreamDestroy(&P64MemoryStreamInstance);
if (snapshot_module_close(m) < 0) {
return -1;
}
return 0;
}
static int mem_write_rom_snapshot_module(snapshot_t *s)
{
snapshot_module_t *m;
int trapfl;
/* Main memory module. */
m = snapshot_module_create(s, snap_rom_module_name,
SNAP_ROM_MAJOR, SNAP_ROM_MINOR);
if (m == NULL)
return -1;
/* disable traps before saving the ROM */
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
if (0
|| SMW_BA(m, c128memrom_kernal_rom, C128_KERNAL_ROM_SIZE) < 0
|| SMW_BA(m, c128memrom_basic_rom, C128_BASIC_ROM_SIZE) < 0
|| SMW_BA(m, c128memrom_basic_rom + C128_BASIC_ROM_SIZE,
C128_EDITOR_ROM_SIZE) < 0
|| SMW_BA(m, mem_chargen_rom, C128_CHARGEN_ROM_SIZE) < 0)
goto fail;
/* FIXME: save cartridge ROM (& RAM?) areas:
first write out the configuration, i.e.
- type of cartridge (banking scheme type)
- state of cartridge (active/which bank, ...)
then the ROM/RAM arrays:
- cartridge ROM areas
- cartridge RAM areas
*/
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
if (snapshot_module_close(m) < 0)
goto fail;
return 0;
fail:
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
if (m != NULL)
snapshot_module_close(m);
return -1;
}
int cbm2_c500_snapshot_write_module(snapshot_t *p)
{
snapshot_module_t *m;
m = snapshot_module_create(p, module_name, C500DATA_DUMP_VER_MAJOR,
C500DATA_DUMP_VER_MINOR);
if (m == NULL)
return -1;
SMW_DW(m, c500_powerline_clk - maincpu_clk);
snapshot_module_close(m);
return 0;
}
int viacore_snapshot_write_module(via_context_t *via_context, snapshot_t *s)
{
snapshot_module_t *m;
if (via_context->tai && (via_context->tai <= *(via_context->clk_ptr)))
viacore_intt1(*(via_context->clk_ptr) - via_context->tai,
(void *)via_context);
if (via_context->tbi && (via_context->tbi <= *(via_context->clk_ptr)))
viacore_intt2(*(via_context->clk_ptr) - via_context->tbi,
(void *)via_context);
m = snapshot_module_create(s, via_context->my_module_name,
VIA_DUMP_VER_MAJOR, VIA_DUMP_VER_MINOR);
if (m == NULL)
return -1;
SMW_B(m, via_context->via[VIA_PRA]);
SMW_B(m, via_context->via[VIA_DDRA]);
SMW_B(m, via_context->via[VIA_PRB]);
SMW_B(m, via_context->via[VIA_DDRB]);
SMW_W(m, (WORD)(via_context->tal));
SMW_W(m, (WORD)myviata(via_context));
SMW_B(m, via_context->via[VIA_T2LL]);
SMW_W(m, (WORD)myviatb(via_context));
SMW_B(m, (BYTE)((via_context->tai ? 0x80 : 0) | (via_context->tbi ? 0x40 : 0)));
SMW_B(m, via_context->via[VIA_SR]);
SMW_B(m, via_context->via[VIA_ACR]);
SMW_B(m, via_context->via[VIA_PCR]);
SMW_B(m, (BYTE)(via_context->ifr));
SMW_B(m, (BYTE)(via_context->ier));
/* FIXME! */
SMW_B(m, (BYTE)((((via_context->pb7 ^ via_context->pb7x)
| via_context->pb7o) ? 0x80 : 0)));
SMW_B(m, 0); /* SRHBITS */
SMW_B(m, (BYTE)((via_context->ca2_state ? 0x80 : 0)
| (via_context->cb2_state ? 0x40 : 0)));
SMW_B(m, via_context->ila);
SMW_B(m, via_context->ilb);
snapshot_module_close(m);
return 0;
}
static int userport_8bss_write_snapshot_module(snapshot_t *s)
{
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)userport_8bss_channel) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
static int mem_write_ram_snapshot_module(snapshot_t *p)
{
snapshot_module_t *m;
BYTE config;
config = (ram_block_0_enabled ? 1 : 0)
| (ram_block_1_enabled ? 2 : 0)
| (ram_block_2_enabled ? 4 : 0)
| (ram_block_3_enabled ? 8 : 0)
| (ram_block_5_enabled ? 32 : 0);
m = snapshot_module_create(p, SNAP_MEM_MODULE_NAME,
VIC20MEM_DUMP_VER_MAJOR,
VIC20MEM_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
SMW_B(m, config);
SMW_B(m, vic20_cpu_last_data);
SMW_B(m, vic20_v_bus_last_data);
SMW_B(m, vic20_v_bus_last_high);
SMW_BA(m, mem_ram, 0x0400);
SMW_BA(m, mem_ram + 0x1000, 0x1000);
if (config & 1) {
SMW_BA(m, mem_ram + 0x0400, 0x0c00);
}
if (config & 2) {
SMW_BA(m, mem_ram + 0x2000, 0x2000);
}
if (config & 4) {
SMW_BA(m, mem_ram + 0x4000, 0x2000);
}
if (config & 8) {
SMW_BA(m, mem_ram + 0x6000, 0x2000);
}
if (config & 32) {
SMW_BA(m, mem_ram + 0xA000, 0x2000);
}
snapshot_module_close(m);
return 0;
}
int sfx_soundsampler_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)sfx_soundsampler_sound_data) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
int rtc72421_write_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;
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->stop) < 0
|| SMW_B(m, (BYTE)context->hour24) < 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_STR(m, context->device) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
static int paperclip64_write_snapshot(struct snapshot_s *s, int port)
{
snapshot_module_t *m;
m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| SMW_DW(m, (DWORD)counter) < 0
|| SMW_B(m, command) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
static int userport_rtc_write_snapshot_module(snapshot_t *s)
{
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)read_line_active) < 0) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return rtc58321a_write_snapshot(rtc58321a_context, s);
}
static int drive_snapshot_write_gcrimage_module(snapshot_t *s, unsigned int dnr)
{
char snap_module_name[10];
snapshot_module_t *m;
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_create(s, snap_module_name, GCRIMAGE_SNAP_MAJOR,
GCRIMAGE_SNAP_MINOR);
if (m == NULL) {
return -1;
}
num_half_tracks = MAX_TRACKS_1571 * 2;
/* Write general data */
if (SMW_DW(m, num_half_tracks) < 0) {
snapshot_module_close(m);
return -1;
}
/* Write half track data */
for (i = 0; i < num_half_tracks; i++) {
data = drive->gcr->tracks[i].data;
track_size = data ? drive->gcr->tracks[i].size : 0;
if (0
|| SMW_DW(m, (DWORD)track_size) < 0
|| (track_size && SMW_BA(m, data, track_size) < 0)
) {
break;
}
}
if (snapshot_module_close(m) < 0 || (i != num_half_tracks)) {
return -1;
}
return 0;
}
int mach5_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_BA(m, roml_banks, 0x2000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
int rex_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| SMW_B(m, (BYTE)rex_active) < 0
|| SMW_BA(m, roml_banks, 0x2000 * 64) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
int freezeframe_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_BA(m, roml_banks, FREEZE_FRAME_CART_SIZE) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
int vic20cart_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
int ret = 0;
m = snapshot_module_create(s, SNAP_MODULE_NAME,
VIC20CART_DUMP_VER_MAJOR, VIC20CART_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
if (SMW_DW(m, (DWORD)vic20cart_type) < 0) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
switch (vic20cart_type) {
case CARTRIDGE_VIC20_GENERIC:
ret = generic_snapshot_write_module(s);
break;
case CARTRIDGE_VIC20_FP:
ret = vic_fp_snapshot_write_module(s);
break;
case CARTRIDGE_VIC20_MEGACART:
ret = megacart_snapshot_write_module(s);
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
ret = finalexpansion_snapshot_write_module(s);
break;
case CARTRIDGE_NONE:
default:
break;
}
return ret;
}
int magicdesk_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)regval) < 0)
|| (SMW_BA(m, roml_banks, 0x2000 * MAXBANKS) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
/* FIXME: implement snapshot support */
int vic20_ieee488_snapshot_write_module(snapshot_t *s)
{
return -1;
#if 0
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) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
#endif
}
