fixed a lot of crap

Makefile

@@ -21,8 +21,8 @@ lib: tokenize.c closures.c tokenize.h RTS.h
 	$(CC) -shared -o closures.so closures.o;
 
 debug:
-	$(CC) -g -Wall -Wextra -pedantic -Wpointer-arith -Wmissing-prototypes -Werror -std=c99 -O3 ./tokenize.c -lmaa;
+	$(CC) -g -Wall -Wextra -pedantic -Wpointer-arith -Wmissing-prototypes -std=c99 -O3 ./tokenize.c -lmaa;
-	$(CC) -g -Wall -Wextra -pedantic -Wpointer-arith -Wmissing-prototypes -Werror -std=c99 -O3 ./closures.c;
+	$(CC) -g -Wall -Wextra -pedantic -Wpointer-arith -Wmissing-prototypes -std=c99 -O3 ./closures.c;
 
 debuglib: tokenize.c closures.c tokenize.h RTS.h
 	$(CC) -g -c -fpic -Wall -Wextra -pedantic -Wpointer-arith -Wmissing-prototypes -Werror -std=c99 ./tokenize.c;

RTS.h

@@ -57,10 +57,10 @@ typedef
   }
   cell;
 
-svalue_t *
+svalue_t
 box_value(svalue_variants_t, stype_t);
 
-closure_t
+closure_t*
 make_closure(svalue_t *(*func)(svalue_t*, svalue_t**),
                                      svalue_t**);
 
@@ -82,4 +82,4 @@ box_string(char *,
            size_t);
 
 inline svalue_t *
-box_closure(closure_t);
+box_closure(closure_t*);

closures.c

@@ -13,36 +13,30 @@ make_doubleadder_inner(svalue_t *, svalue_t **);
 static svalue_t*
 make_doubleadder(svalue_t *, svalue_t **);
 
-static svalue_t*
+inline svalue_t
-make_adder_inner(svalue_t*, svalue_t **);
-
-static closure_t
-make_adder(svalue_t *);
-
-inline svalue_t *
 box_value(svalue_variants_t value,
           stype_t type) {
 
-  svalue_t *val = calloc(sizeof(svalue_t), 1);
+  svalue_t val;
-  CHECK(val);
   switch (type) {
     case INT:
-      val->value = value;
+      val.value.integer = value.integer;
-      val->type_tag = type;
+      val.type_tag = type;
       break;
     case FLOAT:
-      val->value = value;
+      val.value.floating = value.floating;
-      val->type_tag = type;
+      val.type_tag = type;
       break;
     case DOUBLE:
-      val->value = value;
+      val.value.doublev = value.doublev;
-      val->type_tag = type;
+      val.type_tag = type;
     case STRING:
-      val->value = value;
+      val.value.string = value.string;
-      val->type_tag = type;
+      val.type_tag = type;
     case CLOSURE:
-      val->value = value;
+      val.value.closure = value.closure;
-      val->type_tag = type;
+      /*printf("%p\n", val->value.closure->func);*/
+      val.type_tag = type;
   }
   return val;
 }
@@ -53,7 +47,7 @@ box_int(int x) {
   CHECK(val);
   svalue_variants_t value_val;
   value_val.integer = x;
-  val = box_value(value_val, INT);
+  *val = box_value(value_val, INT);
   return val;
 }
 
@@ -63,7 +57,7 @@ box_float(float x) {
   CHECK(val);
   svalue_variants_t value_val;
   value_val.floating = x;
-  val = box_value(value_val, FLOAT);
+  *val = box_value(value_val, FLOAT);
   return val;
 }
 
@@ -73,7 +67,7 @@ box_double(double x) {
   CHECK(val);
   svalue_variants_t value_val;
   value_val.doublev = x;
-  val = box_value(value_val, DOUBLE);
+  *val = box_value(value_val, DOUBLE);
   return val;
 }
 
@@ -88,50 +82,34 @@ box_string(char *chars, size_t n) {
 
   svalue_variants_t value_val;
   value_val.string = strval;
-  val = box_value(value_val, STRING);
+  *val = box_value(value_val, STRING);
   return val;
 }
 
 inline svalue_t *
-box_closure(closure_t closure) {
+box_closure(closure_t *closure) {
-  svalue_t *val = malloc(sizeof(svalue_t));
+  svalue_t *val = calloc(sizeof(svalue_t), 1);
   CHECK(val);
   svalue_variants_t value_val;
-  value_val.closure = (struct closure_t *)(&closure);
+  value_val.closure = closure;
-  val = box_value(value_val, CLOSURE);
+  *val = box_value(value_val, CLOSURE);
   return val;
 }
 
 
-inline closure_t
+closure_t*
 make_closure(svalue_t *(*func)(svalue_t*, svalue_t**),
              svalue_t **fvars) {
-  closure_t closure;
+  closure_t *closure = calloc(sizeof(closure_t), 1);
-  closure.func = func;
+  closure->func = func;
-  closure.fvars = fvars;
+  closure->fvars = fvars;
   return closure;
 }
 
 inline svalue_t*
 invoke(svalue_t *closure, svalue_t *val) {
-  svalue_t *(*func)(svalue_t*, svalue_t**) = closure->value.closure->func;
+  printf("In invoke: %p\n", closure->value.closure->func);
-  return func(val, closure->value.closure->fvars);
+  return closure->value.closure->func(val, closure->value.closure->fvars);
-}
-
-static svalue_t*
-make_adder_inner(svalue_t *x, svalue_t **env) {
-  svalue_variants_t val;
-  val.integer = env[0]->value.integer + x->value.integer;
-  return box_value(val, INT);
-}
-
-static closure_t
-make_adder(svalue_t *inc) {
-  svalue_t **env = calloc(sizeof(svalue_t *), 1);
-  CHECK(env);
-  env[0] = inc;
-  closure_t closure = make_closure(make_adder_inner, env);
-  return closure;
 }
 
 
@@ -147,30 +125,37 @@ make_doubleadder_inner_inner(svalue_t *z, svalue_t **env) {
 static svalue_t*
 make_doubleadder_inner(svalue_t *y, svalue_t **env) {
   env[1] = y;
-  closure_t inner = make_closure(make_doubleadder_inner_inner, env);
+  closure_t *inner = make_closure(make_doubleadder_inner_inner, env);
   return box_closure(inner);
 }
 
 static svalue_t*
 make_doubleadder(svalue_t *x, svalue_t **env) {
   env[0] = x;
-  closure_t closure = make_closure(make_doubleadder_inner, env);
+  closure_t *closure = make_closure(make_doubleadder_inner, env);
   return box_closure(closure);
 }
 
+void printpointer(closure_t);
+void printpointer(closure_t closure) {
+  printf("%p\n", closure.func);
+}
+
 int
 main(void) {
-  (void)make_adder;
   (void)box_float;
   (void)box_double;
   (void)box_string;
-  (void)box_closure;
+  svalue_t **env = calloc(sizeof(svalue_t *), 2);
-  (void)make_doubleadder_inner_inner;
+  closure_t *closure1_closure = make_closure(make_doubleadder, env);
-  (void)make_doubleadder_inner;
+  printf("First %p\n", closure1_closure->func);
-  (void)make_doubleadder;
+  svalue_t *closure1 = box_closure(closure1_closure);
-  svalue_t **env = calloc(sizeof(svalue_t), 2);
+  printf("Second %p\n", closure1->value.closure->func);
-  svalue_t *closure1 = box_closure(make_closure(make_doubleadder, env));
+  svalue_t *c1 = invoke(closure1, box_int(23));
-  CHECK(env);
+  printf("Last %p\n", c1->value.closure->func);
-  printf("%d\n", invoke(invoke(invoke(closure1, box_int(23)), box_int(3)), box_int(5))->value.integer);
+  svalue_t *c2 = invoke(c1, box_int(5));
+  printf("%d\n", c2->value.closure->fvars[1]->value.integer);
+  svalue_t *result = invoke(c2, box_int(334));
+  printf("%d\n", result->value.integer);
   return 0;
 }

tokenize.h

@@ -67,3 +67,4 @@ match_symbol(source_t, uint32_t, const uint32_t);
 int
 free_token(const void *,
            const void *);
+