![[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 [HATARI the Atari ST Emulator] / hatari / src|
Return to memorySnapShot.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: Memory Snapshot
5:
6: This handles the saving/restoring of the emulator's state so any game/application can be saved
7: and restored at any time. This is quite complicated as we need to store all STRam, all chip states,
8: all emulation variables and then things get really complicated as we need to restore file handles
9: and such like.
10: To help keep things simple each file has one function which is used to save/restore all variables
11: that are local to it. We use one function to reduce redundancy and the function 'MemorySnapShot_Store'
12: decides if it should save or restore the data.
13: */
14:
15: #include "main.h"
16: /*#include "compress.h"*/
17: #include "debug.h"
18: #include "dialog.h"
19: #include "fdc.h"
20: #include "file.h"
21: #include "floppy.h"
22: #include "gemdos.h"
23: #include "ikbd.h"
24: #include "int.h"
25: #include "m68000.h"
26: #include "memorySnapShot.h"
27: #include "mfp.h"
28: #include "psg.h"
29: #include "reset.h"
30: #include "sound.h"
31: #include "tos.h"
32: #include "video.h"
33: #include "view.h"
34:
35: //#define COMPRESS_MEMORYSNAPSHOT // Compress snapshots to reduce disc space used
36:
37: //HFILE CaptureFile;
38: //OFSTRUCT CaptureFileInfo;
39: BOOL bCaptureSave, bCaptureError;
40: BOOL bSaveMemoryState=FALSE, bRestoreMemoryState=FALSE;
41: char szSnapShotFileName[MAX_FILENAME_LENGTH];
42:
43: //-----------------------------------------------------------------------
44: /*
45: Check if need to save/restore emulation memory state, via flag 'bSaveMemoryState', and 'bRestoreMemoryState'
46: */
47: void MemorySnapShot_CheckSaveRestore(void)
48: {
49: // Is chose to save memory state, one of these two flags will be set
50: /*FIXME*/
51: /*
52: if (bSaveMemoryState || bRestoreMemoryState) {
53: Main_PauseEmulation(); // Hold things...
54: View_ToggleWindowsMouse(MOUSE_WINDOWS); // Put mouse into ST mode
55: View_LimitCursorToScreen(); // Free mouse from Window constraints
56:
57: // Do we need user to enter a filename?
58: if (strlen(ConfigureParams.Memory.szMemoryCaptureFileName)<=0) {
59: if (!File_OpenSelectDlg(hWnd,ConfigureParams.Memory.szMemoryCaptureFileName,FILEFILTER_MEMORYFILE,FALSE,bSaveMemoryState))
60: bSaveMemoryState = bRestoreMemoryState = FALSE;
61: }
62:
63: // Do save/load
64: if (bSaveMemoryState)
65: MemorySnapShot_Capture(ConfigureParams.Memory.szMemoryCaptureFileName);
66: else if (bRestoreMemoryState)
67: MemorySnapShot_Restore(ConfigureParams.Memory.szMemoryCaptureFileName);
68: bSaveMemoryState = bRestoreMemoryState = FALSE;
69:
70: View_LimitCursorToClient(); // And limit mouse in Window
71: View_ToggleWindowsMouse(MOUSE_ST); // Put mouse into ST mode
72: Main_UnPauseEmulation(); // And off we go...
73: }
74: */
75: }
76:
77: //-----------------------------------------------------------------------
78: /*
79: Get filename to save/restore to, so can compress
80: */
81: char *MemorySnapShot_CompressBegin(char *pszFileName)
82: {
83: #ifdef COMPRESS_MEMORYSNAPSHOT
84: // Create temporary filename
85: sprintf(szSnapShotFileName,"%s/%s",szWorkingDir,"snapshot.mem");
86: return(szSnapShotFileName);
87: #else //COMPRESS_MEMORYSNAPSHOT
88: return(pszFileName);
89: #endif //COMPRESS_MEMORYSNAPSHOT
90: }
91:
92: //-----------------------------------------------------------------------
93: /*
94: Compress memory snap shot
95: */
96: void MemorySnapShot_CompressEnd(char *pszFileName)
97: {
98: #ifdef COMPRESS_MEMORYSNAPSHOT
99: // Compress file from temporary to final destination
100: Compress_Pack_File(szSnapShotFileName,pszFileName);
101: // And delete temporary
102: File_Delete(szSnapShotFileName);
103: #endif //COMPRESS_MEMORYSNAPSHOT
104: }
105:
106: //-----------------------------------------------------------------------
107: /*
108: Uncompress memory snap shot to temporary file
109: */
110: char *MemorySnapShot_UnCompressBegin(char *pszFileName)
111: {
112: #ifdef COMPRESS_MEMORYSNAPSHOT
113: // Uncompress to temporary file
114: sprintf(szSnapShotFileName,"%s/%s",szWorkingDir,"snapshot.mem");
115: Compress_UnPack_File(pszFileName,szSnapShotFileName);
116: return(szSnapShotFileName);
117: #else //COMPRESS_MEMORYSNAPSHOT
118: return(pszFileName);
119: #endif //COMPRESS_MEMORYSNAPSHOT
120: }
121:
122: //-----------------------------------------------------------------------
123: /*
124: Clean up after uncompression
125: */
126: void MemorySnapShot_UnCompressEnd(void)
127: {
128: // And delete temporary
129: File_Delete(szSnapShotFileName);
130: }
131:
132: //-----------------------------------------------------------------------
133: /*
134: Open/Create snapshot file, and set flag so 'MemorySnapShot_Store' knows how to handle data
135: */
136: BOOL MemorySnapShot_OpenFile(char *pszFileName,BOOL bSave)
137: {
138: char szString[256];
139: char VersionString[VERSION_STRING_SIZE];
140: /* FIXME */
141: /*
142: // Set error
143: bCaptureError = FALSE;
144:
145: // Open file, set flag so 'MemorySnapShot_Store' can load to/save from file
146: if (bSave) {
147: // Save
148: CaptureFile = OpenFile(pszFileName,&CaptureFileInfo,OF_CREATE | OF_WRITE);
149: if (CaptureFile==HFILE_ERROR) {
150: bCaptureError = TRUE;
151: return(FALSE);
152: }
153: bCaptureSave = TRUE;
154: // Store version string
155: MemorySnapShot_Store(VERSION_STRING,VERSION_STRING_SIZE);
156: }
157: else {
158: // Restore
159: CaptureFile = OpenFile(pszFileName,&CaptureFileInfo,OF_READ);
160: if (CaptureFile==HFILE_ERROR) {
161: bCaptureError = TRUE;
162: return(FALSE);
163: }
164: bCaptureSave = FALSE;
165: // Restore version string
166: MemorySnapShot_Store(VersionString,VERSION_STRING_SIZE);
167: // Does match current version?
168: if (stricmp(VersionString,VERSION_STRING)) {
169: // No, inform user and error
170: sprintf(szString,"Unable to Restore Memory State.\nFile is only compatible with Hatari v%s",VersionString);
171: Main_Message(szString,PROG_NAME,MB_OK | MB_ICONSTOP);
172: bCaptureError = TRUE;
173: return(FALSE);
174: }
175: }
176:
177: // All OK
178: return(TRUE);
179: */
180: return FALSE;
181: }
182:
183: //-----------------------------------------------------------------------
184: /*
185: Close snapshot file
186: */
187: void MemorySnapShot_CloseFile(void)
188: {
189: //FIXME _lclose(CaptureFile);
190: }
191:
192: //-----------------------------------------------------------------------
193: /*
194: Save/Restore data to/from file
195: */
196: void MemorySnapShot_Store(void *pData, int Size)
197: {
198: long nBytes;
199: /*FIXME*/
200: /*
201: // Check no file errors
202: if (CaptureFile!=HFILE_ERROR) {
203: // Saving or Restoring?
204: if (bCaptureSave)
205: nBytes = _hwrite(CaptureFile,(char *)pData,Size);
206: else
207: nBytes = _hread(CaptureFile,(char *)pData,Size);
208:
209: // Did save OK?
210: if (nBytes==HFILE_ERROR)
211: bCaptureError = TRUE;
212: else if (nBytes!=Size)
213: bCaptureError = TRUE;
214: }
215: */
216: }
217:
218: //-----------------------------------------------------------------------
219: /*
220: Save 'snapshot' of memory/chips/emulation variables
221: */
222: void MemorySnapShot_Capture(char *pszFileName)
223: {
224: char *pszSnapShotFileName;
225: /*FIXME*/
226: /*
227: // Wait...
228: SetCursor(Cursors[CURSOR_HOURGLASS]);
229:
230: // If to be compressed, return temporary filename
231: pszSnapShotFileName = MemorySnapShot_CompressBegin(pszFileName);
232:
233: // Set to 'saving'
234: if (MemorySnapShot_OpenFile(pszSnapShotFileName,TRUE)) {
235: // Capture each files details
236: Main_MemorySnapShot_Capture(TRUE);
237: FDC_MemorySnapShot_Capture(TRUE);
238: Floppy_MemorySnapShot_Capture(TRUE);
239: GemDOS_MemorySnapShot_Capture(TRUE);
240: IKBD_MemorySnapShot_Capture(TRUE);
241: Int_MemorySnapShot_Capture(TRUE);
242: M68000_MemorySnapShot_Capture(TRUE);
243: M68000_Decode_MemorySnapShot_Capture(TRUE);
244: MFP_MemorySnapShot_Capture(TRUE);
245: PSG_MemorySnapShot_Capture(TRUE);
246: Sound_MemorySnapShot_Capture(TRUE);
247: TOS_MemorySnapShot_Capture(TRUE);
248: Video_MemorySnapShot_Capture(TRUE);
249:
250: // And close
251: MemorySnapShot_CloseFile();
252: }
253:
254: // And compress, if need to
255: MemorySnapShot_CompressEnd(pszFileName);
256:
257: // We're back
258: SetCursor(Cursors[CURSOR_ARROW]);
259:
260: // Did error
261: if (bCaptureError)
262: Main_Message("Unable to Save Memory State to file.",PROG_NAME,MB_OK | MB_ICONSTOP);
263: else
264: Main_Message("Memory State file saved.",PROG_NAME,MB_OK | MB_ICONINFORMATION);
265: */
266: }
267:
268: //-----------------------------------------------------------------------
269: /*
270: Restore 'snapshot' of memory/chips/emulation variables
271: */
272: void MemorySnapShot_Restore(char *pszFileName)
273: {
274: char *pszSnapShotFileName;
275: /*FIXME*/
276: /*
277: // Wait...
278: SetCursor(Cursors[CURSOR_HOURGLASS]);
279:
280: // If to be uncompressed, return temporary filename
281: pszSnapShotFileName = MemorySnapShot_UnCompressBegin(pszFileName);
282:
283: // Set to 'restore'
284: if (MemorySnapShot_OpenFile(pszSnapShotFileName,FALSE)) {
285: // Reset emulator to get things running
286: Reset_Cold();
287:
288: // Capture each files details
289: Main_MemorySnapShot_Capture(FALSE);
290: FDC_MemorySnapShot_Capture(FALSE);
291: Floppy_MemorySnapShot_Capture(FALSE);
292: GemDOS_MemorySnapShot_Capture(FALSE);
293: IKBD_MemorySnapShot_Capture(FALSE);
294: Int_MemorySnapShot_Capture(FALSE);
295: M68000_MemorySnapShot_Capture(FALSE);
296: M68000_Decode_MemorySnapShot_Capture(FALSE);
297: MFP_MemorySnapShot_Capture(FALSE);
298: PSG_MemorySnapShot_Capture(FALSE);
299: Sound_MemorySnapShot_Capture(FALSE);
300: TOS_MemorySnapShot_Capture(FALSE);
301: Video_MemorySnapShot_Capture(FALSE);
302:
303: // And close
304: MemorySnapShot_CloseFile();
305: }
306:
307: // And clean up
308: MemorySnapShot_UnCompressEnd();
309:
310: // We're back
311: SetCursor(Cursors[CURSOR_ARROW]);
312:
313: // Did error
314: if (bCaptureError)
315: Main_Message("Unable to Restore Memory State from file.",PROG_NAME,MB_OK | MB_ICONSTOP);
316: else
317: Main_Message("Memory State file restored.",PROG_NAME,MB_OK | MB_ICONINFORMATION);
318: */
319: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.