Project restructuring to support the new direction

example/asm/fib.scm

@@ -0,0 +1,34 @@
+  (variable result 0)
+  (ref result)
+  (push fib)
+  (call)
+  (push cleanup)
+  (jmp)
+fib
+  (dup)
+  (push 0)
+  (=)
+  (over)
+  (push 1)
+  (=)
+  (or)
+  (push recur)
+  (branch)
+  (return)
+recur
+  (dup)
+  (push 1)
+  (-)
+  (push fib)
+  (call)
+  (over)
+  (push 2)
+  (-)
+  (push fib)
+  (call)
+  (+)
+  (nip)
+  (return)
+cleanup
+  (set! result)
+  (bye)

example/asm/runtime.scm

@@ -0,0 +1,153 @@
+(push main)
+(jmp)
+
+;; Note that this is scheme syntax wrapping asm for a stack machine
+(variable eol 0)
+(variable scan 0)
+(variable free 0)
+;; These need to be initialized with the runtime
+(variable eom 0)
+(variable old 0) 
+(variable new 0)
+(variable root 0)
+
+alloc ;; ( -- p)
+;; Test if free will go beyond eom
+(ref free)
+(dup) ; ( -- free free)
+(push 8)
+(+)
+(dup) ; ( -- free free+8 free+8)
+(ref eom)
+(<) ; ( -- free free+8 (free+8 < eom))
+(push alloc-do-gc)
+(if)
+;; write free+8 to free
+(set! free)
+;; return the old free, it is memory the program can use
+(return)
+alloc-do-gc
+;; Empty the stack
+(drop)
+(drop)
+;; Run garbage collection
+(push gc-run)
+(call)
+;; Tail-call allocation
+(push alloc)
+(jmp)
+
+gc-run ;; ( -- )
+; Move scan & free to start of new memory
+(ref new)
+(dup)
+(set! free)
+(set! scan)
+(ref root)
+(push relocate-cons)
+(call)
+(push gc-loop)
+(call)
+; Flip old and new
+(ref old)
+(dup)
+(ref new)
+(set! old)
+(set! new)
+(push 512)
+(+)
+(set! eom)
+(return)
+
+relocate-cons ;; (o -- )
+(dup)
+(@)
+(push relocate-reg)
+(call)
+(push 4)
+(+)
+(@)
+(push relocate-reg)
+
+relocate-reg ;; (r -- )
+(dup)
+(push #x80000000) ;; Is this a cons?
+(and)
+(push reg-relocated)
+(if)
+(dup)
+(ref eol)
+(=) ;; Is this eol?
+(not)
+(push reg-relocated)
+(if)
+(dup)
+(push #x40000000) ;; Is it a broken heart?
+(and)
+(push copy-and-construct)
+(if)
+(dup) ;; Broken heart, copy updated address from cdr
+(push 4)
+(+)
+(@)   ;; Retrieve new address
+(dup)
+(!)   ;; Write it here
+(push reg-relocated)
+(jmp)
+copy-and-construct
+(dup) ;; Wasn't a broken heart, move car to new memory
+(@) 
+(push free)
+(!)
+(dup) ;; Push cdr to new memory
+(push 4)
+(+)
+(@)
+(push free)
+(push 4)
+(+)
+(!)
+(push #x40000000)
+(over)
+(!)
+(ref free)
+(over)
+(push 4)
+(+)
+(!)
+(ref free) ;; Move free pointer
+(push 8)
+(+)
+(set! free)
+reg-relocated
+(drop)
+(return)
+
+gc-loop
+(ref free)
+(ref scan)
+(<)
+(branch gc-loop-done)
+(ref scan)
+(push relocate-reg)
+(push gc-loop)
+(jmp)
+gc-loop-done
+(return)
+
+
+main
+;; These need to be initialized with the runtime
+(push memory)
+(dup)
+(set! new)
+(push 512)
+(+)
+(dup)
+(set! eom)
+(set! old)
+;; TODO set up root
+;; <<USER PROGRAM HERE >>
+(bye)
+
+memory

example/c/.gitignore

@@ -0,0 +1,3 @@
+*.o
+scheme
+scheme.exe

example/c/Makefile

@@ -0,0 +1,5 @@
+CFLAGS=-g
+
+all: scheme
+
+scheme: gc.o runtime.o

example/c/common.h

@@ -0,0 +1,27 @@
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#define SIZE 1024
+#define BROKEN_HEART 1
+#define CONS 2
+#define INTEGER 3
+#define SYMBOL 4
+#define BYE 5
+
+typedef struct box_t {
+  char type;
+  union {
+    int integer;
+    char* symbol;
+    struct cons_t* cons;
+  };
+} box_t;
+
+typedef struct cons_t {
+  box_t car;
+  box_t cdr;
+} cons_t;
+
+extern cons_t *the_empty_list;
+
+#endif // _COMMON_H_

example/c/gc.c

@@ -0,0 +1,64 @@
+// Cheney style stop and copy garbage collector
+#include "gc.h"
+
+cons_t *the_empty_list = NULL;
+
+static cons_t *old, *new, *scanptr, *freeptr, *eom, *root;
+size_t tos;
+
+void gc_init() {
+  old = calloc(sizeof(cons_t), SIZE);
+  freeptr = old;
+  eom = old + (SIZE / 2);
+  new = eom + 1;
+  root = alloc();
+}
+
+cons_t *alloc() {
+  if (freeptr < eom) {
+    cons_t *retval = freeptr;
+    freeptr++;
+    return retval;
+  } else {
+    gc_run();
+    return alloc();
+  }
+}
+
+void gc_run() {
+  freeptr = new;
+  scanptr = new;
+  // Relocate root
+  relocate(root);
+  // Enter the main GC loop
+  gc_loop();
+  // Flip old and new;
+  cons_t *temp = old;
+  old = new;
+  new = temp;
+}
+
+void gc_loop() {
+  while (scanptr < freeptr) {
+    relocate(scanptr);
+    scanptr++;
+  }
+}
+
+void move(box_t box) {
+  if (box.type == CONS && box.cons != the_empty_list) {
+    if (box.cons->car.type == BROKEN_HEART) {
+      box.cons = box.cons->cdr.cons;
+    } else {
+      memcpy(freeptr, box.cons, sizeof(cons_t));
+      box.cons->car.type = BROKEN_HEART;
+      box.cons->cdr.cons = freeptr;
+      freeptr++;
+    }
+  }
+}
+
+void relocate(cons_t* cons) {
+  move(cons->car);
+  move(cons->cdr);
+}

example/c/gc.h

@@ -0,0 +1,16 @@
+#ifndef _GC_H_
+#define _GC_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "common.h"
+
+void gc_init();
+cons_t *alloc();
+void gc_run();
+void gc_loop();
+void relocate(cons_t*);
+
+#endif // _GC_H_