pondman/lisp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP: refactor api

Browse Source
This commit is contained in:
Tim Teichmann
2026-07-21 19:18:53 +02:00
parent 5b6c343ae3
commit 8ec82a66e0
4 changed files with 214 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
builtins.c
+42 -47
View File
@@ -1,26 +1,26 @@
#include "lisp.h" #include "lisp.h"
#define func_arithmetic_ex(name, operator, operator_name) \ #define func_arithmetic_ex(name, operator, operator_name) \
Node *name(Nodes *args, Scopes *scopes) { \ int name(Nodes *args, Scopes *scopes, Node *result) { \
UNUSED(scopes); \ UNUSED(scopes); \
if (args->count != 2) { \ if (args->count != 2) { \
puts("'" operator_name "' expects two arguments!\n"); \ puts("'" operator_name "' expects two arguments!\n"); \
return NULL; \ return 1; \
} \ } \
if (args->items[0].kind != NODE_KIND_NUMBER || \ if (args->items[0].kind != NODE_KIND_NUMBER || \
args->items[1].kind != NODE_KIND_NUMBER) { \ args->items[1].kind != NODE_KIND_NUMBER) { \
puts("'" operator_name \ puts("'" operator_name \
"' only works on numbers, you specified something " \ "' only works on numbers, you specified something " \
"else!\n"); \ "else!\n"); \
return NULL; \ return 1; \
} \ } \
Node *node = malloc(sizeof(Node)); \
node->kind = NODE_KIND_NUMBER; \
long long a = args->items[0].as_number; \ long long a = args->items[0].as_number; \
long long b = args->items[1].as_number; \ long long b = args->items[1].as_number; \
node->as_number = a operator b; \ result->as_number = a operator b; \
return node; \ result->kind = NODE_KIND_NUMBER; \
return 0; \
} }
#define func_arithmetic(name, operator) \ #define func_arithmetic(name, operator) \
func_arithmetic_ex(name, operator, #operator) func_arithmetic_ex(name, operator, #operator)
@@ -35,46 +35,43 @@ func_arithmetic(lisp_function_gt, >);
func_arithmetic(lisp_function_lt_eq, <=); func_arithmetic(lisp_function_lt_eq, <=);
func_arithmetic(lisp_function_gt_eq, >=); func_arithmetic(lisp_function_gt_eq, >=);
Node *lisp_function_println(Nodes *args, Scopes *scopes) { int lisp_function_println(Nodes *args, Scopes *scopes, Node *result) {
if (args->count != 1) { if (args->count != 1) {
printf("'+' expects one argument!\n"); printf("'+' expects one argument!\n");
return NULL; return 0;
} }
Node *result = eval(&args->items[0], scopes); eval_one(args->items[0], scopes, result);
node_print(*result); node_print(*result);
printf("\n"); printf("\n");
return result; return 1;
} }
Node *lisp_function_list(Nodes *args, Scopes *scopes) { int lisp_function_list(Nodes *args, Scopes *scopes, Node *result) {
UNUSED(scopes); UNUSED(scopes);
Node *node = malloc(sizeof(Node)); result->kind = NODE_KIND_LIST;
node->kind = NODE_KIND_LIST; result->as_list = args;
node->as_list = args; return 0;
return node;
} }
Node *lisp_function_append(Nodes *args, Scopes *scopes) { int lisp_function_append(Nodes *args, Scopes *scopes, Node *result) {
UNUSED(scopes); UNUSED(scopes);
if (args->count != 2) { if (args->count != 2) {
printf("'append' expects two arguments!\n"); printf("'append' expects two arguments!\n");
return NULL; return 1;
} }
Node *node = malloc(sizeof(Node));
node->kind = NODE_KIND_LIST;
if (args->items[0].kind != NODE_KIND_LIST || if (args->items[0].kind != NODE_KIND_LIST ||
args->items[1].kind != NODE_KIND_LIST) { args->items[1].kind != NODE_KIND_LIST) {
printf("'append' can only append two lists!\n"); printf("'append' can only append two lists!\n");
return NULL; return 1;
} }
Nodes *nodes = malloc(sizeof(Nodes)); Nodes *nodes = malloc(sizeof(Nodes));
memset(nodes, 0, sizeof(Nodes));
Nodes *a = args->items[0].as_list; Nodes *a = args->items[0].as_list;
nob_da_append_many(nodes, a->items, a->count); nob_da_append_many(nodes, a->items, a->count);
@@ -82,62 +79,60 @@ Node *lisp_function_append(Nodes *args, Scopes *scopes) {
Nodes *b = args->items[1].as_list; Nodes *b = args->items[1].as_list;
nob_da_append_many(nodes, b->items, b->count); nob_da_append_many(nodes, b->items, b->count);
node->as_list = nodes; result->as_list = nodes;
return node; result->kind = NODE_KIND_LIST;
return 0;
} }
Node *lisp_function_length(Nodes *args, Scopes *scopes) { int lisp_function_length(Nodes *args, Scopes *scopes, Node *result) {
UNUSED(scopes); UNUSED(scopes);
if (args->count != 1) { if (args->count != 1) {
printf("'length' expects one argument!\n"); printf("'length' expects one argument!\n");
return NULL; return 1;
} }
if (args->items[0].kind != NODE_KIND_LIST) { if (args->items[0].kind != NODE_KIND_LIST) {
printf("'length' can only be used on lists!\n"); printf("'length' can only be used on lists!\n");
return NULL; return 1;
} }
Node *node = malloc(sizeof(Node)); result->kind = NODE_KIND_NUMBER;
node->kind = NODE_KIND_NUMBER; result->as_number = args->items[0].as_list->count;
node->as_number = args->items[0].as_list->count; return 0;
return node;
} }
Node *lisp_function_isnull(Nodes *args, Scopes *scopes) { int lisp_function_isnull(Nodes *args, Scopes *scopes, Node *result) {
UNUSED(scopes); UNUSED(scopes);
if (args->count != 1) { if (args->count != 1) {
printf("'null?' expects one argument!\n"); printf("'null?' expects one argument!\n");
return NULL; return 1;
} }
if (args->items[0].kind != NODE_KIND_LIST) { if (args->items[0].kind != NODE_KIND_LIST) {
printf("'null?' can only be used on lists!\n"); printf("'null?' can only be used on lists!\n");
return NULL; return 1;
} }
Node *node = malloc(sizeof(Node)); result->kind = NODE_KIND_NUMBER;
node->kind = NODE_KIND_NUMBER; result->as_number = args->items[0].as_list->count == 0 ? 1 : 0;
node->as_number = args->items[0].as_list->count == 0 ? 1 : 0; return 0;
return node;
} }
Node *lisp_function_builtins(Nodes *args, Scopes *scopes) { int lisp_function_builtins(Nodes *args, Scopes *scopes, Node *result) {
if (args->count != 0) { if (args->count != 0) {
printf("'builtins' expects no arguments!\n"); printf("'builtins' expects no arguments!\n");
return NULL; return 1;
} }
Node *node = malloc(sizeof(Node)); Scope *global_scope = nob_da_first(scopes);
node->kind = NODE_KIND_LIST;
Scope global_scope = nob_da_first(scopes);
Nodes *nodes = malloc(sizeof(Node)); Nodes *nodes = malloc(sizeof(Node));
nob_da_foreach(ScopeObject, scope_object, &global_scope) { nob_da_foreach(ScopeObject, scope_object, global_scope) {
nob_da_append(nodes, scope_object->node); nob_da_append(nodes, scope_object->node);
} }
node->as_list = nodes;
return node; result->as_list = nodes;
result->kind = NODE_KIND_LIST;
return 0;
} }
lisp.c
+133 -57
View File
@@ -2,17 +2,18 @@
static Scope globalScope = {0}; static Scope globalScope = {0};
static Node *scope_lookup(Scopes *scopes, Nob_String_View name) { static int scope_lookup(Scopes *scopes, Nob_String_View name, Node *result) {
nob_da_foreach(Scope, scope, scopes) { nob_da_foreach(Scope *, scope, scopes) {
nob_da_foreach(ScopeObject, scopeObject, scope) { nob_da_foreach(ScopeObject, scopeObject, *scope) {
if (nob_sv_eq(name, scopeObject->name)) { if (nob_sv_eq(name, scopeObject->name)) {
return &scopeObject->node; *result = scopeObject->node;
return 0;
} }
} }
} }
printf("Undefined symbol: '" SV_Fmt "'!\n", SV_Arg(name)); printf("Undefined symbol: '" SV_Fmt "'!\n", SV_Arg(name));
return NULL; return 1;
} }
static void scope_add_function(Scope *scope, const char *name, static void scope_add_function(Scope *scope, const char *name,
@@ -57,7 +58,7 @@ void build_scopes(Scopes *scopes) {
scope_add_function(&globalScope, "builtins", lisp_function_builtins); scope_add_function(&globalScope, "builtins", lisp_function_builtins);
// clang-format on // clang-format on
nob_da_append(scopes, globalScope); nob_da_append(scopes, &globalScope);
} }
const char *token_kind_name(TokenKind kind) { const char *token_kind_name(TokenKind kind) {
@@ -157,51 +158,47 @@ void tokenize(Nob_String_View content, Tokens *tokens) {
} }
} }
Node *parse(Tokens *tokens) { int parse_one(Tokens *tokens, Node *node) {
if (tokens->count == 0) { if (tokens == NULL || node == NULL || tokens->count == 0) {
printf("unexpected end of input"); printf("unexpected end of input");
return NULL; return 1;
} }
Token tok = tokens->items[0]; Token tok = tokens->items[0];
tokens->items++; tokens->items++;
tokens->count--; tokens->count--;
Node *node = malloc(sizeof(Node)); switch (tok.kind) {
if (tok.kind == TOKEN_KIND_PAR_LEFT) { case TOKEN_KIND_PAR_LEFT: {
Nodes *nodes = malloc(sizeof(Nodes)); Nodes *nodes = malloc(sizeof(Nodes));
memset(nodes, 0, sizeof(Nodes)); memset(nodes, 0, sizeof(Nodes));
while (true) { while (true) {
if (tokens->count == 0) { if (tokens->count == 0) {
printf("expected closing ')'"); printf("expected closing ')'");
return NULL; return 1;
} }
if (tokens->items[0].kind == TOKEN_KIND_PAR_RIGHT) { if (tokens->items[0].kind == TOKEN_KIND_PAR_RIGHT) {
tokens->items++; tokens->items++;
tokens->count--; tokens->count--;
if (tokens->count > 0) {
}
break; break;
} }
Node *node = parse(tokens); parse_one(tokens, node);
if (node == NULL)
return NULL;
nob_da_append(nodes, *node); nob_da_append(nodes, *node);
} }
node->kind = NODE_KIND_LIST; node->kind = NODE_KIND_LIST;
node->as_list = nodes; node->as_list = nodes;
return node; } break;
} case TOKEN_KIND_PAR_RIGHT: {
if (tok.kind == TOKEN_KIND_PAR_RIGHT) {
printf("unexpected ')'"); printf("unexpected ')'");
return NULL; return 1;
} }
switch (tok.kind) {
case TOKEN_KIND_NUMBER: { case TOKEN_KIND_NUMBER: {
long long num = strtoll(tok.data.data, NULL, 10); long long num = strtoll(tok.data.data, NULL, 10);
// TODO: // TODO:
@@ -219,56 +216,135 @@ Node *parse(Tokens *tokens) {
UNREACHABLE(""); UNREACHABLE("");
} break; } break;
} }
return node; return 0;
} }
Node *eval(Node *node, Scopes *scopes) { void parse(Tokens *tokens, Nodes *nodes) {
if (node == NULL || scopes == NULL) if (nodes == NULL)
return NULL; return;
switch (node->kind) { for (size_t i = 0; i < tokens->count; i++) {
if (tokens->items[i].kind == TOKEN_KIND_PAR_LEFT) {
size_t sub_size = tokens->count - i;
Tokens toks = {.count = sub_size,
.capacity = sub_size,
.items = tokens->items + i};
Node result = {0};
parse_one(&toks, &result);
nob_da_append(nodes, result);
}
}
}
int eval_one(Node input, Scopes *scopes, Node *result) {
if (scopes == NULL || result == NULL)
return 1;
switch (input.kind) {
case NODE_KIND_NUMBER: case NODE_KIND_NUMBER:
return node; *result = input;
return 0;
case NODE_KIND_SYMBOL: { case NODE_KIND_SYMBOL: {
return scope_lookup(scopes, node->as_symbol); return scope_lookup(scopes, input.as_symbol, result);
} }
case NODE_KIND_LIST: { case NODE_KIND_LIST: {
Nodes *children = node->as_list; Nodes *children = input.as_list;
if (children->count == 0) if (children->count == 0) {
return node; *result = input;
return 0;
}
Node *head = &children->items[0]; Node head = children->items[0];
if (head->kind != NODE_KIND_SYMBOL) if (head.kind != NODE_KIND_SYMBOL) {
return node; *result = input;
return 0;
}
if (nob_sv_eq(head.as_symbol,
(Nob_String_View){.count = 2, .data = "if"})) {
if (children->count != 3 + 1) {
printf("'if' expects three arguments!\n");
return 1;
}
Node condition = {0};
eval_one(children->items[0 + 1], scopes, &condition);
if (node_is_true(condition)) {
eval_one(children->items[1 + 1], scopes, result);
} else {
eval_one(children->items[2 + 1], scopes, result);
}
return 0;
}
if (nob_sv_eq(head.as_symbol,
(Nob_String_View){.count = 6, .data = "define"})) {
if (children->count != 2 + 1) {
printf("'define' expects two arguments!\n");
return 1;
}
Node name_node = children->items[0 + 1];
if (name_node.kind != NODE_KIND_SYMBOL) {
printf("First argument of 'define' must be a symbol!\n");
return 1;
}
Node value = {0};
eval_one(children->items[1 + 1], scopes, &value);
nob_da_foreach(ScopeObject, scope_object, &globalScope) {
if (nob_sv_eq(scope_object->name, name_node.as_symbol)) {
scope_object->node = value;
result = &children->items[0 + 1];
return 0;
}
}
ScopeObject obj =
(ScopeObject){.name = name_node.as_symbol, .node = value};
nob_da_append(&globalScope, obj);
result = &children->items[0 + 1];
return 0;
}
Nodes *args = malloc(sizeof(Nodes)); Nodes *args = malloc(sizeof(Nodes));
for (size_t i = 1; i < children->count; i++) { for (size_t i = 1; i < children->count; i++) {
nob_da_append(args, *eval(&children->items[i], scopes)); Node n = {0};
eval_one(children->items[i], scopes, &n);
nob_da_append(args, n);
} }
if (nob_sv_eq(head->as_symbol, Node func_node = {0};
(Nob_String_View){.count = 2, .data = "if"})) { int ret = eval_one(head, scopes, &func_node);
if (args->count != 3) { if (ret != 0) {
printf("'if' expects three arguments!\n"); return ret;
return NULL;
}
Node *condition = eval(&args->items[0], scopes);
return node_is_true(*condition) ? eval(&args->items[1], scopes)
: eval(&args->items[2], scopes);
} else {
Node *func_node = eval(head, scopes);
if (func_node->kind == NODE_KIND_FUNCTION) {
return func_node->as_function.apply(args, scopes);
}
printf("Not a function: '");
node_print(*func_node);
printf("'\n");
return NULL;
} }
if (func_node.kind == NODE_KIND_FUNCTION) {
func_node.as_function.apply(args, scopes, result);
return 0;
}
printf("Not a function: '");
node_print(func_node);
printf("'\n");
return 1;
} }
default: default:
UNREACHABLE(""); UNREACHABLE("");
} }
return NULL; return 0;
}
int eval(Nodes *inputs, Scopes *scopes, Nodes *results) {
nob_da_foreach(Node, input, inputs) {
Node result = {0};
int ret = 0;
if ((ret = eval_one(*input, scopes, &result)) != 0) {
return ret;
}
nob_da_append(results, result);
}
return 0;
} }
lisp.h
+24 -20
View File
@@ -32,7 +32,7 @@ typedef struct s_Node Node;
typedef struct s_Nodes Nodes; typedef struct s_Nodes Nodes;
typedef struct s_Scopes Scopes; typedef struct s_Scopes Scopes;
typedef Node *(*LispFunction)(Nodes *args, Scopes *scopes); typedef int (*LispFunction)(Nodes *args, Scopes *scopes, Node *result);
struct s_Node { struct s_Node {
NodeKind kind; NodeKind kind;
@@ -66,7 +66,7 @@ typedef struct s_Scope {
} Scope; } Scope;
struct s_Scopes { struct s_Scopes {
Scope *items; Scope **items;
size_t count; size_t count;
size_t capacity; size_t capacity;
}; };
@@ -76,27 +76,31 @@ void node_print(Node node);
void build_scopes(Scopes *scopes); void build_scopes(Scopes *scopes);
void tokenize(Nob_String_View content, Tokens *tokens); void tokenize(Nob_String_View content, Tokens *tokens);
Node *parse(Tokens *tokens);
Node *eval(Node *node, Scopes *scopes); int parse_one(Tokens *tokens, Node *node);
void parse(Tokens *tokens, Nodes *nodes);
int eval_one(Node input, Scopes *scopes, Node *result);
int eval(Nodes *inputs, Scopes *scopes, Nodes *results);
// builtins // builtins
Node *lisp_function_add(Nodes *args, Scopes *scopes); int lisp_function_add(Nodes *args, Scopes *scopes, Node *result);
Node *lisp_function_sub(Nodes *args, Scopes *scopes); int lisp_function_sub(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_div(Nodes *args, Scopes *scopes); int lisp_function_div(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_mul(Nodes *args, Scopes *scopes); int lisp_function_mul(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_mod(Nodes *args, Scopes *scopes); int lisp_function_mod(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_eq(Nodes *args, Scopes *scopes); int lisp_function_eq(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_lt(Nodes *args, Scopes *scopes); int lisp_function_lt(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_gt(Nodes *args, Scopes *scopes); int lisp_function_gt(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_lt_eq(Nodes *args, Scopes *scopes); int lisp_function_lt_eq(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_gt_eq(Nodes *args, Scopes *scopes); int lisp_function_gt_eq(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_println(Nodes *args, Scopes *scopes); int lisp_function_println(Nodes *args, Scopes *scopes, Node *result);
Node *lisp_function_list(Nodes *args, Scopes *scopes); int lisp_function_list(Nodes *args, Scopes *scopes, Node *result);
Node *lisp_function_append(Nodes *args, Scopes *scopes); int lisp_function_append(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_length(Nodes *args, Scopes *scopes); int lisp_function_length(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_isnull(Nodes *args, Scopes *scopes); int lisp_function_isnull(Nodes *args, Scopes *scope, Node *result);
Node *lisp_function_builtins(Nodes *args, Scopes *scopes); int lisp_function_builtins(Nodes *args, Scopes *scopes, Node *result);
#endif // LISP_H #endif // LISP_H
main.c
+15 -7
View File
@@ -40,14 +40,22 @@ int main(int argc, char **argv) {
Scopes scopes = {0}; Scopes scopes = {0};
build_scopes(&scopes); build_scopes(&scopes);
Node *result = parse(&tokens); Nodes result = {0};
if (result == NULL) parse(&tokens, &result);
return 1;
result = eval(result, &scopes); #if 0
printf("= "); nob_da_foreach(Node, node, &result) {
node_print(*result); node_print(*node);
printf("\n"); printf("\n");
}
#endif
Nodes evaluated = {0};
int ret = eval(&result, &scopes, &evaluated);
nob_da_foreach(Node, node, &evaluated) {
node_print(*node);
printf("\n");
}
return 0; return 0;
} }