Insane refactoring.

Author: AaronJackson

.gitignore

@@ -0,0 +1,2 @@
+*.o
+./lisp

alloc.c

@@ -0,0 +1,63 @@
+#include <stdlib.h>
+
+#include "util.h"
+#include "obj.h"
+#include "machine.h"
+#include "alloc.h"
+
+
+obj_t * alloc_obj(type)
+     obj_type_t type;
+{
+  obj_t *o;
+
+  if (VM->alloc_offset == VM->semispace_size) gc();
+  if (VM->alloc_offset == VM->semispace_size) fuck("game over");
+
+  o = &VM->from_space[++VM->alloc_offset];
+  o->type = type;
+  return o;
+}
+
+obj_t *alloc_int(val)
+     int val;
+{
+  obj_t * x = alloc_obj(TINT);
+  x->value.i = val;
+  return x;
+}
+
+obj_t * alloc_string(s)
+     char * s;
+{
+  obj_t *x = alloc_obj(TSTRING);
+  x->value.str = s;
+  return x;
+}
+
+obj_t * alloc_cons(ca, cd)
+  obj_t *ca, *cd;
+{
+  obj_t *x = alloc_obj(TCONS);
+  CAR(x) = ca;
+  CDR(x) = cd;
+  return x;
+}
+
+obj_t *alloc_primitive(code)
+     primitive_t code;
+{
+  obj_t *x = alloc_obj(TPRIMITIVE);
+  x->value.prim.code = code;
+  return x;
+}
+
+obj_t *alloc_function(params, body, env)
+     obj_t *params, *body, *env;
+{
+  obj_t *x = alloc_obj(TFUNCTION);
+  x->value.fun.params = params;
+  x->value.fun.body = body;
+  x->value.fun.env = env;
+  return x;
+}

alloc.h

@@ -0,0 +1,7 @@
+
+obj_t *alloc_obj();
+obj_t *alloc_int();
+obj_t *alloc_string();
+obj_t *alloc_cons();
+obj_t *alloc_primitive();
+obj_t *alloc_function();

env.c

@@ -0,0 +1,57 @@
+#include <stdlib.h>
+#include <assert.h>
+
+#include "util.h"
+#include "obj.h"
+#include "alloc.h"
+#include "lisp.h"
+#include "symbol.h"
+#include "env.h"
+
+obj_t *lookup_env(env, sym)
+  obj_t *env, *sym;
+{
+  obj_t *entry;
+  assert(TSYMBOL == sym->type);
+  for (; nil != env; env = CDR(env)) {
+    entry = CAR(env);
+    assert(TCONS == entry->type);
+    if (sym == CAR(entry))
+      return entry;
+  }
+  return NULL;
+}
+
+obj_t *push_env(env, sym, val)
+  obj_t *env, *sym, *val;
+{
+  obj_t *entry = alloc_cons(sym, val);
+  return alloc_cons(entry, env);
+}
+
+/* syms: list of symbols
+   vals: list of evaluated values */
+obj_t *augment_env(env, syms, vals)
+  obj_t *env, *syms, *vals;
+{
+  obj_t *entry;
+  obj_t *aug_env = env;
+  if (list_length(syms) != list_length(vals)) fuck("fun/arg mismatch");
+  while (nil != syms) {
+    entry = alloc_cons(CAR(syms), CAR(vals));
+    aug_env = alloc_cons(entry, aug_env);
+    syms = CDR(syms);
+    vals = CDR(vals);
+  }
+  assert(nil == syms);
+  assert(nil == vals);
+  return aug_env;
+}
+
+obj_t *pop_env(env)
+     obj_t *env;
+{
+  /* memory leak */
+  if (nil == env) return nil;
+  return CDR(env);
+}

env.h

@@ -0,0 +1,4 @@
+obj_t *lookup_env();
+obj_t *push_env();
+obj_t *augment_env();
+obj_t *pop_env();