visible data area, e.g. thread's stack. (This behavior is viewed as a bug, but
as one that is exceedingly hard to fix without some `libc` hooks.)
-**void * `GC_MALLOC`(size_t _bytes_)** - Allocates and clears _bytes_
+`void * GC_MALLOC(size_t _bytes_)` - Allocates and clears _bytes_
of storage. Requires (amortized) time proportional to _bytes_. The resulting
object will be automatically deallocated when unreferenced. References from
objects allocated with the system malloc are usually not considered by the
is defined before `gc.h` is included, a debugging version that checks
occasionally for overwrite errors, and the like.
-**void * `GC_MALLOC_ATOMIC`(size_t _bytes_)** - Allocates _bytes_
+`void * GC_MALLOC_ATOMIC(size_t _bytes_)` - Allocates _bytes_
of storage. Requires (amortized) time proportional to _bytes_. The resulting
object will be automatically deallocated when unreferenced. The client
promises that the resulting object will never contain any pointers. The memory
arrays, bitmaps, etc. More precise information about pointer locations can be
communicated to the collector using the interface in `gc_typed.h`.
-**void * `GC_MALLOC_UNCOLLECTABLE`(size_t _bytes_)** - Identical
+`void * GC_MALLOC_UNCOLLECTABLE(size_t _bytes_)` - Identical
to `GC_MALLOC`, except that the resulting object is not automatically
deallocated. Unlike the system-provided `malloc`, the collector does scan the
object for pointers to garbage-collectible memory, even if the block itself
does not appear to be reachable. (Objects allocated in this way are
effectively treated as roots by the collector.)
-**void * `GC_REALLOC`(void * _old_object_, size_t _new_bytes_)** - Allocates
+`void * GC_REALLOC(void * _old_object_, size_t _new_bytes_)` - Allocates
a new object of the indicated size and copy the old object's content into the
new object. The old object is reused in place if convenient. If the original
object was allocated with `GC_MALLOC_ATOMIC`, the new object is subject to the
same constraints. If it was allocated as an uncollectible object, then the new
object is uncollectible, and the old object (if different) is deallocated.
-**void `GC_FREE`(void * _object_)** - Explicitly deallocates an _object_.
+`void GC_FREE(void * _object_)` - Explicitly deallocates an _object_.
Typically not useful for small collectible objects.
-**void * `GC_MALLOC_IGNORE_OFF_PAGE`(size_t _bytes_)** and
-**void * `GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE`(size_t _bytes_)** - Analogous
+`void * GC_MALLOC_IGNORE_OFF_PAGE(size_t _bytes_)` and
+`void * GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(size_t _bytes_)` - Analogous
to `GC_MALLOC` and `GC_MALLOC_ATOMIC`, respectively, except that the client
guarantees that as long as the resulting object is of use, a pointer
is maintained to someplace inside the first 512 bytes of the object. This
called at program start (this, however, is generally not suitable for C++ code
because of multiple inheritance).
-**void `GC_INIT()`** - On some platforms, it is necessary to invoke this _from
+`void GC_INIT()` - On some platforms, it is necessary to invoke this _from
the main executable_, _not from a dynamic library_, before the initial
invocation of a GC routine. It is recommended that this be done in portable
code, though we try to ensure that it expands to a no-op on as many platforms
as possible.
-**void `GC_gcollect`(void)** - Explicitly forces a garbage collection.
+`void GC_gcollect(void)` - Explicitly forces a garbage collection.
-**void `GC_enable_incremental`(void)** - Causes the garbage collector
+`void GC_enable_incremental(void)` - Causes the garbage collector
to perform a small amount of work every few invocations of `GC_MALLOC` or the
like, instead of performing an entire collection at once. This is likely
to increase total running time. It will improve response on a platform that
Win32 if the collector was suitably built). On many platforms this interacts
poorly with system calls that write to the garbage collected heap.
-**void `GC_set_warn_proc`(GC_warn_proc)** - Replaces the default procedure
+`void GC_set_warn_proc(GC_warn_proc)` - Replaces the default procedure
used by the collector to print warnings. The collector may otherwise
write to `stderr`, most commonly because `GC_malloc` was used in a situation
in which `GC_malloc_ignore_off_page` would have been more appropriate. See
`gc.h` for details.
-**void `GC_REGISTER_FINALIZER`(...)** - Registers a function to be called when
+`void GC_REGISTER_FINALIZER(...)` - Registers a function to be called when
an object becomes inaccessible. This is often useful as a backup method for
releasing system resources (e.g. closing files) when the object referencing
them becomes inaccessible. It is not an acceptable method to perform actions
projects / gc / commitdiff