printxf

Makefile

 
 arch-x86_64_test: arch-x86_64_test.o arch-x86_64.o type.o
 type_test: type_test.o type.o
+printxf_test: printxf_test.o printxf.o
 
 check: $(cprogs)
 	$(foreach prog,$(cprogs),./$(prog);)

arch-x86_64.c

 	{ .name = "rsp",      .type = &t_ulong },
 	{ .name = "ss",       .type = &t_ulong },
 
-	{ .type = &t_void }
+	{ .type = NULL }
 };
 
 struct type t_pt_regs = {

func.c

+#include <errno.h>
+
+#include "func.h"
+#include "node.h"
+#include "sym.h"
+#include "type.h"
+
+int func_validate_expr(const struct func *func, struct node *n, int strict)
+{
+	struct tfield *f;
+	struct node *arg;
+	int 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) )
+			continue;
+
+		node_error(n, stderr, "type mismatch for argument %d, expected %T, got %T",
+			   nargs, f->type, arg->sym->type);
+	}
+
+	return 0;
+}
+
+int func_static_validate(const struct func *func, struct node *n)
+{
+	if ((n->ntype == N_NUM) || (n->ntype == N_STRING)) {
+	}
+
+	switch (n->ntype) {
+	case N_EXPR:
+		if (func->type->ttype != T_FUNC) {
+			node_error(n, stderr, "'%s' is not callable",
+				   n->expr.func);
+			return -EINVAL;
+		}
+		return func_validate_expr(func, n, 0);
+
+	case N_IDENT:
+		if (func->type->ttype == T_FUNC) {
+			node_error(n, stderr, "'%s' is a function",
+				   n->ident.name);
+			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;
+	}
+
+	return 0;
+}

global.c

 #include "type.h"
 
 
+/* :map */
+
 static struct type *global_map_ktype(struct node *n)
 {
 	struct node *map, *key;
 
 	map = n->expr.args;
 
-	if (node_nargs(n) == 2)
+	if (nargs == 2)
 		return map->next->sym->type;
 
 	ktype = calloc(1, sizeof(*ktype));
 		f->type = key->sym->type;
 	}
 
-	f->type = &t_void;
-
 	asprintf(&ktype->sou.name, ":%s_key", map->ident.name);
 	ktype->ttype = T_STRUCT;
 	ktype->sou.fields = kfields;
 	return ktype;
 }
 
+static int global_map_type_infer(struct prog *prog, struct node *n)
+{
+	struct node *map = n->expr.args;
+
+	if (n->sym->type || !map->sym->type)
+		return 0;
+
+	assert(map->sym->type->ttype == T_MAP);
+
+	/* given `m[key]` where m's type is known, infer that the
+	 * expression's type is equal to m's value type. */
+	n->sym->type = map->sym->type->map.vtype;
+	return 0;
+}
+
+static int global_map_static_verify(struct node *n)
+{
+	int nargs = node_nargs(n);
+
+	if (nargs < 2) {
+		node_error(n, stderr, "map without key");
+		return -EINVAL;
+	}
+
+	if (n->expr.args->ntype != N_IDENT) {
+		node_error(n, stderr, "map must be identifier");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+/* :assign */
+
 static int global_assign_type_infer_map(struct node *n)
 {
 	struct node *map, *key;
 		return 0;
 
 	if (!lval->sym->type) {
+		/* given `a = b` where b's type is known but not a's,
+		 * infer that a's type must be equal to b's */
 		lval->sym->type = rval->sym->type;
 
 		if (node_is_map(lval))
 	return -EINVAL;
 }
 
+
+/* pid */
+
 struct type t_pid = {
 	.ttype = T_TYPEDEF,
 
 	.tdef = { .name = ":pid", .type = &t_u32 },
 };
 
+
+/* time */
+
 struct type t_time = {
-	.ttype = T_TYPEDEF,
+	.ttype = T_TYPEDEF,	/* TODO: should be a T_FUNC with a static
+				 * signature */
 
 	.tdef = { .name = ":time", .type = &t_s64 },
 };
 
+
 static const struct func global_funcs[] = {
 	{ .name = ":block", .type = &t_void, },
 
 	
 	{
 		.name = ":assign",
-		.static_verify = global_assign_static_verify,
 		.type_infer = global_assign_type_infer,
+		.static_verify = global_assign_static_verify,
 	},
 	{
 		.name = ":map",
-		/* .static_verify = global_map_static_verify, */
-		/* .type_infer = global_map_type_infer, */
+		.type_infer = global_map_type_infer,
+		.static_verify = global_map_static_verify,
 	},
 
 	{ .name = "pid",  .type = &t_pid, },

ply.c

 	printf("\n\n-- globals\n");
 	symtab_dump(ctx->globals, stdout);
 
-	printf("\n\n-- decls\n");
-	type_dump_decls(stdout);
+	/* printf("\n\n-- decls\n"); */
+	/* type_dump_decls(stdout); */
 
 	if (err)
 		printf("ERR: %d\n", err);

printxf.c

+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "printxf.h"
+
+struct printxf printxf_default;
+
+/* allow domains an easy way to defer standard specifiers to the
+ * system's implementation. */
+int printxf_vfprintf(struct printxf *pxf,
+		     FILE *fp, const char *spec, va_list ap)
+{
+	return vfprintf(fp, spec, ap);
+}
+
+int __printxf_wsegment(FILE *fp, const char **fmt, size_t ssize, size_t *tsize)
+{
+	size_t wsize;
+
+	wsize = fwrite(*fmt, 1, ssize, fp);
+	*tsize += wsize;
+	*fmt   += wsize;
+
+	return (wsize < ssize) ? EOF : 0;
+}
+
+int vfprintxf(struct printxf *pxf, FILE *fp, const char *fmt, va_list ap)
+{
+	size_t tsize = 0, wsize, ssize;
+	vfprintxf_fn handler;
+	char spec[16];
+
+	pxf = pxf ? : &printxf_default;
+
+	if (!fmt)
+		return 0;
+
+	while (*fmt) {
+		ssize = strcspn(fmt, "%");
+
+		/* leading segment containing no format specifiers. */
+		if (ssize && __printxf_wsegment(fp, &fmt, ssize, &tsize))
+			break;
+
+		if (fmt[0] == '\0') {
+			/* this was the last segment */
+			break;
+		} else if ((fmt[0] == '%')
+			   && ((fmt[1] == '\0') || (fmt[1] == '%'))) {
+			/* "%" or "%%", write "%" */
+			if (!fwrite("%", 1, 1, fp))
+				break;
+
+			tsize++;
+			fmt += fmt[1] ? 2 : 1;
+			continue;
+		}
+		
+		ssize = strspn(fmt + 1, " #$'*+,-.0123456789:;L_hjlqtvz") + 1;
+
+		if (!fmt[ssize]) {
+			/* corner case. fmt ends with an unterminated
+			 * format. e.g. "evilness: 100%" */
+			__printxf_wsegment(fp, &fmt, ssize, &tsize);
+			break;
+		}
+
+		handler = pxf->vfprintxf[fmt[ssize] & 0x7f];
+		if (!handler) {
+			/* unsupported specifier, write the entire
+			 * specifier unformatted to the output */
+			if (__printxf_wsegment(fp, &fmt, ssize + 1, &tsize))
+				break;
+
+			continue;
+		}
+
+		ssize++;
+		memset(spec, '\0', sizeof(spec));
+		strncpy(spec, fmt, (ssize >= sizeof(spec)) ? sizeof(spec) - 1 : ssize);
+		fmt += ssize;
+
+		tsize += handler(pxf, fp, spec, ap);
+	}
+
+	return tsize;
+}
+
+int fprintxf(struct printxf *pxf, FILE *fp, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vfprintxf(pxf, fp, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+int vprintxf(struct printxf *pxf, const char *fmt, va_list ap)
+{
+	return vfprintxf(pxf, stdout, fmt, ap);
+}
+
+int printxf(struct printxf *pxf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vprintxf(pxf, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+__attribute__((constructor))
+static void printxf_init(void)
+{
+	const char *std = "aAcdeEfFgGiosuxX";
+
+	for (; *std; std++)
+		printxf_default.vfprintxf[(int)*std] = &printxf_vfprintf;
+}

printxf.h

+#ifndef _PRINTXF_H
+#define _PRINTXF_H
+
+#include <stdio.h>
+
+struct printxf;
+
+typedef int (*vfprintxf_fn)(struct printxf *pxf,
+			    FILE *fp, const char *spec, va_list ap);
+
+extern int printxf_vfprintf(struct printxf *pxf,
+			    FILE *fp, const char *spec, va_list ap);
+
+struct printxf {
+	vfprintxf_fn vfprintxf[0x80];
+};
+
+extern struct printxf printxf_default;
+
+int vfprintxf(struct printxf *pxf, FILE *stream, const char *fmt, va_list ap);
+int  fprintxf(struct printxf *pxf, FILE *stream, const char *fmt, ...);
+int  vprintxf(struct printxf *pxf,               const char *fmt, va_list ap);
+int   printxf(struct printxf *pxf,               const char *fmt, ...);
+
+#endif	/* _PRINTXF_H */

printxf_test.c

+#include "printxf.h"
+
+
+int main(void)
+{
+	printxf(NULL, "testing %% %.*s %d\n", 3, "w000t", 13);
+}

type.c

 #include <assert.h>
 #include <errno.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "printxf.h"
 #include "type.h"
 
 static void __sgr(FILE *fp, int sgr, const char *s)
 		return;
 	}
 
-	for (arg = t->func.args; arg->type != T_VOID; arg++) {
+	tfields_foreach(arg, t->func.args) {
 		if (arg != t->func.args)
 			fputs(", ", fp);
 
 
 void type_dump(struct type *t, const char *name, FILE *fp)
 {
-	if (!t)
-		goto print_void;
-
+	if (!t) {
+		__faint(fp, "(none)");
+		goto print_name;
+	}
 
 	switch (t->ttype){
 	case T_VOID:
-	print_void:
 		__faint(fp, "void");
-		fputs(name ? " " : "", fp);
-		__bold(fp, name);
 		break;
 	case T_TYPEDEF:
 		__faint(fp, t->tdef.name);
-		fputs(name ? " " : "", fp);
-		__bold(fp, name);
 		break;
 	case T_SCALAR:
 		__faint(fp, t->scalar.name);
-		fputs(name ? " " : "", fp);
-		__bold(fp, name);
 		break;
 	case T_POINTER:
 		type_dump(t->ptr.type, NULL, fp);
 		fputs(" *", fp);
 		__bold(fp, name);
-		break;
+		return;
 	case T_ARRAY:
 		type_dump(t->array.type, NULL, fp);
 		fputs(name ? " " : "", fp);
 		__bold(fp, name);
 		fprintf(fp, "[%zu]", t->array.len);
-		break;
+		return;
 	case T_STRUCT:
 		fputs("struct ", fp);
 		__faint(fp, t->sou.name);
-		__bold(fp, name);
 		break;
 	case T_FUNC:
 		type_dump_func(t, name, fp);
-		break;
+		return;
 	case T_MAP:
 		type_dump(t->map.vtype, NULL, fp);
 		fputs(name ? " " : "", fp);		
 		fputc('{', fp);
 		type_dump(t->map.ktype, NULL, fp);
 		fputc('}', fp);
-		break;
+		return;
 	}
+print_name:
+	fputs(name ? " " : "", fp);
+	__bold(fp, name);
 }
 
 static void type_dump_decl_sou(struct type *t, FILE *fp)
 	}
 }
 
+int type_vfprintxf(struct printxf *pxf, FILE *fp, const char *spec, va_list ap)
+{
+	struct type *t;
+
+	t = va_arg(ap, struct type *);
+	type_dump(t, NULL, fp);
+	return 0;
+}
 
 struct type *type_normalize(struct type *t)
 {
 static void type_init(void)
 {
 	type_add_list(builtin_types);
+
+	printxf_default.vfprintxf['T'] = type_vfprintxf;
 }

type.h

 struct tfield {
 	char *name;
 	struct type *type;
-
-	/* function arguments */
-	int optional:1;
 };
 
 #define tfields_foreach(_f, _fields) \
-	for ((_f) = (_fields); (_f)->type->ttype != T_VOID; (_f)++)
+	for ((_f) = (_fields); (_f)->type; (_f)++)
 
 struct tstruct {
 	char *name;
+	struct tfield *fields;
 
 	int packed:1;
-	struct tfield *fields;
 };
 
 struct tfunc {
 	struct type *type;
 	struct tfield *args;
+
+	int vargs:1;
+	int aggregation:1;
 };
 
 enum ttype {

type_test.c

 		{ .name = "c", .type = type_array_of(&t_char, 3) },
 		{ .name = "d", .type = &t_short },
 
-		{ .type = &t_void }
+		{ .type = NULL }
 	};
 	struct type t_t1 = {
 		.ttype = T_STRUCT,
 		{ .name = "c", .type = type_array_of(&t_char, 3) },
 		{ .name = "d", .type = &t_short },
 
-		{ .type = &t_void }
+		{ .type = NULL }
 	};
 	struct type t_t1 = {
 		.ttype = T_STRUCT,