WIP: refactor api

builtins.c

@@ -1,26 +1,26 @@
 #include "lisp.h"
 
 #define func_arithmetic_ex(name, operator, operator_name)                      \
-    Node *name(Nodes *args, Scopes *scopes) {                                  \
+    int name(Nodes *args, Scopes *scopes, Node *result) {                      \
         UNUSED(scopes);                                                        \
         if (args->count != 2) {                                                \
             puts("'" operator_name "' expects two arguments!\n");              \
-            return NULL;                                                       \
+            return 1;                                                          \
         }                                                                      \
         if (args->items[0].kind != NODE_KIND_NUMBER ||                         \
             args->items[1].kind != NODE_KIND_NUMBER) {                         \
             puts("'" operator_name                                             \
                  "' only works on numbers, you specified something "           \
                  "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 b = args->items[1].as_number;                                \
-        node->as_number = a operator b;                                        \
-        return node;                                                           \
+        result->as_number = a operator b;                                      \
+        result->kind = NODE_KIND_NUMBER;                                       \
+        return 0;                                                              \
     }
+
 #define func_arithmetic(name, 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_gt_eq, >=);
 
-Node *lisp_function_println(Nodes *args, Scopes *scopes) {
+int lisp_function_println(Nodes *args, Scopes *scopes, Node *result) {
     if (args->count != 1) {
         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);
     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);
 
-    Node *node = malloc(sizeof(Node));
-    node->kind = NODE_KIND_LIST;
-    node->as_list = args;
-    return node;
+    result->kind = NODE_KIND_LIST;
+    result->as_list = args;
+    return 0;
 }
 
-Node *lisp_function_append(Nodes *args, Scopes *scopes) {
+int lisp_function_append(Nodes *args, Scopes *scopes, Node *result) {
     UNUSED(scopes);
 
     if (args->count != 2) {
         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 ||
         args->items[1].kind != NODE_KIND_LIST) {
         printf("'append' can only append two lists!\n");
-        return NULL;
+        return 1;
     }
 
     Nodes *nodes = malloc(sizeof(Nodes));
+    memset(nodes, 0, sizeof(Nodes));
 
     Nodes *a = args->items[0].as_list;
     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;
     nob_da_append_many(nodes, b->items, b->count);
 
-    node->as_list = nodes;
-    return node;
+    result->as_list = nodes;
+    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);
 
     if (args->count != 1) {
         printf("'length' expects one argument!\n");
-        return NULL;
+        return 1;
     }
 
     if (args->items[0].kind != NODE_KIND_LIST) {
         printf("'length' can only be used on lists!\n");
-        return NULL;
+        return 1;
     }
 
-    Node *node = malloc(sizeof(Node));
-    node->kind = NODE_KIND_NUMBER;
-    node->as_number = args->items[0].as_list->count;
-    return node;
+    result->kind = NODE_KIND_NUMBER;
+    result->as_number = args->items[0].as_list->count;
+    return 0;
 }
 
-Node *lisp_function_isnull(Nodes *args, Scopes *scopes) {
+int lisp_function_isnull(Nodes *args, Scopes *scopes, Node *result) {
     UNUSED(scopes);
 
     if (args->count != 1) {
         printf("'null?' expects one argument!\n");
-        return NULL;
+        return 1;
     }
 
     if (args->items[0].kind != NODE_KIND_LIST) {
         printf("'null?' can only be used on lists!\n");
-        return NULL;
+        return 1;
     }
 
-    Node *node = malloc(sizeof(Node));
-    node->kind = NODE_KIND_NUMBER;
-    node->as_number = args->items[0].as_list->count == 0 ? 1 : 0;
-    return node;
+    result->kind = NODE_KIND_NUMBER;
+    result->as_number = args->items[0].as_list->count == 0 ? 1 : 0;
+    return 0;
 }
 
-Node *lisp_function_builtins(Nodes *args, Scopes *scopes) {
+int lisp_function_builtins(Nodes *args, Scopes *scopes, Node *result) {
     if (args->count != 0) {
         printf("'builtins' expects no arguments!\n");
-        return NULL;
+        return 1;
     }
 
-    Node *node = malloc(sizeof(Node));
-    node->kind = NODE_KIND_LIST;
-
-    Scope global_scope = nob_da_first(scopes);
+    Scope *global_scope = nob_da_first(scopes);
     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);
     }
-    node->as_list = nodes;
-    return node;
+
+    result->as_list = nodes;
+    result->kind = NODE_KIND_LIST;
+    return 0;
 }