struct garbage {
    struct garbage         *next;
    void                   *object;
};

struct destructor {
    int                   (*function)(void *, void *);
    void                   *payload;
};

struct reference {
    long                    count;
    union {
        struct garbage     *garbage;
        struct destructor  *destructor;
    };
};

/* Garbage chain */
struct garbage             *garbage = NULL;

/** get_reference() - Get a reference (increase reference count).
 * The function returns 0 if success, error code (errno.h) otherwise.
*/
int get_reference(struct reference *ref)
{
    if (!ref)
        return EINVAL; /* Invalid object */

    if (__sync_add_and_fetch(&(ref->count), 1L) <= 1L) {
        __sync_sub_and_fetch(&(ref->count), 1L);
        return ENOENT; /* Already gone */
    }

    return 0;
}

/** put_reference() - Release a reference (decrease reference count).
 * The function returns 0 if success, error code (errno.h) otherwise.
*/
int put_reference(struct reference *const ref, void *const object)
{
    int             result;
    struct garbage *temp;

    if (!ref || !object)
        return EINVAL; /* Invalid object */

    if (__sync_sub_and_fetch(&(ref->count), 1L) != 0L)
        return 0; /* Success */

    /* Mark object dead. Avoids races with 32768 concurrent threads. */
    if (__sync_sub_and_fetch(&(ref->count), 32768L) < -49152L)
        return 0; /* Not the first racing thread */

    /* Call destructor function */
    if (ref->destructor)
        result = ref->destructor->function(object, ref->destructor->payload);
    else
        result = 0;

    /* Move to garbage chain (atomically). */
    do {
        temp = __sync_or_and_fetch(&garbage, (struct garbage *)0L);
        ref->garbage->object = object;
        ref->garbage->next = temp;
    } while (!__sync_bool_compare_and_swap(&garbage, temp, ref->garbage));

    return result;
}

/** all_garbage() - Safely get the entire garbage chain
*/
struct reference *all_garbage(void)
{
    struct garbage *chain;

    do {
        chain = __sync_or_and_fetch(&garbage, (struct garbage *)0L);
    } while (!__sync_bool_compare_and_swap(&garbage, chain, NULL));

    return chain;
}

struct embedded {
    struct reference   refcount;
    :
    my stuff
    :
};

struct embedded *object;

if (get_reference(&(object->refcount)))
    Failure, object is gone

if (put_reference(&(object->refcount), object))
    Error when releasing object

#define UNWRAP_BEFORE(payload) ((struct reference *)( (char *)(payload) - sizeof(struct reference) ))

if (get_reference(UNWRAP_BEFORE(object))
    Failure, object is already gone

if (put_reference(UNWRAP_BEFORE(object), object))
    Error when releasing object

#define UNWRAP_AFTER(payload, size) ((struct reference *)( (char *)(payload) + (size_t)(size) ))

if (get_reference(UNWRAP_AFTER(object, sizeof(object)), object))
    Failure, object is already gone

if (put_reference(UNWRAP_AFTER(object, sizeof(object)), object))
    Error when releasing object

/** A base "class" for reference-counted objects.
 * To make your struct a "subclass" put OBJECT_TEMPLATE as the
 * very first element of your struct, call object_init on it in your
 * initialization function, and if you need to do some cleanup before the
 * struct is destroyed, set the member named "free" to a pointer to a function
 * that cleans up and then frees the struct itself.
 */

#ifndef __REFCOUNT_OBJECT_H_INCLUDE_GUARD__
#define __REFCOUNT_OBJECT_H_INCLUDE_GUARD__

#include <stdlib.h>

#define OBJECT_TEMPLATE \
	size_t refcount; \
	void (*free)(void*);

/** A struct to serve as an abstract base class for refcounted objects.
 * This is purely a convenience struct that any refcount object can be cast
 * to.
 */
typedef struct { OBJECT_TEMPLATE } object_t;

#define NEWREF(x) ((void*) object_new_ref((object_t*) x))
#define DELREF(x) object_del_ref((object_t*) x)

/** Initialize a refcount object.
 * This function sets the reference count to 1 and the free function to the
 * free() function in stdlib.h.
 * @param obj A pointer to the refcount object to initialize.
 */
void object_init(object_t *obj)
{
	obj->frecount = 1;
	obj->free = &free; // just use the free() from stdlib.h
}

/** Add a new reference.
 * @param obj A pointer to a refcount object.
 * @returns the same thing passed in the obj parameter, for convenience.
 */
inline object_t* object_new_ref(object_t* obj)
{
	obj->refcount++;
	return obj;
}

/** Delete a reference.
 * The object is automatically freed if the counter reaches 0.
 * @param obj The reference to be deleted.
 */
inline void object_del_ref(object_t* obj)
{
	obj->refcount--;
	if (obj->refcount <= 0)
		obj->free(obj);
}

#endif

function_that_stores_reference(example_refcounted_object_new());

object_t *temporary_object = example_refcounted_object_new();
function_that_stores_reference(temporary_object);
DELREF(temporary_object);

LangObject* Node::eval(Table *scope)
{
	switch (type) {
		
		case IntegerNode:
			return new IntegerObject();
		
		case MemberNode:
			if (childCount == 1) {
				Table *table = dynamic_cast<Table*>(children[0]->eval(scope));
				if (table)
					return table->get(payload.str);
				else
					return NULL; //TODO throw error
			}
			return scope->get(payload.str);

		<snip>

		default:
			break;
	}
	fprintf(stderr, "Unknown node type. Evaluating to null.");
	return NULL;
}

Function *func = dynamic_cast<Function*>(children[0]->eval(scope));