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

more refactoring and error checking

Browse Source
This commit is contained in:
Tim Teichmann
2026-07-21 20:45:06 +02:00
parent 09b552ed8c
commit 3f04adcd6b
3 changed files with 75 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
builtins.c
+42 -30
View File
@@ -1,21 +1,21 @@
#include "lisp.h" #include "lisp.h"
#define func_arithmetic_ex(name, operator, operator_name) \ #define func_arithmetic_ex(name, operator, operator_name) \
int name(Nodes *args, Scopes *scopes, Node *result) { \ 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 1; \ 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 1; \ return 1; \
} \ } \
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; \
result->as_number = a operator b; \ result->as_number = a operator b; \
result->kind = NODE_KIND_NUMBER; \ result->kind = NODE_KIND_NUMBER; \
return 0; \ return 0; \
@@ -35,48 +35,60 @@ 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, >=);
int lisp_function_println(Nodes *args, Scopes *scopes, Node *result) { 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 1; return 1;
} }
eval_one(args->items[0], scopes, result); eval_one(args.items[0], scopes, result);
node_print(*result); node_print(*result);
printf("\n"); printf("\n");
return 0; return 0;
} }
int lisp_function_list(Nodes *args, Scopes *scopes, Node *result) { int lisp_function_list(Nodes args, Scopes *scopes, Node *result) {
UNUSED(scopes); UNUSED(scopes);
Nodes *nodes = malloc(sizeof(Nodes));
if (nodes == NULL) {
printf("Failed to allocate memory, something is very wrong!\n");
return 1;
}
memcpy(nodes, &args, sizeof(Nodes));
result->kind = NODE_KIND_LIST; result->kind = NODE_KIND_LIST;
result->as_list = args; result->as_list = nodes;
return 0; return 0;
} }
int lisp_function_append(Nodes *args, Scopes *scopes, Node *result) { 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 1; return 1;
} }
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 1; return 1;
} }
Nodes *nodes = malloc(sizeof(Nodes)); Nodes *nodes = malloc(sizeof(Nodes));
if (nodes == NULL) {
printf("Failed to allocate memory, something is very wrong!\n");
return 1;
}
memset(nodes, 0, 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);
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);
result->as_list = nodes; result->as_list = nodes;
@@ -84,55 +96,55 @@ int lisp_function_append(Nodes *args, Scopes *scopes, Node *result) {
return 0; return 0;
} }
int lisp_function_length(Nodes *args, Scopes *scopes, Node *result) { 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 1; 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 1; return 1;
} }
result->kind = NODE_KIND_NUMBER; result->kind = NODE_KIND_NUMBER;
result->as_number = args->items[0].as_list->count; result->as_number = args.items[0].as_list->count;
return 0; return 0;
} }
int lisp_function_isnull(Nodes *args, Scopes *scopes, Node *result) { 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 1; 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 1; return 1;
} }
result->kind = NODE_KIND_NUMBER; result->kind = NODE_KIND_NUMBER;
result->as_number = args->items[0].as_list->count == 0 ? 1 : 0; result->as_number = args.items[0].as_list->count == 0 ? 1 : 0;
return 0; return 0;
} }
int lisp_function_builtins(Nodes *args, Scopes *scopes, Node *result) { 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 1; return 1;
} }
Scope *global_scope = nob_da_first(scopes); Scope *global_scope = nob_da_first(scopes);
Nodes *nodes = malloc(sizeof(Node)); Nodes nodes = {0};
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);
} }
result->as_list = nodes; *result->as_list = nodes;
result->kind = NODE_KIND_LIST; result->kind = NODE_KIND_LIST;
return 0; return 0;
} }
lisp.c
+14 -10
View File
@@ -164,6 +164,8 @@ int parse_one(Tokens *tokens, Node *node) {
return 1; return 1;
} }
// equivalent to queue.poll
// TODO: implement a 'da_poll' macro
Token tok = tokens->items[0]; Token tok = tokens->items[0];
tokens->items++; tokens->items++;
tokens->count--; tokens->count--;
@@ -171,6 +173,10 @@ int parse_one(Tokens *tokens, Node *node) {
switch (tok.kind) { switch (tok.kind) {
case TOKEN_KIND_PAR_LEFT: { case TOKEN_KIND_PAR_LEFT: {
Nodes *nodes = malloc(sizeof(Nodes)); Nodes *nodes = malloc(sizeof(Nodes));
if (nodes == NULL) {
printf("Failed to allocate memory, something is very wrong!\n");
return 1;
}
memset(nodes, 0, sizeof(Nodes)); memset(nodes, 0, sizeof(Nodes));
while (true) { while (true) {
@@ -182,13 +188,13 @@ int parse_one(Tokens *tokens, Node *node) {
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;
} }
parse_one(tokens, node); int ret = parse_one(tokens, node);
if (ret != 0)
return ret;
nob_da_append(nodes, *node); nob_da_append(nodes, *node);
} }
@@ -213,6 +219,8 @@ int parse_one(Tokens *tokens, Node *node) {
node->as_symbol = tok.data; node->as_symbol = tok.data;
} break; } break;
default: { default: {
// unknown token kind, therefore an error
// should I use UNREACHABLE instead?
return 1; return 1;
} }
} }
@@ -242,10 +250,6 @@ int parse(Tokens *tokens, Nodes *nodes) {
Tokens toks = {.count = sub_size, Tokens toks = {.count = sub_size,
.capacity = sub_size, .capacity = sub_size,
.items = tokens->items + last_idx}; .items = tokens->items + last_idx};
printf("Parsing:\n");
nob_da_foreach(Token, token, &toks) {
printf(" %s\n", token_kind_name(token->kind));
}
Node result = {0}; Node result = {0};
int ret = parse_one(&toks, &result); int ret = parse_one(&toks, &result);
@@ -336,14 +340,14 @@ int eval_one(Node input, Scopes *scopes, Node *result) {
return 0; return 0;
} }
Nodes *args = malloc(sizeof(Nodes)); Nodes args = {0};
for (size_t i = 1; i < children->count; i++) { for (size_t i = 1; i < children->count; i++) {
Node n = {0}; Node n = {0};
int ret = eval_one(children->items[i], scopes, &n); int ret = eval_one(children->items[i], scopes, &n);
if (ret != 0) { if (ret != 0) {
return ret; return ret;
} }
nob_da_append(args, n); nob_da_append(&args, n);
} }
Node func_node = {0}; Node func_node = {0};
lisp.h
+19 -17
View File
@@ -32,7 +32,9 @@ 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 int (*LispFunction)(Nodes *args, Scopes *scopes, Node *result); // args is specifically not a pointer,
// functions shouldn't be able to mess with their arguments
typedef int (*LispFunction)(Nodes args, Scopes *scopes, Node *result);
struct s_Node { struct s_Node {
NodeKind kind; NodeKind kind;
@@ -84,23 +86,23 @@ int eval_one(Node input, Scopes *scopes, Node *result);
int eval(Nodes inputs, Scopes *scopes, Nodes *results); int eval(Nodes inputs, Scopes *scopes, Nodes *results);
// builtins // builtins
int lisp_function_add(Nodes *args, Scopes *scopes, Node *result); int lisp_function_add(Nodes args, Scopes *scopes, Node *result);
int lisp_function_sub(Nodes *args, Scopes *scope, Node *result); int lisp_function_sub(Nodes args, Scopes *scope, Node *result);
int lisp_function_div(Nodes *args, Scopes *scope, Node *result); int lisp_function_div(Nodes args, Scopes *scope, Node *result);
int lisp_function_mul(Nodes *args, Scopes *scope, Node *result); int lisp_function_mul(Nodes args, Scopes *scope, Node *result);
int lisp_function_mod(Nodes *args, Scopes *scope, Node *result); int lisp_function_mod(Nodes args, Scopes *scope, Node *result);
int lisp_function_eq(Nodes *args, Scopes *scope, Node *result); int lisp_function_eq(Nodes args, Scopes *scope, Node *result);
int lisp_function_lt(Nodes *args, Scopes *scope, Node *result); int lisp_function_lt(Nodes args, Scopes *scope, Node *result);
int lisp_function_gt(Nodes *args, Scopes *scope, Node *result); int lisp_function_gt(Nodes args, Scopes *scope, Node *result);
int lisp_function_lt_eq(Nodes *args, Scopes *scope, Node *result); int lisp_function_lt_eq(Nodes args, Scopes *scope, Node *result);
int lisp_function_gt_eq(Nodes *args, Scopes *scope, Node *result); int lisp_function_gt_eq(Nodes args, Scopes *scope, Node *result);
int lisp_function_println(Nodes *args, Scopes *scopes, Node *result); int lisp_function_println(Nodes args, Scopes *scopes, Node *result);
int lisp_function_list(Nodes *args, Scopes *scopes, Node *result); int lisp_function_list(Nodes args, Scopes *scopes, Node *result);
int lisp_function_append(Nodes *args, Scopes *scope, Node *result); int lisp_function_append(Nodes args, Scopes *scope, Node *result);
int lisp_function_length(Nodes *args, Scopes *scope, Node *result); int lisp_function_length(Nodes args, Scopes *scope, Node *result);
int lisp_function_isnull(Nodes *args, Scopes *scope, Node *result); int lisp_function_isnull(Nodes args, Scopes *scope, Node *result);
int lisp_function_builtins(Nodes *args, Scopes *scopes, Node *result); int lisp_function_builtins(Nodes args, Scopes *scopes, Node *result);
#endif // LISP_H #endif // LISP_H