/*!
Dumps all the memory.
\param path the file path to put all inside
\return FALSE if an error occurred
*/
syx_bool
syx_memory_save_image (syx_symbol path)
{
SyxObject *object;
FILE *image;
syx_int32 data = 0;
SyxObject *stack;
SyxOop process;
if (!path)
path = SYX_OBJECT_SYMBOL (syx_globals_at ("ImageFileName"));
if (!path)
return FALSE;
image = fopen (path, "wb");
if (!image)
return FALSE;
syx_memory_gc ();
data = SYX_COMPAT_SWAP_32 (_syx_memory_size);
fwrite (&data, sizeof (syx_int32), 1, image);
data = SYX_COMPAT_SWAP_32 (_syx_freed_memory_top);
fwrite (&data, sizeof (syx_int32), 1, image);
_syx_memory_write (_syx_freed_memory, FALSE, _syx_freed_memory_top, image);
_syx_scheduler_save (image);
_syx_memory_write (&syx_globals, FALSE, 1, image);
_syx_memory_write (&syx_symbols, FALSE, 1, image);
/* First store the processes */
process = syx_processor_active_process;
if (!SYX_IS_NIL (process))
{
do
{
_syx_memory_write_process_stack (SYX_OBJECT (process), image);
process = SYX_PROCESS_NEXT (process);
} while (SYX_OOP_NE (process, syx_processor_active_process));
}
for (object=syx_memory; object <= SYX_MEMORY_TOP; object++)
{
/* the mark check is not related to the GC but means the object has been already written */
if (SYX_IS_NIL (object->klass) || object->is_marked)
continue;
_syx_memory_write_object_with_vars (object, image);
/* store data */
data = SYX_COMPAT_SWAP_32 (object->data_size);
fwrite (&data, sizeof (syx_varsize), 1, image);
if (object->data_size > 0)
{
if (object->has_refs)
_syx_memory_write (object->data, TRUE, object->data_size, image);
else
{
#ifdef HAVE_LIBGMP
if (SYX_OBJECT_IS_LARGE_INTEGER ((SyxOop)object))
{
/* This algorithm is used to store large integers.
We need to specify how many bytes GMP wrote to the image,
for systems that don't support GMP */
syx_int32 offset = 0;
syx_nint start, end;
/* specify that's a large integer */
fputc (SYX_MEMORY_TYPE_LARGE_INTEGER, image);
/* make space to hold the offset */
fwrite (&offset, sizeof (syx_int32), 1, image);
start = ftell (image);
mpz_out_raw (image, SYX_OBJECT_LARGE_INTEGER ((SyxOop)object));
end = ftell (image);
offset = end - start;
/* go back to the offset */
fseek (image, - offset - sizeof (syx_int32), SEEK_CUR);
/* now write the length of the data written by mpz_out_raw () */
data = SYX_COMPAT_SWAP_32 (offset);
fwrite (&data, sizeof (syx_int32), 1, image);
/* return again to continue normal writing */
fseek (image, offset, SEEK_CUR);
}
else
#endif /* HAVE_LIBGMP */
{
/* it's not a large integer */
fputc (SYX_MEMORY_TYPE_NORMAL, image);
fwrite (object->data, sizeof (syx_int8), object->data_size, image);
}
}
}
/* Check for block closures that are not attached to any process */
if (SYX_OOP_EQ (object->klass, syx_block_closure_class))
{
stack = SYX_OBJECT (object->vars[SYX_VARS_BLOCK_CLOSURE_OUTER_FRAME]);
/* Check if the stack has been collected or written to the image */
if (SYX_IS_NIL (SYX_POINTER_CAST_OOP (stack)) || stack->is_marked)
continue;
_syx_memory_write_object_with_vars (stack, image);
data = SYX_COMPAT_SWAP_32 (stack->data_size);
fwrite (&data, sizeof (syx_varsize), 1, image);
/* Store the index of this frame */
fputc (SYX_MEMORY_TYPE_BOF, image);
data = SYX_COMPAT_SWAP_32 (0);
fwrite (&data, sizeof (syx_varsize), 1, image);
/* Outer frames have only one frame */
_syx_memory_write_frame (NULL, (SyxInterpFrame *)stack->data, NULL, image);
fputc (SYX_MEMORY_TYPE_EOS, image);
fwrite (&data, sizeof (syx_varsize), 1, image);
stack->is_marked = TRUE;
}
}
fclose (image);
/* be sure all objects are unmarked */
for (object=syx_memory; object <= SYX_MEMORY_TOP; object++)
object->is_marked = FALSE;
return TRUE;
}
/*!
Dumps all the memory.
\param path the file path to put all inside
\return FALSE if an error occurred
*/
syx_bool
syx_memory_save_image (syx_symbol path)
{
SyxObject *object;
FILE *image;
syx_int32 data;
if (!path)
path = SYX_OBJECT_SYMBOL (syx_globals_at ("ImageFileName"));
if (!path)
return FALSE;
image = fopen (path, "wb");
if (!image)
return FALSE;
syx_memory_gc ();
data = SYX_COMPAT_SWAP_32 (_syx_memory_size);
fwrite (&data, sizeof (syx_int32), 1, image);
data = SYX_COMPAT_SWAP_32 (_syx_freed_memory_top);
fwrite (&data, sizeof (syx_int32), 1, image);
_syx_memory_write (_syx_freed_memory, FALSE, _syx_freed_memory_top, image);
_syx_scheduler_save (image);
_syx_memory_write (&syx_globals, FALSE, 1, image);
_syx_memory_write (&syx_symbols, FALSE, 1, image);
for (object=syx_memory; object <= SYX_MEMORY_TOP; object++)
{
if (SYX_IS_NIL (object->klass))
continue;
_syx_memory_write ((SyxOop *)&object, FALSE, 1, image);
_syx_memory_write (&object->klass, FALSE, 1, image);
fputc (object->has_refs, image);
fputc (object->is_constant, image);
/* store instance variables */
data = syx_object_vars_size ((SyxOop)object);
data = SYX_COMPAT_SWAP_32(data);
fwrite (&data, sizeof (syx_varsize), 1, image);
_syx_memory_write (object->vars, TRUE, SYX_COMPAT_SWAP_32(data), image);
/* store data */
data = SYX_COMPAT_SWAP_32 (object->data_size);
fwrite (&data, sizeof (syx_varsize), 1, image);
if (object->data_size > 0)
{
if (object->has_refs)
_syx_memory_write (object->data, TRUE, object->data_size, image);
else
{
#ifdef HAVE_LIBGMP
if (SYX_OBJECT_IS_LARGE_INTEGER ((SyxOop)object))
{
/* This algorithm is used to store large integers.
We need to specify how many bytes GMP wrote to the image,
for systems that doesn't support GMP */
syx_int32 offset = 0;
syx_nint start, end;
/* specify that's a large integer */
fputc (1, image);
/* make space to hold the offset */
fwrite (&offset, sizeof (syx_int32), 1, image);
start = ftell (image);
mpz_out_raw (image, SYX_OBJECT_LARGE_INTEGER ((SyxOop)object));
end = ftell (image);
offset = end - start;
/* go back to the offset */
fseek (image, - offset - sizeof (syx_int32), SEEK_CUR);
data = SYX_COMPAT_SWAP_32 (offset);
fwrite (&data, sizeof (syx_int32), 1, image);
/* return again to continue normal writing */
fseek (image, offset, SEEK_CUR);
}
else
#endif
{
/* it's not a large integer */
fputc (0, image);
fwrite (object->data, sizeof (syx_int8), object->data_size, image);
}
}
}
}
fclose (image);
return TRUE;
}
