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

Consolidate expression creation functions in expr module

Browse Source
This commit is contained in:
Camden Dixie O'Brien
2025-08-10 13:27:20 +01:00
parent fade9395fa
commit 03bd0ff597
9 changed files with 189 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/CMakeLists.txt
View File

@@ -1,6 +1,7 @@
add_library(imp
am.c
env.c
expr.c
memory_stream.c
parse.c
store.c

13
lib/env.c
View File

@@ -49,9 +49,7 @@ static expr_t **lookup(am_t *am, bool *found)
void env_init(am_t *am, store_t *store)
{
am->env = store_alloc(store);
am->env->is_atom = true;
am->env->atom.type = ATOM_TYPE_EMPTY_LIST;
am->env = expr_empty_list(store);
}
void env_fetch(am_t *am)
@@ -69,12 +67,7 @@ void env_set(am_t *am, store_t *store)
*loc = am->val;
} else {
(*loc)->is_atom = false;
(*loc)->pair.cdr = store_alloc(store);
(*loc)->pair.cdr->is_atom = true;
(*loc)->pair.cdr->atom.type = ATOM_TYPE_EMPTY_LIST;
expr_t *entry = (*loc)->pair.car = store_alloc(store);
entry->pair.car = am->expr;
entry->pair.cdr = am->val;
(*loc)->pair.cdr = expr_empty_list(store);
(*loc)->pair.car = expr_pair(store, am->expr, am->val);
}
}

46
lib/expr.c Normal file
View File

@@ -0,0 +1,46 @@
#include "expr.h"
#include "store.h"
#include <string.h>
expr_t *expr_integer(store_t *store, int64_t value)
{
expr_t *expr = store_alloc(store);
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 = store_alloc(store);
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)
{
symbol_t symbol = { .len = strlen(str) };
memcpy(symbol.buf, str, symbol.len);
return expr_symbol(store, &symbol);
}
expr_t *expr_empty_list(store_t *store)
{
expr_t *expr = store_alloc(store);
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 = store_alloc(store);
expr->is_atom = false;
expr->pair.car = car;
expr->pair.cdr = cdr;
return expr;
}

8
lib/include/expr.h
View File

@@ -40,4 +40,12 @@ typedef struct expr {
};
} expr_t;
struct store;
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);
#endif

2
lib/include/store.h
View File

@@ -5,7 +5,7 @@
#define STORE_SIZE 256U
typedef struct {
typedef struct store {
expr_t *free;
expr_t buffer[STORE_SIZE];
} store_t;

55
lib/parse.c
View File

@@ -23,33 +23,16 @@ static parse_state_t pop_state(parse_ctx_t *ctx)
return *++ctx->sp;
}
static void load_integer(parse_ctx_t *ctx, expr_t **expr, int64_t integer)
static void append(parse_ctx_t *ctx, expr_t *expr)
{
*expr = store_alloc(ctx->store);
(*expr)->is_atom = true;
(*expr)->atom.type = ATOM_TYPE_INTEGER;
(*expr)->atom.integer = integer;
}
expr_t *list = ctx->am->expr;
while (!list->is_atom)
list = list->pair.cdr;
assert(list->atom.type == ATOM_TYPE_EMPTY_LIST);
static void
load_symbol(parse_ctx_t *ctx, expr_t **expr, const symbol_t *symbol)
{
*expr = store_alloc(ctx->store);
(*expr)->is_atom = true;
(*expr)->atom.type = ATOM_TYPE_SYMBOL;
memcpy(&(*expr)->atom.symbol, symbol, sizeof(symbol_t));
}
static expr_t **append(parse_ctx_t *ctx, expr_t *expr)
{
while (!expr->is_atom)
expr = expr->pair.cdr;
assert(expr->atom.type == ATOM_TYPE_EMPTY_LIST);
expr->is_atom = false;
expr->pair.cdr = store_alloc(ctx->store);
expr->pair.cdr->is_atom = true;
expr->pair.cdr->atom.type = ATOM_TYPE_EMPTY_LIST;
return &expr->pair.car;
list->is_atom = false;
list->pair.car = expr;
list->pair.cdr = expr_empty_list(ctx->store);
}
parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
@@ -58,18 +41,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:
load_integer(ctx, &ctx->am->expr, token->integer);
ctx->am->expr = expr_integer(ctx->store, token->integer);
ctx->state = PARSE_STATE_DONE;
break;
case TOKEN_TYPE_SYMBOL:
load_symbol(ctx, &ctx->am->expr, &token->symbol);
ctx->am->expr = expr_symbol(ctx->store, &token->symbol);
ctx->state = PARSE_STATE_DONE;
break;
case TOKEN_TYPE_OPEN_PAREN:
push_state(ctx, PARSE_STATE_DONE);
ctx->am->expr = store_alloc(ctx->store);
ctx->am->expr->is_atom = true;
ctx->am->expr->atom.type = ATOM_TYPE_EMPTY_LIST;
ctx->am->expr = expr_empty_list(ctx->store);
ctx->state = PARSE_STATE_LIST;
break;
case TOKEN_TYPE_CLOSE_PAREN:
@@ -80,21 +61,16 @@ parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
case PARSE_STATE_LIST:
switch (token->type) {
expr_t **end_car;
case TOKEN_TYPE_INTEGER:
end_car = append(ctx, ctx->am->expr);
load_integer(ctx, end_car, token->integer);
append(ctx, expr_integer(ctx->store, token->integer));
break;
case TOKEN_TYPE_SYMBOL:
end_car = append(ctx, ctx->am->expr);
load_symbol(ctx, end_car, &token->symbol);
append(ctx, expr_symbol(ctx->store, &token->symbol));
break;
case TOKEN_TYPE_OPEN_PAREN:
am_push(ctx->am);
push_state(ctx, PARSE_STATE_LIST);
ctx->am->expr = store_alloc(ctx->store);
ctx->am->expr->is_atom = true;
ctx->am->expr->atom.type = ATOM_TYPE_EMPTY_LIST;
ctx->am->expr = expr_empty_list(ctx->store);
ctx->state = PARSE_STATE_LIST;
break;
case TOKEN_TYPE_CLOSE_PAREN:
@@ -102,8 +78,7 @@ parse_state_t parse_proc(parse_ctx_t *ctx, const token_t *token)
if (ctx->state == PARSE_STATE_LIST) {
expr_t *expr = ctx->am->expr;
am_pop(ctx->am);
end_car = append(ctx, ctx->am->expr);
*end_car = expr;
append(ctx, expr);
}
break;
}

1
tests/CMakeLists.txt
View File

@@ -11,6 +11,7 @@ endfunction()
add_test_suites(
am_tests.c
env_tests.c
expr_tests.c
parse_tests.c
store_tests.c
token_tests.c

32
tests/env_tests.c
View File

@@ -6,24 +6,6 @@
static am_t am;
static store_t store;
static expr_t *integer(int64_t value)
{
expr_t *expr = store_alloc(&store);
expr->is_atom = true;
expr->atom.type = ATOM_TYPE_INTEGER;
expr->atom.integer = value;
return expr;
}
static expr_t *symbol(const char *s)
{
expr_t *expr = store_alloc(&store);
expr->is_atom = true;
expr->atom.type = ATOM_TYPE_SYMBOL;
memcpy(expr->atom.symbol.buf, s, strlen(s));
return expr;
}
void setUp(void)
{
am_init(&am);
@@ -37,11 +19,11 @@ void tearDown(void)
static void test_set_foo_to_42_then_fetch(void)
{
am.expr = symbol("foo");
am.val = integer(42);
am.expr = expr_str_symbol(&store, "foo");
am.val = expr_integer(&store, 42);
env_set(&am, &store);
am.expr = symbol("foo");
am.expr = expr_str_symbol(&store, "foo");
am.val = NULL;
env_fetch(&am);
@@ -53,13 +35,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 = symbol("foo");
am.val = integer(123);
am.expr = expr_str_symbol(&store, "foo");
am.val = expr_integer(&store, 123);
env_set(&am, &store);
am.val = integer(456);
am.val = expr_integer(&store, 456);
env_set(&am, &store);
am.expr = symbol("foo");
am.expr = expr_str_symbol(&store, "foo");
am.val = NULL;
env_fetch(&am);

107
tests/expr_tests.c Normal file
View File

@@ -0,0 +1,107 @@
#include "expr.h"
#include "store.h"
#include "unity.h"
static store_t store;
void setUp(void)
{
store_init(&store);
}
void tearDown(void)
{
}
static void test_expr_integer_123(void)
{
expr_t *expr = expr_integer(&store, 123);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, expr->atom.type);
TEST_ASSERT_EQUAL(123, expr->atom.integer);
}
static void test_expr_integer_456(void)
{
expr_t *expr = expr_integer(&store, 456);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, expr->atom.type);
TEST_ASSERT_EQUAL(456, expr->atom.integer);
}
static void test_expr_symbol_foo(void)
{
const symbol_t symbol = { .buf = "foo", .len = 3 };
expr_t *expr = expr_symbol(&store, &symbol);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
TEST_ASSERT_EQUAL(3, expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("foo", expr->atom.symbol.buf, 3);
}
static void test_expr_symbol_quux(void)
{
const symbol_t symbol = { .buf = "quux", .len = 4 };
expr_t *expr = expr_symbol(&store, &symbol);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
TEST_ASSERT_EQUAL(4, expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("quux", expr->atom.symbol.buf, 4);
}
static void test_expr_str_symbol_foo(void)
{
expr_t *expr = expr_str_symbol(&store, "foo");
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
TEST_ASSERT_EQUAL(3, expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("foo", expr->atom.symbol.buf, 3);
}
static void test_expr_str_symbol_quux(void)
{
expr_t *expr = expr_str_symbol(&store, "quux");
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, expr->atom.type);
TEST_ASSERT_EQUAL(4, expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("quux", expr->atom.symbol.buf, 4);
}
static void test_expr_empty_list(void)
{
expr_t *expr = expr_empty_list(&store);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_TRUE(expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, expr->atom.type);
}
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);
TEST_ASSERT_NOT_NULL(expr);
TEST_ASSERT_FALSE(expr->is_atom);
TEST_ASSERT_EQUAL(car, expr->pair.car);
TEST_ASSERT_EQUAL(cdr, expr->pair.cdr);
}
int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_expr_integer_123);
RUN_TEST(test_expr_integer_456);
RUN_TEST(test_expr_symbol_foo);
RUN_TEST(test_expr_symbol_quux);
RUN_TEST(test_expr_str_symbol_foo);
RUN_TEST(test_expr_str_symbol_quux);
RUN_TEST(test_expr_empty_list);
RUN_TEST(test_expr_pair);
return UNITY_END();
}