Garbage collection now working.

README.md

@@ -15,14 +15,14 @@ A dumb lisp interpreter, made for practice.
   - [(lambda (arg-a arg-b ...) stmnt-a stmnt-b ...)](#lambda-arg-a-arg-b--stmnt-a-stmnt-b-)
   - [Arithmatic Operators (+, -, /, *)](#arithmatic-operators-----)
   - [Comparison Operators (=, <, >)](#comparison-operators---)
-- [TODO](#todo)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
 ## Features
 - A libreadline-based REPL
 - Create `lambda` functions with closures
 - Create macros
+- Garbage collection using the Boehm GC
 - It's dumb
 
 ## Built-in Functions
@@ -58,6 +58,3 @@ A dumb lisp interpreter, made for practice.
 ### Arithmatic Operators (+, -, /, *)
 
 ### Comparison Operators (=, <, >)
-
-## TODO
-- Garbage collection

src/builtins.c

@@ -4,6 +4,8 @@
 #include <assert.h>
 #include <string.h>
 
+#include "gc.h"
+
 /* HELPER FUNCTIONS */
 
 static int len(expr *list) {
@@ -416,7 +418,7 @@ expr *builtin_strcat(scope *scope, expr *arguments) {
   assert(a != NULL && a->type == STRING_EXPR);
   assert(b != NULL && b->type == STRING_EXPR);
 
-  char *newstring = malloc(strlen(a->string_value) + strlen(b->string_value) + 1);
+  char *newstring = GC_MALLOC_ATOMIC(strlen(a->string_value) + strlen(b->string_value) + 1);
   strcpy(newstring, a->string_value);
   strcat(newstring, b->string_value);
 
@@ -436,7 +438,7 @@ expr *builtin_substr(scope *scope, expr *arguments) {
   assert(start->int_value >= 0 && start->int_value <= strlen(string->string_value));
   assert(n->int_value >= 0 && start->int_value + n->int_value <= strlen(string->string_value));
 
-  char *newstring = malloc(n->int_value + 1);
+  char *newstring = GC_MALLOC_ATOMIC(n->int_value + 1);
   strncpy(newstring, string->string_value + start->int_value, n->int_value);
   newstring[n->int_value] = '\0';
 

src/expression.c

@@ -5,9 +5,10 @@
 #include "assert.h"
 #include "emitter.h"
 
+#include "gc.h"
+
 static inline expr *make_expr() {
-  expr *e = malloc(sizeof(expr));
-  memset(e, 0, sizeof(expr));
+  expr *e = GC_MALLOC(sizeof(expr));
   return e;
 }
 

src/lexer.c

@@ -5,6 +5,8 @@
 #include <ctype.h>
 #include "stringpool.h"
 
+#include "gc.h"
+
 void create_file_lexer(lexing_context *ctx, const char *filename) {
   ctx->filename = filename;
   ctx->lineno = 1;
@@ -54,12 +56,12 @@ static void advance_until_newline(lexing_context *ctx) {
 
 // Read a string literal, ending on a close-quote
 const char *read_string(lexing_context *ctx) {
-  char literal[MAX_LITERAL_SIZE];
+  char buffer[MAX_LITERAL_SIZE];
   int position = 0;
   while (true) {
     int c = get_char(ctx);
     if (c == '\"') {
-      literal[position] = '\0';
+      buffer[position] = '\0';
       break;
     }
 
@@ -81,10 +83,12 @@ const char *read_string(lexing_context *ctx) {
       }
     }
 
-    literal[position] = c;
+    buffer[position] = c;
     ++position;
   }
-  return strdup(literal);
+  char *literal = GC_MALLOC_ATOMIC(strlen(buffer) + 1);
+  strcpy(literal, buffer);
+  return literal;
 }
 
 bool is_validsymbolchar(char c) {
@@ -137,7 +141,7 @@ bool is_letter(char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
 bool is_alphanumeric(char c) { return is_letter(c) || is_digit(c); }
 
 void unget_token(lexing_context *ctx, token_t *token) {
-  token_t *new_token = malloc(sizeof(token_t));
+  token_t *new_token = GC_MALLOC(sizeof(token_t));
   memcpy(new_token, token, sizeof(token_t));
   new_token->next = ctx->stack;
   ctx->stack = new_token;
@@ -149,7 +153,7 @@ void get_next_token(lexing_context *ctx, token_t *token) {
     token_t *next_tok = ctx->stack;
     ctx->stack = next_tok->next;
     memcpy(token, next_tok, sizeof(token_t));
-    free(next_tok);
+    GC_FREE(next_tok);
     return;
   }
 

src/scope.c

@@ -3,6 +3,8 @@
 #include "stdlib.h"
 #include "string.h"
 
+#include "gc.h"
+
 struct expr *scope_lookup(struct scope *scope, const char *symbol) {
   for (struct scope *curr = scope; curr != NULL; curr = curr->parent) {
     struct expr *e = scope_probe(curr, symbol);
@@ -22,14 +24,14 @@ struct expr *scope_probe(struct scope *scope, const char *symbol) {
 }
 
 struct scope *scope_create(struct scope *parent) {
-  struct scope *scope = malloc(sizeof(struct scope));
+  struct scope *scope = GC_MALLOC(sizeof(struct scope));
   scope->parent = parent;
   scope->mappings = NULL;
   return scope;
 }
 
 void scope_add_mapping(struct scope *scope, const char *symbol, struct expr *value) {
-  struct mapping *m = malloc(sizeof(struct mapping));
+  struct mapping *m = GC_MALLOC(sizeof(struct mapping));
   m->symbol = symbol;
   m->value = value;