objects.c

/* this helps manage non-gc allocations from modules */

#include "es.h"
#include "prim.h"
#include "stdenv.h"

typedef struct {
	char *name;
	int (*deallocate)(Object *); /* called before an object is freed */
	int (*refdeps)(Object *);
	char *(*stringify)(Object *);
	int (*onfork)(Object *);
	Result (*objectify)(char *);
	Object* (*allocate)(void);
} Typedef;

size_t typessz = 0;
Typedef **typedefs = nil;
size_t objectssz = 0;
Object **objects = nil;

void
init_typedefs(void)
{
	assert(typessz == 0);
	assert(typedefs == nil);

	typessz = 4;
	typedefs = ealloc(sizeof(Typedef *) * typessz);
}

void
grow_typedefs(void)
{
	size_t newsize = 0;
	Typedef **oldtypedefs = nil;

	assert(typedefs);

	newsize = typessz * 2;
	oldtypedefs = typedefs;
	typedefs = ealloc(sizeof(Typedef *) * newsize);
	memcpy(typedefs, oldtypedefs, typessz * sizeof(Typedef *));
	efree(oldtypedefs);
	typessz = newsize;
}

void
init_objects(void)
{
	assert(objectssz == 0);
	assert(objects == nil);

	objectssz = 4;
	objects = ealloc(sizeof(Object *) * objectssz);
}

void
grow_objects(void)
{
	size_t newsize = 0;
	Object **oldobjects = nil;

	assert(objects);

	newsize = objectssz * 2;
	oldobjects = objects;
	objects = ealloc(sizeof(Object *) * newsize);
	memcpy(objects, oldobjects, objectssz * sizeof(Object *));
	efree(oldobjects);
	objectssz = newsize;
}

int32_t
gettypeindex(char *name)
{
	int32_t i;

	assert(name);
	for(i = 0; i < (int32_t)typessz; i++) {
		if(typedefs[i] == nil)
			continue;
		if(streq(typedefs[i]->name, name))
			return i;
	}

	return -1;
}

char *
gettypename(int32_t index)
{
	if(index >= (int32_t)typessz)
		unreachable();
	if(typedefs[index] == nil)
		unreachable();

	return typedefs[index]->name;
}

int32_t
define_type(char *name, int (*deallocate)(Object *), int (*refdeps)(Object *))
{
	Typedef *newtype;
	int32_t typen;
	int32_t i;

	if((typen = gettypeindex(name)) >= 0)
		return typen;

	newtype = ealloc(sizeof(Typedef));

	newtype->name = estrdup(name);
	newtype->deallocate = deallocate;
	newtype->refdeps = refdeps;
	newtype->stringify = nil;

	for(i = 0; i < (int32_t)typessz; i++)
		if(typedefs[i] == nil) {
			typedefs[i] = newtype;
			return i;
		}

	grow_typedefs();

	for(i = 0; i < (int32_t)typessz; i++)
		if(typedefs[i] == nil) {
			typedefs[i] = newtype;
			return i;
		}

	unreachable();
}

int
define_stringifier(char *name, char *(*stringify)(Object *))
{
	int index;
	Typedef *type;

	assert(name);

	assert((index = gettypeindex(name)) >= 0);
	type = typedefs[index];

	type->stringify = stringify;
	return 0;
}

int
define_objectifier(char *name, Result (*objectify)(char *))
{
	int index;
	Typedef *type;

	assert(name);
	assert((index = gettypeindex(name)) >= 0);
	type = typedefs[index];

	type->objectify = objectify;

	return 0;
}

int
define_onfork_callback(char *name, int (*onfork)(Object *))
{
	int index;
	Typedef *type;

	assert(name);

	assert((index = gettypeindex(name)) >= 0);
	type = typedefs[index];

	type->onfork = onfork;
	return 0;
}

int
define_allocator(char *name, Object* (*allocator)(void))
{
	int index;
	Typedef *type;

	assert(name);
	assert((index = gettypeindex(name)) >= 0);

	type = typedefs[index];

	type->allocate = allocator;
	return 0;
}

int
undefine_type(char *name)
{
	int32_t index;
	Typedef *oldtype;
	size_t i = 0;

	if((index = gettypeindex(name)) < 0)
		return 0;

	assert(typedefs[index]);

	for(i = 0; i < objectssz; i++) {
		if(!objects[i])
			continue;
		if(objects[i]->type == index)
			return ObjectErrorTypeInUse;
	}

	oldtype = typedefs[index];
	typedefs[index] = nil;
	efree(oldtype->name);
	efree(oldtype);

	return 0;
}

Object *
allocate_object(char *type, size_t size)
{
	int32_t typeidx;
	Object *newobject;
	int32_t i;

	if((typeidx = gettypeindex(type)) < 0)
		unreachable();

	newobject = ealloc(sizeof(Object) + size);
	newobject->type = typeidx;
	newobject->size = size;
	newobject->data = ((char *)newobject) + sizeof(Object);

	for(i = 0; i < (int32_t)objectssz; i++)
		if(objects[i] == nil) {
			objects[i] = newobject;
			newobject->id = i;
			return newobject;
		}

	grow_objects();

	for(i = 0; i < (int32_t)objectssz; i++)
		if(objects[i] == nil) {
			objects[i] = newobject;
			newobject->id = i;
			return newobject;
		}

	unreachable();
}

void
deallocate_object(Object *obj)
{
	Typedef *objtype;

	assert(obj);
	assert(obj->type < (int32_t)typessz);
	assert(objects[obj->id] != nil);
	assert(objects[obj->id] == obj);

	assert(objtype = typedefs[obj->type]);

	if(objtype->deallocate && obj->sysflags & ObjectInitialized)
		if(objtype->deallocate(obj) != 0)
			return;
	objects[obj->id] = nil;
	efree(obj);
}

void
assert_type(Object *obj, char *name)
{
	int32_t typeindex;

	typeindex = gettypeindex(name);
	assert(typeindex >= 0);
	assert(obj);
	assert(obj->type == typeindex);
}

int
object_is_type(Object *obj, char *name)
{
	int32_t typeindex;

	typeindex = gettypeindex(name);
	assert(typeindex >= 0);

	if(obj == nil)
		return 0;
	if(obj->type != typeindex)
		return 0;
	return 1;
}

char *
stringify(Object *obj)
{
	Typedef *objtype;

	assert(obj);
	assert(obj->type < (int32_t)typessz);
	assert(objects[obj->id] != nil);
	assert(objects[obj->id] == obj);

	assert(objtype = typedefs[obj->type]);

	if(objtype->stringify)
		return objtype->stringify(obj);
	return nil;
}

Result
result_obj(Object *obj, int status)
{
	return result(obj, status);
}

Object *
ok_obj(Result r)
{
	return (Object *)ok(r);
}

Result
objectify(char *type, char *str)
{
	Result res;
	Typedef *objtype;
	int32_t typeidx;
	size_t strsize;
	size_t i, j;
	char bufstr[128];
	char *databuf = nil;
	char *objstr = nil;
	enum { StateNormal, StateInQuote } state = StateNormal;

	if(hasprefix(str, "%obj:")) {
		/* the %obj:TYPE prefix overrides the given type */
		strsize = strlen(str);
		if(strsize < 9)
			return result(nil, ObjectifyInvalidObjectFormat);

		memset(&bufstr[0], 0, sizeof(bufstr));
		for(i = 5; i < strsize && i < sizeof(bufstr); i++) {
			if(str[i] == '(')
				break;
			bufstr[i - 5] = str[i];
		}

		if((typeidx = gettypeindex(bufstr)) < 0)
			return result(nil, ObjectifyInvalidType);

		assert(objtype = typedefs[typeidx]);

		if(objtype->objectify == nil)
			return result(nil, ObjectifyOk);

		i++;
		if(str[i] != '\'')
			return result(nil, ObjectifyInvalidFormat);
		i++;

		if(str[strsize - 1] != ')')
			return result(nil, ObjectifyInvalidFormat);
		if(str[strsize - 2] != '\'')
			return result(nil, ObjectifyInvalidFormat);

		databuf = ealloc(strsize);

		for(j = 0; i < (strsize - 2); i++) {
			switch(state) {
			default:
				unreachable();
				break;
			case StateNormal:
				if(str[i] == '\'') {
					state = StateInQuote;
					j++;
					continue;
				}
				databuf[j] = str[i];
				j++;
				break;
			case StateInQuote:
				if(str[i] != '\'') {
					efree(databuf);
					return result(nil, ObjectifyInvalidFormat);
				}
				databuf[j] = '\'';
				state = StateNormal;
				j++;
				break;
			}
		}

		objstr = estrdup(databuf);
		efree(databuf);
	} else if(type != nil) {
		assert(str != nil);
		if((typeidx = gettypeindex(type)) < 0)
			return result(nil, ObjectifyInvalidType);
		assert(objtype = typedefs[typeidx]);

		if(objtype->objectify == nil)
			return result(nil, ObjectifyOk);

		objstr = estrdup(str);
	} else
		return result(nil, ObjectifyInvalidFormat);
	res = objtype->objectify(objstr);
	efree(objstr);
	return res;
}

void
refobject(Object *obj)
{
	Typedef *objtype;

	assert(obj);
	obj->refcount++;
	objtype = typedefs[obj->type];
	if(objtype->refdeps)
		objtype->refdeps(obj);
}

void
derefobject(Object *obj)
{
	assert(obj);
	if(obj->refcount > 0)
		obj->refcount--;
}

int64_t
object_refs(Object *obj)
{
	assert(obj);
	return obj->refcount;
}

Object*
newobject(char *type)
{
	int32_t typeindex;
	Typedef *objtype;

	typeindex = gettypeindex(type);
	assert(typeindex >= 0);
	objtype = typedefs[typeindex];
	if(objtype->allocate)
		return objtype->allocate();
	return nil;
}

/* to gc objects:
 * 1. call derefallobjects
 * 2. when the marker/sweeper hits an object term the object is ref'd
 * 3. call dealloc_unrefed_objects
 */

void
derefallobjects(void)
{
	int32_t i;

	for(i = 0; i < (int32_t)objectssz; i++)
		if(objects[i] != nil && objects[i]->sysflags & ObjectGcManaged)
			objects[i]->refcount = 0;
}

void
dealloc_unrefed_objects(void)
{
	int32_t i;

	for(i = 0; i < (int32_t)objectssz; i++)
		if(objects[i] != nil && objects[i]->refcount == 0 &&
		   objects[i]->sysflags & (ObjectFreeWhenNoRefs | ObjectGcManaged))
			deallocate_object(objects[i]);
}

void
gcmanageobj(Object *obj)
{
	assert(obj);
	assert(obj->type < (int32_t)typessz);
	assert(objects[obj->id] != nil);
	assert(objects[obj->id] == obj);

	obj->sysflags |= ObjectGcManaged;
	obj->sysflags |= ObjectFreeWhenNoRefs;
}

void
gcunmanageobj(Object *obj)
{
	assert(obj);
	assert(obj->type < (int32_t)typessz);
	assert(objects[obj->id] != nil);
	assert(objects[obj->id] == obj);

	obj->sysflags &= ~ObjectGcManaged;
	obj->sysflags &= ~ObjectFreeWhenNoRefs;
}

void
deallocate_all_objects(void)
{
	int32_t i = 0;
	Typedef *objtype = nil;

	if(objects == nil)
		return;
	for(i = 0; i < (int32_t)objectssz; i++, objtype = nil) {
		if(!objects[i])
			continue;

		assert(objects[i]->type < (int32_t)typessz);
		assert(objtype = typedefs[objects[i]->type]);

		if(objtype->deallocate && objects[i]->sysflags & ObjectInitialized)
			objtype->deallocate(objects[i]);
		efree(objects[i]);
		objects[i] = nil;
	}
}

void
all_objects_onfork_ops(void)
{
	int32_t i = 0;
	Typedef *objtype = nil;
	int onfork_callback = (ObjectInitialized | ObjectCallbackOnFork);
	int onfork_free = (ObjectInitialized | ObjectCloseOnFork);

	if(objects == nil)
		return;

	for(i = 0; i < (int32_t)objectssz; i++, objtype = nil) {
		if(!objects[i])
			continue;

		assert(objects[i]->type < (int32_t)typessz);
		assert(objtype = typedefs[objects[i]->type]);

		if((objects[i]->sysflags & onfork_callback) == onfork_callback) {
			if(objtype->onfork)
				if(objtype->onfork(objects[i]))
					dprintf(2, "es:objects: %s onfork callback failed", objtype->name);
		}

		if((objects[i]->sysflags & onfork_free) == onfork_free) {
			if(objtype->deallocate)
				objtype->deallocate(objects[i]);
			efree(objects[i]);
			objects[i] = nil;
		}
	}
}