bltin.c

@@ -2,7 +2,6 @@
 #include "fn.h"
 
 Object Nil	= (Object){.type=OSYMBOL, .beg="nil"};
-Object Top	= (Object){.type=OSYMBOL, .beg="top"};
 Object Splice= (Object){.type=OSYMBOL, .beg="@"};
 Object Comma= (Object){.type=OSYMBOL, .beg=","};
 Object Minus= (Object){.type=OBLTIN, .beg="-"};
@@ -21,16 +20,13 @@ Object Not	= (Object){.type=OBLTIN, .beg= "not"};
 
 Object Bquote= (Object){.type=OBLTIN, .beg="`"};
 Object Lambda= (Object){.type=OBLTIN, .beg="lambda"};
-Object Block= (Object){.type=OBLTIN, .beg="block"};
-Object RetFrom = (Object){.type=OBLTIN, .beg="return-from"};
-Object Let= (Object){.type=OBLTIN, .beg="let"};
 Object Progn=(Object){.type=OBLTIN, .beg="progn"};
 Object Car	= (Object){.type=OBLTIN, .beg="car"};
 Object Cdr	= (Object){.type=OBLTIN, .beg="cdr"};
 Object Quote= (Object){.type=OBLTIN, .beg="'"};
 Object Cons	= (Object){.type=OBLTIN, .beg="cons"};
 Object Define= (Object){.type=OBLTIN, .beg="define"};
-Object Macro= (Object){.type=OBLTIN, .beg="defmacro"};
+Object Macro= (Object){.type=OBLTIN, .beg="macro"};
 Object Setq	= (Object){.type=OBLTIN, .beg="setq"};
 Object If	= (Object){.type=OBLTIN, .beg="if"};
 
@@ -39,12 +35,9 @@ extern Object* fnmul(Object *, Object *);
 extern Object* fndiv(Object *, Object *);
 extern Object* fnmod(Object *, Object *);
 extern Object* fnlambda(Object *, Object *);
-extern Object* fnlet(Object *, Object *);
 extern Object* fnprogn(Object *, Object *);
-extern Object* fnblock(Object *, Object *);
-extern Object* fnretfrom(Object *, Object *);
 extern Object* fndefine(Object *, Object *);
-extern Object* fndefmacro(Object *, Object *);
+extern Object* fnmacro(Object *, Object *);
 extern Object* fnsetq(Object *, Object *);
 extern Object* fnundef(Object *, Object *);
 extern Object* fnquote(Object *, Object *);
@@ -72,16 +65,13 @@ bltinlookup(Object *obj)
 	}bltins[] = {
 		{&Lambda , fnlambda},
 		{&Progn , fnprogn},
-		{&Block , fnblock},
-		{&RetFrom ,fnretfrom},
 		{&Plus , fnplus},
 		{&Mul , fnmul},
 		{&Mod , fnmod},
 		{&Div , fndiv},
 		{&Define ,fndefine},
-		{&Macro ,fndefmacro},
+		{&Macro ,fnmacro},
 		{&Setq ,fnsetq},
-		{&Let ,fnlet},
 		{&Quote ,fnquote},
 		{&Bquote,  fnbquote},
 		{&Car ,fncar},

dat.h

@@ -13,8 +13,6 @@ enum OType
 	OINT,
 	OFUNC,
 	OMACRO,
-	OBLOCK,
-	OFRAME,
 	OENV,
 };
 
@@ -37,41 +35,23 @@ struct Object
 			char *ptr;
 			char *end;
 		};
-		/* Block */
-		struct{
-			Object *_tag;
-			Object *_up;
-			Object *_body;
-			void *jmp;
-		};
 		/* function */
 		struct{
 			Object *params;
-			Object *frame; /* running frame */
 			Object *body;
-			Object *block;
+			Object *env;
 		};
-		/* Frame */
+		/* env */ 
 		struct{
-			Object *tag;    /* Frame enter name  */
+			Object *name;
 			Object *up;
-			Object *local;  /* local vars  */
-		};
-		/* Env */
-		struct{
-			Object *frames;
-			Object *bp;
-			Object *sp;      /* current */
-			Object *retval; /* for return-from */
+			Object *vars;
 		};
 	};
 };
 
 extern GC *gc;
 extern Object Nil;
-extern Object Top;
-extern Object Block;
-extern Object RetFrom;
 extern Object Comma;
 extern Object Splice;
 extern Object Bquote;
@@ -89,7 +69,6 @@ extern Object Define;
 extern Object Progn;
 extern Object Macro;
 extern Object Setq;
-extern Object Let;
 extern Object Eq;
 extern Object Not;
 extern Object Ne;

eval.c

@@ -1,64 +1,14 @@
 #include "dat.h"
 #include "fn.h"
-#include <assert.h>
-#include <setjmp.h>
-#include <string.h>
-
-#define cdr(x) ((x)!= &Nil && (x)->type == OCELL ? (x)->cdr : &Nil)
-#define car(x) ((x)!= &Nil && (x)->type == OCELL ? (x)->car : &Nil)
-
-static char *typtab[] = {
-	[ONONE] = "error",
-	[OBLTIN] = "bltin",
-	[OSYMBOL] = "symbol",
-	[OCELL] = "cell",
-	[OIDENT] = "ident",
-	[OSTRING] = "string",
-	[OINT] = "int",
-	[OFUNC] = "func",
-	[OMACRO] = "macro",
-	[OENV] = "env",
-};
 
 static Object* evallist(Object *env, Object *list);
 
-static Object* curblock(Object *env) { return env->sp->car->block;	}
-static Object* curframe(Object *env) { return env->sp->car;	}
-
-static int
-_streq(Object *a, Object *b)
-{
-	int la = strlen(a->beg);
-	return la == strlen(b->beg) && memcmp(a->beg, b->beg, la) == 0;
-}
-
-static void
-enterframe(Object *env, Object *tag, Object *local, Object *up)
-{
-	assert(env->bp != &Nil);
-	Object *frame = newframe(gc, tag, local, up, curblock(env));
-	env->sp = env->sp->cdr = newcons(gc, frame, &Nil);
-}
-
-static void
-leaveframe(Object *env)
-{
-	assert(env->sp != env->bp);
-	Object *p = env->bp;
-	while(cdr(p) != env->sp)
-		p = p->cdr;
-	p->cdr = &Nil;
-	env->sp = p;
-}
-
 static int
 exprlen(Object *expr)
 {
 	int l = 0;
-	while(expr != &Nil){
-		expr = cdr(expr);
-		l += 1;
-	}
+	for(;expr->type==OCELL; expr=expr->cdr)
+		++l;	
 	return l;
 }
 
@@ -73,18 +23,14 @@ clone(Object *p)
 {
 	switch(p->type){
 	default: panic("unreachable");
-	case OFRAME:
-	case OENV:
 	case OSYMBOL:
-	case OINT:
-	case OIDENT:
-	case OBLTIN:
-		return p;
+	case OBLTIN: return p;
+	case OINT: return newint(gc, p->num);
+	case OIDENT: return newsymbol(gc, p->beg, p->ptr - p->beg);
+	case OCELL: return newcons(gc, clone(p->car), clone(p->cdr));
+	case OENV: return p;
 	case OMACRO:
-	case OFUNC:
-		return newfn(gc, p->frame, clone(p->params), clone(p->body), p->type);
-	case OCELL:
-		return newcons(gc, clone(p->car), clone(p->cdr));
+	case OFUNC: return newfn(gc, p->env, clone(p->params), clone(p->body), p->type);
 	case OSTRING:{
 		Object *s = newstr(gc, p->end - p->beg);
 		strinit(s, p);
@@ -96,10 +42,10 @@ clone(Object *p)
 static Object*
 find(Object *env, Object *obj)
 {
-	for(Object *cur=curframe(env); cur!=&Nil; cur=cur->up)
-	for(Object *p=cur->local; p!=&Nil; p=cdr(p))
-		if(strequal(obj, car(car(p))))
-			return clone(cdr(car(p)));
+	for(Object *cur=env; cur!=&Nil; cur=cur->up)
+	for(Object *p=cur->vars; p!=&Nil; p=p->cdr)
+		if(strequal(obj, p->car->car))
+			return clone(p->car->cdr);
 	error("not exist variable");
 	return 0;
 }
@@ -109,24 +55,21 @@ _newfn(Object *env, Object *l, enum OType type)
 {
 	if(l->type!=OCELL || islist(l->car)==0 || l->cdr->type!=OCELL)
 		error("malformed function");
-	for(Object *p=l->car; p->type==OCELL; p=cdr(p))
+	for(Object *p=l->car; p->type==OCELL; p=p->cdr)
 		if(p->car->type!=OIDENT)
 			error("parameter is not IDNET");
 	Object *params = l->car;
 	Object *body = l->cdr;
-	return newfn(gc, curframe(env), params, body, type);
+	return newfn(gc, env, params, body, type);
 }
 
-static void 
+static Object* 
 defvar(Object *env, Object *id, Object *val)
 {
-	if(id->type != OIDENT)
-		error("can't define, already using id");
-	Object *frame = env->bp->car;
-	for(Object *p=frame->local; p!=&Nil; p=cdr(p))
-		if(strequal(id, car(car(p))))
+	for(Object *p=env->vars; p!=&Nil; p=p->cdr)
+		if(strequal(id, p->car->car))
 			error("already exist variable. use setq plz...");
-	frame->local = newacons(gc, id, val, frame->local);
+	return newacons(gc, id, val, env->vars);
 }
 
 Object*
@@ -136,21 +79,19 @@ fnlambda(Object *env, Object *l)
 }
 
 Object*
-fndefmacro(Object *env, Object *l)
+fnmacro(Object *env, Object *l)
 {
-	if(l->type != OCELL)
-		error("Malformed macro");
 	Object *macro = _newfn(env, l->cdr, OMACRO);
-	defvar(env, l->car, macro);
+	env->vars = defvar(env, l->car, macro);
 	return macro;
 }
 
 static Object*
 progn(Object *env, Object *list)
 {
-	Object *r = &Nil;
-	for(Object *p=list; p!=&Nil; p=cdr(p)){
-		r = eval(env, car(p));
+	Object *r = 0;
+	for(Object *p=list; p!=&Nil; p=p->cdr){
+		r = eval(env, p->car);
 	}
 	return r;
 }
@@ -161,86 +102,29 @@ fnprogn(Object *env, Object *list)
 	return progn(env, list);
 }
 
-Object*
-fnblock(Object *env, Object *list)
-{
-	if(list->type != OCELL|| (list->car->type != OSYMBOL&&list->car->type != OIDENT))
-		error("Malformed block");
-	Object *tag = car(list);
-	Object *body = cdr(list);
-	jmp_buf jmp;
-	Object *b = newblock(gc, tag, curblock(env), body, &jmp);
-	Object *sp = env->sp;
-	sp->car->block = b;
-	Object *res = &Nil;
-
-	if(setjmp(jmp) == 1){
-		env->sp->block = b->up;
-		env->sp = sp;
-		res = env->retval;
-		env->retval = &Nil;
-		return res;
-	}
-
-	res = progn(env, body);
-	sp->car->block = b->up;
-	return res;
-}
-
-Object*
-fnretfrom(Object *env, Object *list)
-{
-	if(list->type != OCELL)
-		error("Malformed return-from");
-	Object *tag = car(list);
-	Object *p = curblock(env);
-	for(; p!= &Top; p=p->up)
-		if(_streq(p->tag, tag)){
-			env->retval = eval(env, car(cdr(list)));
-			longjmp(*(jmp_buf*)p->jmp, 1);
-		}
-	error("can't excute return-from");
-	return 0;
-}
-
 Object*
 fnsetq(Object *env, Object *list)
 {
-	if(list->type != OCELL || exprlen(list)!=2 || list->car->type!=OIDENT)
+	if(exprlen(list)!=2 || list->car->type!=OIDENT)
 		error("Malformed setq");
-	for(Object *frame=curframe(env); frame!=&Nil; frame=frame->up)
-	for(Object *p=frame->local; p!=&Nil; p=cdr(p))
-		if(strequal(list->car, car(car(p))))
-			return p->car->cdr = eval(env, car(cdr(list)));
-
+	Object *cur = env;
+	Object *p = 0;
+	for(; cur!=&Nil; cur=cur->up)
+	for(p=cur->vars; p!=&Nil; p=p->cdr)
+		if(strequal(list->car, p->car->car))
+				goto found;
 	error("setq not exist variable");
-	return 0;
-}
-
-Object*
-fnlet(Object *env, Object *list)
-{
-	if(exprlen(list) < 2)
-		error("let (vars) bodys");
-	Object *local = &Nil;
-	for(Object *p=car(list); p!=&Nil; p=cdr(p)){
-		Object *id = car(car(p));
-		Object *val = eval(env, car(cdr(car(p))));
-		local = newacons(gc, id, val, local);
-	}
-	enterframe(env, &Let, local, curframe(env));
-	Object *res = progn(env, cdr(list));
-	leaveframe(env);
-	return res;
+found:;
+	return p->car->cdr = eval(env, list->cdr->car);	
 }
 
 Object*
 fndefine(Object *env, Object *list)
 {
-	if(exprlen(list)!=2)
+	if(exprlen(list)!=2 || list->car->type!=OIDENT)
 		error("Malformed define");
-	Object *val = eval(env, car(cdr(list)));
-	defvar(env, car(list), val);
+	Object *val = eval(env, list->cdr->car);
+	env->vars = defvar(env, list->car, val);
 	return val;
 }
 
@@ -258,15 +142,16 @@ evalcomma(Object *env, Object *p)
 	if(p->type != OCELL)
 		return p;
 	if(p->car == &Comma){
-		if(car(cdr(p)) == &Splice)
+		if(p->cdr->type == OCELL && p->cdr->car == &Splice){
 			return newcons(gc, &Splice, eval(env, p->cdr->cdr));
+		}else
 			return eval(env, p->cdr);
 	}
 	p->car = evalcomma(env, p->car);
 	p->cdr = evalcomma(env, p->cdr);
-	if(car(car(p)) == &Splice){
+	if(p->car->type == OCELL && p->car->car == &Splice){
 		Object *i = p->car;
-		while(cdr(i) != &Nil)
+		while(i->cdr->type == OCELL && i->cdr != &Nil)
 			i = i->cdr;
 		if(i->type == OCELL){
 			i->cdr = p->cdr;
@@ -282,25 +167,29 @@ fnbquote(Object *env, Object *list)
 {
 	if(exprlen(list) != 1)
 		error("Malformed fnbquote");	
-	return evalcomma(env, car(list));
+	return evalcomma(env, list->car);
 }
 
 Object*
 fncar(Object *env, Object *list)
 {
     list = evallist(env, list);
-	if(car(list)->type != OCELL)
-		error("expected list");
-	return car(car(list));
+    if(list->car == &Nil)
+    	return &Nil;
+    if(list->car->type != OCELL)
+		error("car: expected list");
+    return list->car->car;
 }
 
 Object*
 fncdr(Object *env, Object *list)
 {
     list = evallist(env, list);
-	if(car(list)->type != OCELL)
-		error("expected list");
-	return cdr(car(list));
+    if(list->car == &Nil)
+    	return &Nil;
+    if(list->car->type != OCELL)
+		error("cdr: expected list");
+    return list->car->cdr;
 }
 
 Object*
@@ -309,9 +198,7 @@ fncons(Object *env, Object *list)
     if(exprlen(list) != 2)
         error("Malformoed cons");
     list = evallist(env, list);
-    if(list->type != OCELL)
-    	error("cons:bad list");
-    list->cdr = car(list->cdr);
+    list->cdr = list->cdr->car;
     return list;
 }
 
@@ -320,7 +207,7 @@ fnplus(Object *env, Object *list)
 {
 	long sum = 0;
     Object *p=evallist(env, list);
-    for(;p!=&Nil; p=cdr(p)){
+    for(;p!=&Nil; p=p->cdr){
 		if(p->car->type != OINT)
 			error("+ take only number");
 		sum += p->car->num;
@@ -332,11 +219,11 @@ Object*
 fnmul(Object *env, Object *list)
 {
     Object *p = evallist(env, list);
-    if(car(p)->type != OINT)
+    if(p->car->type != OINT)
 		error("* take only [INT]");
 	long sum = p->car->num;
-    for(p=p->cdr;p!=&Nil; p=cdr(p)){
-		if(car(p)->type != OINT)
+    for(p=p->cdr;p!=&Nil; p=p->cdr){
+		if(p->car->type != OINT)
 			error("* take only [INT]");
 		sum *= p->car->num;
 	}
@@ -350,8 +237,8 @@ fndiv(Object *env, Object *list)
     if(p->car->type != OINT)
 		error("/ take only [INT]");
 	long sum = p->car->num;
-    for(p=p->cdr;p!=&Nil; p=cdr(p)){
-		if(car(p)->type != OINT)
+    for(p=p->cdr;p!=&Nil; p=p->cdr){
+		if(p->car->type != OINT)
 			error("/ take only [INT]");
         if(p->car->num == 0)
             error("Can't div zero");
@@ -367,8 +254,8 @@ fnmod(Object *env, Object *list)
 	if(p->car->type != OINT)
 		error("%% take only [INT]");
 	long sum = p->car->num;
-    for(p=p->cdr;p!=&Nil; p=cdr(p)){
-		if(car(p)->type != OINT)
+    for(p=p->cdr;p!=&Nil; p=p->cdr){
+		if(p->car->type != OINT)
 			error("%% take only [INT]");
         if(p->car->num == 0)
             error("Can't mod zero");
@@ -380,8 +267,8 @@ fnmod(Object *env, Object *list)
 static long
 cmp(Object *env, Object *list)
 {
-    Object *a = eval(env, car(list));
-    Object *b = eval(env, car(cdr(list)));
+    Object *a = eval(env, list->car);
+    Object *b = eval(env, list->cdr->car);
 	if(a->type != OINT || b->type != OINT)
 		error("cmp only take [INT]");
 	return a->num - b->num;	
@@ -398,9 +285,9 @@ _newint(int n)
 Object*
 fnnot(Object *env, Object *list)
 {
-	if(exprlen(list) != 1)
+	if(list->type != OCELL)
 		error("Malformed not");
-	return _newint(eval(env, car(list)) == &Nil);
+	return _newint(eval(env, list->car) == &Nil);
 }
 
 Object*
@@ -442,14 +329,15 @@ fnne(Object *env, Object *list)
 Object*
 fnif(Object *env, Object *list)
 {
-	if(cdr(list)->type != OCELL)
+	if(list->type != OCELL || list->cdr->type != OCELL)
 		error("Malformed if stmt");
-	Object *test = list->car;
-	Object *then = car(cdr(list));
-	Object *else_ = car(cdr(cdr(list)));
-	if(eval(env, test)!=&Nil)
-		return eval(env, then);
-	return eval(env, else_);
+	if(eval(env, list->car)!=&Nil)
+		return eval(env, list->cdr->car);
+	if(list->cdr->cdr == &Nil)
+		return &Nil;
+	if(list->cdr->cdr->type != OCELL)
+		error("Malformed else stmt");
+	return eval(env, list->cdr->cdr->car);
 }
 
 static Object*
@@ -457,64 +345,73 @@ evallist(Object *env, Object *list)
 {
 	if(list == &Nil)
 		return &Nil;
-	Object *car = eval(env, car(list));
-	Object *cdr = evallist(env, cdr(list));
+	if(list->type != OCELL)
+		error("expected list");
+	Object *car = eval(env, list->car);
+	Object *cdr = evallist(env, list->cdr);
 	return newcons(gc, car, cdr);
 }
 
 static Object*
-applyargs(Object *fn, Object *args)
+enter(Object *env, Object *vars, Object *args)
 {
+#define cdr(x) (x!=&Nil ? x->cdr : &Nil)
+#define car(x) (x!=&Nil ? x->car : &Nil)
+
 	Object *map = &Nil;
-	Object *vars = fn->params;
-	for(;vars->type==OCELL; vars=cdr(vars), args=cdr(args)){
+	for(;vars->type==OCELL; vars=vars->cdr, args=cdr(args)){
 		if(args != &Nil && args->type!=OCELL)
 			error("Cna't apply function argment dose not match");
-		Object *id  = car(vars);
+		Object *id  = vars->car;
 		Object *val = car(args);
 		map = newacons(gc, id, val, map);
 	}
 	if(vars != &Nil)
 		map = newacons(gc, vars, args, map);
-	return map;
+	return newenv(gc, &Nil, map, env);
+
+#undef car
+#undef cdr
 }
 
 static Object*
-applyfn(Object *env, Object *tag, Object *fn, Object *args)
+applyfn(Object *fn, Object *args)
 {
-	Object *local = applyargs(fn, args);
-	enterframe(env, tag, local,fn->frame);
-	Object *res = progn(env, fn->body);
-	leaveframe(env);
-	return res;
+	Object *env = enter(fn->env, fn->params, args);
+	return progn(env, fn->body);
 }
 
 static Object*
-applymacro(Object *env, Object *tag, Object* fn, Object *args)
+applymacro(Object *env, Object* fn, Object *args)
 {
-	Object *local = applyargs(fn, args);
-	enterframe(env, tag, local, fn->frame);
-	Object *r = progn(env, fn->body);
-	leaveframe(env);
+	Object *nenv = enter(fn->env, fn->params, args);
+	Object *r = 0;
+	for(Object *p=fn->body; p!=&Nil; p=p->cdr){
+		r = p->car;
+		r = eval(nenv, r);
+	}
 	return eval(env, r);
 }
 
 static Object*
-apply(Object *env, Object *tag, Object *fn, Object *args)
+apply(Object *env, Object *fn, Object *args)
 {
+	if(islist(args) == 0)
+		error("args is not list type");
 	switch(fn->type){
 	default:
-		error("apply:can't eval type");
-		return 0;
+		error("apply only tabke [MACRO BLTIN FUNC]");
+    case OMACRO:
+    	return applymacro(env, fn, args);
 	case OBLTIN:{
             Bltinfn blt = bltinlookup(fn);
+            if(blt==0)
+                error("not builtin type!");
             return blt(env, args);
         }
-	case OMACRO:
-		return applymacro(env, tag, fn, args);
 	case OFUNC:{
 			Object *elist = evallist(env, args);
-			Object*res = applyfn(env, tag, fn, elist);
+			Object*res = applyfn(fn, elist);
 			return res;
 		}
 	}
@@ -525,18 +422,20 @@ eval(Object *env, Object *obj)
 {
 	switch(obj->type){
 	default:
-		error("eval: can't eval type");
-		return 0;
+		error("can't eval");
 	case OSTRING:
 	case OINT:
 	case OBLTIN:
 	case OSYMBOL:
 		return obj;
-	case OIDENT:
+	case OIDENT:{
 			return find(env, obj);
+		}
 	case OCELL:{
 			Object *fn = eval(env, obj->car);
-			Object *res = apply(env, obj->car, fn, obj->cdr);
+			if(fn == &Nil)
+				return &Nil;
+			Object *res = apply(env, fn, obj->cdr);
 			return res;
 		}
 	}

fn.h

@@ -12,13 +12,11 @@ Object* eval(Object *env, Object *expr);
 /* new */
 Object* newint(GC *,long);
 Object* newcons(GC *,Object*,Object*);
-Object* newenv(GC *gc, Object *frames, Object *bp, Object *sp);
-Object* newblock(GC *gc, Object* tag, Object *up, Object *body, void *jmp);
-Object* newframe(GC *gc, Object* tag, Object *local, Object *up, Object *block);
+Object* newenv(GC *,Object*name, Object *vars, Object *up);
 Object* newacons(GC *,Object*, Object*, Object*);
 Object* newsymbol(GC *,char*, int);
 Object* newstr(GC *,int);
-Object* newfn(GC *,Object *frame, Object *params, Object *body, enum OType type);
+Object* newfn(GC *,Object *env, Object *params, Object *body, enum OType type);
 
 /* gc.c */
 GC* newgc(void *top, int cap);

gc.c

@@ -66,31 +66,16 @@ cloneobj(GC *dst, GC *src, Object *obj)
 		break;
 	case OENV:
 		obj->forward = p = newenv(dst, &Nil, &Nil, &Nil);
-		p->frames = cloneobj(dst, src, obj->frames);
-		p->bp = cloneobj(dst, src, obj->bp);
-		p->sp = cloneobj(dst, src, obj->sp);
-		p->retval = cloneobj(dst, src, obj->retval);
-		break;
-	case OBLOCK:
-		obj->forward = p = newblock(dst, &Nil, &Nil, &Nil, obj->jmp);
-		p->tag = cloneobj(dst, src, obj->tag);
+		p->name = cloneobj(dst, src, obj->name);
+		p->vars = cloneobj(dst, src, obj->vars);
 		p->up = cloneobj(dst, src, obj->up);
-		p->body = cloneobj(dst, src, obj->body);
-		p->jmp = obj->jmp;
-		break;
-	case OFRAME:
-		obj->forward = p = newframe(dst, &Nil, &Nil, &Nil, &Nil);
-		p->tag = cloneobj(dst, src, obj->tag);
-		p->local = cloneobj(dst, src, obj->local);
-		p->up = cloneobj(dst, src, obj->up);
-		p->block = cloneobj(dst, src, obj->block);
 		break;
 	case OMACRO:
 	case OFUNC:
 		obj->forward = p = newfn(dst, &Nil, &Nil, &Nil, obj->type);
 		p->params = cloneobj(dst, src, obj->params);
 		p->body = cloneobj(dst, src, obj->body);
-		p->frame = cloneobj(dst, src, obj->frame);
+		p->env = cloneobj(dst, src, obj->env);
 		break;
 	}
 	return p;
@@ -143,27 +128,15 @@ mark(GC *gc, Object *obj)
 		mark(gc, obj->cdr);
 		break;
 	case OENV:
-		mark(gc, obj->frames);
-		mark(gc, obj->bp);
-		mark(gc, obj->sp);
-		mark(gc, obj->retval);
-		break;
-	case OBLOCK:
-		mark(gc, obj->tag);
+		mark(gc, obj->name);
+		mark(gc, obj->vars);
 		mark(gc, obj->up);
-		mark(gc, obj->body);
-		break;
-	case OFRAME:
-		mark(gc, obj->tag);
-		mark(gc, obj->local);
-		mark(gc, obj->up);
-		mark(gc, obj->block);
 		break;
 	case OMACRO:
 	case OFUNC:
 		mark(gc, obj->params);
 		mark(gc, obj->body);
-		mark(gc, obj->frame);
+		mark(gc, obj->env);
 		break;
 	}
 }

lib/lib.lisp

@@ -1,36 +1,8 @@
-(defmacro defun (name args body) 
-		`(define ,name (lambda ,args (block ,name ,body))))
-
-(defmacro cond (expr . rest)
-	(if (not expr)
-		nil
-		(let ((test  (car expr)))
-			`(if ,test
-				(progn ,test ,@(cdr expr))
-				(cond ,@rest)))))
-
-(defmacro and (expr . rest)
-	(if (not rest)
-		expr
-		(if (cond (not expr) nil)
-			`(and ,@rest))))
-
-(defmacro or (expr . rest)
-	(if rest
-		(cond (expr) (`(or ,@rest)))
-		expr))
-
-(defmacro when (test . rest)
-	`(if ,test
-		(progn ,@rest)))
-
-(defmacro unless (test . rest)
-	`(if (not ,test)
-		(progn ,@rest)))
-
-(defmacro return (res)
-	(return-from nil `,res))
+(macro defun (name args body) 
+		`(define ,name (lambda ,args ,body)))
 
 (defun list (x . y) (cons x y))
 
-
+(macro cond (expr . rest)
+	(if (not expr) nil
+		`(if ,(car expr) (progn ,@expr) (cond ,@rest))))

main.c

@@ -31,17 +31,9 @@ SExprint(Object *obj)
 	case OSYMBOL:
 		printf("%s", obj->beg);
 		break;
-	case OBLOCK:
-		printf("\n<block-%s>\n", obj->tag->beg);
-		break;
-	case OFRAME:
-		printf("\n<frame-%s>\n", obj->tag->beg);
-		printexpr(obj->local);
-		printexpr(obj->block);
-		break;
 	case OENV:
 		printf("<env>");
-		printexpr(obj->frames);
+		SExprint(obj->vars);
 		break;
 	case OMACRO:
 		printf("<macro>");
@@ -68,7 +60,7 @@ int
 main(int argc, char *argv[])
 {
 	*argv = "lib/lib.lisp";
-	gc = newgc(&argc, 24000);
+	gc = newgc(&argc, 400);
 	lispmain(argv);
 	panic("unreachable");
 }

obj.c

@@ -29,38 +29,15 @@ newcons(GC *gc, Object *car, Object *cdr)
 }
 
 Object*
-newblock(GC *gc, Object* tag, Object *up, Object *body, void *jmp)
+newenv(GC *gc, Object* name, Object *vars, Object *up)
 {
-	Object *obj = newobj(gc, OBLOCK, 0);
-	obj->tag = tag;
+	Object *obj = newobj(gc, OENV, 0);
+	obj->name = name;
 	obj->up = up;
-	obj->body = body;
-	obj->jmp = jmp;
+	obj->vars = vars;
 	return obj;
 }
 
-Object*
-newframe(GC *gc, Object* tag, Object *local, Object *up, Object *block)
-{
-	Object *obj = newobj(gc, OFRAME, 0);
-	obj->tag = tag;
-	obj->local = local;
-	obj->up = up;
-	obj->block = block;
-	return obj;
-}
-
-Object*
-newenv(GC *gc, Object *frames, Object *bp, Object *sp)
-{
-	Object *env = newobj(gc, OENV, 0);
-	env->frames = frames;
-	env->bp = bp;
-	env->sp = sp;
-	env->retval = &Nil;
-	return env;
-}
-
 Object*
 newacons(GC *gc, Object *x, Object *y, Object *z)
 {
@@ -69,13 +46,13 @@ newacons(GC *gc, Object *x, Object *y, Object *z)
 }
 
 Object*
-newfn(GC *gc, Object *frame, Object *params, Object *body, enum OType type)
+newfn(GC *gc, Object *env, Object *params, Object *body, enum OType type)
 {
 	Object *fn = newobj(gc, type, 0);
 	fn->type = type;
 	fn->params = params;
 	fn->body = body;
-	fn->frame = frame; 
+	fn->env = env; 
 	return fn;
 }
 
@@ -86,7 +63,7 @@ newsymbol(GC *gc, char *str, int len)
 		&Nil,  &Minus, &Plus, &Mul, &Mod, &Div, &Ge, &Le,
 		&Lt, &Gt, &Ne, &Lambda, &Car, &Cdr, &Quote, &Cons,
 		&Define, &Setq, &Eq, &If, &Macro, &Progn, &Bquote,
-		&Comma, &Not, &Splice, &Let, &Block, &RetFrom,
+		&Comma, &Not, &Splice,
 	};
 	for(int i = 0; i < sizeof(syms)/sizeof(syms[0]); ++i){
 		Object *c = syms[i];

repl.c

@@ -31,16 +31,6 @@ error(char *fmt, ...)
 	exit(1);
 }
 
-/* remove all frames except Top */
-static void
-clearenv(Object *env)
-{
-	env->bp->cdr = &Nil;
-	env->bp->car->block = &Top; 
-	env->sp = env->bp;
-	env->retval = &Nil;
-}
-
 static void
 repl(Object *env, FILE *f, char *pre)
 {
@@ -49,7 +39,6 @@ repl(Object *env, FILE *f, char *pre)
 	if(setjmp(err) == 1){
 		if(feof(f))
 			exit(1);
-		clearenv(env);
 		skipline(f);
 	}
 	while(1){
@@ -57,6 +46,7 @@ repl(Object *env, FILE *f, char *pre)
 		Object *res = nextexpr(f);
 		res = eval(env, res);
 		printexpr(res);
+		printgc("status", gc);
 	}
 }
 
@@ -77,9 +67,7 @@ readlib(FILE *f, Object *env)
 void
 lispmain(char *argv[])
 {
-	Object *frame = newframe(gc, &Top, &Nil, &Nil, &Top);
-	Object *cons = newcons(gc, frame, &Nil);
-	Object *env = newenv(gc, cons, cons, cons);
+	Object *env = newenv(gc , &Nil, &Nil, &Nil);
 	for(; *argv; ++argv){
 		FILE *f = fopen(*argv, "r");
 		if(f == 0)