3 files changed, 28 insertions, 259 deletions

diff --git a/inc/term.h b/inc/term.h
index b70e60a..8fbdad7 100644
--- a/inc/term.h
+++ b/inc/term.h
@@ -6,7 +6,6 @@
 typedef enum { INV, ABS, APP, VAR, CLOSURE, CACHE } term_type;
 
 struct term {
-	int tracker;
 	term_type type;
 	union {
 		struct {
diff --git a/src/reducer.c b/src/reducer.c
index 76982f2..1d4f5e6 100644
--- a/src/reducer.c
+++ b/src/reducer.c
@@ -12,30 +12,25 @@
 #include <term.h>
 
 struct tracked {
-	int tracker;
 	void *stuff;
 };
 
 struct stack {
-	int tracker;
 	void *data;
 	struct stack *next;
 };
 
 struct closure {
-	int tracker;
 	struct term *term;
 	struct store *store;
 };
 
 struct box {
-	int tracker;
 	enum { TODO, DONE } state;
 	struct term *term;
 };
 
 struct cache {
-	int tracker;
 	struct box *box;
 	struct term *term;
 };
@@ -62,140 +57,9 @@ static int name_generator(void)
 	return current++;
 }
 
-static void *track(void *ptr)
-{
-	struct tracked *tracked = ptr;
-	tracked->tracker = 0;
-	return ptr;
-}
-
-static void release(void **ptr)
-{
-	struct tracked *tracked = *ptr;
-	tracked->tracker--;
-	if (tracked->tracker == 0) {
-		fprintf(stderr, "Release %p (free)\n", (void *)tracked);
-		free(*ptr);
-	} else {
-		fprintf(stderr, "Release %p (%d)\n", (void *)tracked,
-			tracked->tracker);
-	}
-}
-
-static void *acquire(void *ptr)
-{
-	struct tracked *tracked = ptr;
-	tracked->tracker++;
-	fprintf(stderr, "Acquire %p (%d)\n", ptr, tracked->tracker);
-	return ptr;
-}
-
-static void release_term(struct term **term)
-{
-	if (!(*term)) // e.g. for empty boxes
-		return;
-
-	struct term *deref = *term;
-	switch (deref->type) {
-	case ABS:
-		release_term(&deref->u.abs.term);
-		break;
-	case APP:
-		release_term(&deref->u.app.lhs);
-		release_term(&deref->u.app.rhs);
-		break;
-	case VAR:
-		break;
-	case CLOSURE:
-		release_term(&((struct closure *)deref->u.other)->term);
-		store_release(&((struct closure *)deref->u.other)->store);
-		release((void **)&deref->u.other);
-		break;
-	case CACHE:
-		release_term(&((struct cache *)deref->u.other)->box->term);
-		release((void **)&((struct cache *)deref->u.other)->box);
-		release_term(&((struct cache *)deref->u.other)->term);
-		release((void **)&deref->u.other);
-		break;
-	default:
-		fprintf(stderr, "Invalid type %d\n", deref->type);
-	}
-	release((void **)term);
-}
-
-static void release_box(struct box **box)
-{
-	release_term(&(*box)->term);
-	release((void **)box);
-	*box = 0;
-}
-
-static void release_cache(struct cache **cache)
-{
-	release_box(&(*cache)->box);
-	release_term(&(*cache)->term);
-	release((void **)cache);
-}
-
-// TODO: probably goes way deeper than necessary (not that it really matters though)
-// TODO: Reduce usage as "specific selection by acquiring once and releasing all other"
-static struct term *acquire_term(struct term *term)
-{
-	if (!term) // e.g. for empty boxes
-		return term;
-
-	fprintf(stderr, "%d\n", term->type);
-	acquire(term);
-	switch (term->type) {
-	case ABS:
-		acquire_term(term->u.abs.term);
-		break;
-	case APP:
-		acquire_term(term->u.app.lhs);
-		acquire_term(term->u.app.rhs);
-		break;
-	case VAR:
-		break;
-	case CLOSURE:
-		acquire(term->u.other);
-		acquire_term(((struct closure *)term->u.other)->term);
-		store_acquire(((struct closure *)term->u.other)->store);
-		break;
-	case CACHE:
-		acquire(term->u.other);
-		acquire(((struct cache *)term->u.other)->box);
-		acquire_term(((struct cache *)term->u.other)->box->term);
-		acquire_term(((struct cache *)term->u.other)->term);
-		break;
-	default:
-		fprintf(stderr, "Invalid type %d\n", term->type);
-	}
-	return term;
-}
-
-static struct box *acquire_box(struct box *box)
-{
-	acquire(box);
-	acquire_term(box->term);
-	return box;
-}
-
-void store_release_callback(void *data);
-void store_release_callback(void *data)
-{
-	struct box *box = data;
-	release_box(&box);
-}
-
-void store_acquire_callback(void *data);
-void store_acquire_callback(void *data)
-{
-	acquire_box(data);
-}
-
 static struct stack *stack_push(struct stack *stack, void *data)
 {
-	struct stack *new = acquire(track(malloc(sizeof(*new))));
+	struct stack *new = malloc(sizeof(*new));
 	new->data = data;
 	new->next = stack;
 	return new;
@@ -204,7 +68,6 @@ static struct stack *stack_push(struct stack *stack, void *data)
 static struct stack *stack_next(struct stack *stack)
 {
 	struct stack *next = stack->next;
-	release((void **)&stack);
 	return next;
 }
 
@@ -229,7 +92,7 @@ static int transition_1(struct term **term, struct store **store,
 {
 	struct term *orig = *term;
 
-	struct closure *closure = track(malloc(sizeof(*closure)));
+	struct closure *closure = malloc(sizeof(*closure));
 	closure->term = (*term)->u.app.rhs;
 	closure->store = *store;
 
@@ -237,29 +100,26 @@ static int transition_1(struct term **term, struct store **store,
 	app->u.app.lhs = new_term(VAR);
 	app->u.app.rhs = new_term(CLOSURE);
 	app->u.app.rhs->u.other = closure;
-	acquire_term(app);
-	fprintf(stderr, "TRACK %p\n", (void *)app->u.app.rhs);
 
-	*term = acquire_term((*term)->u.app.lhs);
+	*term = (*term)->u.app.lhs;
 	*store = *store;
 	*stack = stack_push(*stack, app);
 
-	release_term(&orig);
 	return 0;
 }
 
 static int transition_2(struct stack **stack, struct term **term,
 			struct store *store)
 {
-	struct box *box = track(malloc(sizeof(*box)));
+	struct box *box = malloc(sizeof(*box));
 	box->state = TODO;
 	box->term = 0;
 
-	struct closure *closure = track(malloc(sizeof(*closure)));
+	struct closure *closure = malloc(sizeof(*closure));
 	closure->term = *term;
 	closure->store = store;
 
-	struct cache *cache = track(malloc(sizeof(*cache)));
+	struct cache *cache = malloc(sizeof(*cache));
 	cache->box = box;
 	cache->term = new_term(CLOSURE);
 	cache->term->u.other = closure;
@@ -267,9 +127,7 @@ static int transition_2(struct stack **stack, struct term **term,
 	*stack = *stack;
 	*term = new_term(CACHE);
 	(*term)->u.other = cache;
-	acquire_term(*term);
 
-	store_release(&store);
 	return 0;
 }
 
@@ -280,21 +138,18 @@ static int transition_3(struct term **term, struct store **store,
 	struct store *orig_store = *store;
 	assert(box->term->type == CLOSURE);
 
-	struct cache *cache = track(malloc(sizeof(*cache)));
+	struct cache *cache = malloc(sizeof(*cache));
 	cache->box = box;
 	cache->term = new_term(VAR);
 
 	struct term *cache_term = new_term(CACHE);
 	cache_term->u.other = cache;
-	acquire_term(cache_term);
 
 	struct closure *closure = box->term->u.other;
-	*term = acquire_term(closure->term);
-	*store = store_acquire(closure->store);
+	*term = closure->term;
+	*store = closure->store;
 	*stack = stack_push(*stack, cache_term);
 
-	release_term(&orig_term);
-	store_release(&orig_store);
 	return 0;
 }
 
@@ -303,10 +158,8 @@ static int transition_4(struct stack **stack, struct term **term,
 {
 	struct term *orig = *term;
 	*stack = *stack;
-	*term = acquire_term(box->term);
+	*term = box->term;
 
-	store_release(&store);
-	release_term(&orig);
 	return 0;
 }
 
@@ -316,20 +169,9 @@ static int transition_5(struct stack **stack, struct term **term,
 	struct cache *cache = peek_term->u.other;
 	struct box *box = cache->box;
 
-	if (box->tracker > 1) {
-		fprintf(stderr, "BOX %p EXISTS\n", (void *)box);
-		struct term **orig = &box->term;
-		box->state = DONE;
-		box->term = *term;
-		acquire_term(*term);
-		release_term(orig);
-	} else {
-		release_box(&cache->box); // TODO
-	}
-
-	release_term(&cache->term);
-	release((void **)&cache);
-	release((void **)&peek_term);
+	struct term **orig = &box->term;
+	box->state = DONE;
+	box->term = *term;
 
 	*stack = stack_next(*stack);
 	*term = *term;
@@ -343,17 +185,14 @@ static int transition_6(struct term **term, struct store **store,
 {
 	struct term *orig = *term;
 
-	struct box *box = track(malloc(sizeof(*box)));
+	struct box *box = malloc(sizeof(*box));
 	box->state = TODO;
 	box->term = peek_term->u.app.rhs;
 
-	*term = acquire_term(closure->term->u.abs.term);
-	*store = store_acquire(
-		store_set(closure->store, &closure->term->u.abs.name, box, 0));
+	*term = closure->term->u.abs.term;
+	*store = store_set(closure->store, &closure->term->u.abs.name, box, 0);
 	*stack = stack_next(*stack);
 
-	release_term(&orig);
-	release_term(&peek_term);
 	return 0;
 }
 
@@ -364,32 +203,28 @@ static int transition_7(struct term **term, struct store **store,
 	struct term *orig = *term;
 	int x = name_generator();
 
-	struct box *var_box = track(malloc(sizeof(*var_box)));
+	struct box *var_box = malloc(sizeof(*var_box));
 	var_box->state = DONE;
 	var_box->term = new_term(VAR);
 	var_box->term->u.var.name = x;
 
-	struct cache *cache = track(malloc(sizeof(*cache)));
+	struct cache *cache = malloc(sizeof(*cache));
 	cache->box = box;
 	cache->term = new_term(VAR);
 
 	struct term *cache_term = new_term(CACHE);
 	cache_term->u.other = cache;
-	acquire_term(cache_term);
 
 	struct term *abs = new_term(ABS);
 	abs->u.abs.name = x;
 	abs->u.abs.term = new_term(VAR);
-	acquire_term(abs);
 
-	*term = acquire_term(closure->term->u.abs.term);
-	*store = store_acquire(store_set(closure->store,
-					 (void *)&closure->term->u.abs.name,
-					 var_box, 0));
+	*term = closure->term->u.abs.term;
+	*store = store_set(closure->store, (void *)&closure->term->u.abs.name,
+			   var_box, 0);
 	*stack = stack_push(*stack, cache_term);
 	*stack = stack_push(*stack, abs);
 
-	release_term(&orig);
 	return 0;
 }
 
@@ -399,9 +234,8 @@ static int transition_8(struct stack **stack, struct term **term,
 	struct term *orig = *term;
 
 	*stack = *stack;
-	*term = acquire_term(box->term);
+	*term = box->term;
 
-	release_term(&orig);
 	return 0;
 }
 
@@ -415,14 +249,11 @@ static int transition_9(struct term **term, struct store **store,
 	struct term *app = new_term(APP);
 	app->u.app.lhs = *term;
 	app->u.app.rhs = new_term(VAR);
-	acquire_term(app);
 
-	*term = acquire_term(closure->term);
-	*store = store_acquire(closure->store);
+	*term = closure->term;
+	*store = closure->store;
 	*stack = stack_push(stack_next(*stack), app);
 
-	release_term(&orig);
-	release_term(&peek_term);
 	return 0;
 }
 
@@ -434,13 +265,10 @@ static int transition_10(struct stack **stack, struct term **term,
 	struct term *app = new_term(APP);
 	app->u.app.lhs = peek_term->u.app.lhs;
 	app->u.app.rhs = *term;
-	acquire_term(app);
 
 	*stack = stack_next(*stack);
 	*term = app;
 
-	release_term(&orig);
-	release_term(&peek_term);
 	return 0;
 }
 
@@ -452,13 +280,10 @@ static int transition_11(struct stack **stack, struct term **term,
 	struct term *abs = new_term(ABS);
 	abs->u.abs.name = peek_term->u.abs.name;
 	abs->u.abs.term = *term;
-	acquire_term(abs);
 
 	*stack = stack_next(*stack);
 	*term = abs;
 
-	release_term(&orig);
-	release_term(&peek_term);
 	return 0;
 }
 
@@ -485,11 +310,9 @@ static int transition_closure(struct conf *conf, int i,
 		struct box *box = store_get(store, &term->u.var.name, 0);
 		int unbound = 0;
 		if (!box) {
-			box = track(malloc(sizeof(*box)));
+			box = malloc(sizeof(*box));
 			box->state = DONE;
 			box->term = term;
-			acquire_box(box);
-			unbound = 1;
 		}
 		if (box->state == TODO) { // (3)
 			callback(i, '3');
@@ -500,8 +323,6 @@ static int transition_closure(struct conf *conf, int i,
 			callback(i, '4');
 			ret = transition_4(&stack, &term, store, box);
 			cconf(conf, stack, term);
-			if (unbound)
-				release_box(&box);
 			return ret;
 		}
 		fprintf(stderr, "Invalid box state %d\n", box->state);
@@ -636,11 +457,10 @@ static uint32_t hash_var(void *key)
 struct term *reduce(struct term *term, void (*callback)(int, char))
 {
 	struct stack stack = { 0 };
-	struct store *store =
-		store_acquire(store_new(hash_var, hash_var_equal));
+	struct store *store = store_new(hash_var, hash_var_equal);
 	struct conf conf = {
 		.type = ECONF,
-		.u.econf.term = acquire_term(term),
+		.u.econf.term = term,
 		.u.econf.store = store,
 		.u.econf.stack = &stack,
 	};
@@ -648,7 +468,5 @@ struct term *reduce(struct term *term, void (*callback)(int, char))
 	assert(conf.type == CCONF);
 
 	struct term *ret = duplicate_term(conf.u.cconf.term);
-	/* release_term(conf.u.cconf.term); // TODO */
-	/* store_destroy(&store); // should already be freed? TODO */
 	return ret;
 }
diff --git a/src/store.c b/src/store.c
index 03247e4..ae1d1bd 100644
--- a/src/store.c
+++ b/src/store.c
@@ -244,41 +244,20 @@ static void iter_pop(struct store_iter *iterator);
  * definitions
  */
 
-extern void store_release_callback(void *data);
-
 static void node_destroy(struct node *node)
 {
 	DEBUG_NOTICE("    destroying " store_node_debug_fmt "@%p\n",
 		     store_node_debug_args(node), (void *)node);
 
-	// reference counting
-	fprintf(stderr, "> node_destroy calling back\n");
-	STORE_NODE_BRANCH_T *branches = STORE_NODE_BRANCHES(node);
-	for (int i = 0; i < node->branch_arity; ++i) {
-		store_node_release(branches[i]);
-	}
-	fprintf(stderr, "> node_destroy calling back done\n");
-
 	free(node);
 }
 
-extern void store_acquire_callback(void *data);
-
 // reference counting
 static struct node *store_node_acquire(struct node *node)
 {
 	if (node == &empty_node)
 		return node;
 	node->ref_count++;
-
-	// aqcuire boxes in node
-	fprintf(stderr, "> node_acquire calling back\n");
-	for (unsigned i = 0; i < node->element_arity; ++i) {
-		struct kv kv = node->content[i];
-		store_acquire_callback(kv.val);
-	}
-	fprintf(stderr, "> node_acquire calling back done\n");
-
 	return node;
 }
 
@@ -288,14 +267,6 @@ static void store_node_release(struct node *node)
 	if (node == &empty_node)
 		return;
 
-	// release boxes in node
-	fprintf(stderr, "> node_release calling back\n");
-	for (unsigned i = 0; i < node->element_arity; ++i) {
-		struct kv kv = node->content[i];
-		store_release_callback(kv.val);
-	}
-	fprintf(stderr, "> node_release calling back done\n");
-
 	if (node->ref_count-- == 1)
 		node_destroy(node);
 }
@@ -922,15 +893,6 @@ struct store *store_new(STORE_HASHFN_T(hash), STORE_EQUALSFN_T(equals))
 
 struct store *store_acquire(struct store *store)
 {
-	// acquire boxes in node // TODO: Necessary? Probably, as release lock
-	fprintf(stderr, "> store_acquire calling back\n");
-	struct node *node = store->root;
-	for (unsigned i = 0; i < node->element_arity; ++i) {
-		struct kv kv = node->content[i];
-		store_acquire_callback(kv.val);
-	}
-	fprintf(stderr, "> store_acquire calling back done\n");
-
 	store->ref_count++;
 	DEBUG_NOTICE("ACQ %p: %d\n", (void *)store, store->ref_count);
 	return store;
@@ -939,18 +901,8 @@ struct store *store_acquire(struct store *store)
 void store_release(struct store **store)
 {
 	DEBUG_NOTICE("REL %p: %d\n", (void *)*store, (*store)->ref_count - 1);
-	if ((*store)->ref_count-- == 1) {
+	if ((*store)->ref_count-- == 1)
 		store_destroy(store);
-	} else {
-		// release boxes in node // TODO: Necessary?
-		fprintf(stderr, "> store_release calling back\n");
-		struct node *node = (*store)->root;
-		for (unsigned i = 0; i < node->element_arity; ++i) {
-			struct kv kv = node->content[i];
-			store_release_callback(kv.val);
-		}
-		fprintf(stderr, "> store_release calling back done\n");
-	}
 }
 
 struct store *store_of(STORE_HASHFN_T(hash), STORE_EQUALSFN_T(equals),