runtime.h

// At several points in our compiler we have decided to rely on the
// fact that pointers are 64 bits wide. The stdint.h header file
// declares a platform aware type that is guaranteed to contain
// 64-bits.
#include <stdint.h>

// Fromspace is our heap which is conceptually an array of 64 bit data
// unless meta information tells us more about about their contents.
int64_t* fromspace_begin;
int64_t* fromspace_end;

// The free pointer should always point to the next free memory
// location. While the mutator (user program) is running this
// should always be pointing into fromspace.
int64_t* free_ptr;

// The root stack is an array of pointers into the heap.  During calls
// to the collector only pointers between the roostack_ptr and
// rootstack_begin are considered as live roots.
int64_t** rootstack_begin;
int64_t** rootstack_end;

// Initialize the memory of the runtime with a fixed rootstack size
// and initial heap size.
void initialize(uint64_t rootstack_size, uint64_t heap_size);

// Collect garbage data making room for a requested amount of memory.
// Use the pointers in the rootstack to determine what values in the
// heap are still live.
void collect(int64_t** rootstack_ptr, uint64_t bytes_requested);

// Read an integer from stdin.
int64_t read_int();

// Print an integer to stdout.
void print_int(int64_t x);

// Print a boolean to stdout.
void print_bool(int64_t x);

void print_heap(int64_t** rootstack_ptr);
void print_vector(int64_t* vector_ptr);
void print_vecbegin();
void print_vecend();
void print_space();

void print_ellipsis();
void print_any(int64_t any);