cdo/imp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add store into abstract machine struct

Browse Source
This commit is contained in:
Camden Dixie O'Brien
2025-08-10 15:21:24 +01:00
parent b20a6749f7
commit d8e51b0aa0
18 changed files with 129 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
lib/am.c
View File

@@ -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)

12
lib/env.c
View File

@@ -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);
prim_load(am, store);
am->env = expr_empty_list(am);
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.car = expr_pair(store, am->expr, am->val);
(*loc)->pair.cdr = expr_empty_list(am);
(*loc)->pair.car = expr_pair(am, am->expr, am->val);
}
}

27
lib/expr.c
View File

@@ -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;

2
lib/include/am.h
View File

@@ -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);

5
lib/include/env.h
View File

@@ -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

15
lib/include/expr.h
View File

@@ -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_symbol(struct store *store, const symbol_t *symbol);
expr_t *expr_str_symbol(struct store *store, const char *str);
expr_t *expr_empty_list(struct store *store);
expr_t *expr_pair(struct store *store, expr_t *car, expr_t *cdr);
expr_t *expr_prim_proc(struct store *store, prim_proc_t prim_proc);
expr_t *expr_integer(struct am *am, int64_t value);
expr_t *expr_symbol(struct am *am, const symbol_t *symbol);
expr_t *expr_str_symbol(struct am *am, const char *str);
expr_t *expr_empty_list(struct am *am);
expr_t *expr_pair(struct am *am, expr_t *car, expr_t *cdr);
expr_t *expr_prim_proc(struct am *am, prim_proc_t prim_proc);
#endif

3
lib/include/parse.h
View File

@@ -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

3
lib/include/prim.h
View File

@@ -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

6
lib/include/store.h
View File

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

17
lib/parse.c
View File

@@ -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:

20
lib/prim.c
View File

@@ -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->val = expr_prim_proc(store, prim_table[i].prim_proc);
env_set(am, store);
am->expr = expr_str_symbol(am, prim_table[i].name);
am->val = expr_prim_proc(am, prim_table[i].prim_proc);
env_set(am);
}
}

12
lib/store.c
View File

@@ -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));
store->free = store->buffer;
memset(&am->store, 0, sizeof(store_t));
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++;
}

23
tests/env_tests.c
View File

@@ -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.val = expr_integer(&store, 42);
env_set(&am, &store);
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 42);
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.val = expr_integer(&store, 123);
env_set(&am, &store);
am.val = expr_integer(&store, 456);
env_set(&am, &store);
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 123);
env_set(&am);
am.val = expr_integer(&am, 456);
env_set(&am);
am.expr = expr_str_symbol(&store, "foo");
am.expr = expr_str_symbol(&am, "foo");
am.val = NULL;
env_fetch(&am);

19
tests/eval_tests.c
View File

@@ -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.val = expr_integer(&store, 42);
env_set(&am, &store);
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 42);
env_set(&am);
am.val = NULL;
eval(&am);

30
tests/expr_tests.c
View File

@@ -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 *cdr = expr_integer(&store, 456);
expr_t *expr = expr_pair(&store, car, cdr);
expr_t *car = expr_integer(&am, 123);
expr_t *cdr = expr_integer(&am, 456);
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);

4
tests/parse_tests.c
View File

@@ -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)

55
tests/prim_tests.c
View File

@@ -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.val->atom.prim_proc(&am, &store);
am.argl = expr_empty_list(&am);
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),
expr_pair(
&store, expr_integer(&store, 3), expr_empty_list(&store))));
am.val->atom.prim_proc(&am, &store);
&am, expr_integer(&am, 2),
expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
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.val->atom.prim_proc(&am, &store);
am.argl = expr_empty_list(&am);
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),
expr_pair(
&store, expr_integer(&store, 4), expr_empty_list(&store))));
am.val->atom.prim_proc(&am, &store);
&am, expr_integer(&am, 3),
expr_pair(&am, expr_integer(&am, 4), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
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(
&store, expr_integer(&store, 1), expr_empty_list(&store));
am.val->atom.prim_proc(&am, &store);
am.argl = expr_pair(&am, expr_integer(&am, 1), expr_empty_list(&am));
am.val->atom.prim_proc(&am);
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),
expr_pair(
&store, expr_integer(&store, 3), expr_empty_list(&store))));
am.val->atom.prim_proc(&am, &store);
&am, expr_integer(&am, 4),
expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);

12
tests/store_tests.c
View File

@@ -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 b = store_alloc(&store);
const expr_t *const a = store_alloc(&am);
const expr_t *const b = store_alloc(&am);
TEST_ASSERT_NOT_EQUAL(a, b);
}