Add store into abstract machine struct

lib/am.c

@@ -1,5 +1,8 @@
 #include "am.h"
 
+#include "env.h"
+#include "store.h"
+
 #include <assert.h>
 #include <string.h>
 
@@ -7,6 +10,8 @@ void am_init(am_t *am)
 {
 	memset(am, 0, sizeof(am_t));
 	am->sp = am->stack + AM_STACK_SIZE - 1;
+	store_init(am);
+	env_init(am);
 }
 
 void am_push(am_t *am)

lib/env.c

@@ -49,10 +49,10 @@ static expr_t **lookup(am_t *am, bool *found)
 	return &prev->pair.cdr;
 }
 
-void env_init(am_t *am, store_t *store)
+void env_init(am_t *am)
 {
-	am->env = expr_empty_list(store);
+	am->env = expr_empty_list(am);
-	prim_load(am, store);
+	prim_load(am);
 }
 
 void env_fetch(am_t *am)
@@ -62,7 +62,7 @@ void env_fetch(am_t *am)
 	am->val = found ? val : NULL;
 }
 
-void env_set(am_t *am, store_t *store)
+void env_set(am_t *am)
 {
 	bool found;
 	expr_t **loc = lookup(am, &found);
@@ -70,7 +70,7 @@ void env_set(am_t *am, store_t *store)
 		*loc = am->val;
 	} else {
 		(*loc)->is_atom = false;
-		(*loc)->pair.cdr = expr_empty_list(store);
+		(*loc)->pair.cdr = expr_empty_list(am);
-		(*loc)->pair.car = expr_pair(store, am->expr, am->val);
+		(*loc)->pair.car = expr_pair(am, am->expr, am->val);
 	}
 }

lib/expr.c

@@ -1,53 +1,54 @@
 #include "expr.h"
-#include "store.h"
+
+#include "am.h"
 
 #include <string.h>
 
-expr_t *expr_integer(store_t *store, int64_t value)
+expr_t *expr_integer(am_t *am, int64_t value)
 {
-	expr_t *expr = store_alloc(store);
+	expr_t *expr = store_alloc(am);
 	expr->is_atom = true;
 	expr->atom.type = ATOM_TYPE_INTEGER;
 	expr->atom.integer = value;
 	return expr;
 }
 
-expr_t *expr_symbol(store_t *store, const symbol_t *symbol)
+expr_t *expr_symbol(am_t *am, const symbol_t *symbol)
 {
-	expr_t *expr = store_alloc(store);
+	expr_t *expr = store_alloc(am);
 	expr->is_atom = true;
 	expr->atom.type = ATOM_TYPE_SYMBOL;
 	memcpy(&expr->atom.symbol, symbol, sizeof(symbol_t));
 	return expr;
 }
 
-expr_t *expr_str_symbol(store_t *store, const char *str)
+expr_t *expr_str_symbol(am_t *am, const char *str)
 {
 	symbol_t symbol = { .len = strlen(str) };
 	memcpy(symbol.buf, str, symbol.len);
-	return expr_symbol(store, &symbol);
+	return expr_symbol(am, &symbol);
 }
 
-expr_t *expr_empty_list(store_t *store)
+expr_t *expr_empty_list(am_t *am)
 {
-	expr_t *expr = store_alloc(store);
+	expr_t *expr = store_alloc(am);
 	expr->is_atom = true;
 	expr->atom.type = ATOM_TYPE_EMPTY_LIST;
 	return expr;
 }
 
-expr_t *expr_pair(store_t *store, expr_t *car, expr_t *cdr)
+expr_t *expr_pair(am_t *am, expr_t *car, expr_t *cdr)
 {
-	expr_t *expr = store_alloc(store);
+	expr_t *expr = store_alloc(am);
 	expr->is_atom = false;
 	expr->pair.car = car;
 	expr->pair.cdr = cdr;
 	return expr;
 }
 
-expr_t *expr_prim_proc(store_t *store, prim_proc_t prim_proc)
+expr_t *expr_prim_proc(am_t *am, prim_proc_t prim_proc)
 {
-	expr_t *expr = store_alloc(store);
+	expr_t *expr = store_alloc(am);
 	expr->is_atom = true;
 	expr->atom.type = ATOM_TYPE_PRIM_PROC;
 	expr->atom.prim_proc = prim_proc;

lib/include/am.h

@@ -2,12 +2,14 @@
 #define AM_H
 
 #include "expr.h"
+#include "store.h"
 
 #define AM_STACK_SIZE 128U
 
 typedef struct am {
 	expr_t *argl, *env, *expr, *val;
 	expr_t **sp, *stack[AM_STACK_SIZE];
+	store_t store;
 } am_t;
 
 void am_init(am_t *am);

lib/include/env.h

@@ -2,10 +2,9 @@
 #define ENV_H
 
 #include "am.h"
-#include "store.h"
 
-void env_init(am_t *am, store_t *store);
+void env_init(am_t *am);
 void env_fetch(am_t *am);
-void env_set(am_t *am, store_t *store);
+void env_set(am_t *am);
 
 #endif

lib/include/expr.h

@@ -8,14 +8,13 @@
 #include <stdint.h>
 
 struct am;
-struct store;
 
 typedef struct {
 	char buf[MAX_SYMBOL_LEN];
 	size_t len;
 } symbol_t;
 
-typedef void (*prim_proc_t)(struct am *am, struct store *store);
+typedef void (*prim_proc_t)(struct am *am);
 
 typedef enum {
 	ATOM_TYPE_EMPTY_LIST,
@@ -47,11 +46,11 @@ typedef struct expr {
 	};
 } expr_t;
 
-expr_t *expr_integer(struct store *store, int64_t value);
+expr_t *expr_integer(struct am *am, int64_t value);
-expr_t *expr_symbol(struct store *store, const symbol_t *symbol);
+expr_t *expr_symbol(struct am *am, const symbol_t *symbol);
-expr_t *expr_str_symbol(struct store *store, const char *str);
+expr_t *expr_str_symbol(struct am *am, const char *str);
-expr_t *expr_empty_list(struct store *store);
+expr_t *expr_empty_list(struct am *am);
-expr_t *expr_pair(struct store *store, expr_t *car, expr_t *cdr);
+expr_t *expr_pair(struct am *am, expr_t *car, expr_t *cdr);
-expr_t *expr_prim_proc(struct store *store, prim_proc_t prim_proc);
+expr_t *expr_prim_proc(struct am *am, prim_proc_t prim_proc);
 
 #endif

lib/include/parse.h

@@ -2,7 +2,6 @@
 #define PARSE_H
 
 #include "am.h"
-#include "store.h"
 #include "token.h"
 
 #define PARSE_MAX_DEPTH 128U
@@ -21,7 +20,7 @@ typedef struct {
 	parse_state_t *sp, stack[PARSE_MAX_DEPTH];
 } parse_ctx_t;
 
-void parse_init(am_t *am, store_t *store, parse_ctx_t *out);
+void parse_init(am_t *am, parse_ctx_t *out);
 parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token);
 
 #endif

lib/include/prim.h

@@ -3,8 +3,7 @@
 
 #include "am.h"
 #include "expr.h"
-#include "store.h"
 
-void prim_load(am_t *am, store_t *store);
+void prim_load(am_t *am);
 
 #endif

lib/include/store.h

@@ -10,7 +10,9 @@ typedef struct store {
 	expr_t buffer[STORE_SIZE];
 } store_t;
 
-void store_init(store_t *store);
+struct am;
-expr_t *store_alloc(store_t *store);
+
+void store_init(struct am *am);
+expr_t *store_alloc(struct am *am);
 
 #endif

lib/parse.c

@@ -3,10 +3,9 @@
 #include <assert.h>
 #include <string.h>
 
-void parse_init(am_t *am, store_t *store, parse_ctx_t *out)
+void parse_init(am_t *am, parse_ctx_t *out)
 {
 	out->am = am;
-	out->store = store;
 	out->state = PARSE_STATE_INIT;
 	out->sp = out->stack + PARSE_MAX_DEPTH - 1;
 }
@@ -32,7 +31,7 @@ static void append(parse_ctx_t *ctx, expr_t *expr)
 
 	list->is_atom = false;
 	list->pair.car = expr;
-	list->pair.cdr = expr_empty_list(ctx->store);
+	list->pair.cdr = expr_empty_list(ctx->am);
 }
 
 parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
@@ -41,16 +40,16 @@ parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
 	case PARSE_STATE_INIT:
 		switch (token->type) {
 		case TOKEN_TYPE_INTEGER:
-			ctx->am->expr = expr_integer(ctx->store, token->integer);
+			ctx->am->expr = expr_integer(ctx->am, token->integer);
 			ctx->state = PARSE_STATE_DONE;
 			break;
 		case TOKEN_TYPE_SYMBOL:
-			ctx->am->expr = expr_symbol(ctx->store, &token->symbol);
+			ctx->am->expr = expr_symbol(ctx->am, &token->symbol);
 			ctx->state = PARSE_STATE_DONE;
 			break;
 		case TOKEN_TYPE_OPEN_PAREN:
 			push_state(ctx, PARSE_STATE_DONE);
-			ctx->am->expr = expr_empty_list(ctx->store);
+			ctx->am->expr = expr_empty_list(ctx->am);
 			ctx->state = PARSE_STATE_LIST;
 			break;
 		case TOKEN_TYPE_CLOSE_PAREN:
@@ -62,15 +61,15 @@ parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
 	case PARSE_STATE_LIST:
 		switch (token->type) {
 		case TOKEN_TYPE_INTEGER:
-			append(ctx, expr_integer(ctx->store, token->integer));
+			append(ctx, expr_integer(ctx->am, token->integer));
 			break;
 		case TOKEN_TYPE_SYMBOL:
-			append(ctx, expr_symbol(ctx->store, &token->symbol));
+			append(ctx, expr_symbol(ctx->am, &token->symbol));
 			break;
 		case TOKEN_TYPE_OPEN_PAREN:
 			am_push(ctx->am);
 			push_state(ctx, PARSE_STATE_LIST);
-			ctx->am->expr = expr_empty_list(ctx->store);
+			ctx->am->expr = expr_empty_list(ctx->am);
 			ctx->state = PARSE_STATE_LIST;
 			break;
 		case TOKEN_TYPE_CLOSE_PAREN:

lib/prim.c

@@ -11,7 +11,7 @@ typedef struct {
 	prim_proc_t prim_proc;
 } prim_table_entry_t;
 
-static void add(am_t *am, store_t *store)
+static void add(am_t *am)
 {
 	assert(am->argl);
 
@@ -21,10 +21,10 @@ static void add(am_t *am, store_t *store)
 		assert(list->pair.car->atom.type == ATOM_TYPE_INTEGER);
 		total += list->pair.car->atom.integer;
 	}
-	am->val = expr_integer(store, total);
+	am->val = expr_integer(am, total);
 }
 
-static void mul(am_t *am, store_t *store)
+static void mul(am_t *am)
 {
 	assert(am->argl);
 
@@ -34,10 +34,10 @@ static void mul(am_t *am, store_t *store)
 		assert(list->pair.car->atom.type == ATOM_TYPE_INTEGER);
 		total *= list->pair.car->atom.integer;
 	}
-	am->val = expr_integer(store, total);
+	am->val = expr_integer(am, total);
 }
 
-static void sub(am_t *am, store_t *store)
+static void sub(am_t *am)
 {
 	assert(am->argl);
 	assert(!am->argl->is_atom);
@@ -55,7 +55,7 @@ static void sub(am_t *am, store_t *store)
 			total -= list->pair.car->atom.integer;
 		}
 	}
-	am->val = expr_integer(store, total);
+	am->val = expr_integer(am, total);
 }
 
 static const prim_table_entry_t prim_table[] = {
@@ -64,11 +64,11 @@ static const prim_table_entry_t prim_table[] = {
 	{ "-", sub },
 };
 
-void prim_load(am_t *am, store_t *store)
+void prim_load(am_t *am)
 {
 	for (unsigned i = 0; i < NELEMS(prim_table); ++i) {
-		am->expr = expr_str_symbol(store, prim_table[i].name);
+		am->expr = expr_str_symbol(am, prim_table[i].name);
-		am->val = expr_prim_proc(store, prim_table[i].prim_proc);
+		am->val = expr_prim_proc(am, prim_table[i].prim_proc);
-		env_set(am, store);
+		env_set(am);
 	}
 }

lib/store.c

@@ -1,14 +1,16 @@
 #include "store.h"
 
+#include "am.h"
+
 #include <string.h>
 
-void store_init(store_t *store)
+void store_init(am_t *am)
 {
-	memset(store, 0, sizeof(store_t));
+	memset(&am->store, 0, sizeof(store_t));
-	store->free = store->buffer;
+	am->store.free = am->store.buffer;
 }
 
-expr_t *store_alloc(store_t *store)
+expr_t *store_alloc(am_t *am)
 {
-	return store->free++;
+	return am->store.free++;
 }

tests/env_tests.c

@@ -4,13 +4,10 @@
 #include <string.h>
 
 static am_t am;
-static store_t store;
 
 void setUp(void)
 {
 	am_init(&am);
-	store_init(&store);
-	env_init(&am, &store);
 }
 
 void tearDown(void)
@@ -19,11 +16,11 @@ void tearDown(void)
 
 static void test_set_foo_to_42_then_fetch(void)
 {
-	am.expr = expr_str_symbol(&store, "foo");
+	am.expr = expr_str_symbol(&am, "foo");
-	am.val = expr_integer(&store, 42);
+	am.val = expr_integer(&am, 42);
-	env_set(&am, &store);
+	env_set(&am);
 
-	am.expr = expr_str_symbol(&store, "foo");
+	am.expr = expr_str_symbol(&am, "foo");
 	am.val = NULL;
 	env_fetch(&am);
 
@@ -35,13 +32,13 @@ static void test_set_foo_to_42_then_fetch(void)
 
 static void test_update_foo_from_123_to_456_then_fetch(void)
 {
-	am.expr = expr_str_symbol(&store, "foo");
+	am.expr = expr_str_symbol(&am, "foo");
-	am.val = expr_integer(&store, 123);
+	am.val = expr_integer(&am, 123);
-	env_set(&am, &store);
+	env_set(&am);
-	am.val = expr_integer(&store, 456);
+	am.val = expr_integer(&am, 456);
-	env_set(&am, &store);
+	env_set(&am);
 
-	am.expr = expr_str_symbol(&store, "foo");
+	am.expr = expr_str_symbol(&am, "foo");
 	am.val = NULL;
 	env_fetch(&am);
 

tests/eval_tests.c

@@ -1,23 +1,18 @@
 #include "am.h"
 #include "env.h"
 #include "eval.h"
-#include "store.h"
 #include "unity.h"
 
 static am_t am;
-static store_t store;
 
-void test_prim_proc(am_t *am, store_t *store)
+void test_prim_proc(am_t *am)
 {
 	(void)am;
-	(void)store;
 }
 
 void setUp(void)
 {
 	am_init(&am);
-	store_init(&store);
-	env_init(&am, &store);
 }
 
 void tearDown(void)
@@ -26,7 +21,7 @@ void tearDown(void)
 
 static void test_42_self_evals(void)
 {
-	am.expr = expr_integer(&store, 42);
+	am.expr = expr_integer(&am, 42);
 
 	eval(&am);
 
@@ -38,7 +33,7 @@ static void test_42_self_evals(void)
 
 static void test_empty_list_self_evals(void)
 {
-	am.expr = expr_empty_list(&store);
+	am.expr = expr_empty_list(&am);
 
 	eval(&am);
 
@@ -49,7 +44,7 @@ static void test_empty_list_self_evals(void)
 
 static void test_prim_proc_self_evals(void)
 {
-	am.expr = expr_prim_proc(&store, test_prim_proc);
+	am.expr = expr_prim_proc(&am, test_prim_proc);
 
 	eval(&am);
 
@@ -61,9 +56,9 @@ static void test_prim_proc_self_evals(void)
 
 static void test_foo_evals_to_42_when_set_in_env(void)
 {
-	am.expr = expr_str_symbol(&store, "foo");
+	am.expr = expr_str_symbol(&am, "foo");
-	am.val = expr_integer(&store, 42);
+	am.val = expr_integer(&am, 42);
-	env_set(&am, &store);
+	env_set(&am);
 	am.val = NULL;
 
 	eval(&am);

tests/expr_tests.c

@@ -1,19 +1,17 @@
 #include "am.h"
 #include "expr.h"
-#include "store.h"
 #include "unity.h"
 
-static store_t store;
+static am_t am;
 
-void test_prim_proc(am_t *am, store_t *store)
+void test_prim_proc(am_t *am)
 {
 	(void)am;
-	(void)store;
 }
 
 void setUp(void)
 {
-	store_init(&store);
+	am_init(&am);
 }
 
 void tearDown(void)
@@ -22,7 +20,7 @@ void tearDown(void)
 
 static void test_expr_integer_123(void)
 {
-	expr_t *expr = expr_integer(&store, 123);
+	expr_t *expr = expr_integer(&am, 123);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, expr->atom.type);
@@ -31,7 +29,7 @@ static void test_expr_integer_123(void)
 
 static void test_expr_integer_456(void)
 {
-	expr_t *expr = expr_integer(&store, 456);
+	expr_t *expr = expr_integer(&am, 456);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, expr->atom.type);
@@ -41,7 +39,7 @@ static void test_expr_integer_456(void)
 static void test_expr_symbol_foo(void)
 {
 	const symbol_t symbol = { .buf = "foo", .len = 3 };
-	expr_t *expr = expr_symbol(&store, &symbol);
+	expr_t *expr = expr_symbol(&am, &symbol);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
@@ -52,7 +50,7 @@ static void test_expr_symbol_foo(void)
 static void test_expr_symbol_quux(void)
 {
 	const symbol_t symbol = { .buf = "quux", .len = 4 };
-	expr_t *expr = expr_symbol(&store, &symbol);
+	expr_t *expr = expr_symbol(&am, &symbol);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
@@ -62,7 +60,7 @@ static void test_expr_symbol_quux(void)
 
 static void test_expr_str_symbol_foo(void)
 {
-	expr_t *expr = expr_str_symbol(&store, "foo");
+	expr_t *expr = expr_str_symbol(&am, "foo");
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
@@ -72,7 +70,7 @@ static void test_expr_str_symbol_foo(void)
 
 static void test_expr_str_symbol_quux(void)
 {
-	expr_t *expr = expr_str_symbol(&store, "quux");
+	expr_t *expr = expr_str_symbol(&am, "quux");
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
@@ -82,7 +80,7 @@ static void test_expr_str_symbol_quux(void)
 
 static void test_expr_empty_list(void)
 {
-	expr_t *expr = expr_empty_list(&store);
+	expr_t *expr = expr_empty_list(&am);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, expr->atom.type);
@@ -90,9 +88,9 @@ static void test_expr_empty_list(void)
 
 static void test_expr_pair(void)
 {
-	expr_t *car = expr_integer(&store, 123);
+	expr_t *car = expr_integer(&am, 123);
-	expr_t *cdr = expr_integer(&store, 456);
+	expr_t *cdr = expr_integer(&am, 456);
-	expr_t *expr = expr_pair(&store, car, cdr);
+	expr_t *expr = expr_pair(&am, car, cdr);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_FALSE(expr->is_atom);
 	TEST_ASSERT_EQUAL(car, expr->pair.car);
@@ -102,7 +100,7 @@ static void test_expr_pair(void)
 static void test_expr_prim_proc(void)
 {
 
-	expr_t *expr = expr_prim_proc(&store, test_prim_proc);
+	expr_t *expr = expr_prim_proc(&am, test_prim_proc);
 	TEST_ASSERT_NOT_NULL(expr);
 	TEST_ASSERT_TRUE(expr->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, expr->atom.type);

tests/parse_tests.c

@@ -1,7 +1,6 @@
 #include "parse.h"
 #include "unity.h"
 
-static store_t store;
 static am_t am;
 static parse_ctx_t ctx;
 
@@ -9,9 +8,8 @@ static parse_ctx_t ctx;
 
 void setUp(void)
 {
-	store_init(&store);
 	am_init(&am);
-	parse_init(&am, &store, &ctx);
+	parse_init(&am, &ctx);
 }
 
 void tearDown(void)

tests/prim_tests.c

@@ -3,13 +3,10 @@
 #include "unity.h"
 
 static am_t am;
-static store_t store;
 
 void setUp(void)
 {
 	am_init(&am);
-	store_init(&store);
-	env_init(&am, &store);
 }
 
 void tearDown(void)
@@ -18,14 +15,14 @@ void tearDown(void)
 
 static void test_add_empty_list_is_0(void)
 {
-	am.expr = expr_str_symbol(&store, "+");
+	am.expr = expr_str_symbol(&am, "+");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
-	am.argl = expr_empty_list(&store);
+	am.argl = expr_empty_list(&am);
-	am.val->atom.prim_proc(&am, &store);
+	am.val->atom.prim_proc(&am);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
@@ -35,19 +32,18 @@ static void test_add_empty_list_is_0(void)
 
 static void test_add_1_2_3_is_6(void)
 {
-	am.expr = expr_str_symbol(&store, "+");
+	am.expr = expr_str_symbol(&am, "+");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
 	am.argl = expr_pair(
-	    &store, expr_integer(&store, 1),
+	    &am, expr_integer(&am, 1),
 	    expr_pair(
-	        &store, expr_integer(&store, 2),
+	        &am, expr_integer(&am, 2),
-	        expr_pair(
+	        expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
-	            &store, expr_integer(&store, 3), expr_empty_list(&store))));
+	am.val->atom.prim_proc(&am);
-	am.val->atom.prim_proc(&am, &store);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
@@ -57,14 +53,14 @@ static void test_add_1_2_3_is_6(void)
 
 static void test_mul_empty_list_is_1(void)
 {
-	am.expr = expr_str_symbol(&store, "*");
+	am.expr = expr_str_symbol(&am, "*");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
-	am.argl = expr_empty_list(&store);
+	am.argl = expr_empty_list(&am);
-	am.val->atom.prim_proc(&am, &store);
+	am.val->atom.prim_proc(&am);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
@@ -74,19 +70,18 @@ static void test_mul_empty_list_is_1(void)
 
 static void test_mul_2_3_4_is_24(void)
 {
-	am.expr = expr_str_symbol(&store, "*");
+	am.expr = expr_str_symbol(&am, "*");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
 	am.argl = expr_pair(
-	    &store, expr_integer(&store, 2),
+	    &am, expr_integer(&am, 2),
 	    expr_pair(
-	        &store, expr_integer(&store, 3),
+	        &am, expr_integer(&am, 3),
-	        expr_pair(
+	        expr_pair(&am, expr_integer(&am, 4), expr_empty_list(&am))));
-	            &store, expr_integer(&store, 4), expr_empty_list(&store))));
+	am.val->atom.prim_proc(&am);
-	am.val->atom.prim_proc(&am, &store);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
@@ -96,15 +91,14 @@ static void test_mul_2_3_4_is_24(void)
 
 static void test_sub_1_is_minus_1(void)
 {
-	am.expr = expr_str_symbol(&store, "-");
+	am.expr = expr_str_symbol(&am, "-");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
-	am.argl = expr_pair(
+	am.argl = expr_pair(&am, expr_integer(&am, 1), expr_empty_list(&am));
-	    &store, expr_integer(&store, 1), expr_empty_list(&store));
+	am.val->atom.prim_proc(&am);
-	am.val->atom.prim_proc(&am, &store);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
@@ -114,19 +108,18 @@ static void test_sub_1_is_minus_1(void)
 
 static void test_sub_5_4_3_is_minus_2(void)
 {
-	am.expr = expr_str_symbol(&store, "-");
+	am.expr = expr_str_symbol(&am, "-");
 	env_fetch(&am);
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);
 	TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
 
 	am.argl = expr_pair(
-	    &store, expr_integer(&store, 5),
+	    &am, expr_integer(&am, 5),
 	    expr_pair(
-	        &store, expr_integer(&store, 4),
+	        &am, expr_integer(&am, 4),
-	        expr_pair(
+	        expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
-	            &store, expr_integer(&store, 3), expr_empty_list(&store))));
+	am.val->atom.prim_proc(&am);
-	am.val->atom.prim_proc(&am, &store);
 
 	TEST_ASSERT_NOT_NULL(am.val);
 	TEST_ASSERT_TRUE(am.val->is_atom);

tests/store_tests.c

@@ -1,11 +1,11 @@
-#include "store.h"
+#include "am.h"
 #include "unity.h"
 
-static store_t store;
+static am_t am;
 
 void setUp(void)
 {
-	store_init(&store);
+	am_init(&am);
 }
 
 void tearDown(void)
@@ -14,14 +14,14 @@ void tearDown(void)
 
 static void test_alloc_returns_non_null_after_init(void)
 {
-	const expr_t *const expr = store_alloc(&store);
+	const expr_t *const expr = store_alloc(&am);
 	TEST_ASSERT_NOT_NULL(expr);
 }
 
 static void test_two_calls_to_alloc_return_distinct(void)
 {
-	const expr_t *const a = store_alloc(&store);
+	const expr_t *const a = store_alloc(&am);
-	const expr_t *const b = store_alloc(&store);
+	const expr_t *const b = store_alloc(&am);
 	TEST_ASSERT_NOT_EQUAL(a, b);
 }