![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to state.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / src|
Return to state.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src |
1.1 ! root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */ ! 2: ! 3: #include <sys/stat.h> ! 4: #include <unistd.h> ! 5: #include <stdio.h> ! 6: #include <stdlib.h> ! 7: #include <errno.h> ! 8: #include <time.h> ! 9: #include <string.h> ! 10: #include <errno.h> ! 11: ! 12: #include "generator.h" ! 13: #include "snprintf.h" ! 14: ! 15: #include "state.h" ! 16: #include "ui.h" ! 17: #include "cpu68k.h" ! 18: #include "cpuz80.h" ! 19: #include "vdp.h" ! 20: #include "gensound.h" ! 21: #include "gensoundi.h" ! 22: #include "snd/fm.h" ! 23: ! 24: /* ! 25: * NB: ! 26: * states are only loaded/saved at the end of the frame ! 27: * all local values are stored in network / 68k format (big endian) ! 28: */ ! 29: ! 30: struct savestate { ! 31: /* must ensure everything is aligned as expected */ ! 32: char s_majorver[1]; ! 33: char s_minorver[1]; ! 34: char reserved1[2]; /* align */ ! 35: char s_ram[0x10000]; ! 36: char s_vram[0x10000]; ! 37: char s_z80ram[0x2000]; ! 38: char s_cram[0x80]; ! 39: char s_vsram[0x50]; ! 40: char s_68k_regs[4*16]; ! 41: char s_68k_pc[4]; ! 42: char s_68k_sp[4]; ! 43: char s_68k_sr[2]; ! 44: char s_68k_stop[1]; ! 45: char s_68k_pending[1]; ! 46: char s_z80_af[2]; ! 47: char s_z80_bc[2]; ! 48: char s_z80_de[2]; ! 49: char s_z80_hl[2]; ! 50: char s_z80_afprime[2]; ! 51: char s_z80_bcprime[2]; ! 52: char s_z80_deprime[2]; ! 53: char s_z80_hlprime[2]; ! 54: char s_z80_ix[2]; ! 55: char s_z80_iy[2]; ! 56: char s_z80_sp[2]; ! 57: char s_z80_pc[2]; ! 58: char s_z80_i[1]; ! 59: char s_z80_r[1]; ! 60: char s_z80_active[1]; ! 61: char reserved2[1]; /* align */ ! 62: char s_z80_bank[4]; ! 63: char s_fmregs1[256]; ! 64: char s_fmregs2[256]; ! 65: char s_fmaddr1[1]; ! 66: char s_fmaddr2[1]; ! 67: char s_vdp_regs[25]; ! 68: char reserved[1]; /* align */ ! 69: char s_vdp_pal[1]; ! 70: char s_vdp_overseas[1]; ! 71: char s_vdp_ctrlflag[1]; ! 72: char s_vdp_code[1]; ! 73: char s_vdp_first[2]; /* possibly only top two bits required here */ ! 74: char s_vdp_second[2]; /* used for unterminated ctrl writes */ ! 75: char s_vdp_dmabytes[4]; ! 76: char s_vdp_address[2]; ! 77: char reserved3[2]; /* align */ ! 78: }; ! 79: ! 80: /*** state_date - return the modification date or 0 for non-existant ***/ ! 81: ! 82: time_t state_date(const int slot) ! 83: { ! 84: char filename[256]; ! 85: struct stat statbuf; ! 86: ! 87: snprintf(filename, sizeof(filename), "%s.gt%d", gen_leafname, slot); ! 88: ! 89: if (stat(filename, &statbuf) != 0) ! 90: return 0; ! 91: return statbuf.st_mtime; ! 92: } ! 93: ! 94: /*** state_load - load the given slot ***/ ! 95: ! 96: int state_load(const int slot) ! 97: { ! 98: char filename[256]; ! 99: struct savestate *ssp; ! 100: char *ss; ! 101: struct stat statbuf; ! 102: FILE *f, *a; ! 103: int i; ! 104: ! 105: snprintf(filename, sizeof(filename), "%s.gt%d", gen_leafname, slot); ! 106: if (stat(filename, &statbuf) != 0) ! 107: return -1; ! 108: ! 109: if ((ss = malloc(statbuf.st_size)) == NULL) { ! 110: LOG_CRITICAL(("Failed to allocate memory whilst loading '%s'", ! 111: filename)); ! 112: return -1; ! 113: } ! 114: if ((f = fopen(filename, "rb")) == NULL) { ! 115: LOG_CRITICAL(("Failed to open '%s': %s", filename, strerror(errno))); ! 116: return -1; ! 117: } ! 118: if (fread(ss, statbuf.st_size, 1, f) != 1) { ! 119: if (feof(f)) { ! 120: LOG_CRITICAL(("EOF whilst reading GTR file '%s'", filename)); ! 121: return -1; ! 122: } ! 123: LOG_CRITICAL(("Error whilst reading GTR file '%s': %s", filename, ! 124: strerror(errno))); ! 125: return -1; ! 126: } ! 127: fclose(f); ! 128: ! 129: ssp = (struct savestate *)ss; ! 130: ! 131: if (ssp->s_majorver[0] != 1) { ! 132: LOG_CRITICAL(("GTR file '%s' is version %d, and we're version 1", ! 133: filename, ssp->s_majorver)); ! 134: return -1; ! 135: } ! 136: if (statbuf.st_size != sizeof(struct savestate)) { ! 137: LOG_CRITICAL(("GTR file '%s' is corrupt - it is not %d bytes long", ! 138: filename, sizeof(struct savestate))); ! 139: return -1; ! 140: } ! 141: ! 142: gen_reset(); ! 143: memcpy(cpu68k_ram, ssp->s_ram, sizeof(ssp->s_ram)); ! 144: memcpy(vdp_vram, ssp->s_vram, sizeof(ssp->s_vram)); ! 145: memcpy(cpuz80_ram, ssp->s_z80ram, sizeof(ssp->s_z80ram)); ! 146: memcpy(vdp_cram, ssp->s_cram, sizeof(ssp->s_cram)); ! 147: memcpy(vdp_vsram, ssp->s_vsram, sizeof(ssp->s_vsram)); ! 148: for (i = 0; i < 16; i++) ! 149: regs.regs[i] = LOCENDIAN32(((uint32 *)ssp->s_68k_regs)[i]); ! 150: regs.pc = LOCENDIAN32(*(uint32 *)ssp->s_68k_pc); ! 151: regs.sp = LOCENDIAN32(*(uint32 *)ssp->s_68k_sp); ! 152: regs.sr.sr_int = LOCENDIAN16(*(uint16 *)ssp->s_68k_sr); ! 153: regs.stop = ssp->s_68k_stop[0]; ! 154: regs.pending = ssp->s_68k_pending[0]; ! 155: cpuz80_z80.z80af = LOCENDIAN16(*(uint16 *)ssp->s_z80_af); ! 156: cpuz80_z80.z80bc = LOCENDIAN16(*(uint16 *)ssp->s_z80_bc); ! 157: cpuz80_z80.z80de = LOCENDIAN16(*(uint16 *)ssp->s_z80_de); ! 158: cpuz80_z80.z80hl = LOCENDIAN16(*(uint16 *)ssp->s_z80_hl); ! 159: cpuz80_z80.z80afprime = LOCENDIAN16(*(uint16 *)ssp->s_z80_afprime); ! 160: cpuz80_z80.z80bcprime = LOCENDIAN16(*(uint16 *)ssp->s_z80_bcprime); ! 161: cpuz80_z80.z80deprime = LOCENDIAN16(*(uint16 *)ssp->s_z80_deprime); ! 162: cpuz80_z80.z80hlprime = LOCENDIAN16(*(uint16 *)ssp->s_z80_hlprime); ! 163: cpuz80_z80.z80ix = LOCENDIAN16(*(uint16 *)ssp->s_z80_ix); ! 164: cpuz80_z80.z80iy = LOCENDIAN16(*(uint16 *)ssp->s_z80_iy); ! 165: cpuz80_z80.z80sp = LOCENDIAN16(*(uint16 *)ssp->s_z80_sp); ! 166: cpuz80_z80.z80pc = LOCENDIAN16(*(uint16 *)ssp->s_z80_pc); ! 167: cpuz80_z80.z80i = ssp->s_z80_i[0]; ! 168: cpuz80_z80.z80r = ssp->s_z80_r[0]; ! 169: cpuz80_bank = LOCENDIAN32(*(uint32 *)ssp->s_z80_bank); ! 170: memcpy(vdp_reg, ssp->s_vdp_regs, sizeof(ssp->s_vdp_regs)); ! 171: vdp_pal = ssp->s_vdp_pal[0]; ! 172: vdp_overseas = ssp->s_vdp_overseas[0]; ! 173: vdp_ctrlflag = ssp->s_vdp_ctrlflag[0]; ! 174: vdp_code = ssp->s_vdp_code[0]; ! 175: vdp_first = LOCENDIAN16(*(uint16 *)ssp->s_vdp_first); ! 176: vdp_second = LOCENDIAN16(*(uint16 *)ssp->s_vdp_second); ! 177: vdp_dmabytes = LOCENDIAN32(*(uint32 *)ssp->s_vdp_dmabytes); ! 178: vdp_address = LOCENDIAN16(*(uint16 *)ssp->s_vdp_address); ! 179: ! 180: /* reset some other run-time stuff that isn't important enough to save */ ! 181: vdp_setupvideo(); ! 182: vdp_dmabusy = vdp_dmabytes > 0 ? 1 : 0; ! 183: ! 184: for (i = 0; i < 256; i++) { ! 185: soundi_ym2612store(0, i); ! 186: soundi_ym2612store(1, ssp->s_fmregs1[i]); ! 187: soundi_ym2612store(2, i); ! 188: soundi_ym2612store(3, ssp->s_fmregs2[i]); ! 189: } ! 190: soundi_ym2612store(0, ssp->s_fmaddr1[0]); ! 191: soundi_ym2612store(1, ssp->s_fmaddr2[0]); ! 192: cpuz80_updatecontext(); ! 193: return 0; ! 194: } ! 195: ! 196: /*** state_save - save to the given slot ***/ ! 197: ! 198: int state_save(const int slot) ! 199: { ! 200: char filename[256]; ! 201: struct savestate ss; ! 202: struct savestate *ssp = &ss; /* I want a pointer like the load routines */ ! 203: struct stat statbuf; ! 204: FILE *f, *a; ! 205: int i; ! 206: ! 207: snprintf(filename, sizeof(filename), "%s.gt%d", gen_leafname, slot); ! 208: if ((f = fopen(filename, "wb")) == NULL) { ! 209: LOG_CRITICAL(("Failed to open '%s' for writing: %s", ! 210: filename, strerror(errno))); ! 211: return -1; ! 212: } ! 213: memset(ssp, 0, sizeof(ss)); ! 214: ssp->s_majorver[0] = 1; ! 215: ssp->s_minorver[0] = 1; ! 216: memcpy(ssp->s_ram, cpu68k_ram, sizeof(ssp->s_ram)); ! 217: memcpy(ssp->s_vram, vdp_vram, sizeof(ssp->s_vram)); ! 218: memcpy(ssp->s_z80ram, cpuz80_ram, sizeof(ssp->s_z80ram)); ! 219: memcpy(ssp->s_cram, vdp_cram, sizeof(ssp->s_cram)); ! 220: memcpy(ssp->s_vsram, vdp_vsram, sizeof(ssp->s_vsram)); ! 221: for (i = 0; i < 16; i++) ! 222: ((uint32 *)ssp->s_68k_regs)[i] = LOCENDIAN32(regs.regs[i]); ! 223: *(uint32 *)ssp->s_68k_pc = LOCENDIAN32(regs.pc); ! 224: *(uint32 *)ssp->s_68k_sp = LOCENDIAN32(regs.sp); ! 225: *(uint16 *)ssp->s_68k_sr = LOCENDIAN16(regs.sr.sr_int); ! 226: ssp->s_68k_stop[0] = regs.stop; ! 227: ssp->s_68k_pending[0] = regs.pending; ! 228: *(uint16 *)ssp->s_z80_af = LOCENDIAN16(cpuz80_z80.z80af); ! 229: *(uint16 *)ssp->s_z80_bc = LOCENDIAN16(cpuz80_z80.z80bc); ! 230: *(uint16 *)ssp->s_z80_de = LOCENDIAN16(cpuz80_z80.z80de); ! 231: *(uint16 *)ssp->s_z80_hl = LOCENDIAN16(cpuz80_z80.z80hl); ! 232: *(uint16 *)ssp->s_z80_afprime = LOCENDIAN16(cpuz80_z80.z80afprime); ! 233: *(uint16 *)ssp->s_z80_bcprime = LOCENDIAN16(cpuz80_z80.z80bcprime); ! 234: *(uint16 *)ssp->s_z80_deprime = LOCENDIAN16(cpuz80_z80.z80deprime); ! 235: *(uint16 *)ssp->s_z80_hlprime = LOCENDIAN16(cpuz80_z80.z80hlprime); ! 236: *(uint16 *)ssp->s_z80_ix = LOCENDIAN16(cpuz80_z80.z80ix); ! 237: *(uint16 *)ssp->s_z80_iy = LOCENDIAN16(cpuz80_z80.z80iy); ! 238: *(uint16 *)ssp->s_z80_sp = LOCENDIAN16(cpuz80_z80.z80sp); ! 239: *(uint16 *)ssp->s_z80_pc = LOCENDIAN16(cpuz80_z80.z80pc); ! 240: ssp->s_z80_i[0] = cpuz80_z80.z80i; ! 241: ssp->s_z80_r[0] = cpuz80_z80.z80r; ! 242: *(uint32 *)ssp->s_z80_bank = LOCENDIAN32(cpuz80_bank); ! 243: memcpy(ssp->s_vdp_regs, vdp_reg, sizeof(ssp->s_vdp_regs)); ! 244: ssp->s_vdp_pal[0] = vdp_pal; ! 245: ssp->s_vdp_overseas[0] = vdp_overseas; ! 246: ssp->s_vdp_ctrlflag[0] = vdp_ctrlflag; ! 247: ssp->s_vdp_code[0] = vdp_code; ! 248: *(uint16 *)ssp->s_vdp_first = LOCENDIAN16(vdp_first); ! 249: *(uint16 *)ssp->s_vdp_second = LOCENDIAN16(vdp_second); ! 250: *(uint32 *)ssp->s_vdp_dmabytes = LOCENDIAN32(vdp_dmabytes); ! 251: *(uint16 *)ssp->s_vdp_address = LOCENDIAN16(vdp_address); ! 252: memcpy(ssp->s_fmregs1, soundi_regs1, sizeof(ssp->s_fmregs1)); ! 253: memcpy(ssp->s_fmregs2, soundi_regs2, sizeof(ssp->s_fmregs2)); ! 254: ssp->s_fmaddr1[0] = soundi_address1; ! 255: ssp->s_fmaddr2[0] = soundi_address2; ! 256: if (fwrite(ssp, sizeof(ss), 1, f) != 1) { ! 257: LOG_CRITICAL(("Error whilst writing GTR file '%s': %s", filename, ! 258: strerror(errno))); ! 259: return -1; ! 260: } ! 261: fclose(f); ! 262: return 0; ! 263: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.