working on type inference

func.h

@@ -0,0 +1,17 @@
+#ifndef _FUNC_H
+#define _FUNC_H
+
+struct node;
+struct prog;
+struct type;
+
+struct func {
+	const char *name;
+	struct type *type;
+
+	int (*static_verify)(struct node *);
+	
+	int (*type_infer)(struct prog *, struct node *);
+};
+
+#endif	/* _FUNC_H */

global.c

@@ -1,164 +1,132 @@
+#include <assert.h>
 #include <errno.h>
 #include <string.h>
 
+#include "arch.h"
 #include "func.h"
 #include "node.h"
 #include "ply.h"
 #include "sym.h"
+#include "type.h"
 
-#if 0
-/* pid */
 
-int pid_generate_ir(prog_t *prog, node_t *node)
+static struct type *global_map_ktype(struct node *n)
 {
-	/* TODO */
-	return 0;
-}
+	struct node *map, *key;
+	struct type *ktype;
+	int nargs = node_nargs(n);
 
-type_t t_pid_t = {
-	.ttype = T_TYPEDEF,
+	map = n->expr.args;
 
-	.t.tdef = {
-		.name = "__ply_pid_t",
-		.type = &t_u32,
-	},
-};
+	if (node_nargs(n) == 2)
+		return map->next->sym->type;
 
-type_t t_pid_func = {
-	.ttype = T_FUNC,
-
-	.t.func = {
-		.name = "pid",
-		.type = &t_pid_t,
-		.args = NULL,
-		.generate_ir = pid_generate_ir,
-	},
-};
+	assert(0);
+	return NULL;
+}
 
-type_t *ts_pid[] = { &t_pid_t, &t_pid_func, NULL };
+static int global_assign_type_infer_map(struct node *n)
+{
+	struct node *map, *key;
+	struct type *ktype;
 
+	map = n->expr.args;
 
-/* quantize */
+	for (key = map->next; key; key = key->next) {
+		node_print(key, stdout);printf("WKZ\n");
+		if (type_sizeof(key->sym->type) < 0)
+			return 0;
+		node_print(key, stdout);printf("WKZ\n");
+	}
 
-int quantize_generate_ir(prog_t *prog, node_t *node)
-{
-	/* TODO */
+	map->sym->type = type_map_of(global_map_ktype(n), n->sym->type);
 	return 0;
 }
 
-type_t t_u64_64 = {
-	.ttype = T_ARRAY,
-	.t.array = {
-		.type = &t_u64,
-		.len = 64,
-	},
-};
+static int global_assign_type_infer(struct prog *prog, struct node *n)
+{
+	struct node *lval, *rval;
 
-type_t t_quantize_t = {
-	.ttype = T_TYPEDEF,
+	lval = n->expr.args;
+	rval = lval->next;
 
-	.t.tdef = {
-		.name = "__ply_quantize_t",
-		.type = &t_u64_64,
-	},
-};
+	if (!rval->sym->type)
+		return 0;
 
-field_t f_quantize_args[] = {
-	{ .type = &t_s64 },
-	{ .type = NULL }
-};
+	if (!lval->sym->type) {
+		lval->sym->type = rval->sym->type;
 
-type_t t_quantize_func = {
-	.ttype = T_FUNC,
+		if (node_is_map(lval))
+			return global_assign_type_infer_map(lval);
 
-	.t.func = {
-		.name = "quantize",
-		.type = &t_quantize_t,
-		.args = f_quantize_args,
-		.generate_ir = quantize_generate_ir,
-	},
-};
+		return 0;
+	}
 
-type_t *ts_quantize[] = { &t_u64_64, &t_quantize_t, &t_quantize_func, NULL };
+	if (type_compatible(lval->sym->type, rval->sym->type))
+		return 0;
 
+	if (lval->ntype == N_IDENT) {
+		node_error(n, stderr, "conflicting types for '%s'",
+			   lval->ident.name);
+	} else {
+		node_error(n, stderr, "conflicting types for '%s'",
+			   lval->expr.args->ident.name);
+	}
 
-/* time */
+	return -EINVAL;
+}
 
-int time_generate_ir(prog_t *prog, node_t *node)
+static int global_assign_static_verify(struct node *n)
 {
-	ir_emit_call(prog->ir, BPF_FUNC_ktime_get_ns);
+	struct node *lval;
+	int nargs = node_nargs(n);
 
-	irs_alloc_reg(&node->irs, prog->ir);
-	ir_emit_insn(prog->ir, MOV(0, 0), node->irs.reg, BPF_REG_0);
-	return 0;
+	if (nargs != 2) {
+		node_error(n, stderr, "assignment operator expects 2 arguments,"
+			   " %d given", nargs);
+		return -EINVAL;
+	}
+
+	lval = n->expr.args;
+
+	if (node_is_map(lval) || (lval->ntype == N_IDENT))
+		return 0;
+
+	node_error(n, stderr, "assignment destination must be a variable or map");
+	return -EINVAL;
 }
 
-type_t t_time_t = {
+struct type t_pid = {
 	.ttype = T_TYPEDEF,
 
-	.t.tdef = {
-		.name = "__ply_time_t",
-		.type = &t_s64,
-	},
+	.tdef = { .name = ":pid", .type = &t_u32 },
 };
 
-type_t t_time_func = {
-	.ttype = T_FUNC,
+struct type t_time = {
+	.ttype = T_TYPEDEF,
 
-	.t.func = {
-		.name = "time",
-		.type = &t_time_t,
-		.args = NULL,
-		.generate_ir = time_generate_ir,
-	},
+	.tdef = { .name = ":time", .type = &t_s64 },
 };
 
-type_t *ts_time[] = { &t_time_t, &t_time_func, NULL };
-
-#endif
-
-/* int global_resolve(prog_t *prog, node_t *n) */
-/* { */
-/* 	type_t **ts = NULL; */
-/* 	type_t *t; */
-/* 	int err; */
-
-/* 	if (!strcmp(n->ident, "pid")) { */
-/* 		ts = ts_pid; */
-/* 		t = &t_pid_func; */
-/* 	} else if (!strcmp(n->ident, "quantize")) { */
-/* 		ts = ts_quantize; */
-/* 		t = &t_quantize_func; */
-/* 	} else if (!strcmp(n->ident, "time")) { */
-/* 		ts = ts_time; */
-/* 		t = &t_time_func; */
-/* 	} else { */
-/* 		return -ENOENT; */
-/* 	} */
-
-/* 	if (ts) { */
-/* 		err = type_add_list(ts); */
-/* 		if (err) */
-/* 			return err; */
-/* 	} */
-
-/* 	n->type = t; */
-/* 	return sym_add(prog->locals, n->ident, t, &n->sym); */
-/* } */
-
 static const struct func global_funcs[] = {
-
-	/* block */
-	{ .name = "{}", },
+	{ .name = ":block", .type = &t_void, },
 
 	{ .name = "+", },
 	{ .name = "-", },
 	
-	{ .name = "=", },
-	{ .name = "[]", },
+	{
+		.name = ":assign",
+		.static_verify = global_assign_static_verify,
+		.type_infer = global_assign_type_infer,
+	},
+	{
+		.name = ":map",
+		/* .static_verify = global_map_static_verify, */
+		/* .type_infer = global_map_type_infer, */
+	},
 
-	{ .name = "pid", },
-	{ .name = "time", },
+	{ .name = "pid",  .type = &t_pid, },
+	{ .name = "time", .type = &t_time, },
 
 	{ .name = "quantize", },
 	
@@ -167,43 +135,83 @@ static const struct func global_funcs[] = {
 
 static const struct func global_num_func = {
 	.name = ":num",
+	.type = &t_int,
+};
+
+struct type t_string_array = {
+	.ttype = T_ARRAY,
+
+	.array = { .type = &t_char, .len = 64 }, /* TODO: tunable */
+};
+
+struct type t_string = {
+	.ttype = T_TYPEDEF,
+
+	.tdef = { .name = ":string", .type = &t_string_array },
 };
 
 static const struct func global_string_func = {
 	.name = ":string",
+	.type = &t_string,
 };
 
 static const struct func global_ident_func = {
 	.name = ":ident",
 };
 
+static const struct func *global_sym_alloc_expr(struct node *n)
+{
+	const struct func *func;
+	int err;
+
+	for (func = global_funcs; func->name; func++) {
+		if (strcmp(func->name, n->expr.func))
+			continue;
+
+		return func;
+	}
+
+	return NULL;
+}
+
 int global_sym_alloc(struct prog *prog, struct node *n)
 {
 	const struct func *func;
+	struct symtab *st = prog->locals;
+	int err;
 
 	switch (n->ntype) {
 	case N_EXPR:
-		for (func = global_funcs; func->name; func++) {
-			if (strcmp(func->name, n->expr.func))
-				continue;
-
-			n->sym = sym_alloc(prog->locals, n, func);
-			return 0;
-		}
-
-		return -ENOENT;
+		func = global_sym_alloc_expr(n);
+		break;
 	case N_IDENT:
-		n->sym = sym_alloc(prog->globals, n, &global_ident_func);
-		return 0;
+		st = prog->globals;
+		func = &global_ident_func;
+		break;
 	case N_NUM:
-		n->sym = sym_alloc(prog->locals, n, &global_num_func);
-		return 0;
+		func = &global_num_func;
+		break;
 	case N_STRING:
-		n->sym = sym_alloc(prog->locals, n, &global_string_func);
-		return 0;
+		func = &global_string_func;
+		break;
 	}
 
-	return -ENOENT;
+	if (!func)
+		return -ENOENT;
+
+	if (func->static_verify) {
+		err = func->static_verify(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;
+
+	return 0;
 }
 
 int global_probe(struct prog *prog)

node.c

@@ -96,6 +96,8 @@ void node_error(struct node *n, FILE *fp, const char *fmt, ...)
 	va_start(ap, fmt);
 	vfprintf(fp, fmt, ap);
 	va_end(ap);
+
+	fputc('\n', fp);
 }
 
 int node_walk(struct node *n,
@@ -149,7 +151,15 @@ int node_is_block(struct node *n)
 	if (!n || (n->ntype != N_EXPR))
 		return 0;
 
-	return !strcmp(n->expr.func, "{}");
+	return !strcmp(n->expr.func, ":block");
+}
+
+int node_is_map(struct node *n)
+{
+	if (!n || (n->ntype != N_EXPR))
+		return 0;
+
+	return !strcmp(n->expr.func, ":map");
 }
 
 

node.h

@@ -60,7 +60,18 @@ struct node *node_expr  (char *func, ...);
 
 /* helpers */
 
+static inline int node_nargs(struct node *n)
+{
+	struct node *arg;
+	int nargs = 0;
+
+	for (arg = n->expr.args; arg; arg = arg->next, nargs++);
+
+	return nargs;
+}
+
 int node_is_block(struct node *n);
+int node_is_map  (struct node *n);
 
 #define node_expr_foreach(_expr, _arg) \
 	for ((_arg) = (_expr)->expr.args; (_arg); (_arg) = (_arg)->next)

ply.c

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "func.h"
 #include "node.h"
 #include "ply.h"
 #include "sym.h"
@@ -68,22 +69,27 @@ struct ctx *ctx_get(void)
 	prog->probe = "k:SyS_read";
 
 	/* { 
+	 * 	us = pid();
 	 * 	@t[0] = time();
-	 * 	@reads[pid()] = quantize(arg2)
+	 * 	@reads[pid()] = quantize(arg2);
 	 * }
 	 */
 	prog->ast =
-		node_expr("{}",
-			  node_expr("=",
-				    node_expr("[]",
-					      node_ident("@t"),
+		node_expr(":block",
+			  node_expr(":assign",
+				    node_ident("us"),
+				    node_expr("pid", NULL),
+				    NULL),
+			  node_expr(":assign",
+				    node_expr(":map",
+					      node_ident("t"),
 					      node_num(0),
 					      NULL),
 				    node_expr("time", NULL),
 				    NULL),
-			  node_expr("=",
-				    node_expr("[]",
-					      node_ident("@reads"),
+			  node_expr(":assign",
+				    node_expr(":map",
+					      node_ident("reads"),
 					      node_expr("pid", NULL),
 					      NULL),
 				    node_expr("quantize", node_ident("arg2"), NULL),
@@ -104,9 +110,9 @@ struct ctx *ctx_get(void)
 	prog->probe = "k:SyS_read2"; 
 	/* { @times[pid()] = quantize(time() - t0) } */
 	prog->ast =
-		node_expr("=",
-			  node_expr("[]",
-				    node_ident("@times"),
+		node_expr(":assign",
+			  node_expr(":map",
+				    node_ident("times"),
 				    node_expr("pid", NULL),
 				    NULL),
 			  node_expr("quantize",
@@ -147,17 +153,15 @@ int pass_sym_alloc(struct node *n, void *_prog)
 	}
 
 	if (err) {
-		if (n->ntype == N_EXPR)
+		if ((err == -ENOENT) && (n->ntype == N_EXPR))
 			node_error(n, stderr, "unknown function '%s'",
 				   n->expr.func);
-		else
-			assert(0);
 	}
 
 	return err;
 }
 
-/* int infer_type_list(struct prog *prog, node_t *n) */
+/* int infer_type_list(struct prog *prog, struct node *n) */
 /* { */
 /* 	type_t *t; */
 
@@ -181,9 +185,9 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return 0; */
 /* } */
 
-/* int infer_type_keyword(struct prog *prog, node_t *n) */
+/* int infer_type_keyword(struct prog *prog, struct node *n) */
 /* { */
-/* 	node_t *dst, *src; */
+/* 	struct node *dst, *src; */
 
 /* 	switch (n->keyword.class) { */
 /* 	case KW_ASSIGN: */
@@ -227,9 +231,9 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return -ENOSYS; */
 /* } */
 
-/* int infer_type_sym(struct prog *prog, node_t *n) */
+/* int infer_type_sym(struct prog *prog, struct node *n) */
 /* { */
-/* 	node_t *parent, *key; */
+/* 	struct node *parent, *key; */
 
 /* 	if (n->sym->type) { */
 /* 		/\* the symbol type could have been inferred in another */
@@ -258,30 +262,19 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return 0; */
 /* } */
 
-/* int pass_infer_types(node_t *n, void *_prog) */
-/* { */
-/* 	struct prog *prog = _prog; */
+int pass_type_infer(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
 
-/* 	if (n->type) */
-/* 		return 0; */
+	if (n->sym->func->type_infer)
+		return n->sym->func->type_infer(prog, n);
 
-/* 	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; */
-/* } */
+	return 0;
+}
 
-/* int validate_func(node_t *n) */
+/* int validate_func(struct node *n) */
 /* { */
-/* 	node_t *arg; */
+/* 	struct node *arg; */
 /* 	field_t *f; */
 /* 	int i; */
 
@@ -316,7 +309,7 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return -EINVAL;	 */
 /* } */
 
-/* int pass_validate_types(node_t *n, void *_prog) */
+/* int pass_validate_types(struct node *n, void *_prog) */
 /* { */
 /* 	struct prog *prog = _prog; */
 
@@ -363,10 +356,10 @@ int pass_sym_alloc(struct node *n, void *_prog)
 
 /* } */
 
-/* int rewrite_const_math(node_t *n) */
+/* int rewrite_const_math(struct node *n) */
 /* { */
 /* 	int64_t result; */
-/* 	node_t *a, *b, *new; */
+/* 	struct node *a, *b, *new; */
 /* 	int op; */
 
 /* 	/\* TODO: handle L/UL/ULL correctly *\/ */
@@ -391,7 +384,7 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return node_replace(n, new); */
 /* } */
 
-/* int pass_rewrite_ast(node_t *n, void *_prog) */
+/* int pass_rewrite_ast(struct node *n, void *_prog) */
 /* { */
 /* 	struct prog *prog = _prog; */
 /* 	provider_t *global = provider_get(":"); */
@@ -420,7 +413,7 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return 0; */
 /* } */
 
-/* int generate_ir_ident(struct prog *prog, node_t *n) */
+/* int generate_ir_ident(struct prog *prog, struct node *n) */
 /* { */
 
 /* 	switch (n->sym->type->ttype) { */
@@ -436,7 +429,7 @@ int pass_sym_alloc(struct node *n, void *_prog)
 /* 	return 0; */
 /* } */
 
-/* int pass_generate_ir(node_t *n, void *_prog) */
+/* int pass_generate_ir(struct node *n, void *_prog) */
 /* { */
 /* 	struct prog *prog = _prog; */
 
@@ -499,7 +492,7 @@ int run_walk(struct pass *pass, struct ctx *ctx)
 
 struct pass passes[] = {
 	{ .run = run_walk, .post = pass_sym_alloc },
-	/* { .run = run_walk, .post = pass_infer_types }, */
+	{ .run = run_walk, .post = pass_type_infer },
 	/* { .run = run_walk, .post = pass_infer_types }, */
 	/* { .run = run_walk, .post = pass_infer_types }, */
 	/* { .run = run_validate_types, .post = pass_validate_types }, */
@@ -525,14 +518,14 @@ int main(void)
 	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("\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);

sym.c

@@ -21,7 +21,7 @@ static struct sym *__sym_alloc(struct symtab *st, const char *name,
 	sym->st   = st;
 	sym->name = name;
 	sym->func = func;
-	return 0;
+	return sym;
 }
 
 static struct sym *sym_alloc_ident(struct symtab *st, struct node *n,

type.c

@@ -30,20 +30,20 @@ static void type_dump_func(struct type *t, const char *name, FILE *fp)
 
 void type_dump(struct type *t, const char *name, FILE *fp)
 {
-	if (!t) {
-		fputs("<NONE>", fp);
-		return;
-	}
+	if (!t)
+		goto print_void;
+
 
 	switch (t->ttype){
 	case T_VOID:
-		fprintf(fp, "void%s%s", name? " " : "", name ? : "");
+	print_void:
+		fprintf(fp, "\e[2mvoid\e[0m%s%s", name? " " : "", name ? : "");
 		break;
 	case T_TYPEDEF:
-		fprintf(fp, "%s%s%s", t->tdef.name, name? " " : "", name ? : "");
+		fprintf(fp, "\e[2m%s\e[0m%s%s", t->tdef.name, name? " " : "", name ? : "");
 		break;
 	case T_SCALAR:
-		fprintf(fp, "%s%s%s", t->scalar.name, name? " " : "", name ? : "");
+		fprintf(fp, "\e[2m%s\e[0m%s%s", t->scalar.name, name? " " : "", name ? : "");
 		break;
 	case T_POINTER:
 		type_dump(t->ptr.type, NULL, fp);
@@ -60,10 +60,10 @@ void type_dump(struct type *t, const char *name, FILE *fp)
 		type_dump_func(t, name, fp);
 		break;
 	case T_MAP:
-		fprintf(fp, "map %s[", name ? : "");
-		type_dump(t->map.ktype, NULL, fp);
-		fputs("] ", fp);
 		type_dump(t->map.vtype, NULL, fp);
+		fprintf(fp, " %s{", name ? : "");
+		type_dump(t->map.ktype, NULL, fp);
+		fputs("} ", fp);
 		break;
 	}
 }
@@ -179,6 +179,9 @@ static ssize_t type_alignof_struct(struct type *t)
 
 ssize_t type_alignof(struct type *t)
 {
+	if (!t)
+		return -EINVAL;
+
 	switch (t->ttype){
 	case T_VOID:
 	case T_SCALAR:
@@ -245,6 +248,9 @@ ssize_t type_offset_size_of(struct type *t, const char *field)
 
 ssize_t type_offsetof(struct type *t, const char *field)
 {
+	if (!t)
+		return -EINVAL;
+
 	return type_offset_size_of(t, field);
 }
 
@@ -255,6 +261,9 @@ ssize_t type_sizeof_struct(struct type *t)
 
 ssize_t type_sizeof(struct type *t)
 {
+	if (!t)
+		return -EINVAL;
+
 	switch (t->ttype){
 	case T_VOID:
 		return sizeof(void);