separate ident/keyword, start on type inference

node.c

 #include <stdio.h>
 #include <stdlib.h>
 
-#include "node.h"
+#include "ply.h"
+
+void __type_dump(type_t *t, FILE *fp)
+{
+	if (!t)
+		return;
+
+	fputs(" \e[2m<", fp);
+	type_dump(t, fp);
+	fputs(">\e[0m", fp);
+}
 
 void node_print(node_t *n, FILE *fp)
 {
 	case N_LIST:
 		fputs("()", fp);
 		break;
+	case N_KEYWORD:
+		fputs("\e[31m", fp);
+		fputc(n->keyword, fp);
+		fputs("\e[0m", fp);
+		break;
 	case N_IDENT:
 		fputs(n->ident, fp);
 		break;
 		fputs("<INVALID>", fp);
 	}
 
-	/* if (n->type) { */
-	/* 	fputc(' ', fp); */
-	/* 	type_dump(n->type, fp); */
-	/* } */
+	__type_dump(n->type, fp);
 }
 
 struct node_dump_info {
 	for (c = n->list; c; c = c->next) {
 		if (c->ntype == N_LIST) {
 			fprintf(info->fp, "\n%*s)", info->indent, "");
+			__type_dump(n->type, info->fp);
 			return 0;
 		}
 	}
 
 	fputc(')', info->fp);
+	__type_dump(n->type, info->fp);
 	return 0;
 }
 
 	return n;
 }
 
+node_t *node_keyword(keyword_t keyword)
+{
+	node_t *n = __node(N_KEYWORD);
+	n->keyword = keyword;
+	return n;
+}
+
 node_t *node_ident(char *name)
 {
 	node_t *n = __node(N_IDENT);
 {
 	node_t *n = __node(N_NUM);
 	n->num = num;
+
+	/* TODO: handle L UL ULL and such nonsense */
+	n->type = &t_s64;
 	return n;
 }
 
 {
 	node_t *n = __node(N_STRING);
 	n->string = string;
+
+	/* TODO: string type like dtrace? */
+	n->type = &t_cp;
 	return n;
 }

node.h

 
 typedef struct node node_t;
 
+typedef enum keyword {
+	KW_SUBSCRIPT = '[',
+	KW_ASSIGN = '=',
+} keyword_t;
+
 typedef enum ntype {
 	N_LIST,
+	N_KEYWORD,
 	N_IDENT,
 	N_NUM,
 	N_STRING,
 	ntype_t ntype;
 	union {
 		node_t *list;
+		keyword_t keyword;
 		char *ident;
 		int64_t num;
 		char *string;
 };
 
 /* debug */
-void node_dump(node_t *n, FILE *fp);
+void node_print(node_t *n, FILE *fp);
+void node_dump (node_t *n, FILE *fp);
 
 typedef int (*walk_fn)(node_t *, void *);
 int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
 node_t *node_list  (node_t *head);
 node_t *node_vlist (node_t *head, ...);
 
-node_t *node_ident (char *name);
-node_t *node_num   (int64_t num);
-node_t *node_string(char *string);
+node_t *node_keyword(keyword_t keyword);
+node_t *node_ident  (char *name);
+node_t *node_num    (int64_t num);
+node_t *node_string (char *string);
 
 static inline node_t *node_head(node_t *n)
 {
 	return n ? n->prev : NULL;
 }
 
+static inline node_t *node_next(node_t *n)
+{
+	return n ? n->next : NULL;
+}
+
 #endif	/* _PLY_NODE_H */

ply.c

 	prog->locals = &locals;
 	prog->globals = &globals;
 
-	/* (@ ('{' reads ((pid))) (quantize arg2)) */
-	prog->probe = "k:SyS_read"; /* { reads{pid()} @ quantize(arg2) } */
+	/* (@ ([ reads ((pid))) (quantize arg2)) */
+	prog->probe = "k:SyS_read"; /* { @reads[pid()] = quantize(arg2) } */
 	prog->ast =
 		node_list(
-			node_vlist(node_ident("@"),
-				   node_vlist(node_ident("{"),
-					      node_ident("reads"),
+			node_vlist(node_keyword('='),
+				   node_vlist(node_keyword('['),
+					      node_ident("@reads"),
 					      node_list(node_ident("pid")),
 					      NULL),
 				   node_vlist(node_ident("quantize"),
 	return prog;
 }
 
-int is_builtin(char *ident)
-{
-	if (!strcmp("@", ident) ||
-	    !strcmp("{", ident))
-		return 1;
-
-	return 0;
-}
 
-int symbol_resolve(node_t *n, void *_prog)
+int pass_resolve_symbols(node_t *n, void *_prog)
 {
 	prog_t *prog = _prog;
 	provider_t *global = provider_get(":");
 		return 0;
 
 	/* .IDENT/->IDENT is a struct/union member, skip */
-	op = node_prev(node_prev(n));
-	if (op && (op->ntype == N_IDENT) && !strcmp(".", op->ident))
-		return 0;
-
-	if (is_builtin(n->ident))
-		return 0;
+	/* op = node_prev(node_prev(n)); */
+	/* if (op && (op->ntype == N_IDENT) && !strcmp(".", op->ident)) */
+	/* 	return 0; */
 
 	err = prog->provider->resolve(prog, n);
 	if (!err || (err != -ENOENT))
 	return sym_add(prog->globals, n->ident, NULL);
 }
 
-/* int symbol_infer(node_t *n, void *_prog) */
-/* { */
-/* 	return 0; */
-/* } */
+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_v;
+		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 *c;
+
+	switch (n->keyword) {
+	case KW_SUBSCRIPT:
+		c = node_next(node_next(n));
+		assert(c);
+		n->type = c->type;
+		return 0;
+	case KW_ASSIGN:
+		/* TODO: assignment is statement for now. do we need
+		 * c-style assignment expressions? e.g `a = b = 2;` */
+		n->type = &t_v;
+		return 0;
+	}
+
+	return -ENOSYS;
+}
+
+int infer_type_sym(prog_t *prog, node_t *n)
+{
+	printf("WKZ\n");
+
+	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 pass_walk(pass_t *pass, prog_t *prog)
 {
 }
 
 pass_t passes[] = {
-	{ .run = pass_walk, .pre = symbol_resolve },
-	/* { .run = pass_walk, .pre = symbol_infer }, */
+	{ .run = pass_walk, .post = pass_resolve_symbols },
+	{ .run = pass_walk, .post = pass_infer_types },
+	{ .run = pass_walk, .post = pass_infer_types },
 
 	{ NULL }
 };

type.c

 
 	if (!t->t.sou.packed && size) {
 		/* align complete struct to requirements of first
-		 * member */
+		 * member, if struct keep going downwards */
 		f = t->t.sou.fields;
+		while (f->type->ttype == T_STRUCT)
+			f = f->type->t.sou.fields;
 
 		size += size % f->type->size;
 	}