work work

func.c

 #include "sym.h"
 #include "type.h"
 
-int func_validate_expr(const struct func *func, struct node *n, int strict)
+static int func_validate_expr(const struct func *func, struct node *n, int strict)
 {
 	struct tfield *f;
 	struct node *arg;
-	int nargs = 0;
+	int fargs, nargs = 0;
 
 	for (f = func->type->func.args, arg = n->expr.args;
-	     f && arg; f++, arg = arg->next, nargs++) {
-		if ((!strict && (arg->sym->type->ttype == T_VOID))
-		    || (f->type->ttype == T_VOID)
-		    || type_compatible(arg->sym->type, f->type) )
+	     f && f->type && arg; f++, arg = arg->next, nargs++) {
+		if ((!strict && (f->type->ttype == T_VOID))
+		    || (!strict && !arg->sym->type)
+		    || (!strict && (arg->sym->type->ttype == T_VOID))
+		    || type_compatible(arg->sym->type, f->type))
 			continue;
 
 		_e("%#N: %O argument is of type '%T', expected '%T'.\n",
 		   n, nargs, arg->sym->type, f->type);
 	}
 
-	return 0;
+	if ((!f || !f->type) && !arg)
+		return 0;
+
+	nargs = node_nargs(n);
+	fargs = type_nargs(func->type);
+	if (f && f->type) {
+		_e("%#N: too few arguments to %N; expected%s %d, got %d.\n",
+		   n, n, func->type->func.vargs? " at least" : "", fargs, nargs);
+		return -EINVAL;
+	}
+
+	if (func->type->func.vargs)
+		return 0;
+
+	_e("%#N: too many arguments to %N; expected %d, got %d.\n",
+	   n, n, fargs, nargs);
+	return -EINVAL;
 }
 
 int func_static_validate(const struct func *func, struct node *n)
 {
-	if ((n->ntype == N_NUM) || (n->ntype == N_STRING)) {
-	}
+	int err = 0;
+
+	if (!func->type)
+		goto check_callback;
 
 	switch (n->ntype) {
 	case N_EXPR:
 			_e("%#N: %N is not callable.\n", n, n);
 			return -EINVAL;
 		}
-		return func_validate_expr(func, n, 0);
+		err = func_validate_expr(func, n, 0);
+		break;
 
 	case N_IDENT:
 		if (func->type->ttype == T_FUNC) {
 			_e("%#N: %N is a function.\n", n, n);
 			return -EINVAL;
 		}
-		/* fall-through */
-	case N_NUM:
-	case N_STRING:
-		/* ident, num, str. nothing to validate. just copy
-		 * type info to the symbol if statically known */
-		n->sym->type = func->type;
+		break;
+
+	default:
+		/* num, str. nothing to validate. */
 		break;
 	}
 
-	return 0;
+check_callback:
+	if (!err && func->static_validate)
+		err = func->static_validate(func, n);
+
+	return err;
+}
+
+struct type *func_return_type(const struct func *func)
+{
+	if (!func->type)
+		return NULL;
+
+	if (func->type->ttype == T_FUNC)
+		return func->type->func.type;
+
+	return func->type;
 }

func.h

 	const char *name;
 	struct type *type;
 
-	int (*static_verify)(struct node *);
-	
-	int (*type_infer)(struct prog *, struct node *);
+	int (*static_validate)(const struct func *, struct node *);
+	int (*type_infer)(const struct func *, struct node *);
 };
 
+int func_static_validate(const struct func *func, struct node *n);
+struct type *func_return_type(const struct func *func);
+
 #endif	/* _FUNC_H */

global.c

 	return ktype;
 }
 
-static int global_map_type_infer(struct prog *prog, struct node *n)
+static int global_map_type_infer(const struct func *func, struct node *n)
 {
 	struct node *map = n->expr.args;
 
 	return 0;
 }
 
-static int global_map_static_verify(struct node *n)
+static int global_map_static_validate(const struct func *func, struct node *n)
 {
-	int nargs = node_nargs(n);
-
-	if (nargs < 2) {		
-		_e("%#N: map without key.\n", n);
-		return -EINVAL;
-	}
-
 	if (n->expr.args->ntype != N_IDENT) {
 		_e("%#N: %N is not subscriptable.\n", n, n);
 		return -EINVAL;
 	return 0;
 }
 
-static int global_assign_type_infer(struct prog *prog, struct node *n)
+static int global_assign_type_infer(const struct func *func, struct node *n)
 {
 	struct node *lval, *rval;
 
 	return -EINVAL;
 }
 
-static int global_assign_static_verify(struct node *n)
+static int global_assign_static_validate(const struct func *func, struct node *n)
 {
 	struct node *lval;
 	int nargs = node_nargs(n);
 	.tdef = { .name = ":pid", .type = &t_u32 },
 };
 
+struct type t_pid_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_pid },
+};
 
 /* time */
 
 	.tdef = { .name = ":time", .type = &t_s64 },
 };
 
+struct type t_time_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_time },
+};
+
+struct type t_block_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_void, .vargs = 1 },
+};
+
+struct tfield f_assign[] = {
+	{ .type = &t_void },
+	{ .type = &t_void },
+
+	{ .type = NULL }
+};
+
+struct type t_assign_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_void, .args = f_assign },
+};
 
 static const struct func global_funcs[] = {
-	{ .name = ":block", .type = &t_void, },
+	{ .name = ":block", .type = &t_block_func, },
 
 	{ .name = "+", },
 	{ .name = "-", },
 	
 	{
 		.name = ":assign",
+		.type = &t_assign_func,
 		.type_infer = global_assign_type_infer,
-		.static_verify = global_assign_static_verify,
+		.static_validate = global_assign_static_validate,
 	},
 	{
 		.name = ":map",
+		/* .type = t_map_func, */
 		.type_infer = global_map_type_infer,
-		.static_verify = global_map_static_verify,
+		.static_validate = global_map_static_validate,
 	},
 
-	{ .name = "pid",  .type = &t_pid, },
-	{ .name = "time", .type = &t_time, },
+	{ .name = "pid",  .type = &t_pid_func, },
+	{ .name = "time", .type = &t_time_func, },
 
 	{ .name = "quantize", },
 	
 	if (!func)
 		return -ENOENT;
 
-	if (func->static_verify) {
-		err = func->static_verify(n);
-		if (err)
-			return err;
-	}
+	err = func_static_validate(func, n);
+	if (err)
+		return err;
 
 	n->sym = sym_alloc(st, n, func);
-
-	if (func->type)
-		/* return type is static, fill it now */
-		n->sym->type = func->type;
-
+	n->sym->type = func_return_type(func);
 	return 0;
 }
 

ply.c

 		node_expr(":block",
 			  node_expr(":assign",
 				    node_ident("us"),
-				    node_expr("pid", NULL),
+				    node_expr("pid", NULL), node_num(0),
 				    NULL),
 			  node_expr(":assign",
 				    node_expr(":map",
 	struct prog *prog = _prog;
 
 	if (n->sym->func->type_infer)
-		return n->sym->func->type_infer(prog, n);
+		return n->sym->func->type_infer(n->sym->func, n);
 
 	return 0;
 }

type.c

 	struct tfield *arg;
 
 	type_dump(t->func.type, NULL, fp);
-	fprintf(fp, " (*\e[1m%s\e[0m)(", name ? : "");
+	fprintf(fp, " %s(*\e[1m%s\e[0m)(",
+		t->func.aggregation ? "@" : "", name ? : "");
 
 	if (!t->func.args) {
-		__faint(fp, "void");
+		__faint(fp, t->func.vargs ? "..." : "void");
 		fputc(')', fp);
 		return;
 	}
 		type_dump(arg->type, NULL, fp);
 	}
 
+	if (t->func.vargs)
+		__faint(fp, ", ...");
+
 	fputc(')', fp);
 }
 

type.h

 extern struct type t_sllong;
 extern struct type t_ullong;
 
+
+/* helpers */
+
+static inline int type_nargs(struct type *t)
+{
+	struct tfield *f;
+	int nargs = 0;
+
+	if (!t->func.args)
+		return 0;
+
+	for (f = t->func.args; f->type; f++, nargs++);
+
+	return nargs;
+
+}
+
 #endif	/* _PLY_TYPE_H */

utils.c

+#include <stdarg.h>
+#include <stdio.h>
+
+#include "node.h"
+#include "printxf.h"
+#include "sym.h"
+#include "type.h"
+
+struct ast_fprint_info {
+	FILE *fp;
+	int indent;
+};
+
+static int __ast_fprint_pre(struct node *n, void *_info)
+{
+	struct ast_fprint_info *info = _info;
+	struct node *arg;
+
+	if (n->prev)
+		fputc(' ', info->fp);
+
+	if (node_is_block(n->up)) {
+		info->indent += 4;
+		fprintf(info->fp, "\n%*s", info->indent, "");
+	}
+
+	if (n->ntype == N_EXPR)
+		fputc('(', info->fp);
+
+	fprintxf(NULL, info->fp,
+		 "%N%T", n, n->sym ? n->sym->type : NULL);
+
+	if ((n->ntype == N_EXPR) && n->expr.args)
+		fputc(' ', info->fp);
+
+	return 0;
+}
+
+static int __ast_fprint_post(struct node *n, void *_info)
+{
+	struct ast_fprint_info *info = _info;
+	struct node *c;
+
+	if (node_is_block(n))
+		fprintf(info->fp, "\n%*s", info->indent, "");
+
+	if (n->ntype == N_EXPR)
+		fputc(')', info->fp);
+
+	if (node_is_block(n->up))
+		info->indent -= 4;
+	
+	return 0;
+}
+
+void ast_fprint(FILE *fp, struct node *root)
+{
+	struct ast_fprint_info info = {
+		.fp = fp,
+	};
+
+	node_walk(root, __ast_fprint_pre, __ast_fprint_post, &info);
+	fputc('\n', fp);		
+}
+
+
+int order_vfprintxf(struct printxf *pxf, FILE *fp, const char *fmt, va_list ap)
+{
+	int arg = va_arg(ap, int);
+
+	switch (arg) {
+	case 1:
+		fputs("1st", fp);
+		return 3;
+	case 2:
+		fputs("2nd", fp);
+		return 3;
+	case 3:
+		fputs("3rd", fp);
+		return 3;
+	}
+
+	return fprintf(fp, "%dth", arg);
+}
+
+__attribute__((constructor))
+static void utils_init(void)
+{
+	printxf_default.vfprintxf['O'] = order_vfprintxf;
+}