kraken/stdlib/mem.krak

import set

__if_comp__ __C__ simple_passthrough """
	#include <stdlib.h>
"""

/* we have a template versions so we don't have to cast (because we don't have that yet) */

fun malloc<T>(size: int): T* {
    var memPtr: T*;
	__if_comp__ __C__ {
        simple_passthrough( size = size, memPtr = memPtr : memPtr = memPtr :) """
			memPtr = malloc(size);
		"""
	}
	return memPtr;
}

fun free<T>(memPtr: T*): void {
	__if_comp__ __C__ {
		simple_passthrough(memPtr = memPtr ::) """
			free(memPtr);
		"""
	}
}

fun sizeof<T>(): int {
	var testObj: T*;
    var result: int;
	__if_comp__ __C__ {
		simple_passthrough(testObj = testObj : result = result:) """
			int result = sizeof(*testObj);
		"""
	}
	return result;
}

fun new<T>(count: int): T* {
	return malloc<T>( sizeof<T>() * count );
}

fun new<T>(): T* {
	return new<T>(1);
}

/* We specilize on the trait Object to decide on whether or not the destructor should be called */
fun delete<T>(toDelete: T*, itemCount: int): void {
    delete<T>(toDelete);
}

/* Calling this with itemCount = 0 allows you to delete destructable objects without calling their destructors. */
fun delete<T(Object)>(toDelete: T*, itemCount: int): void {
    // start at one because the actual delete will call the destructor of the first one as it
    // finishes the pointer
    for (var i: int = 0; i < itemCount; i++;)
        toDelete[i].destruct();
    free<T>(toDelete);
    //delete<T>(toDelete);
}

/* We specilize on the trait Object to decide on whether or not the destructor should be called */
fun delete<T>(toDelete: T*): void {
    free<T>(toDelete);
}

fun delete<T(Object)>(toDelete: T*): void {
    toDelete->destruct();
    free<T>(toDelete);
}

// a wrapper for construct if it has the Object trait
fun maybe_construct<T>(it:T*):T* {
    return it
}

fun maybe_construct<T(Object)>(it:T*):T* {
    return it->construct()
}


// a wrapper for copy constructing if it has the Object trait
fun maybe_copy_construct<T>(to:T*, from:T*):void {
    *to = *from
}

fun maybe_copy_construct<T(Object)>(to:T*, from:T*):void {
    to->copy_construct(from)
}

// a wrapper for destruct if it has the Object trait
fun maybe_destruct<T>(it:T*):void {}

fun maybe_destruct<T(Object)>(it:T*):void {
    it->destruct()
}

// a function that allows the safe deletion of recursive and complicated data structures
fun safe_recursive_delete<T>(first: T*, addingFunc: fun(T*): set::set<T*>) {
    var toDelete = set::set<T*>()
    var next = set::set(first)
    while (toDelete != next) {
        toDelete = next
        toDelete.for_each( fun(it: T*) next.add(addingFunc(it)); )
    }
    toDelete.for_each( fun(it: T*) delete(it); )
}