uint64_t RIFFds64Chunk::GetTableEntrySize(uint_t entry, uint32_t& id) const
{
const ds64_CHUNK *ds64;
uint64_t size = 0;
if (((ds64 = (const ds64_CHUNK *)GetData()) != NULL) && (entry < ds64->TableEntryCount))
{
size = Convert32bitSizes(ds64->Table[entry].ChunkSizeLow, ds64->Table[entry].ChunkSizeHigh);
id = IFFID(ds64->Table[entry].ChunkId);
}
return size;
}
/* perform_restore():
Pull a state pointer from a stream. This returns 0 on success,
1 on failure. Note that if it succeeds, the frameptr, localsbase,
and valstackbase registers are invalid; they must be rebuilt from
the stack.
If fromshell is true, the restore is being invoked by the library
shell (an autorestore of some kind). This currently happens only in
iosglk.
*/
glui32 perform_restore(strid_t str, int fromshell)
{
dest_t dest;
int ix;
glui32 lx, res, val;
glui32 filestart, filelen;
glui32 heapsumlen = 0;
glui32 *heapsumarr = NULL;
/* If profiling is enabled and active then fail. */
#if VM_PROFILING
if (profile_profiling_active())
return 1;
#endif /* VM_PROFILING */
stream_get_iosys(&val, &lx);
if (val != 2 && !fromshell) {
/* Not using the Glk I/O system, so bail. This function only
knows how to read from a Glk stream. (But in the autorestore
case, iosys hasn't been set yet, so ignore this test.) */
fatal_error("Streams are only available in Glk I/O system.");
}
if (str == 0)
return 1;
dest.ismem = FALSE;
dest.size = 0;
dest.pos = 0;
dest.ptr = NULL;
dest.str = str;
res = 0;
/* ### the format errors checked below should send error messages to
the current stream. */
if (res == 0) {
res = read_long(&dest, &val);
}
if (res == 0 && val != IFFID('F', 'O', 'R', 'M')) {
/* ### bad header */
return 1;
}
if (res == 0) {
res = read_long(&dest, &filelen);
}
filestart = dest.pos;
if (res == 0) {
res = read_long(&dest, &val);
}
if (res == 0 && val != IFFID('I', 'F', 'Z', 'S')) { /* ### ? */
/* ### bad header */
return 1;
}
while (res == 0 && dest.pos < filestart+filelen) {
/* Read a chunk and deal with it. */
glui32 chunktype=0, chunkstart=0, chunklen=0;
unsigned char dummy;
if (res == 0) {
res = read_long(&dest, &chunktype);
}
if (res == 0) {
res = read_long(&dest, &chunklen);
}
chunkstart = dest.pos;
if (chunktype == IFFID('I', 'F', 'h', 'd')) {
for (ix=0; res==0 && ix<128; ix++) {
res = read_byte(&dest, &dummy);
if (res == 0 && Mem1(ix) != dummy) {
/* ### non-matching header */
return 1;
}
}
}
else if (chunktype == IFFID('C', 'M', 'e', 'm')) {
res = read_memstate(&dest, chunklen);
}
else if (chunktype == IFFID('M', 'A', 'l', 'l')) {
res = read_heapstate(&dest, chunklen, TRUE, &heapsumlen, &heapsumarr);
}
else if (chunktype == IFFID('S', 't', 'k', 's')) {
res = read_stackstate(&dest, chunklen, TRUE);
}
else {
/* Unknown chunk type. Skip it. */
for (lx=0; res==0 && lx<chunklen; lx++) {
res = read_byte(&dest, &dummy);
}
}
if (chunkstart+chunklen != dest.pos) {
/* ### funny chunk length */
return 1;
}
if ((chunklen & 1) != 0) {
if (res == 0) {
res = read_byte(&dest, &dummy);
}
}
}
if (res == 0) {
if (heapsumarr) {
/* The summary might have come from any interpreter, so it could
be out of order. We'll sort it. */
glulx_sort(heapsumarr+2, (heapsumlen-2)/2, 2*sizeof(glui32),
&sort_heap_summary);
res = heap_apply_summary(heapsumlen, heapsumarr);
}
}
if (res)
return 1;
return 0;
}
/* perform_save():
Write the state to the output stream. This returns 0 on success,
1 on failure.
*/
glui32 perform_save(strid_t str)
{
dest_t dest;
int ix;
glui32 res, lx, val;
glui32 memstart, memlen, stackstart, stacklen, heapstart, heaplen;
glui32 filestart=0, filelen;
stream_get_iosys(&val, &lx);
if (val != 2) {
/* Not using the Glk I/O system, so bail. This function only
knows how to write to a Glk stream. */
fatal_error("Streams are only available in Glk I/O system.");
}
if (str == 0)
return 1;
dest.ismem = FALSE;
dest.size = 0;
dest.pos = 0;
dest.ptr = NULL;
dest.str = str;
res = 0;
/* Quetzal header. */
if (res == 0) {
res = write_long(&dest, IFFID('F', 'O', 'R', 'M'));
}
if (res == 0) {
res = write_long(&dest, 0); /* space for file length */
filestart = dest.pos;
}
if (res == 0) {
res = write_long(&dest, IFFID('I', 'F', 'Z', 'S')); /* ### ? */
}
/* Header chunk. This is the first 128 bytes of memory. */
if (res == 0) {
res = write_long(&dest, IFFID('I', 'F', 'h', 'd'));
}
if (res == 0) {
res = write_long(&dest, 128);
}
for (ix=0; res==0 && ix<128; ix++) {
res = write_byte(&dest, Mem1(ix));
}
/* Always even, so no padding necessary. */
/* Memory chunk. */
if (res == 0) {
res = write_long(&dest, IFFID('C', 'M', 'e', 'm'));
}
if (res == 0) {
res = write_long(&dest, 0); /* space for chunk length */
}
if (res == 0) {
memstart = dest.pos;
res = write_memstate(&dest);
memlen = dest.pos - memstart;
}
if (res == 0 && (memlen & 1) != 0) {
res = write_byte(&dest, 0);
}
/* Heap chunk. */
if (res == 0) {
res = write_long(&dest, IFFID('M', 'A', 'l', 'l'));
}
if (res == 0) {
res = write_long(&dest, 0); /* space for chunk length */
}
if (res == 0) {
heapstart = dest.pos;
res = write_heapstate(&dest, TRUE);
heaplen = dest.pos - heapstart;
}
/* Always even, so no padding necessary. */
/* Stack chunk. */
if (res == 0) {
res = write_long(&dest, IFFID('S', 't', 'k', 's'));
}
if (res == 0) {
res = write_long(&dest, 0); /* space for chunk length */
}
if (res == 0) {
stackstart = dest.pos;
res = write_stackstate(&dest, TRUE);
stacklen = dest.pos - stackstart;
}
if (res == 0 && (stacklen & 1) != 0) {
res = write_byte(&dest, 0);
}
filelen = dest.pos - filestart;
/* Okay, fill in all the lengths. */
if (res == 0) {
res = reposition_write(&dest, memstart-4);
}
if (res == 0) {
res = write_long(&dest, memlen);
}
if (res == 0) {
res = reposition_write(&dest, heapstart-4);
}
if (res == 0) {
res = write_long(&dest, heaplen);
}
if (res == 0) {
res = reposition_write(&dest, stackstart-4);
}
if (res == 0) {
res = write_long(&dest, stacklen);
}
if (res == 0) {
res = reposition_write(&dest, filestart-4);
}
if (res == 0) {
res = write_long(&dest, filelen);
}
/* All done. */
return res;
}
