![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memorySnapShot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to memorySnapShot.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 root 1: /*
2: Hatari - memorySnapShot.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: Memory Snapshot
8:
9: This handles the saving/restoring of the emulator's state so any game or
10: application can be saved and restored at any time. This is quite complicated
11: as we need to store all STRam, all chip states, all emulation variables and
12: then things get really complicated as we need to restore file handles
13: and such like.
14: To help keep things simple each file has one function which is used to
15: save/restore all variables that are local to it. We use one function to
16: reduce redundancy and the function 'MemorySnapShot_Store' decides if it
17: should save or restore the data.
18: */
19: const char MemorySnapShot_fileid[] = "Hatari memorySnapShot.c : " __DATE__ " " __TIME__;
20:
21: #include <SDL_types.h>
22: #include <errno.h>
23:
24: #include "main.h"
25: #include "configuration.h"
26: #include "debugui.h"
27: #include "file.h"
28: #include "cycInt.h"
29: #include "cycles.h"
30: #include "ioMem.h"
31: #include "log.h"
32: #include "m68000.h"
33: #include "memorySnapShot.h"
34: #include "reset.h"
35: #include "str.h"
36: #include "nextMemory.h"
37: #include "video.h"
38:
39:
40: #define VERSION_STRING "0.0.1" /* Version number of compatible memory snapshots - Always 6 bytes (inc' NULL) */
41: #define VERSION_STRING_SIZE 6 /* Size of above (inc' NULL) */
42:
43:
44: #define COMPRESS_MEMORYSNAPSHOT /* Compress snapshots to reduce disk space used */
45:
46: #ifdef COMPRESS_MEMORYSNAPSHOT
47:
48: #include <zlib.h>
49: typedef gzFile MSS_File;
50:
51: #else
52:
53: typedef FILE* MSS_File;
54:
55: #endif
56:
57:
58: static MSS_File CaptureFile;
59: static bool bCaptureSave, bCaptureError;
60:
61:
62: /*-----------------------------------------------------------------------*/
63: /**
64: * Open file.
65: */
66: static MSS_File MemorySnapShot_fopen(const char *pszFileName, const char *pszMode)
67: {
68: #ifdef COMPRESS_MEMORYSNAPSHOT
69: return gzopen(pszFileName, pszMode);
70: #else
71: return fopen(pszFileName, pszMode);
72: #endif
73: }
74:
75:
76: /*-----------------------------------------------------------------------*/
77: /**
78: * Close file.
79: */
80: static void MemorySnapShot_fclose(MSS_File fhndl)
81: {
82: #ifdef COMPRESS_MEMORYSNAPSHOT
83: gzclose(fhndl);
84: #else
85: fclose(fhndl);
86: #endif
87: }
88:
89:
90: /*-----------------------------------------------------------------------*/
91: /**
92: * Read from file.
93: */
94: static int MemorySnapShot_fread(MSS_File fhndl, char *buf, int len)
95: {
96: #ifdef COMPRESS_MEMORYSNAPSHOT
97: return gzread(fhndl, buf, len);
98: #else
99: return fread(buf, 1, len, fhndl);
100: #endif
101: }
102:
103:
104: /*-----------------------------------------------------------------------*/
105: /**
106: * Write data to file.
107: */
108: static int MemorySnapShot_fwrite(MSS_File fhndl, const char *buf, int len)
109: {
110: #ifdef COMPRESS_MEMORYSNAPSHOT
111: return gzwrite(fhndl, buf, len);
112: #else
113: return fwrite(buf, 1, len, fhndl);
114: #endif
115: }
116:
117:
118: /*-----------------------------------------------------------------------*/
119: /**
120: * Open/Create snapshot file, and set flag so 'MemorySnapShot_Store' knows
121: * how to handle data.
122: */
123: static bool MemorySnapShot_OpenFile(const char *pszFileName, bool bSave)
124: {
125: char VersionString[VERSION_STRING_SIZE];
126:
127: /* Set error */
128: bCaptureError = false;
129:
130: /* Open file, set flag so 'MemorySnapShot_Store' can load to/save from file */
131: if (bSave)
132: {
133: /* Save */
134: CaptureFile = MemorySnapShot_fopen(pszFileName, "wb");
135: if (!CaptureFile)
136: {
137: fprintf(stderr, "Failed to open save file '%s': %s\n",
138: pszFileName, strerror(errno));
139: bCaptureError = true;
140: return false;
141: }
142: bCaptureSave = true;
143: /* Store version string */
144: strcpy(VersionString, VERSION_STRING);
145: MemorySnapShot_Store(VersionString, VERSION_STRING_SIZE);
146: }
147: else
148: {
149: /* Restore */
150: CaptureFile = MemorySnapShot_fopen(pszFileName, "rb");
151: if (!CaptureFile)
152: {
153: fprintf(stderr, "Failed to open file '%s': %s\n",
154: pszFileName, strerror(errno));
155: bCaptureError = true;
156: return false;
157: }
158: bCaptureSave = false;
159: /* Restore version string */
160: MemorySnapShot_Store(VersionString, VERSION_STRING_SIZE);
161: /* Does match current version? */
162: if (strcasecmp(VersionString, VERSION_STRING))
163: {
164: /* No, inform user and error */
165: Log_AlertDlg(LOG_ERROR, "Unable to Restore Memory State.\nFile is "
166: "only compatible with Hatari v%s", VersionString);
167: bCaptureError = true;
168: return false;
169: }
170: }
171:
172: /* All OK */
173: return true;
174: }
175:
176:
177: /*-----------------------------------------------------------------------*/
178: /**
179: * Close snapshot file.
180: */
181: static void MemorySnapShot_CloseFile(void)
182: {
183: MemorySnapShot_fclose(CaptureFile);
184: }
185:
186:
187: /*-----------------------------------------------------------------------*/
188: /**
189: * Save/Restore data to/from file.
190: */
191: void MemorySnapShot_Store(void *pData, int Size)
192: {
193: long nBytes;
194:
195: /* Check no file errors */
196: if (CaptureFile != NULL)
197: {
198: /* Saving or Restoring? */
199: if (bCaptureSave)
200: nBytes = MemorySnapShot_fwrite(CaptureFile, (char *)pData, Size);
201: else
202: nBytes = MemorySnapShot_fread(CaptureFile, (char *)pData, Size);
203:
204: /* Did save OK? */
205: if (nBytes != Size)
206: bCaptureError = true;
207: }
208: }
209:
210:
211: /*-----------------------------------------------------------------------*/
212: /**
213: * Save 'snapshot' of memory/chips/emulation variables
214: */
215: void MemorySnapShot_Capture(const char *pszFileName, bool bConfirm)
216: {
217: /* Set to 'saving' */
218: if (MemorySnapShot_OpenFile(pszFileName, true))
219: {
220: /* Capture each files details */
221: Configuration_MemorySnapShot_Capture(true);
222: // STMemory_MemorySnapShot_Capture(true);
223: CycInt_MemorySnapShot_Capture(true);
224: Cycles_MemorySnapShot_Capture(true);
225: M68000_MemorySnapShot_Capture(true);
226: Video_MemorySnapShot_Capture(true);
227: DebugUI_MemorySnapShot_Capture(pszFileName, true);
228:
229: /* And close */
230: MemorySnapShot_CloseFile();
231: }
232:
233: /* Did error */
234: if (bCaptureError)
235: Log_AlertDlg(LOG_ERROR, "Unable to save memory state to file.");
236: else if (bConfirm)
237: Log_AlertDlg(LOG_INFO, "Memory state file saved.");
238: }
239:
240:
241: /*-----------------------------------------------------------------------*/
242: /**
243: * Restore 'snapshot' of memory/chips/emulation variables
244: */
245: void MemorySnapShot_Restore(const char *pszFileName, bool bConfirm)
246: {
247: /* Set to 'restore' */
248: if (MemorySnapShot_OpenFile(pszFileName, false))
249: {
250: Configuration_MemorySnapShot_Capture(false);
251:
252: /* Reset emulator to get things running */
253: IoMem_UnInit(); IoMem_Init();
254: Reset_Cold();
255:
256: /* Capture each files details */
257: // STMemory_MemorySnapShot_Capture(false);
258: CycInt_MemorySnapShot_Capture(false);
259: Cycles_MemorySnapShot_Capture(false);
260: M68000_MemorySnapShot_Capture(false);
261: Video_MemorySnapShot_Capture(false);
262: DebugUI_MemorySnapShot_Capture(pszFileName, false);
263:
264: /* And close */
265: MemorySnapShot_CloseFile();
266: }
267:
268: /* Did error? */
269: if (bCaptureError)
270: Log_AlertDlg(LOG_ERROR, "Unable to restore memory state from file.");
271: else if (bConfirm)
272: Log_AlertDlg(LOG_INFO, "Memory state file restored.");
273: }
274:
275:
276: /*-----------------------------------------------------------------------*/
277: /*
278: * Save and restore functions required by the UAE CPU core...
279: * ... don't use them in normal Hatari code!
280: */
281: #include <savestate.h>
282:
283: void save_u32(uae_u32 data)
284: {
285: MemorySnapShot_Store(&data, 4);
286: }
287:
288: void save_u16(uae_u16 data)
289: {
290: MemorySnapShot_Store(&data, 2);
291: }
292:
293: uae_u32 restore_u32(void)
294: {
295: uae_u32 data;
296: MemorySnapShot_Store(&data, 4);
297: return data;
298: }
299:
300: uae_u16 restore_u16(void)
301: {
302: uae_u16 data;
303: MemorySnapShot_Store(&data, 2);
304: return data;
305: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.