multiple probes

global.c

 
 type_t *ts_quantize[] = { &t_u64_64, &t_quantize_t, &t_quantize_func, NULL };
 
+
+/* time */
+
+type_t t_time_t = {
+	.ttype = T_TYPEDEF,
+
+	.t.tdef = {
+		.name = "__ply_time_t",
+		.type = &t_u32,
+	},
+};
+
+type_t t_time_func = {
+	.ttype = T_FUNC,
+
+	.t.func = {
+		.name = "time",
+		.type = &t_time_t,
+		.args = NULL,
+	},
+};
+
+type_t *ts_time[] = { &t_time_t, &t_time_func, NULL };
+
+
 int global_resolve(prog_t *prog, node_t *n)
 {
 	type_t **ts = NULL;
 	} 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;
 	}

node.h

 typedef enum keyword {
 	KW_SUBSCRIPT = '[',
 	KW_ASSIGN = '=',
+	KW_ADD = '+',
+	KW_SUB = '-',
+	KW_MUL = '*',
+	KW_DIV = '/',
 } keyword_t;
 
 typedef enum ntype {

ply.c

 
 typedef struct pass pass_t;
 struct pass {
-	int (*run)(pass_t *, prog_t *);
+	int (*run)(pass_t *, ctx_t *);
 	walk_fn pre;
 	walk_fn post;
 };
 symtab_t globals = { .sym = NULL, .len = 0 };
 symtab_t locals = { .sym = NULL, .len = 0 };
 
-prog_t *prog_get(void)
+ctx_t *ctx_get(void)
 {
+	ctx_t *ctx;
 	prog_t *prog;
 
-	prog = calloc(1, sizeof(*prog));
+	ctx = calloc(1, sizeof(*ctx));
+	ctx->globals = calloc(1, sizeof(*ctx->globals));
+
+	ctx->progs = calloc(3, sizeof(*ctx->progs));
 
-	prog->locals = &locals;
-	prog->globals = &globals;
+	/* PROBE0 */
+	prog = calloc(1, sizeof(*prog));
+	prog->locals = calloc(1, sizeof(*prog->locals));
+	prog->globals = ctx->globals;
 
-	/* (@ ([ reads ((pid))) (quantize arg2)) */
-	prog->probe = "k:SyS_read"; /* { @reads[pid()] = quantize(arg2) } */
+	prog->probe = "k:SyS_read";
+	/* { t0 = time(); @reads[pid()] = quantize(arg2) } */
 	prog->ast =
-		node_list(
+		node_vlist(
+			node_vlist(node_keyword('='),
+				   node_ident("t0"),
+				   node_list(node_ident("time")),
+				   NULL),
 			node_vlist(node_keyword('='),
 				   node_vlist(node_keyword('['),
 					      node_ident("@reads"),
 				   node_vlist(node_ident("quantize"),
 					      node_ident("arg2"),
 					      NULL),
+				   NULL),
+			NULL);
+
+	prog->provider = provider_get("k");
+	prog->provider->probe(prog);
+	ctx->progs[0] = prog;
+
+	/* PROBE1 */
+	prog = calloc(1, sizeof(*prog));
+	prog->locals = calloc(1, sizeof(*prog->locals));
+	prog->globals = ctx->globals;
+
+	/* TODO: k -> kret */
+	prog->probe = "k:SyS_read2"; 
+	/* { @times[pid()] = quantize(time() - t0) } */
+	prog->ast =
+		node_list(
+			node_vlist(node_keyword('='),
+				   node_vlist(node_keyword('['),
+					      node_ident("@times"),
+					      node_list(node_ident("pid")),
+					      NULL),
+				   node_vlist(node_ident("quantize"),
+					      node_vlist(node_keyword('-'),
+							 node_list(node_ident("time")),
+							 node_ident("t0"),
+							 NULL),
+					      NULL),
 				   NULL)
 			);
 
 	prog->provider = provider_get("k");
 	prog->provider->probe(prog);
-	return prog;
+	ctx->progs[1] = prog;
+
+	return ctx;
 }
 
 
 		if (!src->type)
 			return 0;
 
-		if (!dst->type)
-			dst->type = src->type;
-
 		/* TODO: assignment is statement for now. do we need
 		 * c-style assignment expressions? e.g `a = b = 2;` */
 		n->type = &t_v;
+
+		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_ADD:
+	case KW_SUB:
+	case KW_MUL:
+	case KW_DIV:
+		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:
 {
 	node_t *parent, *key;
 
-	if (n->sym->type)
+	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);
 	return 0;
 }
 
+/* int pass_walk(pass_t *pass, prog_t *prog) */
+/* { */
+/* 	return node_walk(prog->ast, pass->pre, pass->post, prog); */
+/* } */
 
-int pass_walk(pass_t *pass, prog_t *prog)
+int pass_validate_types(node_t *n, void *_prog)
 {
-	return node_walk(prog->ast, pass->pre, pass->post, prog);
+	prog_t *prog = _prog;
+
+	
+	return 0;
+}
+
+int pass_walk(pass_t *pass, ctx_t *ctx)
+{
+	prog_t **prog;
+	int err;
+
+	for (prog = ctx->progs; *prog; prog++) {
+		err = node_walk((*prog)->ast, pass->pre, pass->post, *prog);
+		if (err)
+			return err;
+	}
+
+	return 0;
 }
 
 pass_t passes[] = {
 	{ .run = pass_walk, .post = pass_resolve_symbols },
 	{ .run = pass_walk, .post = pass_infer_types },
 	{ .run = pass_walk, .post = pass_infer_types },
+	{ .run = pass_walk, .post = pass_infer_types },
+	{ .run = pass_walk, .post = pass_validate_types },
 
 	{ NULL }
 };
 
 int main(void)
 {
-	prog_t *prog = prog_get();
+	ctx_t *ctx = ctx_get();
+	prog_t **prog;
 	pass_t *pass;
 	int err;
 
 	for (pass = passes; pass->run; pass++) {
-		err = pass->run(pass, prog);
+		err = pass->run(pass, ctx);
 		if (err)
 			break;
 	}
 
-	printf("AST\n===\n");
-	node_dump(prog->ast, stdout);
-	printf("\nLOCALS\n======\n");
-	symtab_dump(prog->locals, stdout);
-	printf("\nGLOBALS\n=======\n");
-	symtab_dump(prog->globals, stdout);
-	/* printf("\nTYPES\n=====\n"); */
-	/* types_dump_cdecl(stdout); */
+	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\n-- globals\n");
+	symtab_dump(ctx->globals, stdout);
 	return err;
 }

ply.h

 	void *provider_data;
 };
 
+typedef struct ctx {
+	prog_t **progs;
 
+	symtab_t *globals;
+} ctx_t;
 
 struct provider {
 	const char *name;

sym.c

 	size_t i;
 
 	for (i = 0; i < st->len; i++) {
-		if (!strcmp(st->sym[i].name, name))
-			return &st->sym[i];
+		if (!strcmp(st->sym[i]->name, name))
+			return st->sym[i];
 	}
 
 	return NULL;
 	st->sym = realloc(st->sym, ++st->len * sizeof(*st->sym));
 	assert(st->sym);
 
-	sym = &st->sym[st->len-1];
+	st->sym[st->len - 1] = calloc(1, sizeof(sym_t));
+	sym = st->sym[st->len - 1];
 	sym->st   = st;
 	sym->name = name;
 	sym->type = type;
 	size_t i;
 
 	for (i = 0; i < st->len; i++) {
-		sym_dump(&st->sym[i], fp);
+		sym_dump(st->sym[i], fp);
 		fputc('\n', fp);
 	}
 }

sym.h

 } sym_t;
 
 struct symtab {
-	sym_t *sym;
+	sym_t **sym;
 	size_t len;
 };
 
 void sym_dump(sym_t *sym, FILE *fp);
 void symtab_dump(symtab_t *st, FILE *fp);
 
+//#define symtab_foreach(_st, _sym) for((_sym) = (_st)->sym; (_sym) < (_st)->sym[(_st)->len]; (_sym)++)
+
 #endif	/* _PLY_SYM_H */