Sol Part 26: Yo Dawg, I Herd U Liek Languages...

ast.h

@@ -5,6 +5,11 @@
 
 #include <stdio.h>
 
+typedef struct {
+	size_t line;
+	size_t col;
+} loc_t;
+
 struct tag_expr_node;
 typedef struct tag_expr_node expr_node;
 
@@ -96,6 +101,7 @@ typedef struct {
 typedef enum {EX_LIT, EX_LISTGEN, EX_MAPGEN, EX_BINOP, EX_UNOP, EX_INDEX, EX_SETINDEX, EX_ASSIGN, EX_REF, EX_CALL, EX_FUNCDECL} expr_t;
 typedef struct tag_expr_node {
 	expr_t type;
+	loc_t loc;
 	union {
 		lit_node *lit;
 		listgen_node *listgen;
@@ -140,6 +146,7 @@ typedef struct tag_stmtlist_node {
 typedef enum {ST_EXPR, ST_IFELSE, ST_LOOP, ST_ITER, ST_LIST, ST_RET, ST_CONT, ST_BREAK} stmt_t;
 typedef struct tag_stmt_node {
 	stmt_t type;
+	loc_t loc;
 	union {
 		expr_node *expr;
 		ifelse_node *ifelse;
@@ -155,6 +162,7 @@ typedef struct tag_stmt_node {
 #define AS(arg, tp) ((tp *) (arg))
 #define NEW_ST() malloc(sizeof(stmt_node))
 #define NEW_EX() malloc(sizeof(expr_node))
+#define SET_LOC(node, l) do { (node)->loc.line = (l).first_line; (node)->loc.col = (l).first_column; } while(0)
 #define NEW(arg) malloc(sizeof(arg))
 #define MAKE_REF_BINOP(nd, tp, name, val) nd = NEW_EX(); \
 	nd->type = EX_BINOP; \
@@ -191,8 +199,8 @@ void sol_compile_free(stmt_node *);
 void st_free(stmt_node *);
 void ex_free(expr_node *);
 
-void st_print(stmt_node *);
-void ex_print(expr_node *);
+void st_print(sol_state_t *, stmt_node *);
+void ex_print(sol_state_t *, expr_node *);
 void ob_print(sol_object_t *);
 
 sol_object_t *sol_eval(sol_state_t *, expr_node *);

astprint.c

@@ -4,310 +4,310 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-void prlev(int lev, const char *fmt, ...) {
+void prlev(sol_state_t *state, int lev, const char *fmt, ...) {
 	va_list vl;
 	int i;
 
-	for(i = 0; i < lev; i++) { putchar('|'); putchar(' '); }
+	for(i = 0; i < lev; i++) { sol_putchar(state, '|'); sol_putchar(state, ' '); }
 	va_start(vl, fmt);
-	vprintf(fmt, vl);
+	sol_vprintf(state, fmt, vl);
 	va_end(vl);
-	putchar('\n');
+	sol_putchar(state, '\n');
 }
 
-void prex(expr_node *, int);
+void prex( sol_state_t *, expr_node *, int);
 
-void prst(stmt_node *node, int lev) {
+void prst(sol_state_t *state, stmt_node *node, int lev) {
 	if(!node) {
-		prlev(lev, "<NULL>");
+		prlev(state, lev, "<NULL>");
 		return;
 	}
 	switch(node->type) {
 		case ST_EXPR:
-			prlev(lev, "Stmt<Expr>:");
-			prex(node->expr, lev+1);
+			prlev(state, lev, "Stmt<Expr>:");
+			prex(state, node->expr, lev+1);
 			break;
 
 		case ST_IFELSE:
-			prlev(lev, "Stmt<IfElse>:");
+			prlev(state, lev, "Stmt<IfElse>:");
 			lev++;
-			prlev(lev, "Cond:");
-			prex(node->ifelse->cond, lev+1);
-			prlev(lev, "IfTrue:");
-			prst(node->ifelse->iftrue, lev+1);
-			prlev(lev, "IfFalse:");
-			prst(node->ifelse->iffalse, lev+1);
+			prlev(state, lev, "Cond:");
+			prex(state, node->ifelse->cond, lev+1);
+			prlev(state, lev, "IfTrue:");
+			prst(state, node->ifelse->iftrue, lev+1);
+			prlev(state, lev, "IfFalse:");
+			prst(state, node->ifelse->iffalse, lev+1);
 			break;
 
 		case ST_LOOP:
-			prlev(lev, "Stmt<Loop>:");
+			prlev(state, lev, "Stmt<Loop>:");
 			lev++;
-			prlev(lev, "Cond:");
-			prex(node->loop->cond, lev+1);
-			prlev(lev, "Loop:");
-			prst(node->loop->loop, lev+1);
+			prlev(state, lev, "Cond:");
+			prex(state, node->loop->cond, lev+1);
+			prlev(state, lev, "Loop:");
+			prst(state, node->loop->loop, lev+1);
 			break;
 
 		case ST_ITER:
-			prlev(lev, "Stmt<Iter>:");
+			prlev(state, lev, "Stmt<Iter>:");
 			lev++;
-			prlev(lev, "Var: %s", node->iter->var);
-			prlev(lev, "Iter:");
-			prex(node->iter->iter, lev+1);
-			prlev(lev, "Loop:");
-			prst(node->iter->loop, lev+1);
+			prlev(state, lev, "Var: %s", node->iter->var);
+			prlev(state, lev, "Iter:");
+			prex(state, node->iter->iter, lev+1);
+			prlev(state, lev, "Loop:");
+			prst(state, node->iter->loop, lev+1);
 			break;
 
 		case ST_LIST:
-			prlev(lev, "Stmt<List>:");
+			prlev(state, lev, "Stmt<List>:");
 			stmtlist_node *cur = node->stmtlist;
 			while(cur && cur->stmt) {
-				prst(cur->stmt, lev+1);
+				prst(state, cur->stmt, lev+1);
 				cur = cur->next;
 			}
 			break;
 
         case ST_RET:
-            prlev(lev, "Stmt<Ret>:");
-            prex(node->ret->ret, lev+1);
+            prlev(state, lev, "Stmt<Ret>:");
+            prex(state, node->ret->ret, lev+1);
             break;
 
         case ST_CONT:
-            prlev(lev, "Stmt<Continue>");
+            prlev(state, lev, "Stmt<Continue>");
             break;
 
         case ST_BREAK:
-            prlev(lev, "Stmt<Break>");
+            prlev(state, lev, "Stmt<Break>");
             break;
 	}
 }
 
-void prex(expr_node *node, int lev) {
+void prex(sol_state_t *state, expr_node *node, int lev) {
 	assoclist_node *cura;
 	exprlist_node *cure;
 	identlist_node *curi;
 	if(!node) {
-		prlev(lev, "<NULL>");
+		prlev(state, lev, "<NULL>");
 		return;
 	}
 	switch(node->type) {
 		case EX_LIT:
-			prlev(lev, "Literal:");
+			prlev(state, lev, "Literal:");
 			lev++;
 			switch(node->lit->type) {
 				case LIT_INT:
-					prlev(lev, "Int: %ld", node->lit->ival);
+					prlev(state, lev, "Int: %ld", node->lit->ival);
 					break;
 
 				case LIT_FLOAT:
-					prlev(lev, "Float: %f", node->lit->fval);
+					prlev(state, lev, "Float: %f", node->lit->fval);
 					break;
 
 				case LIT_STRING:
-					prlev(lev, "String: %s", node->lit->str);
+					prlev(state, lev, "String: %s", node->lit->str);
 					break;
 
 				case LIT_NONE:
-					prlev(lev, "None");
+					prlev(state, lev, "None");
 					break;
 			}
 			break;
 
 		case EX_LISTGEN:
-			prlev(lev, "ListGen:");
+			prlev(state, lev, "ListGen:");
 			cure = node->listgen->list;
 			while(cure && cure->expr) {
-				prex(cure->expr, lev+1);
+				prex(state, cure->expr, lev+1);
 				cure = cure->next;
 			}
 			break;
 
 		case EX_MAPGEN:
-			prlev(lev, "MapGen:");
+			prlev(state, lev, "MapGen:");
 			lev++;
 			cura = node->mapgen->map;
 			while(cura && cura->item) {
-				prlev(lev, "<Key>:");
-				prex(cura->item->key, lev+1);
-				prlev(lev, "<Value>:");
-				prex(cura->item->value, lev+1);
+				prlev(state, lev, "<Key>:");
+				prex(state, cura->item->key, lev+1);
+				prlev(state, lev, "<Value>:");
+				prex(state, cura->item->value, lev+1);
 				cura = cura->next;
 			}
 			break;
 
 		case EX_BINOP:
-			prlev(lev, "BinOp:");
+			prlev(state, lev, "BinOp:");
 			lev++;
 			switch(node->binop->type) {
 				case OP_ADD:
-					prlev(lev, "Op: +");
+					prlev(state, lev, "Op: +");
 					break;
 
 				case OP_SUB:
-					prlev(lev, "Op: -");
+					prlev(state, lev, "Op: -");
 					break;
 
 				case OP_MUL:
-					prlev(lev, "Op: *");
+					prlev(state, lev, "Op: *");
 					break;
 
 				case OP_DIV:
-					prlev(lev, "Op: /");
+					prlev(state, lev, "Op: /");
 					break;
 
                 case OP_MOD:
-					prlev(lev, "Op: %");
+					prlev(state, lev, "Op: %");
 					break;
 
 				case OP_POW:
-					prlev(lev, "Op: **");
+					prlev(state, lev, "Op: **");
 					break;
 
 				case OP_BAND:
-					prlev(lev, "Op: &");
+					prlev(state, lev, "Op: &");
 					break;
 
 				case OP_BOR:
-					prlev(lev, "Op: |");
+					prlev(state, lev, "Op: |");
 					break;
 
 				case OP_BXOR:
-					prlev(lev, "Op: ^");
+					prlev(state, lev, "Op: ^");
 					break;
 
 				case OP_LAND:
-					prlev(lev, "Op: &&");
+					prlev(state, lev, "Op: &&");
 					break;
 
 				case OP_LOR:
-					prlev(lev, "Op: ||");
+					prlev(state, lev, "Op: ||");
 					break;
 
 				case OP_EQUAL:
-					prlev(lev, "Op: ==");
+					prlev(state, lev, "Op: ==");
 					break;
 
 				case OP_LESS:
-					prlev(lev, "Op: <");
+					prlev(state, lev, "Op: <");
 					break;
 
 				case OP_GREATER:
-					prlev(lev, "Op: >");
+					prlev(state, lev, "Op: >");
 					break;
 
 				case OP_LESSEQ:
-					prlev(lev, "Op: <=");
+					prlev(state, lev, "Op: <=");
 					break;
 
 				case OP_GREATEREQ:
-					prlev(lev, "Op: >=");
+					prlev(state, lev, "Op: >=");
 					break;
 
 				case OP_LSHIFT:
-					prlev(lev, "Op: <<");
+					prlev(state, lev, "Op: <<");
 					break;
 
 				case OP_RSHIFT:
-					prlev(lev, "Op: >>");
+					prlev(state, lev, "Op: >>");
 					break;
 			}
-			prlev(lev, "Left:");
-			prex(node->binop->left, lev+1);
-			prlev(lev, "Right:");
-			prex(node->binop->right, lev+1);
+			prlev(state, lev, "Left:");
+			prex(state, node->binop->left, lev+1);
+			prlev(state, lev, "Right:");
+			prex(state, node->binop->right, lev+1);
 			break;
 
 		case EX_UNOP:
-			prlev(lev, "UnOp:");
+			prlev(state, lev, "UnOp:");
 			lev++;
 			switch(node->unop->type) {
 				case OP_NEG:
-					prlev(lev, "Op: -");
+					prlev(state, lev, "Op: -");
 					break;
 
 				case OP_BNOT:
-					prlev(lev, "Op: ~");
+					prlev(state, lev, "Op: ~");
 					break;
 
 				case OP_LNOT:
-					prlev(lev, "Op: !");
+					prlev(state, lev, "Op: !");
 					break;
 
 				case OP_LEN:
-					prlev(lev, "Op: #");
+					prlev(state, lev, "Op: #");
 					break;
 			}
-			prlev(lev, "Expr:");
-			prex(node->unop->expr, lev+1);
+			prlev(state, lev, "Expr:");
+			prex(state, node->unop->expr, lev+1);
 			break;
 
 		case EX_INDEX:
-			prlev(lev, "Index:");
+			prlev(state, lev, "Index:");
 			lev++;
-			prlev(lev, "Expr:");
-			prex(node->index->expr, lev+1);
-			prlev(lev, "Index:");
-			prex(node->index->index, lev+1);
+			prlev(state, lev, "Expr:");
+			prex(state, node->index->expr, lev+1);
+			prlev(state, lev, "Index:");
+			prex(state, node->index->index, lev+1);
 			break;
 
 		case EX_SETINDEX:
-			prlev(lev, "SetIndex:");
+			prlev(state, lev, "SetIndex:");
 			lev++;
-			prlev(lev, "Expr:");
-			prex(node->setindex->expr, lev+1);
-			prlev(lev, "Index:");
-			prex(node->setindex->index, lev+1);
-			prlev(lev, "Value:");
-			prex(node->setindex->value, lev+1);
+			prlev(state, lev, "Expr:");
+			prex(state, node->setindex->expr, lev+1);
+			prlev(state, lev, "Index:");
+			prex(state, node->setindex->index, lev+1);
+			prlev(state, lev, "Value:");
+			prex(state, node->setindex->value, lev+1);
 			break;
 
 		case EX_ASSIGN:
-			prlev(lev, "Assign:");
+			prlev(state, lev, "Assign:");
 			lev++;
-			prlev(lev, "Ident: %s", node->assign->ident);
-			prlev(lev, "Value:");
-			prex(node->assign->value, lev+1);
+			prlev(state, lev, "Ident: %s", node->assign->ident);
+			prlev(state, lev, "Value:");
+			prex(state, node->assign->value, lev+1);
 			break;
 
 		case EX_REF:
-			prlev(lev, "Ref: %s", node->ref->ident);
+			prlev(state, lev, "Ref: %s", node->ref->ident);
 			break;
 
 		case EX_CALL:
-			prlev(lev, "Call:");
+			prlev(state, lev, "Call:");
 			lev++;
-			prlev(lev, "Expr:");
-			prex(node->call->expr, lev+1);
-			prlev(lev, "Args:");
+			prlev(state, lev, "Expr:");
+			prex(state, node->call->expr, lev+1);
+			prlev(state, lev, "Args:");
 			cure = node->call->args;
 			while(cure && cure->expr) {
-				prex(cure->expr, lev+1);
+				prex(state, cure->expr, lev+1);
 				cure = cure->next;
 			}
 			break;
 
 		case EX_FUNCDECL:
-			prlev(lev, "FuncDecl:");
+			prlev(state, lev, "FuncDecl:");
 			lev++;
-			prlev(lev, "Name: %s", node->funcdecl->name);
-			prlev(lev, "Args:");
+			prlev(state, lev, "Name: %s", node->funcdecl->name);
+			prlev(state, lev, "Args:");
 			curi = node->funcdecl->args;
 			while(curi && curi->ident) {
-				prlev(lev+1, curi->ident);
+				prlev(state, lev+1, curi->ident);
 				curi = curi->next;
 			}
-			prlev(lev, "Body:");
-			prst(node->funcdecl->body, lev+1);
+			prlev(state, lev, "Body:");
+			prst(state, node->funcdecl->body, lev+1);
 			break;
 	}
 }
 
-void st_print(stmt_node *stmt) {
-    prst(stmt, 0);
+void st_print(sol_state_t *state, stmt_node *stmt) {
+    prst(state, stmt, 0);
 }
 
-void ex_print(expr_node *expr) {
-    prex(expr, 0);
+void ex_print(sol_state_t *state, expr_node *expr) {
+    prex(state, expr, 0);
 }
 
 /*int main(int argc, char **argv) {
@@ -318,11 +318,11 @@ void ex_print(expr_node *expr) {
 	if(yyparse(&program)) {
 		printf("Syntax error (somewhere)\n");
 		printf("Partial tree:\n");
-		prst(program, 0);
+		prst(state, program, 0);
 		return 1;
 	}
 
-	prst(program, 0);
+	prst(state, program, 0);
 	return 0;
 }*/
 

build.sh

@@ -6,6 +6,7 @@ gcc -c -g lex.yy.c
 gcc -c -g parser.tab.c
 gcc -c -g astprint.c
 gcc -c -g runtime.c
+gcc -c -g gc.c
 gcc -c -g object.c
 gcc -c -g state.c
 gcc -c -g builtins.c

builtins.c

@@ -95,6 +95,7 @@ sol_object_t *sol_f_try(sol_state_t *state, sol_object_t *args) {
 		sol_obj_free(err);
 		sol_list_insert(state, ls, 0, zero);
 		sol_obj_free(zero);
+		sol_list_insert(state, ls, 2, state->traceback);
 		return ls;
 	}
 	sol_list_insert(state, ls, 0, res);
@@ -207,11 +208,11 @@ void ob_print(sol_object_t *obj) {
 			break;
 			
 		case SOL_STMT:
-			st_print(obj->node);
+			st_print(NULL, obj->node); //TODO: FIXME
 			break;
 			
 		case SOL_EXPR:
-			ex_print(obj->node);
+			ex_print(NULL, obj->node); //TODO: FIXME
 			break;
 			
 		case SOL_BUFFER:
@@ -235,14 +236,17 @@ void ob_print(sol_object_t *obj) {
 
 sol_object_t *sol_f_prepr(sol_state_t *state, sol_object_t *args) {
 	int i, sz = sol_list_len(state, args);
-    sol_object_t *obj;
+    sol_object_t *obj, *str;
 	seen = dsl_seq_new_array(NULL, NULL);
 	for(i=0; i<sz; i++) {
 		obj = sol_list_get_index(state, args, i);
-		ob_print(obj);
-		printf(" ");
+		str = sol_cast_repr(state, obj);
+		sol_printf(state, "%s", str->str);
+		sol_printf(state, " ");
 		sol_obj_free(obj);
+		sol_obj_free(str);
 	}
+	sol_printf(state, "\n");
 	printf("\n");
 	dsl_free_seq(seen);
 	seen = NULL;
@@ -375,6 +379,39 @@ sol_object_t *sol_f_parse(sol_state_t *state, sol_object_t *args) {
 	return sol_new_stmtnode(state, program);
 }
 
+sol_object_t *sol_f_ord(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *arg = sol_list_get_index(state, args, 0), *str = sol_cast_string(state, arg);
+	sol_object_t *idx = sol_new_int(state, 0), *arg2, *iarg, *res;
+	size_t len = strlen(str->str);
+	sol_obj_free(arg);
+	if(sol_list_len(state, args)>1) {
+		arg2 = sol_list_get_index(state, args, 1);
+		iarg = sol_cast_int(state, arg2);
+		sol_obj_free(arg2);
+		idx->ival = iarg->ival;
+		sol_obj_free(iarg);
+	}
+	if(idx->ival < 0 || idx->ival >= len) {
+		sol_obj_free(str);
+		sol_obj_free(idx);
+		return sol_set_error_string(state, "Compute ord of out-of-bounds index");
+	}
+	res = sol_new_int(state, str->str[idx->ival]);
+	sol_obj_free(str);
+	sol_obj_free(idx);
+	return res;
+}
+
+sol_object_t *sol_f_chr(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *arg = sol_list_get_index(state, args, 0), *iarg = sol_cast_int(state, arg);
+	char cbuf[2]={iarg->ival, 0};
+	sol_object_t *res = sol_new_string(state, cbuf);
+	sol_obj_free(arg);
+	sol_obj_free(iarg);
+	return res;
+}
+	
+
 sol_object_t *sol_f_debug_getref(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj = sol_list_get_index(state, args, 0);
 	sol_object_t *res = sol_new_int(state, obj->refcnt - 2); // NB: We grabbed a reference, and there's one in the arglist, so account for them.
@@ -477,6 +514,17 @@ sol_object_t *sol_f_iter_map(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_ast_print(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *obj = sol_list_get_index(state, args, 0);
+	if(sol_is_aststmt(obj)) {
+		st_print(state, obj->node);
+	} else {
+		ex_print(state, obj->node);
+	}
+	sol_obj_free(obj);
+	return sol_incref(state->None);
+}
+
 sol_object_t *sol_f_singlet_tostring(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *obj = sol_list_get_index(state, args, 0), *res = sol_new_string(state, obj->str);
 	sol_obj_free(obj);
@@ -845,6 +893,16 @@ sol_object_t *sol_f_str_split(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_str_find(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *str = sol_list_get_index(state, args, 0), *substr = sol_list_get_index(state, args, 1), *ssubstr = sol_cast_string(state, substr);
+	char *ptr = strstr(str->str, ssubstr->str);
+	sol_object_t *res = sol_new_int(state, ptr?ptr-str->str:-1);
+	sol_obj_free(str);
+	sol_obj_free(substr);
+	sol_obj_free(ssubstr);
+	return res;
+}
+
 sol_object_t *sol_f_list_add(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *a = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1), *ls;
 	if(!sol_is_list(b)) {
@@ -1039,22 +1097,25 @@ sol_object_t *sol_f_map_index(sol_state_t *state, sol_object_t *args) {
 	sol_object_t *map = sol_list_get_index(state, args, 0), *b = sol_list_get_index(state, args, 1);
 	sol_object_t *indexf = sol_map_get_name(state, map, "__index");
 	sol_object_t *res = NULL, *newls;
-	if(!sol_is_none(state, indexf)) {
-		if(indexf->ops->call && (sol_is_func(indexf) || sol_is_cfunc(indexf)) && indexf->ops->call != sol_f_not_impl) {
-			newls = sol_new_list(state);
-			sol_list_insert(state, newls, 0, indexf);
-			sol_list_append(state, newls, args);
-			res = indexf->ops->call(state, newls);
-			sol_obj_free(newls);
-		} else if(indexf->ops->index && indexf->ops->index != sol_f_not_impl) {
-            newls = sol_new_list(state);
-            sol_list_insert(state, newls, 0, indexf);
-            sol_list_insert(state, newls, 1, b);
-			res = indexf->ops->index(state, newls);
-			sol_obj_free(newls);
+	res = sol_map_get(state, map, b);
+	if(sol_is_none(state, res)) {
+		if(!sol_is_none(state, indexf)) {
+			sol_obj_free(res);
+			if(indexf->ops->call && (sol_is_func(indexf) || sol_is_cfunc(indexf)) && indexf->ops->call != sol_f_not_impl) {
+				newls = sol_new_list(state);
+				sol_list_insert(state, newls, 0, indexf);
+				sol_list_append(state, newls, args);
+				res = indexf->ops->call(state, newls);
+				sol_obj_free(newls);
+			} else if(indexf->ops->index && indexf->ops->index != sol_f_not_impl) {
+				newls = sol_new_list(state);
+				sol_list_insert(state, newls, 0, indexf);
+				sol_list_insert(state, newls, 1, b);
+				res = indexf->ops->index(state, newls);
+				sol_obj_free(newls);
+			}
 		}
 	}
-	if(!res) res = sol_map_get(state, map, b);
 	sol_obj_free(indexf);
 	sol_obj_free(map);
 	sol_obj_free(b);
@@ -1120,9 +1181,38 @@ sol_object_t *sol_f_map_iter(sol_state_t *state, sol_object_t *args) {
 }
 
 sol_object_t *sol_f_map_tostring(sol_state_t *state, sol_object_t *args) {
-	sol_object_t *cur = sol_new_string(state, "{"), *next, *str, *obj = sol_list_get_index(state, args, 0), *item;
-	dsl_seq_iter *iter = dsl_new_seq_iter(obj->seq);
+	sol_object_t *map = sol_list_get_index(state, args, 0), *res;
+	sol_object_t *tostrf = sol_map_get_name(state, map, "__tostring"), *fargs;
+	if(!sol_is_none(state, tostrf) && tostrf->ops->call) {
+		fargs = sol_new_list(state);
+		sol_list_insert(state, fargs, 0, tostrf);
+		sol_list_insert(state, fargs, 1, map);
+		res = tostrf->ops->call(state, fargs);
+		sol_obj_free(fargs);
+	} else {
+		res = sol_cast_repr(state, map);
+	}
+	sol_obj_free(tostrf);
+	sol_obj_free(map);
+	return res;
+}
+
+sol_object_t *sol_f_map_repr(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *cur = sol_new_string(state, "{"), *next, *str, *obj = sol_list_get_index(state, args, 0), *item, *reprf = sol_map_get_name(state, obj, "__repr"), *fargs;
+	dsl_seq_iter *iter;
 	char s[64];
+	if(!sol_is_none(state, reprf) && reprf->ops->call) {
+		sol_obj_free(cur);
+		fargs = sol_new_list(state);
+		sol_list_insert(state, fargs, 0, reprf);
+		sol_list_insert(state, fargs, 1, obj);
+		cur = reprf->ops->call(state, fargs);
+		sol_obj_free(fargs);
+		sol_obj_free(obj);
+		sol_obj_free(reprf);
+		return cur;
+	}
+	iter = dsl_new_seq_iter(obj->seq);
 	while(!dsl_seq_iter_is_invalid(iter)) {
 		item = AS_OBJ(dsl_seq_iter_at(iter));
 		if(test_seen(item)) {
@@ -1293,6 +1383,10 @@ sol_object_t *sol_f_astnode_index(sol_state_t *state, sol_object_t *args) {
 	if(sol_is_aststmt(obj)) {
 		if(sol_string_eq(state, str, "type")) {
 			res = sol_new_int(state, stmt->type);
+		} else if(sol_string_eq(state, str, "loc")) {
+			res = sol_new_map(state);
+			sol_map_set_name(state, res, "line", sol_new_int(state, stmt->loc.line));
+			sol_map_set_name(state, res, "col", sol_new_int(state, stmt->loc.col));
 		} else {
 			switch(stmt->type) {
 					case ST_EXPR:
@@ -1350,6 +1444,10 @@ sol_object_t *sol_f_astnode_index(sol_state_t *state, sol_object_t *args) {
 	} else {
 		if(sol_string_eq(state, str, "type")) {
 			res = sol_new_int(state, expr->type);
+		} else if(sol_string_eq(state, str, "loc")) {
+			res = sol_new_map(state);
+			sol_map_set_name(state, res, "line", sol_new_int(state, expr->loc.line));
+			sol_map_set_name(state, res, "col", sol_new_int(state, expr->loc.col));
 		} else {
 			switch(expr->type) {
 				case EX_LIT:
@@ -1482,15 +1580,26 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 	stmt_node *stmt = (stmt_node *) obj->node;
 	stmtlist_node *curs, *prevs;
 	expr_node *expr = (expr_node *) obj->node;
-	exprlist_node *cure, *preve;
-	assoclist_node *cura, *preva;
-	identlist_node *curi, *previ;
+	exprlist_node *cure, *preve = NULL;
+	assoclist_node *cura, *preva = NULL;
+	identlist_node *curi, *previ = NULL;
 	int i=0, len;
 	if(sol_is_aststmt(obj)) {
 		if(sol_string_eq(state, str, "type")) {
 			ival = sol_cast_int(state, val);
 			stmt->type = ival->ival;
 			sol_obj_free(ival);
+		} else if(sol_string_eq(state, str, "loc") && sol_is_map(val)) {
+			pair = sol_map_get_name(state, val, "line");
+			ival = sol_cast_int(state, pair);
+			stmt->loc.line = ival->ival;
+			sol_obj_free(ival);
+			sol_obj_free(pair);
+			pair = sol_map_get_name(state, val, "col");
+			ival = sol_cast_int(state, pair);
+			stmt->loc.col = ival->ival;
+			sol_obj_free(ival);
+			sol_obj_free(pair);
 		} else {
 			switch(stmt->type) {
 				case ST_EXPR:
@@ -1543,8 +1652,9 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 									prevs->next = curs;
 								}
 							}
+							if(stmt->stmtlist == curs) stmt->stmtlist = NULL;
 							free(curs);
-							prevs->next = NULL;
+							if(prevs) prevs->next = NULL;
 						} else {
 							stmt->stmtlist = NULL;
 						}
@@ -1563,6 +1673,17 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 			ival = sol_cast_int(state, val);
 			expr->type = ival->ival;
 			sol_obj_free(ival);
+		} else if(sol_string_eq(state, str, "loc") && sol_is_map(val)) {
+			pair = sol_map_get_name(state, val, "line");
+			ival = sol_cast_int(state, pair);
+			expr->loc.line = ival->ival;
+			sol_obj_free(ival);
+			sol_obj_free(pair);
+			pair = sol_map_get_name(state, val, "col");
+			ival = sol_cast_int(state, pair);
+			expr->loc.col = ival->ival;
+			sol_obj_free(ival);
+			sol_obj_free(pair);
 		} else {
 			switch(expr->type) {
 				case EX_LIT:
@@ -1592,15 +1713,16 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 							cure = malloc(sizeof(exprlist_node));
 							expr->listgen->list = cure;
 							for(i=0; i<len; i++) {
-								if(sol_is_aststmt(sol_list_get_index(state, val, i))) {
+								if(sol_is_astexpr(sol_list_get_index(state, val, i))) {
 									cure->expr = sol_list_get_index(state, val, i)->node;
 									preve = cure;
 									cure = malloc(sizeof(exprlist_node));
 									preve->next = cure;
 								}
 							}
+							if(expr->listgen->list == cure) expr->listgen->list = NULL;
 							free(cure);
-							preve->next = NULL;
+							if(preve) preve->next = NULL;
 						} else {
 							expr->listgen->list = NULL;
 						}
@@ -1626,8 +1748,9 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 									}
 								}
 							}
+							if(expr->mapgen->map == cura) expr->mapgen->map = NULL;
 							free(cura);
-							preva->next = NULL;
+							if(preva) preva->next = NULL;
 						} else {
 							expr->mapgen->map = NULL;
 						}
@@ -1701,15 +1824,16 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 							cure = malloc(sizeof(exprlist_node));
 							expr->call->args= cure;
 							for(i=0; i<len; i++) {
-								if(sol_is_aststmt(sol_list_get_index(state, val, i))) {
+								if(sol_is_astexpr(sol_list_get_index(state, val, i))) {
 									cure->expr = sol_list_get_index(state, val, i)->node;
 									preve = cure;
 									cure = malloc(sizeof(exprlist_node));
 									preve->next = cure;
 								}
 							}
+							if(expr->call->args == cure) expr->call->args = NULL;
 							free(cure);
-							preve->next = NULL;
+							if(preve) preve->next = NULL;
 						} else {
 							expr->call->args = NULL;
 						}
@@ -1727,17 +1851,16 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 							curi = malloc(sizeof(identlist_node));
 							expr->funcdecl->args= curi;
 							for(i=0; i<len; i++) {
-								if(sol_is_aststmt(sol_list_get_index(state, val, i))) {
-									sval = sol_cast_string(state, sol_list_get_index(state, val, i));
-									curi->ident = strdup(sval->str);
-									sol_obj_free(sval);
-									previ = curi;
-									curi = malloc(sizeof(identlist_node));
-									previ->next = curi;
-								}
+								sval = sol_cast_string(state, sol_list_get_index(state, val, i));
+								curi->ident = strdup(sval->str);
+								sol_obj_free(sval);
+								previ = curi;
+								curi = malloc(sizeof(identlist_node));
+								previ->next = curi;
 							}
+							if(expr->funcdecl->args == curi) expr->funcdecl->args = NULL;
 							free(curi);
-							previ->next = NULL;
+							if(previ) previ->next = NULL;
 						} else {
 							expr->funcdecl->args = NULL;
 						}
@@ -1751,11 +1874,10 @@ sol_object_t *sol_f_astnode_setindex(sol_state_t *state, sol_object_t *args) {
 	sol_obj_free(obj);
 	sol_obj_free(key);
 	sol_obj_free(str);
-	sol_obj_free(val);
-	return sol_incref(state->None);
+	return val;
 }
 
-static char *sol_StmtNames[]={"EXPR", "IFSELSE", "LOOP", "ITER", "RET", "CONT", "BREAK"};
+static char *sol_StmtNames[]={"EXPR", "IFSELSE", "LOOP", "ITER", "LIST", "RET", "CONT", "BREAK"};
 static char *sol_ExprNames[]={"LIT", "LISTGEN", "MAPGEN", "BINOP", "UNOP", "INDEX", "SETINDEX", "ASSIGN", "REF", "CALL", "FUNCDECL"}; 
 
 sol_object_t *sol_f_astnode_tostring(sol_state_t *state, sol_object_t *args) {
@@ -2161,7 +2283,7 @@ sol_object_t *sol_f_stream_read(sol_state_t *state, sol_object_t *args) {
 		iamt = sol_cast_int(state, amt);
 		s = malloc((iamt->ival + 1)*sizeof(char));
 		count = sol_stream_fread(state, stream, s, sizeof(char), iamt->ival);
-		s[iamt->ival]='\0';
+		s[count]='\0';
 		sol_obj_free(iamt);
 	}
 	if(s) {
@@ -2201,6 +2323,12 @@ sol_object_t *sol_f_stream_flush(sol_state_t *state, sol_object_t *args) {
 	return res;
 }
 
+sol_object_t *sol_f_stream_eof(sol_state_t *state, sol_object_t *args) {
+	sol_object_t *stream = sol_list_get_index(state, args, 0), *res = sol_new_int(state, sol_stream_feof(state, stream));
+	sol_obj_free(stream);
+	return res;
+}
+
 static char *sol_FileModes[]={
 	NULL,
 	"r",

gc.c

@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include "sol.h"
+
+#ifdef DEBUG_GC
+
+#else
+
+sol_object_t *sol_alloc_object(sol_state_t *state) {
+	sol_object_t *res = malloc(sizeof(sol_object_t));
+	if(!res) {
+		sol_set_error(state, state->OutOfMemory);
+		return sol_incref(state->None);
+	}
+	res->refcnt = 0;
+	res->ops = &(state->NullOps);
+	return sol_incref(res);
+}
+
+sol_object_t *sol_obj_acquire(sol_object_t *obj) {
+	return sol_incref(obj);
+}
+
+void sol_obj_free(sol_object_t *obj) {
+	if(!obj) {
+		printf("WARNING: Attempt to free NULL\n");
+		return;
+	}
+	if(sol_decref(obj) <= 0) {
+		if(obj->refcnt < 0) {
+			printf("WARNING: Encountered refcnt < 0!\nObject %p type %d ref %d\n", obj, obj->type, obj->refcnt);
+		} else {
+			sol_obj_release(obj);
+		}
+	}
+}
+
+void sol_obj_release(sol_object_t *obj) {
+    if(obj->ops->free) obj->ops->free(NULL, obj);
+    free(obj);
+}
+
+#endif

interp.sol

@@ -56,6 +56,16 @@ while __interp.running do
 						__interp.result = try(__interp.program[1])
 						if !__interp.result[0] then
 							print(__interp.result[1])
+							print(__interp.result[2])
+							for ent in __interp.result[2] do
+								st = ent[0]
+								scope = ent[1]
+								if st.type == ast.ST_LIST then continue end
+								print('In', st, 'at', st.loc.line, ',', st.loc.col, ':')
+								ast.print(st)
+								print(scope)
+								print('---')
+							end
 						else
 							if __interp.isexpr then
 								prepr(__interp.result[1])

lex.yy.c

@@ -8,7 +8,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 39
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -161,12 +161,7 @@ typedef unsigned int flex_uint32_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-extern yy_size_t yyleng;
+extern int yyleng;
 
 extern FILE *yyin, *yyout;
 
@@ -175,7 +170,6 @@ extern FILE *yyin, *yyout;
 #define EOB_ACT_LAST_MATCH 2
 
     #define YY_LESS_LINENO(n)
-    #define YY_LINENO_REWIND_TO(ptr)
     
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
@@ -193,6 +187,11 @@ extern FILE *yyin, *yyout;
 
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
@@ -210,7 +209,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -280,8 +279,8 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* yy_hold_char holds the character lost when yytext is formed. */
 static char yy_hold_char;
-static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */
-yy_size_t yyleng;
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+int yyleng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
@@ -309,7 +308,7 @@ static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
-YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 
 void *yyalloc (yy_size_t  );
 void *yyrealloc (void *,yy_size_t  );
@@ -605,7 +604,7 @@ static void update_loc(YYLTYPE *yylloc, char *yytext){
 <STRING>. { str_putc(*yytext); }
 
 */
-#line 609 "lex.yy.c"
+#line 608 "lex.yy.c"
 
 #define INITIAL 0
 
@@ -644,7 +643,7 @@ FILE *yyget_out (void );
 
 void yyset_out  (FILE * out_str  );
 
-yy_size_t yyget_leng (void );
+int yyget_leng (void );
 
 char *yyget_text (void );
 
@@ -806,6 +805,11 @@ YY_DECL
     
         YYLTYPE * yylloc;
     
+#line 85 "tokenizer.lex"
+
+
+#line 812 "lex.yy.c"
+
     yylval = yylval_param;
 
     yylloc = yylloc_param;
@@ -836,12 +840,6 @@ YY_DECL
 		yy_load_buffer_state( );
 		}
 
-	{
-#line 85 "tokenizer.lex"
-
-
-#line 844 "lex.yy.c"
-
 	while ( 1 )		/* loops until end-of-file is reached */
 		{
 		yy_cp = (yy_c_buf_p);
@@ -858,7 +856,7 @@ YY_DECL
 yy_match:
 		do
 			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 			if ( yy_accept[yy_current_state] )
 				{
 				(yy_last_accepting_state) = yy_current_state;
@@ -1206,7 +1204,7 @@ YY_RULE_SETUP
 #line 207 "tokenizer.lex"
 ECHO;
 	YY_BREAK
-#line 1210 "lex.yy.c"
+#line 1208 "lex.yy.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1337,7 +1335,6 @@ case YY_STATE_EOF(INITIAL):
 			"fatal flex scanner internal error--no action found" );
 	} /* end of action switch */
 		} /* end of scanning one token */
-	} /* end of user's declarations */
 } /* end of yylex */
 
 /* yy_get_next_buffer - try to read in a new buffer
@@ -1393,21 +1390,21 @@ static int yy_get_next_buffer (void)
 
 	else
 		{
-			yy_size_t num_to_read =
+			int num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
 			int yy_c_buf_p_offset =
 				(int) ((yy_c_buf_p) - b->yy_ch_buf);
 
 			if ( b->yy_is_our_buffer )
 				{
-				yy_size_t new_size = b->yy_buf_size * 2;
+				int new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1438,7 +1435,7 @@ static int yy_get_next_buffer (void)
 
 		/* Read in more data. */
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			(yy_n_chars), num_to_read );
+			(yy_n_chars), (size_t) num_to_read );
 
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 		}
@@ -1533,7 +1530,7 @@ static int yy_get_next_buffer (void)
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 	yy_is_jam = (yy_current_state == 111);
 
-		return yy_is_jam ? 0 : yy_current_state;
+	return yy_is_jam ? 0 : yy_current_state;
 }
 
     static void yyunput (int c, register char * yy_bp )
@@ -1548,7 +1545,7 @@ static int yy_get_next_buffer (void)
 	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		register yy_size_t number_to_move = (yy_n_chars) + 2;
+		register int number_to_move = (yy_n_chars) + 2;
 		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
 					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 		register char *source =
@@ -1597,7 +1594,7 @@ static int yy_get_next_buffer (void)
 
 		else
 			{ /* need more input */
-			yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
+			int offset = (yy_c_buf_p) - (yytext_ptr);
 			++(yy_c_buf_p);
 
 			switch ( yy_get_next_buffer(  ) )
@@ -1757,6 +1754,10 @@ static void yy_load_buffer_state  (void)
 	yyfree((void *) b  );
 }
 
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a yyrestart() or at EOF.
@@ -1869,7 +1870,7 @@ void yypop_buffer_state (void)
  */
 static void yyensure_buffer_stack (void)
 {
-	yy_size_t num_to_alloc;
+	int num_to_alloc;
     
 	if (!(yy_buffer_stack)) {
 
@@ -1966,12 +1967,12 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
  * 
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
+YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 {
 	YY_BUFFER_STATE b;
 	char *buf;
 	yy_size_t n;
-	yy_size_t i;
+	int i;
     
 	/* Get memory for full buffer, including space for trailing EOB's. */
 	n = _yybytes_len + 2;
@@ -2053,7 +2054,7 @@ FILE *yyget_out  (void)
 /** Get the length of the current token.
  * 
  */
-yy_size_t yyget_leng  (void)
+int yyget_leng  (void)
 {
         return yyleng;
 }
@@ -2201,7 +2202,7 @@ void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 206 "tokenizer.lex"
+#line 207 "tokenizer.lex"
 
 
 

monty.sol

@@ -0,0 +1,472 @@
+TOK = {LPAREN = 1, RPAREN = 2, INT = 3, BOOL = 4, NAME = 5, QUOTE = 6, EOF = 7}
+keys = []
+for k in TOK do keys:insert(#keys, k) end
+for k in keys do TOK[TOK[k]]=k end
+
+token = {
+	new = func (type, value)
+		return {type = type, value = value, __index = token}
+	end,
+	pretty = func(self)
+		tname = TOK[self.type]
+		tval = tostring(self.value)
+		return '{'+tname+':'+tval+'}'
+	end
+}
+
+tokenizer = {
+	WS = " "+chr(8)+chr(9)+chr(10),
+	NAMESET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ=+-*/.<>?!@$%^~",
+	DIGITS = "0123456789",
+	EOF = {},
+	new = func (str)
+		res = {str = str, pushed = None, __index = tokenizer}
+		res:init()
+		return res
+	end,
+	init = func(self)
+		--print('In init, self is', self)
+		res.cur = res:token()
+		res.next = res:token()
+	end,
+	next_char = func(self)
+		if self.pushed == None then
+			--print('In next_char, self is', self)
+			--print('In next_char, self.str is', self.str)
+			if self.str:eof() then return self.EOF end
+			res = self.str:read(1)
+		else
+			--print('Retrieving from pushback', self.pushed)
+			res = self.pushed[0]
+			self.pushed = self.pushed:sub(1)
+			if self.pushed == "" then self.pushed = None end
+		end
+		--print(res)
+		return res
+	end,
+	push_back = func(self, s)
+		--print('Pushing back', s)
+		if s == self.EOF then print('WARNING: Attempted to push_back EOF'); return end
+		if self.pushed == None then
+			self.pushed = s
+		else
+			self.pushed = s + self.pushed
+		end
+		--print('self.pushed:', self.pushed)
+	end,
+	token = func (self)
+		--print('In token, self is', self)
+		--print('In token, self.str is', self.str)
+		c = self:next_char()
+		while !(c == self.EOF) do
+			if c == "" then return token.new(TOK.EOF, None) end
+			if c == "(" then return token.new(TOK.LPAREN, c) end
+			if c == ")" then return token.new(TOK.RPAREN, c) end
+			if self.NAMESET:find(c) >= 0 then
+				--print('{NAME}')
+				name = c
+				c = self:next_char()
+				while 1 do
+					found = 0
+					if self.NAMESET:find(c) >= 0 then found = 1 end
+					if self.DIGITS:find(c) >= 0 then found = 1 end
+					if !found then break end
+					name += c
+					c = self:next_char()
+					if c == self.EOF then continue end
+				end
+				self:push_back(c)
+				return token.new(TOK.NAME, name)
+			end
+			if self.DIGITS:find(c) >= 0 then
+				val = c
+				c = self:next_char()
+				while self.DIGITS:find(c) >= 0 do
+					val += c
+					c = self:next_char()
+					if c == self.EOF then continue end
+				end
+				self:push_back(c)
+				return token.new(TOK.INT, toint(val))
+			end
+			if c == "#" then
+				c = self:next_char()
+				if c == "t" then return token.new(TOK.BOOL, 1) end
+				if c == "f" then return token.new(TOK.BOOL, 0) end
+				error("Invalid value for bool literal: "+c)
+			end
+			if c == "'" then return token.new(TOK.QUOTE, c) end
+			if self.WS:find(c) >= 0 then
+				c = self:next_char()
+				continue
+			end
+			if c == ";" then
+				c = self:next_char()
+				while 1 do
+					if c == chr(10) then break end
+					c = self:next_char()
+				end
+				c = self:next_char()
+				continue
+			end
+			error("Invalid character in token stream: "+c)
+		end
+		return token.new(TOK.EOF, None)
+	end,
+	advance = func(self)
+		self.cur = self.next
+		self.next = self:token()
+	end
+}
+
+
+
+ttreegen = {
+	new = func(tok)
+		return {tok = tok, __index = ttreegen}
+	end,
+	generate = func(self, consume)
+		res = self.TT_DISPATCH[self.tok.cur.type](self, self.tok.cur)
+		if None == consume then self.tok:advance() end
+		return res
+	end,
+	TT_DISPATCH = {
+		[TOK.LPAREN] = func(self, tok)
+			toklist = []
+			self.tok:advance()
+			tok = self.tok.cur
+			while 1 do
+				if tok.type == TOK.RPAREN then break end
+				if tok.type == TOK.EOF then error('Encountered EOF while matching delimiter') end
+				toklist:insert(#toklist, self.TT_DISPATCH[tok.type](self, tok))
+				self.tok:advance()
+				tok = self.tok.cur
+			end
+			return toklist
+		end,
+		[TOK.RPAREN] = func(self, tok)
+			error("Unexpected right parenthesis")
+		end,
+		[TOK.INT] = func(self, tok)
+			return tok
+		end,
+		[TOK.BOOL] = func(self, tok)
+			return tok
+		end,
+		[TOK.NAME] = func(self, tok)
+			return tok
+		end,
+		[TOK.QUOTE] = func(self, tok)
+			self.tok:advance()
+			tok.quoting = self:generate(0)
+			return tok
+		end,
+		[TOK.EOF] = func(self, tok)
+			return None
+		end
+	}
+}
+
+EX = {CALL=1, ASSIGN=2, FUNCDECL=3, SCOPE=4, IFELSE=5, DATUM=6, LIT=7, REF=8, LIST=9}
+keys = []
+for k in EX do keys:insert(#keys, k) end
+for k in keys do EX[EX[k]]=k end
+
+node = {
+	new = func(type, value)
+		return {type=type, value=value, __index=node}
+	end,
+	pretty = func(self) return self.PRETTY_DISPATCH[self.type](self) end
+	PRETTY_DISPATCH = {
+		[EX.CALL] = func(self)
+			return '<CALL NAME='+(self.value.name)+' ARGS='+tostring(self.value.args:copy():map(func(i) if !(None == i) then return i:pretty() else return tostring(i) end end))+'>'
+		end,
+		[EX.ASSIGN] = func(self)
+			return '<ASSIGN NAME='+(self.value.name)+' VALUE='+(self.value.value:pretty())+'>'
+		end,
+		[EX.FUNCDECL] = func(self)
+			return '<FUNCDECL PARAMS='+tostring(self.value.params)+' BODY='+(self.value.body:pretty())+'>'
+		end,
+		[EX.SCOPE] = func(self)
+			return '<SCOPE '+(self.value:copy():map(func(i) return i:pretty() end))+'>'
+		end,
+		[EX.IFELSE] = func(self)
+			return '<IFELSE COND='+(self.value.cond:pretty())+' IFT='+(self.value.ift:pretty())+' IFF='+(self.value.iff:pretty())+'>'
+		end,
+		[EX.DATUM] = func(self)
+			return '#'+tostring(self.value)
+		end,
+		[EX.LIT] = func(self)
+			if type(self.value) == 'list' then
+				return '/'+tostring(self.value:copy():map(func(i) return i:pretty() end))
+			end
+			return '/'+tostring(self.value)
+		end,
+		[EX.REF] = func(self)
+			--print('In EX.REF, self is', self)
+			res = '@'+tostring(self.value)
+			--print('In EX.REF, returning', res)
+			return res
+		end,
+		[EX.LIST] = func(self)
+			--print('In EX.LIST, self is', self)
+			return '<LIST '+(self.value:copy():map(func(i) return i:pretty() end))+'>'
+		end
+	}
+}
+
+parser = {
+	new = func(ttgen)
+		return {ttgen = ttgen, __index = parser}
+	end,
+	parse = func(self, tt)
+		if type(tt) == 'map' then
+			--print('In parse, self is', self)
+			--print('In parse, tt is', tt)
+			--print('In parse, dispatch to', self.TT_PARSE_DISPATCH[tt.type])
+			res = self.TT_PARSE_DISPATCH[tt.type](self, tt)
+		else
+			name = tt[0]
+			if !(name.type == TOK.NAME) then
+				error('Expected name as first element of expression-list')
+			end
+			rest = tt:copy()
+			rest:remove(0)
+			sc = self.SCALL_DISPATCH[name.value]
+			if !(None == sc) then
+				sc = None
+				res = self.SCALL_DISPATCH[name.value](self, rest)
+			else
+				res = node.new(EX.CALL, {name=name.value, args=rest:map(func(i) return self:parse(i) end)})
+			end
+		end
+		--print('In parse, returning', res:pretty())
+		return res
+	end,
+	TT_PARSE_DISPATCH = {
+		[TOK.INT] = func(self, tok)
+			return node.new(EX.LIT, tok.value)
+		end,
+		[TOK.BOOL] = func(self, tok)
+			return node.new(EX.LIT, tok.value)
+		end,
+		[TOK.NAME] = func(self, tok)
+			--print('In TOK.NAME, tok is', tok)
+			res =  node.new(EX.REF, tok.value)
+			--print('In TOK.NAME, returning', res)
+			return res
+		end,
+		[TOK.QUOTE] = func(self, tok)
+			return self:parse_datum(tok.quoting)
+		end
+	},
+	SCALL_DISPATCH = {
+		define = func(self, args)
+			name = args[0]
+			if !(name.type == TOK.NAME) then error('Define: expected name as first argument') end
+			value = self:parse(args[1])
+			return node.new(EX.ASSIGN, {name=name.value, value=value})
+		end,
+		["if"] = func(self, args)
+			cond = self:parse(args[0])
+			ift = self:parse(args[1])
+			iff = self:parse(args[2])
+			return node.new(EX.IFELSE, {cond=cond, ift=ift, iff=iff})
+		end,
+		begin = func(self, args)
+			args:map(func(i) return self:parse(i) end)
+			return node.new(EX.LIST, args)
+		end,
+		lambda = func(self, args)
+			--print('Lambda args:', args)
+			params = args[0]
+			if !(type(params) == 'list') then error('Lambda: expected parameters as first argument (got '+tostring(params)+')') end
+			params:map(func(i)
+				if !(type(i) == 'map') then error('Lambda: expected name token in argument list (got sublist)') end
+				if !(i.type == TOK.NAME) then error('Lambda: expected name token in argument list (got '+(i:pretty())+')') end
+				return i.value
+			end)
+			body = args:copy()
+			body:remove(0)
+			--print('Lambda body:', body)
+			body:map(func(i) return self:parse(i) end)
+			return node.new(EX.FUNCDECL, {params=params, body=node.new(EX.LIST, body)})
+		end,
+		let = func(self, args)
+			defs = args[0]
+			if !(type(defs) == 'list') then error('Let: expected list of bindings are first argument') end
+			defs:map(func(i)
+				if !(type(i) == 'list') then error('Let: expected a binding entry') end
+				return self.SCALL_DISPATCH.define(self, i)
+			end)
+			body = args:copy()
+			body:remove(0)
+			body:map(func(i) return self:parse(i) end)
+			return node.new(EX.SCOPE, defs+body)
+		end,
+		letrec = func(self, args)
+			defs = args[0]
+			if !(type(defs) == 'list') then error('Let: expected list of bindings are first argument') end
+			defs:map(func(i)
+				if !(type(i) == 'list') then error('Let: expected a binding entry') end
+				return self.SCALL_DISPATCH.define(self, i)
+			end)
+			body = args:copy()
+			body:remove(0)
+			body:map(func(i) return self:parse(i) end)
+			return node.new(EX.LIST, defs+body)
+		end
+	}
+	parse_datum = func(self, tt)
+		if type(tt) == 'map' then
+			return self.TT_PARSE_DATUM_DISPATCH[tt.type](self, tt)
+		else
+			list = []
+			for tok in tt do
+				list:insert(#list, self:parse_datum(tok))
+			end
+			return node.new(EX.LIT, list)
+		end
+	end,
+	TT_PARSE_DATUM_DISPATCH = {
+		[TOK.INT] = func(self, tok)
+			return node.new(EX.LIT, tok.value)
+		end,
+		[TOK.BOOL] = func(self, tok)
+			return node.new(EX.LIT, tok.value)
+		end,
+		[TOK.NAME] = func(self, tok)
+			return node.new(EX.LIT, tok.value)
+		end,
+		[TOK.QUOTE] = func(self, tok)
+			return self:parse(tok.quoting)
+		end
+	},
+	run = func(self)
+		tt = self.ttgen:generate()
+		list = []
+		while 1 do
+			if None == tt then break end
+			--if type(tt) == 'list' then
+				list:insert(#list, self:parse(tt))
+			--end
+			tt = self.ttgen:generate()
+		end
+		--print('In run, list is', list)
+		return node.new(EX.LIST, list)
+	end
+}
+
+converter = {
+	new = func(p)
+		return {parser=p, __index = converter}
+	end,
+	make = func(self, node)
+		--print('In make, node is a', EX[node.type], 'of value', node)
+		res = self.MAKE_DISPATCH[node.type](self, node)
+		--print('In make, returning', res)
+		if type(res) == "astnode" then ast.print(res) end
+		return res
+	end,
+	MAKE_DISPATCH = {
+		[EX.CALL] = func(self, node)
+			e = parse('f()').stmtlist[0].expr
+			e.expr.ident = node.value.name
+			args = node.value.args:copy():map(func(i) return self:make(i) end)
+			--print('In EX.CALL, replacement args are', args)
+			e.args = args
+			--print('In EX.CALL, args are', e.args)
+			return e
+		end,
+		[EX.ASSIGN] = func(self, node)
+			e = parse('a = b').stmtlist[0].expr
+			e.ident = node.value.name
+			e.value = self:make(node.value.value)
+			return e
+		end,
+		[EX.FUNCDECL] = func(self, node)
+			e = parse('func() None None end').stmtlist[0].expr
+			params = node.value.params
+			--print('In EX.FUNCDECL, params are', params)
+			e.args = params
+			--print('In EX.FUNCDECL, args are', e.args)
+			e.body.stmtlist = self:make(node.value.body)
+			return e
+		end,
+		[EX.SCOPE] = func(self, node)
+			e = parse('(func() None None end)()').stmtlist[0].expr
+			node.type = EX.LIST
+			e.expr.body.stmtlist = self:make(node)
+			node.type = EX.SCOPE
+			return e
+		end,
+		[EX.IFELSE] = func(self, node)
+			e = parse('(func() if None then return None else return None end end)()').stmtlist[0].expr
+			e.expr.body.stmtlist[0].cond = self:make(node.value.cond)
+			e.expr.body.stmtlist[0].iftrue.stmtlist[0].ret = self:make(node.value.ift)
+			e.expr.body.stmtlist[0].iffalse.stmtlist[0].ret = self:make(node.value.iff)
+			return e
+		end,
+		[EX.DATUM] = func(self, node) error('EX.DATUM: Not implemented') end,
+		[EX.LIT] = func(self, node)
+			if type(node.value) == 'list' then
+				e = parse('[None]').stmtlist[0].expr
+				e.list = node.value:copy():map(func(i) return self:make(i) end)
+			else
+				e = parse('None').stmtlist[0].expr
+				if type(node.value) == "int" then
+					e.littype = ast.LIT_INT
+					e.ival = node.value
+				end
+				if type(node.value) == "string" then
+					e.littype = ast.LIT_STRING
+					e.str = node.value
+				end
+			end
+			return e
+		end,
+		[EX.REF] = func(self, node)
+			e = parse('a').stmtlist[0].expr
+			e.ident = node.value
+			return e
+		end,
+		[EX.LIST] = func(self, node)
+			e = parse('func() None end').stmtlist[0].expr
+			l = node.value:copy()
+			l:map(func(i)
+				s = parse('None').stmtlist[0]
+				s.expr = self:make(i)
+				return s
+			end)
+			lastidx = (#l) - 1
+			r = parse('return None').stmtlist[0]
+			r.ret = l[lastidx].expr
+			l[lastidx] = r
+			--print('In EX.LIST, e is now' e)
+			e.body.stmtlist = l
+			return e.body.stmtlist
+		end
+	},
+	run = func(self)
+		list = self:make(self.parser:run())
+		res = parse('(func() None None end)()')
+		--print('In run, list is', list)
+		--for i in list do ast.print(i) end
+		res.stmtlist[0].expr.expr.body.stmtlist = list
+		return res
+	end
+}
+
+_G = debug.globals()
+_G['+'] = func(a, b) return a + b end
+_G['-'] = func(a, b) return a - b end
+_G['*'] = func(a, b) return a * b end
+_G['/'] = func(a, b) return a / b end
+_G['<'] = func(a, b) return a < b end
+_G['>'] = func(a, b) return a > b end
+_G['<='] = func(a, b) return a <= b end
+_G['>='] = func(a, b) return a >= b end
+_G['=='] = func(a, b) return a == b end
+_G['eq'] = _G['==']
+_G['or'] = func(a, b) return a || b end
+_G['and'] = func(a, b) return a && b end

object.c

@@ -55,49 +55,15 @@ sol_object_t *sol_new_singlet(sol_state_t *state, const char *name) {
 		res->ops = &(state->SingletOps);
 		res->str = strdup(name);
 	}
-	return sol_incref(res);
+	return sol_incref(res); // XXX Segfault
 }
 
 // And, now, for the rest of the checked stuff...
 
-sol_object_t *sol_alloc_object(sol_state_t *state) {
-	sol_object_t *res = malloc(sizeof(sol_object_t));
-	if(!res) {
-		sol_set_error(state, state->OutOfMemory);
-		return sol_incref(state->None);
-	}
-	res->refcnt = 0;
-	res->ops = &(state->NullOps);
-	return sol_incref(res);
-}
-
 void sol_init_object(sol_state_t *state, sol_object_t *obj) {
 	if(obj->ops->init) obj->ops->init(state, obj);
 }
 
-sol_object_t *sol_obj_acquire(sol_object_t *obj) {
-	return sol_incref(obj);
-}
-
-void sol_obj_free(sol_object_t *obj) {
-	if(!obj) {
-		printf("WARNING: Attempt to free NULL\n");
-		return;
-	}
-	if(sol_decref(obj) <= 0) {
-		if(obj->refcnt < 0) {
-			printf("WARNING: Encountered refcnt < 0!\nObject %p type %d ref %d\n", obj, obj->type, obj->refcnt);
-		} else {
-			sol_obj_release(obj);
-		}
-	}
-}
-
-void sol_obj_release(sol_object_t *obj) {
-    if(obj->ops->free) obj->ops->free(NULL, obj);
-    free(obj);
-}
-
 sol_object_t *sol_new_int(sol_state_t *state, long i) {
 	sol_object_t *res = sol_alloc_object(state);
 	res->type = SOL_INTEGER;
@@ -549,7 +515,7 @@ size_t sol_stream_printf(sol_state_t *state, sol_object_t *stream, const char *f
 	va_list va;
 	size_t res;
 	if(!(stream->modes & MODE_WRITE)) {
-		sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
+		if(state) sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
 		return 0;
 	}
 	va_start(va, fmt);
@@ -558,11 +524,19 @@ size_t sol_stream_printf(sol_state_t *state, sol_object_t *stream, const char *f
 	return res;
 }
 
+size_t sol_stream_vprintf(sol_state_t *state, sol_object_t *stream, const char *fmt, va_list va) {
+	if(!(stream->modes & MODE_WRITE)) {
+		if(state) sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
+		return 0;
+	}
+	return vfprintf(stream->stream, fmt, va);
+}
+
 size_t sol_stream_scanf(sol_state_t *state, sol_object_t *stream, const char *fmt, ...) {
 	va_list va;
 	size_t res;
 	if(!(stream->modes & MODE_READ)) {
-		sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
+		if(state) sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
 		return 0;
 	}
 	va_start(va, fmt);
@@ -573,7 +547,7 @@ size_t sol_stream_scanf(sol_state_t *state, sol_object_t *stream, const char *fm
 
 size_t sol_stream_fread(sol_state_t *state, sol_object_t *stream, char *buffer, size_t sz, size_t memb) {
 	if(!(stream->modes & MODE_READ)) {
-		sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
+		if(state) sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
 		return 0;
 	}
 	return fread(buffer, sz, memb, stream->stream);
@@ -581,7 +555,7 @@ size_t sol_stream_fread(sol_state_t *state, sol_object_t *stream, char *buffer,
 
 size_t sol_stream_fwrite(sol_state_t *state, sol_object_t *stream, char *buffer, size_t sz, size_t memb) {
 	if(!(stream->modes & MODE_WRITE)) {
-		sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
+		if(state) sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
 		return 0;
 	}
 	return fwrite(buffer, sz, memb, stream->stream);
@@ -589,12 +563,20 @@ size_t sol_stream_fwrite(sol_state_t *state, sol_object_t *stream, char *buffer,
 
 char *sol_stream_fgets(sol_state_t *state, sol_object_t *stream, char *buffer, size_t sz) {
 	if(!(stream->modes & MODE_READ)) {
-		sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
+		if(state) sol_obj_free(sol_set_error_string(state, "Read from non-readable stream"));
 		return NULL;
 	}
 	return fgets(buffer, sz, stream->stream);
 }
 
+int sol_stream_fputc(sol_state_t *state, sol_object_t *stream, int ch) {
+	if(!(stream->modes & MODE_WRITE)) {
+		if(state) sol_obj_free(sol_set_error_string(state, "Write to non-writable stream"));
+		return 0;
+	}
+	return fputc(ch, stream->stream);
+}
+
 int sol_stream_feof(sol_state_t *state, sol_object_t *stream) {
 	return feof(stream->stream);
 }

parser.output

@@ -61,7 +61,7 @@ Grammar
     1 program: stmt_list
 
     2 stmt_list: stmt_list stmt
-    3          | %empty
+    3          | /* empty */
 
     4 stmt: expr
     5     | IF expr THEN stmt_list END
@@ -164,17 +164,17 @@ Grammar
 
    85 paren_expr: LPAREN expr RPAREN
 
-   86 expr_list: %empty
+   86 expr_list: /* empty */
    87          | expr
    88          | expr_list COMMA
    89          | expr_list expr
 
-   90 ident_list: %empty
+   90 ident_list: /* empty */
    91           | IDENT
    92           | ident_list COMMA
    93           | ident_list IDENT
 
-   94 assoc_list: %empty
+   94 assoc_list: /* empty */
    95           | assoc_item
    96           | assoc_list COMMA
    97           | assoc_list assoc_item
@@ -309,7 +309,7 @@ State 0
     0 $accept: . program $end
     1 program: . stmt_list
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
 
     $default  reduce using rule 3 (stmt_list)
 
@@ -1122,7 +1122,7 @@ State 18
 State 19
 
    83 gen_expr: LBRACE . assoc_list RBRACE
-   94 assoc_list: . %empty  [IDENT, RBRACE, LBRACKET, COMMA]
+   94 assoc_list: .  [IDENT, RBRACE, LBRACKET, COMMA]
    95           | . assoc_item
    96           | . assoc_list COMMA
    97           | . assoc_list assoc_item
@@ -1325,7 +1325,7 @@ State 21
    83         | . LBRACE assoc_list RBRACE
    84         | . paren_expr
    85 paren_expr: . LPAREN expr RPAREN
-   86 expr_list: . %empty  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, LBRACKET, RBRACKET, COMMA, POUND]
+   86 expr_list: .  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, LBRACKET, RBRACKET, COMMA, POUND]
    87          | . expr
    88          | . expr_list COMMA
    89          | . expr_list expr
@@ -1742,7 +1742,7 @@ State 45
 State 46
 
    67 funcdecl_expr: FUNC LPAREN . ident_list RPAREN stmt_list END
-   90 ident_list: . %empty  [IDENT, RPAREN, COMMA]
+   90 ident_list: .  [IDENT, RPAREN, COMMA]
    91           | . IDENT
    92           | . ident_list COMMA
    93           | . ident_list IDENT
@@ -5353,7 +5353,7 @@ State 90
    83         | . LBRACE assoc_list RBRACE
    84         | . paren_expr
    85 paren_expr: . LPAREN expr RPAREN
-   86 expr_list: . %empty  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, RPAREN, LBRACKET, COMMA, POUND]
+   86 expr_list: .  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, RPAREN, LBRACKET, COMMA, POUND]
    87          | . expr
    88          | . expr_list COMMA
    89          | . expr_list expr
@@ -6408,7 +6408,7 @@ State 100
 State 101
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
     5 stmt: IF expr THEN . stmt_list END
     6     | IF expr THEN . stmt_list ELSE stmt_list END
 
@@ -6420,7 +6420,7 @@ State 101
 State 102
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
     7 stmt: WHILE expr DO . stmt_list END
 
     $default  reduce using rule 3 (stmt_list)
@@ -6541,7 +6541,7 @@ State 103
 State 104
 
    66 funcdecl_expr: FUNC IDENT LPAREN . ident_list RPAREN stmt_list END
-   90 ident_list: . %empty  [IDENT, RPAREN, COMMA]
+   90 ident_list: .  [IDENT, RPAREN, COMMA]
    91           | . IDENT
    92           | . ident_list COMMA
    93           | . ident_list IDENT
@@ -8099,7 +8099,7 @@ State 160
 State 161
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
    67 funcdecl_expr: FUNC LPAREN ident_list RPAREN . stmt_list END
 
     $default  reduce using rule 3 (stmt_list)
@@ -8235,7 +8235,7 @@ State 167
    83         | . LBRACE assoc_list RBRACE
    84         | . paren_expr
    85 paren_expr: . LPAREN expr RPAREN
-   86 expr_list: . %empty  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, RPAREN, LBRACKET, COMMA, POUND]
+   86 expr_list: .  [FUNC, NONE, IDENT, INT, FLOAT, STRING, MINUS, BNOT, LNOT, LBRACE, LPAREN, RPAREN, LBRACKET, COMMA, POUND]
    87          | . expr
    88          | . expr_list COMMA
    89          | . expr_list expr
@@ -8293,7 +8293,7 @@ State 167
 State 168
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
     6 stmt: IF expr THEN stmt_list ELSE . stmt_list END
 
     $default  reduce using rule 3 (stmt_list)
@@ -8318,7 +8318,7 @@ State 170
 State 171
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
     8 stmt: FOR IDENT IN expr DO . stmt_list END
 
     $default  reduce using rule 3 (stmt_list)
@@ -8329,7 +8329,7 @@ State 171
 State 172
 
     2 stmt_list: . stmt_list stmt
-    3          | . %empty
+    3          | .
    66 funcdecl_expr: FUNC IDENT LPAREN ident_list RPAREN . stmt_list END
 
     $default  reduce using rule 3 (stmt_list)

parser.tab.h

@@ -1,19 +1,19 @@
-/* A Bison parser, made by GNU Bison 3.0.2.  */
+/* A Bison parser, made by GNU Bison 2.7.12-4996.  */
 
 /* Bison interface for Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
-
+   
+      Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
-
+   
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-
+   
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
@@ -26,13 +26,13 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-
+   
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
 #ifndef YY_YY_PARSER_TAB_H_INCLUDED
 # define YY_YY_PARSER_TAB_H_INCLUDED
-/* Debug traces.  */
+/* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
 #endif
@@ -40,94 +40,106 @@
 extern int yydebug;
 #endif
 
-/* Token type.  */
+/* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
-  enum yytokentype
-  {
-    IF = 258,
-    THEN = 259,
-    ELSE = 260,
-    WHILE = 261,
-    FOR = 262,
-    IN = 263,
-    DO = 264,
-    FUNC = 265,
-    RETURN = 266,
-    BREAK = 267,
-    CONTINUE = 268,
-    END = 269,
-    NONE = 270,
-    IDENT = 271,
-    INT = 272,
-    FLOAT = 273,
-    STRING = 274,
-    PLUS = 275,
-    MINUS = 276,
-    STAR = 277,
-    SLASH = 278,
-    PERCENT = 279,
-    DSTAR = 280,
-    BAND = 281,
-    BOR = 282,
-    BXOR = 283,
-    BNOT = 284,
-    LAND = 285,
-    LOR = 286,
-    LNOT = 287,
-    ASSIGN = 288,
-    ASSIGNPLUS = 289,
-    ASSIGNMINUS = 290,
-    ASSIGNSTAR = 291,
-    ASSIGNSLASH = 292,
-    ASSIGNDSTAR = 293,
-    ASSIGNBAND = 294,
-    ASSIGNBOR = 295,
-    ASSIGNBXOR = 296,
-    EQUAL = 297,
-    LESS = 298,
-    GREATER = 299,
-    LESSEQ = 300,
-    GREATEREQ = 301,
-    RSHIFT = 302,
-    LSHIFT = 303,
-    LBRACE = 304,
-    RBRACE = 305,
-    LPAREN = 306,
-    RPAREN = 307,
-    LBRACKET = 308,
-    RBRACKET = 309,
-    DOT = 310,
-    COLON = 311,
-    SEMICOLON = 312,
-    COMMA = 313,
-    POUND = 314
-  };
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     IF = 258,
+     THEN = 259,
+     ELSE = 260,
+     WHILE = 261,
+     FOR = 262,
+     IN = 263,
+     DO = 264,
+     FUNC = 265,
+     RETURN = 266,
+     BREAK = 267,
+     CONTINUE = 268,
+     END = 269,
+     NONE = 270,
+     IDENT = 271,
+     INT = 272,
+     FLOAT = 273,
+     STRING = 274,
+     PLUS = 275,
+     MINUS = 276,
+     STAR = 277,
+     SLASH = 278,
+     PERCENT = 279,
+     DSTAR = 280,
+     BAND = 281,
+     BOR = 282,
+     BXOR = 283,
+     BNOT = 284,
+     LAND = 285,
+     LOR = 286,
+     LNOT = 287,
+     ASSIGN = 288,
+     ASSIGNPLUS = 289,
+     ASSIGNMINUS = 290,
+     ASSIGNSTAR = 291,
+     ASSIGNSLASH = 292,
+     ASSIGNDSTAR = 293,
+     ASSIGNBAND = 294,
+     ASSIGNBOR = 295,
+     ASSIGNBXOR = 296,
+     EQUAL = 297,
+     LESS = 298,
+     GREATER = 299,
+     LESSEQ = 300,
+     GREATEREQ = 301,
+     RSHIFT = 302,
+     LSHIFT = 303,
+     LBRACE = 304,
+     RBRACE = 305,
+     LPAREN = 306,
+     RPAREN = 307,
+     LBRACKET = 308,
+     RBRACKET = 309,
+     DOT = 310,
+     COLON = 311,
+     SEMICOLON = 312,
+     COMMA = 313,
+     POUND = 314
+   };
 #endif
 
-/* Value type.  */
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef int YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
-/* Location type.  */
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE YYLTYPE;
-struct YYLTYPE
+typedef struct YYLTYPE
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-};
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 
-
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
 int yyparse (stmt_node **program);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
 #endif /* !YY_YY_PARSER_TAB_H_INCLUDED  */

parser.y

@@ -55,15 +55,15 @@ stmt_list:
 ;
 
 stmt:
-  expr { $$ = NEW_ST(); AS_ST($$)->type = ST_EXPR; AS_ST($$)->expr = $1; }
-| IF expr THEN stmt_list END { $$ = NEW_ST(); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = NULL; }
-| IF expr THEN stmt_list ELSE stmt_list END { $$ = NEW_ST(); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = $6; }
-| WHILE expr DO stmt_list END { $$ = NEW_ST(); AS_ST($$)->type = ST_LOOP; AS_ST($$)->loop = NEW(loop_node); AS_ST($$)->loop->cond = $2; AS_ST($$)->loop->loop = $4; }
-| FOR IDENT IN expr DO stmt_list END { $$ = NEW_ST(); AS_ST($$)->type = ST_ITER; AS_ST($$)->iter = NEW(iter_node); AS_ST($$)->iter->var = $2; AS_ST($$)->iter->iter = $4; AS_ST($$)->iter->loop = $6; }
-| RETURN expr { $$ = NEW_ST(); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = $2; }
-| RETURN { $$ = NEW_ST(); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = NULL; }
-| BREAK { $$ = NEW_ST(); AS_ST($$)->type = ST_BREAK; }
-| CONTINUE { $$ = NEW_ST(); AS_ST($$)->type = ST_CONT; }
+  expr { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_EXPR; AS_ST($$)->expr = $1; }
+| IF expr THEN stmt_list END { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = NULL; }
+| IF expr THEN stmt_list ELSE stmt_list END { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_IFELSE; AS_ST($$)->ifelse = NEW(ifelse_node); AS_ST($$)->ifelse->cond = $2; AS_ST($$)->ifelse->iftrue = $4; AS_ST($$)->ifelse->iffalse = $6; }
+| WHILE expr DO stmt_list END { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_LOOP; AS_ST($$)->loop = NEW(loop_node); AS_ST($$)->loop->cond = $2; AS_ST($$)->loop->loop = $4; }
+| FOR IDENT IN expr DO stmt_list END { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_ITER; AS_ST($$)->iter = NEW(iter_node); AS_ST($$)->iter->var = $2; AS_ST($$)->iter->iter = $4; AS_ST($$)->iter->loop = $6; }
+| RETURN expr { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = $2; }
+| RETURN { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_RET; AS_ST($$)->ret = NEW(ret_node); AS_ST($$)->ret->ret = NULL; }
+| BREAK { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_BREAK; }
+| CONTINUE { $$ = NEW_ST(); SET_LOC(AS_ST($$), @$); AS_ST($$)->type = ST_CONT; }
 | stmt SEMICOLON { $$ = $1; }
 ;
 

runtime.c

@@ -450,6 +450,9 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
     switch(stmt->type) {
         case ST_EXPR:
             sol_obj_free(sol_eval(state, stmt->expr));
+			if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
             break;
 
         case ST_IFELSE:
@@ -462,6 +465,9 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
             }
             sol_obj_free(value);
             sol_obj_free(vint);
+			if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
             break;
 
         case ST_LOOP:
@@ -471,11 +477,19 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
                 sol_obj_free(value);
                 sol_obj_free(vint);
                 sol_exec(state, stmt->loop->loop);
-                if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) break;
+                if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) {
+					value = sol_incref(state->None);
+					vint = sol_new_int(state, 0);
+					continue;
+				}
+				state->sflag = SF_NORMAL;
                 value = sol_eval(state, stmt->loop->cond);
                 vint = sol_cast_int(state, value);
             }
             state->sflag = SF_NORMAL;
+			if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
 			sol_obj_free(value);
 			sol_obj_free(vint);
             break;
@@ -503,13 +517,20 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
                 sol_state_assign_l_name(state, stmt->iter->var, item);
                 sol_exec(state, stmt->iter->loop);
 				sol_obj_free(item);
-                if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) break;
+                if(state->ret || state->sflag == SF_BREAKING || sol_has_error(state)) {
+					item = sol_incref(state->StopIteration);
+				}
+				state->sflag = SF_NORMAL;
                 item = iter->ops->call(state, list);
             }
             state->sflag = SF_NORMAL;
-			sol_obj_free(list);
+			if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
 			sol_obj_free(iter);
 			sol_obj_free(value);
+			sol_obj_free(list);
+			sol_obj_free(item);
             break;
 
         case ST_LIST:
@@ -518,6 +539,9 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
                 if(curs->stmt) sol_exec(state, curs->stmt);
                 curs = curs->next;
             }
+            if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
             break;
 
         case ST_RET:
@@ -526,6 +550,9 @@ void sol_exec(sol_state_t *state, stmt_node *stmt) {
             } else {
                 state->ret = sol_incref(state->None);
             }
+            if(sol_has_error(state)) {
+				sol_add_traceback(state, sol_new_stmtnode(state, stmt));
+			}
             break;
 
         case ST_CONT:
@@ -594,7 +621,6 @@ sol_object_t *sol_f_func_call(sol_state_t *state, sol_object_t *args) {
 
 sol_object_t *sol_new_func(sol_state_t *state, identlist_node *identlist, stmt_node *body, char *name) {
     sol_object_t *obj = sol_alloc_object(state);
-    if(sol_has_error(state)) return sol_incref(state->None);
     obj->func = body;
     obj->args = identlist;
 	obj->fname = (name?strdup(name):NULL);
@@ -607,7 +633,6 @@ sol_object_t *sol_new_func(sol_state_t *state, identlist_node *identlist, stmt_n
 
 sol_object_t *sol_new_stmtnode(sol_state_t *state, stmt_node *stmt) {
 	sol_object_t *obj = sol_alloc_object(state);
-	if(sol_has_error(state)) return sol_incref(state->None);
 	obj->type = SOL_STMT;
 	obj->ops = &(state->ASTNodeOps);
 	obj->node = stmt;
@@ -616,7 +641,6 @@ sol_object_t *sol_new_stmtnode(sol_state_t *state, stmt_node *stmt) {
 
 sol_object_t *sol_new_exprnode(sol_state_t *state, expr_node *expr) {
 	sol_object_t *obj = sol_alloc_object(state);
-	if(sol_has_error(state)) return sol_incref(state->None);
 	obj->type = SOL_EXPR;
 	obj->ops = &(state->ASTNodeOps);
 	obj->node = expr;

sol.h

@@ -6,6 +6,7 @@
 #endif
 
 #include <stdio.h>
+#include <stdarg.h>
 #include "dsl/dsl.h"
 
 #define VERSION "0.1a0"
@@ -156,6 +157,7 @@ typedef enum {SF_NORMAL, SF_BREAKING, SF_CONTINUING} sol_state_flag_t;
 typedef struct sol_tag_state_t {
 	sol_object_t *scopes; // A list of scope maps, innermost out, ending at the global scope
 	sol_object_t *ret; // Return value of this function, for early return
+	sol_object_t *traceback; // The last stack of statement (nodes) in the last error, or NULL
 	sol_state_flag_t sflag; // Used to implement break/continue
 	sol_object_t *error; // Some arbitrary error descriptor, None if no error
 	sol_object_t *None;
@@ -179,6 +181,9 @@ typedef struct sol_tag_state_t {
 	sol_object_t *modules;
 	sol_object_t *methods;
 	dsl_object_funcs obfuncs;
+#ifdef DEBUG_GC
+	dsl_seq *objects;
+#endif
 } sol_state_t;
 
 // state.c
@@ -201,6 +206,10 @@ sol_object_t *sol_set_error(sol_state_t *, sol_object_t *);
 sol_object_t *sol_set_error_string(sol_state_t *, const char *);
 void sol_clear_error(sol_state_t *);
 
+void sol_init_traceback(sol_state_t *);
+void sol_add_traceback(sol_state_t *, sol_object_t *);
+sol_object_t *sol_traceback(sol_state_t *);
+
 void sol_register_module(sol_state_t *, sol_object_t *, sol_object_t *);
 void sol_register_module_name(sol_state_t *, char *, sol_object_t *);
 sol_object_t *sol_get_module(sol_state_t *, sol_object_t *);
@@ -239,6 +248,8 @@ sol_object_t *sol_f_exec(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_eval(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_execfile(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_parse(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_ord(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_chr(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_debug_getref(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_debug_setref(sol_state_t *, sol_object_t *);
@@ -251,6 +262,8 @@ sol_object_t *sol_f_iter_str(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_iter_list(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_iter_map(sol_state_t *, sol_object_t *);
 
+sol_object_t *sol_f_ast_print(sol_state_t *, sol_object_t *);
+
 sol_object_t *sol_f_singlet_tostring(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_int_add(sol_state_t *, sol_object_t *);
@@ -293,6 +306,7 @@ sol_object_t *sol_f_str_repr(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_str_sub(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_str_split(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_str_find(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_list_add(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_list_mul(sol_state_t *, sol_object_t *);
@@ -316,6 +330,7 @@ sol_object_t *sol_f_map_call(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_len(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_iter(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_map_tostring(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_map_repr(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_mcell_tostring(sol_state_t *, sol_object_t *);
 
@@ -368,18 +383,12 @@ sol_object_t *sol_f_stream_read(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_seek(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_tell(sol_state_t *, sol_object_t *);
 sol_object_t *sol_f_stream_flush(sol_state_t *, sol_object_t *);
+sol_object_t *sol_f_stream_eof(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_f_stream_open(sol_state_t *, sol_object_t *);
 
 // object.c
 
-#define sol_incref(obj) (++((obj)->refcnt), obj)
-#define sol_decref(obj) (--((obj)->refcnt))
-
-sol_object_t *sol_obj_acquire(sol_object_t *);
-void sol_obj_free(sol_object_t *);
-void sol_obj_release(sol_object_t *);
-
 #define sol_is_singlet(obj) ((obj)->type == SOL_SINGLET)
 #define sol_is_none(state, obj) ((obj) == state->None)
 #define sol_is_oom(state, obj) ((obj) == state->OutOfMemory)
@@ -398,8 +407,6 @@ void sol_obj_release(sol_object_t *);
 
 #define sol_has_error(state) (!sol_is_none((state), (state)->error))
 
-sol_object_t *sol_alloc_object(sol_state_t *);
-
 sol_object_t *sol_new_singlet(sol_state_t *, const char *);
 sol_object_t *sol_new_int(sol_state_t *, long);
 sol_object_t *sol_new_float(sol_state_t *, double);
@@ -454,14 +461,18 @@ sol_object_t *sol_new_dysym(sol_state_t *, void *, dsl_seq *, sol_buftype_t);
 
 sol_object_t *sol_new_stream(sol_state_t *, FILE *, sol_modes_t);
 size_t sol_stream_printf(sol_state_t *, sol_object_t *, const char *, ...);
+size_t sol_stream_vprintf(sol_state_t *, sol_object_t *, const char *, va_list);
 size_t sol_stream_scanf(sol_state_t *, sol_object_t *, const char *, ...);
 size_t sol_stream_fread(sol_state_t *, sol_object_t *, char *, size_t, size_t);
 size_t sol_stream_fwrite(sol_state_t *, sol_object_t *, char *, size_t, size_t);
 char *sol_stream_fgets(sol_state_t *, sol_object_t *, char *, size_t);
+int sol_stream_fputc(sol_state_t *, sol_object_t *, int);
 #define sol_printf(state, ...) sol_stream_printf(state, sol_get_stdout(state), __VA_ARGS__)
+#define sol_vprintf(state, ...) sol_stream_vprintf(state, sol_get_stdout(state), __VA_ARGS__)
 #define sol_scanf(state, ...) sol_stream_scanf(state, sol_get_stdin(state, __VA_ARGS__)
 #define sol_fread(state, ...) sol_stream_fread(state, sol_get_stdin(state), __VA_ARGS__)
 #define sol_fwrite(state, ...) sol_stream_fwrite(state, sol_get_stdout(state), __VA_ARGS__)
+#define sol_putchar(state, ...) sol_stream_fputc(state, sol_get_stdout(state), __VA_ARGS__)
 int sol_stream_feof(sol_state_t *, sol_object_t *);
 int sol_stream_ferror(sol_state_t *, sol_object_t *);
 #define sol_stream_ready(state, stream) (!(sol_stream_feof((state), (stream)) || sol_stream_ferror((state), (stream))))
@@ -489,6 +500,31 @@ int sol_validate_map(sol_state_t *, sol_object_t *);
 
 sol_object_t *sol_util_call(sol_state_t *, sol_object_t *, int *, int, ...);
 
+// gc.c
+
+#ifdef DEBUG_GC
+
+sol_object_t *_int_sol_incref(const char *, sol_object_t *);
+void _int_sol_obj_free(const char *, sol_object_t *);
+#define sol_incref(obj) (_int_sol_incref(__func__, (obj)))
+#define sol_obj_free(obj) (_int_sol_obj_free(__func__, (obj)))
+
+#else
+
+#define sol_incref(obj) (++((obj)->refcnt), obj)
+void sol_obj_free(sol_object_t *);
+
+#endif
+
+#define sol_decref(obj) (--((obj)->refcnt))
+
+sol_object_t *sol_obj_acquire(sol_object_t *);
+void sol_obj_release(sol_object_t *);
+
+sol_object_t *sol_alloc_object(sol_state_t *);
+
+void sol_mm_finalize(sol_state_t *);
+
 #define AS_OBJ(x) ((sol_object_t *) (x))
 
 #endif

solrun.c

@@ -41,10 +41,10 @@ int main(int argc, char **argv) {
 	
 	if(prgstream!=stdin) fclose(prgstream);
 
-    if(printtree) st_print(program);
+	sol_state_init(&state);
+    if(printtree) st_print(&state, program);
 
     if(program) {
-        sol_state_init(&state);
         sol_exec(&state, program);
 		if(sol_has_error(&state)) {
 			printf("Error: ");

state.c

@@ -10,6 +10,7 @@ int sol_state_init(sol_state_t *state) {
 	state->OutOfMemory = NULL;
 	state->scopes = NULL;
 	state->error = NULL;
+	state->traceback = NULL;
 	state->ret = NULL;
 	state->sflag = SF_NORMAL;
 
@@ -102,6 +103,7 @@ int sol_state_init(sol_state_t *state) {
 	state->MapOps.len = sol_f_map_len;
 	state->MapOps.iter = sol_f_map_iter;
 	state->MapOps.tostring = sol_f_map_tostring;
+	state->MapOps.repr = sol_f_map_repr;
 	state->MapOps.free = sol_f_map_free;
 	
 	state->MCellOps.tname = "mcell";
@@ -178,6 +180,8 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_set_name(state, globals, "eval", sol_new_cfunc(state, sol_f_eval));
 	sol_map_set_name(state, globals, "execfile", sol_new_cfunc(state, sol_f_execfile));
 	sol_map_set_name(state, globals, "parse", sol_new_cfunc(state, sol_f_parse));
+	sol_map_set_name(state, globals, "ord", sol_new_cfunc(state, sol_f_ord));
+	sol_map_set_name(state, globals, "chr", sol_new_cfunc(state, sol_f_chr));
 	
 	mod = sol_new_map(state);
 	sol_map_set_name(state, mod, "getref", sol_new_cfunc(state, sol_f_debug_getref));
@@ -240,7 +244,12 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_set_name(state, mod, "OP_BNOT", sol_new_int(state, OP_BNOT));
 	sol_map_set_name(state, mod, "OP_LNOT", sol_new_int(state, OP_LNOT));
 	sol_map_set_name(state, mod, "OP_LEN", sol_new_int(state, OP_LEN));
+	sol_map_set_name(state, mod, "LIT_INT", sol_new_int(state, LIT_INT));
+	sol_map_set_name(state, mod, "LIT_FLOAT", sol_new_int(state, LIT_FLOAT));
+	sol_map_set_name(state, mod, "LIT_STRING", sol_new_int(state, LIT_STRING));
+	sol_map_set_name(state, mod, "LIT_NONE", sol_new_int(state, LIT_NONE));
 	sol_map_invert(state, mod);
+	sol_map_set_name(state, mod, "print", sol_new_cfunc(state, sol_f_ast_print));
 	sol_register_module_name(state, "ast", mod);
 	
 	btype = sol_new_map(state);
@@ -360,12 +369,14 @@ int sol_state_init(sol_state_t *state) {
 	sol_map_set_name(state, meths, "seek", sol_new_cfunc(state, sol_f_stream_seek));
 	sol_map_set_name(state, meths, "tell", sol_new_cfunc(state, sol_f_stream_tell));
 	sol_map_set_name(state, meths, "flush", sol_new_cfunc(state, sol_f_stream_flush));
+	sol_map_set_name(state, meths, "eof", sol_new_cfunc(state, sol_f_stream_eof));
 	sol_register_methods_name(state, "stream", meths);
 	sol_obj_free(meths);
 	
 	meths = sol_new_map(state);
 	sol_map_set_name(state, meths, "sub", sol_new_cfunc(state, sol_f_str_sub));
 	sol_map_set_name(state, meths, "split", sol_new_cfunc(state, sol_f_str_split));
+	sol_map_set_name(state, meths, "find", sol_new_cfunc(state, sol_f_str_find));
 	sol_register_methods_name(state, "string", meths);
 	sol_obj_free(meths);