4 GC Collector Language, 2🔗ℹ 
GC Collector Scheme is based on PLAI.  It provides
additional procedures and syntax for writing garbage collectors.
4.1 Garbage Collector Interface for GC2🔗ℹ 
The GC Collector Scheme language provides the following functions that provide access
to the heap and root set:
Returns the size of the heap.  The size of the heap is specified by the mutator
that uses the garbage collector.  See 
allocator-setup for more
information.
Determines if 
v is an integer between 
0 and
(- (heap-size) 1) inclusive.
Determines if v is a root.
Sets the value at loc to val.
Returns the value at loc.
Returns the current 
root?s as a list. This returns
valid roots only when invoked via the mutator language. Otherwise
it returns only what has been set up with 
with-roots.
Note that if your collector is being invoked via gc:cons
or gc:closure, then there may be live data that is
not reachable via the result of get-root-set, but that
is reachable via the roots passed as arguments to those functions.
Returns the location of root.
Updates root to refer to loc.
Makes a root that is initialized with l.
Creates a new root. When 
read-root is called, it invokes
get and when 
set-root! is called, it invokes
set.
For example, this creates a root that uses the local variable
x to hold its location:
Evaluates each of the body-exprs in a context where
the value of heap-expr is used as the heap. Useful in
tests:
Bound to the current heap inside of 
with-heap.
| (with-roots (root-var ...) expr1 expr2 ...)
 | 
|  | 
|  | 
Evaluates each of 
expr1 and the 
expr2s in
in a context with additional roots, one for each of
the 
root-vars. The 
get-root-set function
returns these additional roots. Calling 
read-root on
one of the newly created roots returns the value of the
corresponding 
root-var and calling 
set-root!
mutates the corresponding variable.
This form is intended to be used in test suites
for collectors. Since your test suites are not running
in the 
 language, 
get-root-set
returns a list consisting only of the roots it created,
not all of the other roots it normally would return.
Use 
with-roots to note specific locations as roots
and set up better tests for your GC.
4.2 Garbage Collector Exports for GC2🔗ℹ 
A garbage collector must define the following functions:
init-allocator is called before all other procedures by a
mutator. Place any requisite initialization code here.
 Given the location of a flat value, this procedure should return that
value.  If the location does not hold a flat value, this function should signal
an error.
This procedure should allocate a flat value (number, symbol, boolean,
or empty list) on the heap, returning its location (a number). The
value should occupy a single heap cell, though you may use additional space to
store a tag, etc. You are also welcome to pre-allocate common constants (e.g.,
the empty list). This procedure may need to perform a garbage-collection. If
there is still insufficient space, it should signal an error.
Given two roots, one for the first and rest values, this
procedure must allocate a cons cell on the heap.  If there is insufficient
space to allocate the cons cell, it should signal an error.
If the given location refers to a cons cell, this should return the first
field. Otherwise, it should signal an error.
If the given location refers to a cons cell, this should return the rest
field. Otherwise, it should signal an error.
If cons-cell refers to a cons cell, set the head of the cons cell to
first-value.  Otherwise, signal an error.
If cons-cell refers to a cons cell, set the tail of the cons cell to
rest-value.  Otherwise, signal an error.
Returns #true if loc refers to a cons cell.  This function
should never signal an error.
Returns #true if loc refers to a flat value.  This function
should never signal an error.
Allocates a closure with code-ptr and the free variables
in the list free-vars.
Given a location returned from an earlier allocation
check to see if it is a closure; if not signal an
error. If so, return the code-ptr for that closure.
Given a location returned from an earlier allocation, check
to see if it is a closure; if not signal an error. If so,
return the ith variable in the closure (counting from 0).
Determine if a previously allocated location
holds a closure. This function will be called only
with locations previous returned from an allocating
function or passed to 
set-root!. It should
never signal an error.