ast rework

Makefile

 CFLAGS ?= -Wall -Wextra -Werror -Wno-unused -O0 -g
 
-objs := $(patsubst %.c,%.o,$(wildcard *.c))
-deps := $(wildcard *.c) $(wildcard *.h)
+srcs := ply.c node.c
+hdrs := node.h ply.h
+
+#srcs := $(wildcard *.c)
+#hdrs := $(wildcard *.h)
+objs := $(patsubst %.c,%.o,$(srcs))
+deps := $(srcs) $(hdrs)
 
 $(objs): $(deps)
 

node.c

 		return;
 
 	fputs(" \e[2m<", fp);
-	type_dump(t, fp);
+	/* type_dump(t, fp); */
 	fputs(">\e[0m", fp);
 }
 
 
 struct node_dump_info {
 	FILE *fp;
-	int indent, width;
+	int indent;
 };
 
 int __node_dump_pre(struct node *n, void *_info)
 	struct node_dump_info *info = _info;
 	struct node *arg;
 
-	if (info->indent)
-		fprintf(info->fp, "\n%*s", info->width, "");
-	else
-		fputc(' ', fp);
+	if (n->prev)
+		fputc(' ', info->fp);
 
-	if (n->ntype == N_EXPR) {
-		fputc('(', fp);
-
-		info->indent = 0;
+	if (node_is_block(n->up)) {
+		info->indent += 4;
+		fprintf(info->fp, "\n%*s", info->indent, "");
+	}
 
-		node_expr_foreach(n, arg) {
-			struct node *subarg;
+	if (n->ntype == N_EXPR)
+		fputc('(', info->fp);
 
-			if (arg->ntype != N_EXPR)
-				continue;
+	node_print(n, info->fp);
 
-			node_expr_foreach(arg, subarg) {
-				if (arg->ntype == N_EXPR) {
-					info->indent = 1;
-					info->width += 2;
-					break;
-				}
-			}
+	if ((n->ntype == N_EXPR) && n->expr.args)
+		fputc(' ', info->fp);
 
-			if (info->indent)
-				break;
-		}
-	}
-
-	node_print(n, info->fp);
 	return 0;
 }
 
 	struct node_dump_info *info = _info;
 	struct node *c;
 
-	
-	if (n->ntype != N_EXPR)
-		return 0;
-
-	/* if (info->ident) { */
-	/* 	info->width -= 2; */
+	if (node_is_block(n))
+		fprintf(info->fp, "\n%*s", info->indent, "");
 
-	/* 	fprintf(info->fp, "\n%*s", info->width, "");		 */
-	/* } */
+	if (n->ntype == N_EXPR)
+		fputc(')', info->fp);
 
-	fputc(')', info->fp);
+	if (node_is_block(n->up))
+		info->indent -= 4;
+	
 	return 0;
 }
 
 	};
 
 	node_walk(n, __node_dump_pre, __node_dump_post, &info);
+	fputc('\n', fp);		
 }
 
 
 	n = calloc(1, sizeof(*n));
 	assert(n);
 
-	n->ntype = N_IDENT;
-	n->ident.name = name;
+	n->ntype = ntype;
 	return n;
 }
 
         va_start(ap, func);
 
         while ((arg = va_arg(ap, struct node *)))
-		append(n, arg);
+		node_append(n, arg);
 
         va_end(ap);
 

node.h

 int node_replace(struct node *n, struct node *new);
 
 #define node_expr_foreach(_expr, _arg) \
-	for ((_arg) = (_expr)->args; (_arg); (_arg) = (_arg)->next)
+	for ((_arg) = (_expr)->expr.args; (_arg); (_arg) = (_arg)->next)
 
 /* constructors */
 struct node *node_string(char *data);
 struct node *node_append(struct node *n, struct node *arg);
 struct node *node_expr  (char *func, ...);
 
+static inline int node_is_block(struct node *n)
+{
+	if (!n || (n->ntype != N_EXPR))
+		return 0;
+
+	return n->expr.func[0] == '\0';
+}
+
 /* static inline node_t *node_head(node_t *n) */
 /* { */
 /* 	if (!n) */

ply.c

 					      node_ident("@t"),
 					      node_num(0),
 					      NULL),
-				    node_expr("time"),
+				    node_expr("time", NULL),
 				    NULL),
 			  node_expr("=",
 				    node_expr("[]",
 				    NULL),
 			  NULL);
 
-	prog->provider = provider_get("k");
-	prog->provider->probe(prog);
-	prog->ir = ir_new();
+	/* prog->provider = provider_get("k"); */
+	/* prog->provider->probe(prog); */
+	/* prog->ir = ir_new(); */
 	ctx->progs[0] = prog;
 
 	/* PROBE1 */
 				    NULL),
 			  NULL);
 
-	prog->provider = provider_get("k");
-	prog->provider->probe(prog);
-	prog->ir = ir_new();
+	/* prog->provider = provider_get("k"); */
+	/* prog->provider->probe(prog); */
+	/* prog->ir = ir_new(); */
 	ctx->progs[1] = prog;
 
 	return ctx;
 }
 
 
-int pass_resolve_symbols(node_t *n, void *_prog)
-{
-	prog_t *prog = _prog;
-	provider_t *global = provider_get(":");
-	node_t *op;
-	int err;
-
-	if (n->ntype != N_IDENT)
-		return 0;
-
-	err = prog->provider->resolve(prog, n);
-	if (!err || (err != -ENOENT))
-		return err;
-
-	err = global->resolve(prog, n);
-	if (!err || (err != -ENOENT))
-		return err;
-
-	/* neither provider identifier nor global ditto => user
-	 * variable, add it as a global symbol of unknown type. */
-	return sym_add(prog->globals, n->ident, NULL, &n->sym);
-}
-
-int infer_type_list(prog_t *prog, node_t *n)
-{
-	type_t *t;
-
-	/* list of lists (code block) => void */
-	if (n->list->ntype == N_LIST) {
-		n->type = &t_void;
-		return 0;
-	}
-
-	t = n->list->type;
-	if (!t)
-		return 0;
-
-	switch (t->ttype) {
-	case T_FUNC:
-		n->type = t->t.func.type;
-		break;
-	default:
-		n->type = t;
-	}
-	return 0;
-}
-
-int infer_type_keyword(prog_t *prog, node_t *n)
-{
-	node_t *dst, *src;
-
-	switch (n->keyword.class) {
-	case KW_ASSIGN:
-		dst = node_next(n);
-		src = node_next(dst);
-		assert(dst && src);
-
-		if (!src->type)
-			return 0;
-
-		/* TODO: assignment is statement for now. do we need
-		 * c-style assignment expressions? e.g `a = b = 2;` */
-		n->type = &t_void;
-
-		if (dst->type)
-			return 0;
-
-		dst->type = src->type;
-
-		if (dst->ntype != N_IDENT)
-			return 0;
-
-		return sym_add(dst->sym->st, dst->ident, dst->type, NULL);
-
-	case KW_BINOP:
-		dst = node_next(n);
-		src = node_next(dst);
-		assert(dst && src);
-
-		if (!(src->type && dst->type && type_equal(src->type, dst->type)))
-			return 0;
-
-		n->type = dst->type;
-		return 0;
-
-	default:
-		n->type = &t_void;
-		return 0;
-	}
-
-	return -ENOSYS;
-}
-
-int infer_type_sym(prog_t *prog, node_t *n)
-{
-	node_t *parent, *key;
-
-	if (n->sym->type) {
-		/* the symbol type could have been inferred in another
-		 * probe, in that case copy the type to this node. */
-		if (!n->type)
-			n->type = n->sym->type;
-
-		return 0;
-	}
-
-	parent = node_up(n);
-	key = node_next(n);
-
-	/* match `somemap[somekey]` where the type of the entire
-	 * expression and the type of the key is known, since that
-	 * means the type of the map itself is also known. */
-	if (parent && parent->type
-	    && (parent->list->ntype == N_KEYWORD)
-	    && (parent->list->keyword.class == KW_SUBSCRIPT)
-	    && key && key->type) {
-		n->type = type_map_of(key->type, parent->type);
-
-		return sym_add(n->sym->st, n->ident, n->type, NULL);
-	}
-
-	return 0;
-}
-
-int pass_infer_types(node_t *n, void *_prog)
-{
-	prog_t *prog = _prog;
-
-	if (n->type)
-		return 0;
-
-	switch (n->ntype) {
-	case N_LIST:
-		return infer_type_list(prog, n);
-	case N_KEYWORD:
-		return infer_type_keyword(prog, n);
-	case N_IDENT:
-		return infer_type_sym(prog, n);
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-int validate_func(node_t *n)
-{
-	node_t *arg;
-	field_t *f;
-	int i;
-
-	for (arg = node_next(n), f = n->type->t.func.args, i = 1;
-	     arg && f && f->type; arg = node_next(arg), f++, i++) {
-		if (type_compatible(arg->type, f->type))
-			continue;
-
-		node_print(n, stderr);
-		fprintf(stderr, ": incompatible type of argument %d (", i);
-		type_dump(arg->type, stderr);
-		fputs("), expected ", stderr);
-		type_dump(f->type, stderr);
-		fputs("\n", stderr);
-		return -EINVAL;
-	}
-
-	if (!arg && (!f || !f->type))
-		return 0;
-
-	if (arg) {
-		node_print(n, stderr);
-		fprintf(stderr, ": too many arguments, expected %d", i);
-		return -EINVAL;
-	}
-
-	if (f->optional)
-		return 0;
-
-	node_print(n, stderr);
-	fputs(": too few arguments", stderr);
-	return -EINVAL;	
-}
-
-int pass_validate_types(node_t *n, void *_prog)
-{
-	prog_t *prog = _prog;
-
-	node_print(n, stdout); putchar('\n'); 
-	if (!n->type) {
-		node_print(n, stderr);
-		fputs(": type unknown\n", stderr);
-		return -EINVAL;
-	}
-
-	if (n->ntype != N_LIST)
-		return 0;
-
-	if (n->list->ntype != N_IDENT)
-		return 0;
-
-	assert(n->list->type->ttype == T_FUNC);
-	return validate_func(n->list);
-}
-
-int validate_syms(prog_t *prog)
-{
-	return 0;
-}
-
-int run_validate_types(pass_t *pass, ctx_t *ctx)
-{
-	prog_t **prog;
-	int err;
-
-	for (prog = ctx->progs; *prog; prog++) {
-		/* check syms first to give better error messages.
-		 * e.g. "i: type unknown", not "b-: type unknown" */
-		err = validate_syms(*prog);
-		if (err)
-			return err;
+/* int pass_resolve_symbols(node_t *n, void *_prog) */
+/* { */
+/* 	prog_t *prog = _prog; */
+/* 	provider_t *global = provider_get(":"); */
+/* 	node_t *op; */
+/* 	int err; */
 
-		err = node_walk((*prog)->ast, pass->pre, pass->post, *prog);
-		if (err)
-			return err;
-	}
+/* 	if (n->ntype != N_IDENT) */
+/* 		return 0; */
 
-	return 0;
-
-}
-
-int rewrite_const_math(node_t *n)
-{
-	int64_t result;
-	node_t *a, *b, *new;
-	int op;
+/* 	err = prog->provider->resolve(prog, n); */
+/* 	if (!err || (err != -ENOENT)) */
+/* 		return err; */
+
+/* 	err = global->resolve(prog, n); */
+/* 	if (!err || (err != -ENOENT)) */
+/* 		return err; */
+
+/* 	/\* neither provider identifier nor global ditto => user */
+/* 	 * variable, add it as a global symbol of unknown type. *\/ */
+/* 	return sym_add(prog->globals, n->ident, NULL, &n->sym); */
+/* } */
+
+/* int infer_type_list(prog_t *prog, node_t *n) */
+/* { */
+/* 	type_t *t; */
+
+/* 	/\* list of lists (code block) => void *\/ */
+/* 	if (n->list->ntype == N_LIST) { */
+/* 		n->type = &t_void; */
+/* 		return 0; */
+/* 	} */
 
-	/* TODO: handle L/UL/ULL correctly */
+/* 	t = n->list->type; */
+/* 	if (!t) */
+/* 		return 0; */
+
+/* 	switch (t->ttype) { */
+/* 	case T_FUNC: */
+/* 		n->type = t->t.func.type; */
+/* 		break; */
+/* 	default: */
+/* 		n->type = t; */
+/* 	} */
+/* 	return 0; */
+/* } */
+
+/* int infer_type_keyword(prog_t *prog, node_t *n) */
+/* { */
+/* 	node_t *dst, *src; */
+
+/* 	switch (n->keyword.class) { */
+/* 	case KW_ASSIGN: */
+/* 		dst = node_next(n); */
+/* 		src = node_next(dst); */
+/* 		assert(dst && src); */
+
+/* 		if (!src->type) */
+/* 			return 0; */
+
+/* 		/\* TODO: assignment is statement for now. do we need */
+/* 		 * c-style assignment expressions? e.g `a = b = 2;` *\/ */
+/* 		n->type = &t_void; */
+
+/* 		if (dst->type) */
+/* 			return 0; */
+
+/* 		dst->type = src->type; */
+
+/* 		if (dst->ntype != N_IDENT) */
+/* 			return 0; */
+
+/* 		return sym_add(dst->sym->st, dst->ident, dst->type, NULL); */
+
+/* 	case KW_BINOP: */
+/* 		dst = node_next(n); */
+/* 		src = node_next(dst); */
+/* 		assert(dst && src); */
+
+/* 		if (!(src->type && dst->type && type_equal(src->type, dst->type))) */
+/* 			return 0; */
+
+/* 		n->type = dst->type; */
+/* 		return 0; */
+
+/* 	default: */
+/* 		n->type = &t_void; */
+/* 		return 0; */
+/* 	} */
+
+/* 	return -ENOSYS; */
+/* } */
+
+/* int infer_type_sym(prog_t *prog, node_t *n) */
+/* { */
+/* 	node_t *parent, *key; */
+
+/* 	if (n->sym->type) { */
+/* 		/\* the symbol type could have been inferred in another */
+/* 		 * probe, in that case copy the type to this node. *\/ */
+/* 		if (!n->type) */
+/* 			n->type = n->sym->type; */
+
+/* 		return 0; */
+/* 	} */
+
+/* 	parent = node_up(n); */
+/* 	key = node_next(n); */
+
+/* 	/\* match `somemap[somekey]` where the type of the entire */
+/* 	 * expression and the type of the key is known, since that */
+/* 	 * means the type of the map itself is also known. *\/ */
+/* 	if (parent && parent->type */
+/* 	    && (parent->list->ntype == N_KEYWORD) */
+/* 	    && (parent->list->keyword.class == KW_SUBSCRIPT) */
+/* 	    && key && key->type) { */
+/* 		n->type = type_map_of(key->type, parent->type); */
+
+/* 		return sym_add(n->sym->st, n->ident, n->type, NULL); */
+/* 	} */
+
+/* 	return 0; */
+/* } */
+
+/* int pass_infer_types(node_t *n, void *_prog) */
+/* { */
+/* 	prog_t *prog = _prog; */
+
+/* 	if (n->type) */
+/* 		return 0; */
+
+/* 	switch (n->ntype) { */
+/* 	case N_LIST: */
+/* 		return infer_type_list(prog, n); */
+/* 	case N_KEYWORD: */
+/* 		return infer_type_keyword(prog, n); */
+/* 	case N_IDENT: */
+/* 		return infer_type_sym(prog, n); */
+/* 	default: */
+/* 		break; */
+/* 	} */
+
+/* 	return 0; */
+/* } */
+
+/* int validate_func(node_t *n) */
+/* { */
+/* 	node_t *arg; */
+/* 	field_t *f; */
+/* 	int i; */
+
+/* 	for (arg = node_next(n), f = n->type->t.func.args, i = 1; */
+/* 	     arg && f && f->type; arg = node_next(arg), f++, i++) { */
+/* 		if (type_compatible(arg->type, f->type)) */
+/* 			continue; */
+
+/* 		node_print(n, stderr); */
+/* 		fprintf(stderr, ": incompatible type of argument %d (", i); */
+/* 		type_dump(arg->type, stderr); */
+/* 		fputs("), expected ", stderr); */
+/* 		type_dump(f->type, stderr); */
+/* 		fputs("\n", stderr); */
+/* 		return -EINVAL; */
+/* 	} */
+
+/* 	if (!arg && (!f || !f->type)) */
+/* 		return 0; */
+
+/* 	if (arg) { */
+/* 		node_print(n, stderr); */
+/* 		fprintf(stderr, ": too many arguments, expected %d", i); */
+/* 		return -EINVAL; */
+/* 	} */
+
+/* 	if (f->optional) */
+/* 		return 0; */
+
+/* 	node_print(n, stderr); */
+/* 	fputs(": too few arguments", stderr); */
+/* 	return -EINVAL;	 */
+/* } */
+
+/* int pass_validate_types(node_t *n, void *_prog) */
+/* { */
+/* 	prog_t *prog = _prog; */
+
+/* 	node_print(n, stdout); putchar('\n');  */
+/* 	if (!n->type) { */
+/* 		node_print(n, stderr); */
+/* 		fputs(": type unknown\n", stderr); */
+/* 		return -EINVAL; */
+/* 	} */
+
+/* 	if (n->ntype != N_LIST) */
+/* 		return 0; */
+
+/* 	if (n->list->ntype != N_IDENT) */
+/* 		return 0; */
+
+/* 	assert(n->list->type->ttype == T_FUNC); */
+/* 	return validate_func(n->list); */
+/* } */
+
+/* int validate_syms(prog_t *prog) */
+/* { */
+/* 	return 0; */
+/* } */
+
+/* int run_validate_types(pass_t *pass, ctx_t *ctx) */
+/* { */
+/* 	prog_t **prog; */
+/* 	int err; */
+
+/* 	for (prog = ctx->progs; *prog; prog++) { */
+/* 		/\* check syms first to give better error messages. */
+/* 		 * e.g. "i: type unknown", not "b-: type unknown" *\/ */
+/* 		err = validate_syms(*prog); */
+/* 		if (err) */
+/* 			return err; */
+
+/* 		err = node_walk((*prog)->ast, pass->pre, pass->post, *prog); */
+/* 		if (err) */
+/* 			return err; */
+/* 	} */
+
+/* 	return 0; */
+
+/* } */
+
+/* int rewrite_const_math(node_t *n) */
+/* { */
+/* 	int64_t result; */
+/* 	node_t *a, *b, *new; */
+/* 	int op; */
+
+/* 	/\* TODO: handle L/UL/ULL correctly *\/ */
 	
-	op = n->list->keyword.op;
-	a = node_next(n->list);
-	b = node_next(a);
-
-	switch (op) {
-	case '*': result = a->num *  b->num; break;
-	case '/': result = a->num /  b->num; break;
-	case '%': result = a->num %  b->num; break;
-	case '+': result = a->num +  b->num; break;
-	case '-': result = a->num -  b->num; break;
-	case '<': result = a->num << b->num; break;
-	case '>': result = a->num >> b->num; break;
-	default: return 0;
-	}
-
-	new = node_num(result);
-	new->type = n->type;
-	return node_replace(n, new);
-}
-
-int pass_rewrite_ast(node_t *n, void *_prog)
-{
-	prog_t *prog = _prog;
-	provider_t *global = provider_get(":");
-	int err;
-
-	if (prog->provider->rewrite_node) {
-		err = prog->provider->rewrite_node(prog, n);
-		if (err)
-			return err;
-	}
-
-	if (global->rewrite_node) {
-		err = global->rewrite_node(prog, n);
-		if (err)
-			return err;
-	}
-
-	/* pre-compute binops where both sides are constants */
-	if ((n->ntype == N_LIST)
-	    && (n->list->ntype == N_KEYWORD)
-	    && (n->list->keyword.class == KW_BINOP)
-	    && (node_next(n->list)->ntype == N_NUM)
-	    && (node_next(node_next(n->list))->ntype == N_NUM))
-		return rewrite_const_math(n);
-
-	return 0;
-}
-
-int generate_ir_ident(prog_t *prog, node_t *n)
-{
-
-	switch (n->sym->type->ttype) {
-	case T_FUNC:
-		return n->sym->type->t.func.generate_ir(prog, n);
-	case T_MAP:
-		ir_emit_ldmap(prog->ir, BPF_REG_0, n->sym);
-		return 0;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-int pass_generate_ir(node_t *n, void *_prog)
-{
-	prog_t *prog = _prog;
-
-	switch (n->ntype) {
-	case N_LIST:
-		return 0;
-	case N_IDENT:
-		return generate_ir_ident(prog, n);
-
-	default:
-		break;
-	}
-	return 0;
-}
-
-int run_generate_ir(pass_t *pass, ctx_t *ctx)
-{
-	prog_t **progp;
-	int err;
-
-	for (progp = ctx->progs; *progp; progp++) {
-		prog_t *prog = *progp;
-
-		int return_label = ir_alloc_label(prog->ir);
-
-		err = prog->provider->ir_prologue ?
-			prog->provider->ir_prologue(prog) : 0;
-		if (err)
-			return err;
-
-		err = node_walk(prog->ast, NULL, pass_generate_ir, prog);
-		if (err)
-			return err;
-
-		err = prog->provider->ir_epilogue ?
-			prog->provider->ir_epilogue(prog) : 0;
-		if (err)
-			return err;
-
-		ir_emit_label(prog->ir, return_label);
-		ir_emit_insn(prog->ir, EXIT, 0, 0);
-	}
-
-	return 0;
-}
+/* 	op = n->list->keyword.op; */
+/* 	a = node_next(n->list); */
+/* 	b = node_next(a); */
+
+/* 	switch (op) { */
+/* 	case '*': result = a->num *  b->num; break; */
+/* 	case '/': result = a->num /  b->num; break; */
+/* 	case '%': result = a->num %  b->num; break; */
+/* 	case '+': result = a->num +  b->num; break; */
+/* 	case '-': result = a->num -  b->num; break; */
+/* 	case '<': result = a->num << b->num; break; */
+/* 	case '>': result = a->num >> b->num; break; */
+/* 	default: return 0; */
+/* 	} */
+
+/* 	new = node_num(result); */
+/* 	new->type = n->type; */
+/* 	return node_replace(n, new); */
+/* } */
+
+/* int pass_rewrite_ast(node_t *n, void *_prog) */
+/* { */
+/* 	prog_t *prog = _prog; */
+/* 	provider_t *global = provider_get(":"); */
+/* 	int err; */
+
+/* 	if (prog->provider->rewrite_node) { */
+/* 		err = prog->provider->rewrite_node(prog, n); */
+/* 		if (err) */
+/* 			return err; */
+/* 	} */
+
+/* 	if (global->rewrite_node) { */
+/* 		err = global->rewrite_node(prog, n); */
+/* 		if (err) */
+/* 			return err; */
+/* 	} */
+
+/* 	/\* pre-compute binops where both sides are constants *\/ */
+/* 	if ((n->ntype == N_LIST) */
+/* 	    && (n->list->ntype == N_KEYWORD) */
+/* 	    && (n->list->keyword.class == KW_BINOP) */
+/* 	    && (node_next(n->list)->ntype == N_NUM) */
+/* 	    && (node_next(node_next(n->list))->ntype == N_NUM)) */
+/* 		return rewrite_const_math(n); */
+
+/* 	return 0; */
+/* } */
+
+/* int generate_ir_ident(prog_t *prog, node_t *n) */
+/* { */
+
+/* 	switch (n->sym->type->ttype) { */
+/* 	case T_FUNC: */
+/* 		return n->sym->type->t.func.generate_ir(prog, n); */
+/* 	case T_MAP: */
+/* 		ir_emit_ldmap(prog->ir, BPF_REG_0, n->sym); */
+/* 		return 0; */
+/* 	default: */
+/* 		break; */
+/* 	} */
+
+/* 	return 0; */
+/* } */
+
+/* int pass_generate_ir(node_t *n, void *_prog) */
+/* { */
+/* 	prog_t *prog = _prog; */
+
+/* 	switch (n->ntype) { */
+/* 	case N_LIST: */
+/* 		return 0; */
+/* 	case N_IDENT: */
+/* 		return generate_ir_ident(prog, n); */
+
+/* 	default: */
+/* 		break; */
+/* 	} */
+/* 	return 0; */
+/* } */
+
+/* int run_generate_ir(pass_t *pass, ctx_t *ctx) */
+/* { */
+/* 	prog_t **progp; */
+/* 	int err; */
+
+/* 	for (progp = ctx->progs; *progp; progp++) { */
+/* 		prog_t *prog = *progp; */
+
+/* 		int return_label = ir_alloc_label(prog->ir); */
+
+/* 		err = prog->provider->ir_prologue ? */
+/* 			prog->provider->ir_prologue(prog) : 0; */
+/* 		if (err) */
+/* 			return err; */
+
+/* 		err = node_walk(prog->ast, NULL, pass_generate_ir, prog); */
+/* 		if (err) */
+/* 			return err; */
+
+/* 		err = prog->provider->ir_epilogue ? */
+/* 			prog->provider->ir_epilogue(prog) : 0; */
+/* 		if (err) */
+/* 			return err; */
+
+/* 		ir_emit_label(prog->ir, return_label); */
+/* 		ir_emit_insn(prog->ir, EXIT, 0, 0); */
+/* 	} */
+
+/* 	return 0; */
+/* } */
 
 int run_walk(pass_t *pass, ctx_t *ctx)
 {
 }
 
 pass_t passes[] = {
-	{ .run = run_walk, .post = pass_resolve_symbols },
-	{ .run = run_walk, .post = pass_infer_types },
-	{ .run = run_walk, .post = pass_infer_types },
-	{ .run = run_walk, .post = pass_infer_types },
-	{ .run = run_validate_types, .post = pass_validate_types },
-	{ .run = run_walk, .post = pass_rewrite_ast },
-	{ .run = run_generate_ir },
+	/* { .run = run_walk, .post = pass_resolve_symbols }, */
+	/* { .run = run_walk, .post = pass_infer_types }, */
+	/* { .run = run_walk, .post = pass_infer_types }, */
+	/* { .run = run_walk, .post = pass_infer_types }, */
+	/* { .run = run_validate_types, .post = pass_validate_types }, */
+	/* { .run = run_walk, .post = pass_rewrite_ast }, */
+	/* { .run = run_generate_ir }, */
 
 	{ NULL }
 };
 	ctx_t *ctx = ctx_get();
 	prog_t **prog;
 	pass_t *pass;
-	int err;
+	int err = 0;
 
 	for (pass = passes; pass->run; pass++) {
 		err = pass->run(pass, ctx);
 	for (prog = ctx->progs; *prog; prog++) {
 		printf("\n\e[34m%s\e[0m\n", (*prog)->probe);
 		node_dump((*prog)->ast, stdout);
-		printf("\n-- locals\n");
-		symtab_dump((*prog)->locals, stdout);
-		printf("-- ir\n");
-		ir_dump((*prog)->ir, stdout);
+		/* printf("\n-- locals\n"); */
+		/* symtab_dump((*prog)->locals, stdout); */
+		/* printf("-- ir\n"); */
+		/* ir_dump((*prog)->ir, stdout); */
 	}
 
-	printf("\n\n-- globals\n");
-	symtab_dump(ctx->globals, stdout);
+	/* printf("\n\n-- globals\n"); */
+	/* symtab_dump(ctx->globals, stdout); */
 
 	if (err)
 		printf("ERR: %d\n", err);