--- /dev/null
+// $Id: savefile.c,v 1.6 2003/10/20 16:05:06 iain Exp $
+
+#include "git.h"
+
+static void writeWord (git_sint32 word)
+{
+ char buffer [4];
+ write32 (buffer, word);
+ glk_put_buffer (buffer, 4);
+}
+
+static git_uint32 readWord (strid_t file)
+{
+ char buffer [4];
+ glk_get_buffer_stream (file, buffer, 4);
+ return (git_uint32) read32 (buffer);
+}
+
+static int sort_heap_summary(const void *p1, const void *p2)
+{
+ const glui32 *v1 = (const glui32 *)p1;
+ const glui32 *v2 = (const glui32 *)p2;
+
+ if (v1 < v2)
+ return -1;
+ if (v1 > v2)
+ return 1;
+ return 0;
+}
+
+git_sint32 restoreFromFile (git_sint32 * base, git_sint32 id,
+ git_uint32 protectPos, git_uint32 protectSize)
+{
+ git_uint32 protectEnd = protectPos + protectSize;
+ git_uint32 i;
+ strid_t file;
+ glui32 fileSize, fileStart;
+
+ int gotIdent = 0;
+ int gotMemory = 0;
+ int gotStack = 0;
+ int gotHeap = 0;
+
+ // Find out what stream they want to use, and make sure it's valid.
+ file = git_find_stream_by_id (id);
+ if (file == 0)
+ return 1;
+
+ // Read IFF header.
+ if (readWord (file) != read32("FORM"))
+ return 1; // Not an IFF file.
+
+ fileSize = readWord (file);
+ fileStart = glk_stream_get_position (file);
+
+ if (readWord (file) != read32("IFZS"))
+ return 1; // Not a Quetzal file.
+
+ // Discard the current heap.
+ heap_clear();
+
+ // Read all the chunks.
+
+ while (glk_stream_get_position(file) < fileStart + fileSize)
+ {
+ git_uint32 chunkType, chunkSize, chunkStart;
+ chunkType = readWord (file);
+ chunkSize = readWord (file);
+ chunkStart = glk_stream_get_position (file);
+
+ if (chunkType == read32("IFhd"))
+ {
+ if (gotIdent)
+ return 1;
+
+ gotIdent = 1;
+
+ if (chunkSize != 128)
+ return 1;
+
+ for (i = 0 ; i < 128 ; ++i)
+ {
+ glui32 c = glk_get_char_stream (file);
+ if (gRom [i] != c)
+ return 1;
+ }
+ }
+ else if (chunkType == read32("Stks"))
+ {
+ if (gotStack)
+ return 1;
+
+ gotStack = 1;
+
+ if (chunkSize & 3)
+ return 1;
+
+ gStackPointer = base;
+ for ( ; chunkSize > 0 ; chunkSize -= 4)
+ *gStackPointer++ = readWord(file);
+ }
+ else if (chunkType == read32("CMem"))
+ {
+ git_uint32 bytesRead = 0;
+ if (gotMemory)
+ return 1;
+
+ gotMemory = 1;
+
+ if (resizeMemory (readWord(file), 1))
+ fatalError ("Can't resize memory map");
+
+ bytesRead = 4;
+ i = gRamStart;
+ while (i < gExtStart && bytesRead < chunkSize)
+ {
+ int mult = 0;
+ char c = (char) glk_get_char_stream(file);
+ ++bytesRead;
+
+ if (c == 0)
+ {
+ mult = (unsigned char) glk_get_char_stream(file);
+ ++bytesRead;
+ }
+
+ for (++mult ; mult > 0 ; --mult, ++i)
+ if (i >= protectEnd || i < protectPos)
+ gRam [i] = gRom [i] ^ c;
+ }
+
+ while (i < gEndMem && bytesRead < chunkSize)
+ {
+ int mult = 0;
+ char c = (char) glk_get_char_stream(file);
+ ++bytesRead;
+
+ if (c == 0)
+ {
+ mult = (unsigned char) glk_get_char_stream(file);
+ ++bytesRead;
+ }
+
+ for (++mult ; mult > 0 ; --mult, ++i)
+ if (i >= protectEnd || i < protectPos)
+ gRam [i] = c;
+ }
+
+ while (i < gExtStart)
+ if (i >= protectEnd || i < protectPos)
+ gRam [i] = gRom [i], ++i;
+
+ while (i < gEndMem)
+ if (i >= protectEnd || i < protectPos)
+ gRam [i] = 0, ++i;
+
+ if (bytesRead != chunkSize)
+ return 1; // Too much data!
+
+ if (chunkSize & 1)
+ glk_get_char_stream (file);
+ }
+ else if (chunkType == read32("MAll"))
+ {
+ glui32 heapSize = 0;
+ glui32 * heap = 0;
+
+ if (gotHeap)
+ return 1;
+
+ gotHeap = 1;
+
+ if (chunkSize & 3)
+ return 1;
+
+ if (chunkSize > 0)
+ {
+ heap = malloc (chunkSize);
+ heapSize = chunkSize / 4;
+ for (i = 0 ; i < heapSize ; ++i)
+ heap[i] = readWord(file);
+
+ /* The summary might have come from any interpreter, so it could
+ be out of order. We'll sort it. */
+ qsort(heap+2, (heapSize-2)/2, 8, &sort_heap_summary);
+
+ if (heap_apply_summary (heapSize, heap))
+ fatalError ("Couldn't apply heap summary");
+ free (heap);
+ }
+ }
+ else
+ {
+ // Unknown chunk type -- just skip it.
+ glk_stream_set_position (file, (chunkSize + 1) & ~1, seekmode_Current);
+ }
+ }
+
+ // Make sure we have all the chunks we need.
+
+ if (!gotIdent)
+ fatalError ("No ident chunk in save file");
+
+ if (!gotStack)
+ fatalError ("No stack chunk in save file");
+
+ if (!gotMemory)
+ fatalError ("No memory chunk in save file");
+
+ // If we reach this point, we restored successfully.
+
+ return 0;
+}
+
+git_sint32 saveToFile (git_sint32 * base, git_sint32 * sp, git_sint32 id)
+{
+ git_uint32 n, zeroCount;
+ glui32 fileSize, fileSizePos;
+ glui32 memSize, memSizePos;
+ glui32 heapSize;
+ glui32* heap;
+
+ strid_t file, oldFile;
+
+ // Find out what stream they want to use, and make sure it's valid.
+ file = git_find_stream_by_id (id);
+ if (file == 0)
+ return 1;
+
+ // Get the state of the heap.
+ if (heap_get_summary (&heapSize, &heap))
+ fatalError ("Couldn't get heap summary");
+
+ // Make the given stream the default.
+ oldFile = glk_stream_get_current ();
+ glk_stream_set_current (file);
+
+ // Write Quetzal header.
+ glk_put_string ("FORM");
+
+ fileSizePos = glk_stream_get_position (file);
+ writeWord (0);
+
+ glk_put_string ("IFZS");
+
+ // Header chunk.
+ glk_put_string ("IFhd");
+ writeWord (128);
+ glk_put_buffer ((char *) gRom, 128);
+
+ // Stack chunk.
+ glk_put_string ("Stks");
+ writeWord ((sp - base) * 4);
+ for (n = 0 ; n < (git_uint32) (sp - base) ; ++n)
+ writeWord (base [n]);
+
+ // Heap chunk.
+ if (heap != 0)
+ {
+ glk_put_string ("MAll");
+ writeWord (heapSize * 4);
+ for (n = 0 ; n < heapSize ; ++n)
+ writeWord (heap [n]);
+ free(heap);
+ }
+
+ // Memory chunk.
+ glk_put_string ("CMem");
+ memSizePos = glk_stream_get_position (file);
+ writeWord (0);
+
+ writeWord (gEndMem);
+ for (zeroCount = 0, n = gRamStart ; n < gEndMem ; ++n)
+ {
+ unsigned char romC = (n < gExtStart) ? gRom[n] : 0;
+ unsigned char c = ((git_uint32) romC) ^ ((git_uint32) gRam[n]);
+ if (c == 0)
+ ++zeroCount;
+ else
+ {
+ for ( ; zeroCount > 256 ; zeroCount -= 256)
+ {
+ glk_put_char (0);
+ glk_put_char (0xff);
+ }
+
+ if (zeroCount > 0)
+ {
+ glk_put_char (0);
+ glk_put_char ((char) (zeroCount - 1));
+ zeroCount = 0;
+ }
+
+ glk_put_char (c);
+ }
+ }
+ // Note: we don't bother writing out any remaining zeroes,
+ // because the memory is padded out with zeroes on restore.
+
+ memSize = glk_stream_get_position (file) - memSizePos - 4;
+ if (memSize & 1)
+ glk_put_char (0);
+
+ // Back up and fill in the lengths.
+ fileSize = glk_stream_get_position (file) - fileSizePos - 4;
+
+ glk_stream_set_position (file, fileSizePos, seekmode_Start);
+ writeWord (fileSize);
+
+ glk_stream_set_position (file, memSizePos, seekmode_Start);
+ writeWord (memSize);
+
+ // Restore the previous default stream.
+ glk_stream_set_current (oldFile);
+
+ // And we're done.
+ return 0;
+}
projects / rodin / chimara.git / blobdiff