save before ast rework

node.c

@@ -18,27 +18,20 @@ void __type_dump(type_t *t, FILE *fp)
 	fputs(">\e[0m", fp);
 }
 
-void node_print(node_t *n, FILE *fp)
+void node_print(struct node *n, FILE *fp)
 {
 	switch (n->ntype) {
-	case N_LIST:
-		fputs("()", fp);
-		break;
-	case N_KEYWORD:
-		fputs("\e[31m", fp);
-		fputc(n->keyword.class, fp);
-		if (n->keyword.op)
-			fputc(n->keyword.op, fp);
-		fputs("\e[0m", fp);
+	case N_EXPR:
+		fprintf(fp, "\e[31m%s\e[0m", n->expr.func);
 		break;
 	case N_IDENT:
-		fputs(n->ident, fp);
+		fputs(n->ident.name, fp);
 		break;
 	case N_NUM:
-		fprintf(fp, "%"PRId64, n->num);
+		fprintf(fp, "%"PRId64, n->num.num);
 		break;
 	case N_STRING:
-		fprintf(fp, "\"%s\"", n->string);
+		fprintf(fp, "\"%s\"", n->string.data);
 		break;
 
 	default:
@@ -50,68 +43,67 @@ void node_print(node_t *n, FILE *fp)
 
 struct node_dump_info {
 	FILE *fp;
-	int indent;
+	int indent, width;
 };
 
-int __node_dump_pre(node_t *n, void *_info)
+int __node_dump_pre(struct node *n, void *_info)
 {
 	struct node_dump_info *info = _info;
+	struct node *arg;
 
-	switch (n->ntype) {
-	case N_LIST:
-		fprintf(info->fp, "%s%*s(",
-			info->indent? "\n" : "",
-			info->indent, "");
-		info->indent += 2;
-		break;
+	if (info->indent)
+		fprintf(info->fp, "\n%*s", info->width, "");
+	else
+		fputc(' ', fp);
 
-	default:
-		if (n->prev) {
-			node_t *c;
+	if (n->ntype == N_EXPR) {
+		fputc('(', fp);
+
+		info->indent = 0;
+
+		node_expr_foreach(n, arg) {
+			struct node *subarg;
 
-			for (c = n->next; c; c = c->next) {
-				if (c->ntype == N_LIST) {
-					fprintf(info->fp, "\n%*s",
-						info->indent, "");
+			if (arg->ntype != N_EXPR)
+				continue;
+
+			node_expr_foreach(arg, subarg) {
+				if (arg->ntype == N_EXPR) {
+					info->indent = 1;
+					info->width += 2;
 					break;
 				}
 			}
 
-			if (!c)
-				fputc(' ', info->fp);
+			if (info->indent)
+				break;
 		}
-
-		node_print(n, info->fp);
 	}
 
+	node_print(n, info->fp);
 	return 0;
 }
 
-int __node_dump_post(node_t *n, void *_info)
+int __node_dump_post(struct node *n, void *_info)
 {
 	struct node_dump_info *info = _info;
-	node_t *c;
+	struct node *c;
 
 	
-	if (n->ntype != N_LIST)
+	if (n->ntype != N_EXPR)
 		return 0;
 
-	info->indent -= 2;
+	/* if (info->ident) { */
+	/* 	info->width -= 2; */
 
-	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;
-		}
-	}
+	/* 	fprintf(info->fp, "\n%*s", info->width, "");		 */
+	/* } */
 
 	fputc(')', info->fp);
-	__type_dump(n->type, info->fp);
 	return 0;
 }
 
-void node_dump(node_t *n, FILE *fp)
+void node_dump(struct node *n, FILE *fp)
 {
 	struct node_dump_info info = {
 		.fp = fp,
@@ -121,9 +113,9 @@ void node_dump(node_t *n, FILE *fp)
 }
 
 
-int node_walk(node_t *n,
-	      int (*pre)(node_t *, void *),
-	      int (*post)(node_t *, void *),
+int node_walk(struct node *n,
+	      int (*pre)(struct node *, void *),
+	      int (*post)(struct node *, void *),
 	      void *ctx)
 {
 	int err = 0;
@@ -131,11 +123,11 @@ int node_walk(node_t *n,
 	if (pre && (err = pre(n, ctx)))
 		return err;
 
-	if (n->ntype == N_LIST) {
-		node_t *c;
+	if (n->ntype == N_EXPR) {
+		struct node *arg;
 
-		for (c = n->list; c; c = c->next) {
-			err = node_walk(c, pre, post, ctx);
+		node_expr_foreach(n, arg) {
+			err = node_walk(arg, pre, post, ctx);
 			if (err)
 				return err;
 		}
@@ -147,7 +139,7 @@ int node_walk(node_t *n,
 	return 0;
 }
 
-int node_replace(node_t *n, node_t *new)
+int node_replace(struct node *n, struct node *new)
 {
 	new->up = n->up;
 
@@ -167,148 +159,77 @@ int node_replace(node_t *n, node_t *new)
 
 /* constructors */
 
-static node_t *__node(ntype_t ntype)
+static struct node *node_new(enum ntype ntype)
 {
-	node_t *n = calloc(1, sizeof(*n));
+	struct node *n;
+
+	n = calloc(1, sizeof(*n));
 	assert(n);
 
-	n->ntype = ntype;
+	n->ntype = N_IDENT;
+	n->ident.name = name;
 	return n;
 }
 
-node_t *node_list(node_t *head)
+struct node *node_string(char *data)
 {
-	node_t *n = __node(N_LIST);
+	struct node *n = node_new(N_STRING);
 
-	n->list = head;
-	head->up = n;
+	n->string.data = data;
 	return n;
 }
 
-node_t *node_vlist(node_t *head, ...)
+struct node *node_num(int64_t num)
 {
-        va_list ap;
-	node_t *n, *next;
-
-	n = node_list(head);
-	
-        va_start(ap, head);
-        while ((next = va_arg(ap, node_t *))) {
-		insque(next, head);
-		next->up = n;
-		head = next;
-        }
-        va_end(ap);
+	struct node *n = node_new(N_NUM);
 
+	n->num.num = num;
 	return n;
 }
 
-node_t *node_keyword(kwclass_t class, int op)
+struct node *node_ident(char *name)
 {
-	node_t *n = __node(N_KEYWORD);
-	n->keyword.class = class;
-	n->keyword.op    = op;
-	return n;
-}
+	struct node *n = node_new(N_IDENT);
 
-node_t *node_ident(const char *name)
-{
-	node_t *n = __node(N_IDENT);
-	n->ident = name;
+	n->ident.name = name;
 	return n;
 }
 
-node_t *node_num(int64_t num)
+struct node *node_append(struct node *n, struct node *arg)
 {
-	node_t *n = __node(N_NUM);
-	n->num = num;
+	struct node *last;
+	assert(n->ntype == N_EXPR);
 
-	/* TODO: handle L UL ULL and such nonsense */
-	n->type = &t_s64;
-	return n;
-}
+	arg->up = n;
 
-node_t *node_string(const char *string)
-{
-	node_t *n = __node(N_STRING);
-	n->string = string;
+	if (!n->expr.args) {
+		n->expr.args = arg;
+		return n;
+	}
+
+	for (last = n->expr.args; last->next; last = last->next);
 
-	/* TODO: string type like dtrace? */
-	n->type = type_ptr_of(&t_char);
+	last->next = arg;
+	arg->prev = last;
 	return n;
 }
 
-/* static struct node *node_new(enum ntype ntype) */
-/* { */
-/* 	struct node *n; */
-
-/* 	n = calloc(1, sizeof(*n)); */
-/* 	assert(n); */
-
-/* 	n->ntype = N_IDENT; */
-/* 	n->ident.name = name; */
-/* 	return n; */
-/* } */
-
-/* struct node *node_string(char *data) */
-/* { */
-/* 	struct node *n = node_new(N_STRING); */
-
-/* 	n->string.data = data; */
-/* 	return n; */
-/* } */
-
-/* struct node *node_num(int64_t num) */
-/* { */
-/* 	struct node *n = node_new(N_NUM); */
-
-/* 	n->num.num = num; */
-/* 	return n; */
-/* } */
-
-/* struct node *node_ident(char *name) */
-/* { */
-/* 	struct node *n = node_new(N_IDENT); */
-
-/* 	n->ident.name = name; */
-/* 	return n; */
-/* } */
-
-/* struct node *node_append(struct node *n, struct node *arg) */
-/* { */
-/* 	struct node *last; */
-/* 	assert(n->ntype == N_EXPR); */
-
-/* 	arg->up = n; */
-
-/* 	if (!n->expr.args) { */
-/* 		n->expr.args = arg; */
-/* 		return n; */
-/* 	} */
-
-/* 	for (last = n->expr.args; last->next; last = last->next); */
-
-/* 	last->next = arg; */
-/* 	arg->prev = last; */
-/* 	return n; */
-/* } */
-
-/* struct node *node_expr(char *func, ...) */
-/* { */
-/*         va_list ap; */
-/* 	struct node *n, *arg; */
+struct node *node_expr(char *func, ...)
+{
+        va_list ap;
+	struct node *n, *arg;
 
-/* 	n = node_new(N_EXPR); */
+	n = node_new(N_EXPR);
 
-/* 	n->expr.func = func; */
+	n->expr.func = func;
 
-/*         va_start(ap, func); */
+        va_start(ap, func);
 
-/*         while ((arg = va_arg(ap, struct node *))) */
-/* 		append(n, arg); */
+        while ((arg = va_arg(ap, struct node *)))
+		append(n, arg);
 
-/*         va_end(ap); */
+        va_end(ap);
 
-/* 	return n; */
+	return n;
 	
-/* } */
+}

node.h

@@ -8,123 +8,85 @@
 #include "sym.h"
 #include "type.h"
 
-/* enum ntype { */
-/* 	N_EXPR, */
-/* 	N_IDENT, */
-/* 	N_NUM, */
-/* 	N_STRING, */
-/* }; */
-
-/* struct node { */
-/* 	struct node *next, *prev, *up; */
-
-/* 	enum ntype ntype; */
-
-/* 	union { */
-/* 		struct { */
-/* 			char *func; */
-/* 			struct node *args; */
-/* 		} expr; */
-/* 		struct { */
-/* 			char *name; */
-/* 		} ident; */
-/* 		struct { */
-/* 			int64_t num; */
-/* 		} num; */
-/* 		struct { */
-/* 			char *data; */
-/* 		} string; */
-/* 	}; */
-/* }; */
-	
+/* REEEEEEEEEEEEEEMOVE */
 typedef struct node node_t;
 
-typedef enum kwclass {
-	KW_SUBSCRIPT = '[',
-	KW_ASSIGN = '=',
-	KW_BINOP = 'b',
-} kwclass_t;
-
-typedef enum kwarith {
-	KW_ADD = '+',
-	KW_SUB = '-',
-	KW_MUL = '*',
-	KW_DIV = '/',
-} kwarith_t;
-
-typedef struct keyword {
-	kwclass_t class;
-	int op;
-} keyword_t;
-
-typedef enum ntype {
-	N_LIST,
-	N_KEYWORD,
+enum ntype {
+	N_EXPR,
 	N_IDENT,
 	N_NUM,
 	N_STRING,
-} ntype_t;
+};
 
 struct node {
-	node_t *next, *prev, *up;
+	struct node *next, *prev, *up;
+
+	enum ntype ntype;
 
-	ntype_t ntype;
 	union {
-		node_t *list;
-		keyword_t keyword;
-		const char *ident;
-		int64_t num;
-		const char *string;
+		struct {
+			char *func;
+			struct node *args;
+		} expr;
+		struct {
+			char *name;
+		} ident;
+		struct {
+			int64_t num;
+		} num;
+		struct {
+			char *data;
+		} string;
 	};
 
+
 	type_t *type;
 	sym_t *sym;
-
 	irstate_t irs;
 };
 
 /* debug */
-void node_print(node_t *n, FILE *fp);
-void node_dump (node_t *n, FILE *fp);
+void node_print(struct node *n, FILE *fp);
+void node_dump (struct node *n, FILE *fp);
 
-typedef int (*walk_fn)(node_t *, void *);
-int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
+typedef int (*walk_fn)(struct node *, void *);
+int node_walk(struct node *n, walk_fn pre, walk_fn post, void *ctx);
 
-int node_replace(node_t *n, node_t *new);
+int node_replace(struct node *n, struct node *new);
 
+#define node_expr_foreach(_expr, _arg) \
+	for ((_arg) = (_expr)->args; (_arg); (_arg) = (_arg)->next)
 
 /* constructors */
-node_t *node_list  (node_t *head);
-node_t *node_vlist (node_t *head, ...);
-
-node_t *node_keyword(kwclass_t class, int op);
-node_t *node_ident  (const char *name);
-node_t *node_num    (int64_t num);
-node_t *node_string (const char *string);
-
-static inline node_t *node_head(node_t *n)
-{
-	if (!n)
-		return NULL;
-
-	for (; n->prev; n = n->prev);
-
-	return n;
-}
-
-static inline node_t *node_prev(node_t *n)
-{
-	return n ? n->prev : NULL;
-}
-
-static inline node_t *node_next(node_t *n)
-{
-	return n ? n->next : NULL;
-}
-
-static inline node_t *node_up(node_t *n)
-{
-	return n ? n->up : NULL;
-}
+struct node *node_string(char *data);
+struct node *node_num   (int64_t num);
+struct node *node_ident (char *name);
+struct node *node_append(struct node *n, struct node *arg);
+struct node *node_expr  (char *func, ...);
+
+/* static inline node_t *node_head(node_t *n) */
+/* { */
+/* 	if (!n) */
+/* 		return NULL; */
+
+/* 	for (; n->prev; n = n->prev); */
+
+/* 	return n; */
+/* } */
+
+/* static inline node_t *node_prev(node_t *n) */
+/* { */
+/* 	return n ? n->prev : NULL; */
+/* } */
+
+/* static inline node_t *node_next(node_t *n) */
+/* { */
+/* 	return n ? n->next : NULL; */
+/* } */
+
+/* static inline node_t *node_up(node_t *n) */
+/* { */
+/* 	return n ? n->up : NULL; */
+/* } */
 
 #endif	/* _PLY_NODE_H */

ply.c

@@ -65,24 +65,22 @@ ctx_t *ctx_get(void)
 	prog->probe = "k:SyS_read";
 	/* { @t[0] = time(); @reads[pid()] = quantize(arg2) } */
 	prog->ast =
-		node_vlist(
-			node_vlist(node_keyword('=', 0),
-				   node_vlist(node_keyword('[', 0),
+		node_expr("",
+			  node_expr("=",
+				    node_expr("[]",
 					      node_ident("@t"),
 					      node_num(0),
 					      NULL),
-				   node_list(node_ident("time")),
-				   NULL),
-			node_vlist(node_keyword('=', 0),
-				   node_vlist(node_keyword('[', 0),
+				    node_expr("time"),
+				    NULL),
+			  node_expr("=",
+				    node_expr("[]",
 					      node_ident("@reads"),
-					      node_list(node_ident("pid")),
+					      node_expr("pid", NULL),
 					      NULL),
-				   node_vlist(node_ident("quantize"),
-					      node_ident("arg2"),
-					      NULL),
-				   NULL),
-			NULL);
+				    node_expr("quantize", node_ident("arg2"), NULL),
+				    NULL),
+			  NULL);
 
 	prog->provider = provider_get("k");
 	prog->provider->probe(prog);
@@ -98,20 +96,18 @@ ctx_t *ctx_get(void)
 	prog->probe = "k:SyS_read2"; 
 	/* { @times[pid()] = quantize(time() - t0) } */
 	prog->ast =
-		node_list(
-			node_vlist(node_keyword('=', 0),
-				   node_vlist(node_keyword('[', 0),
-					      node_ident("@times"),
-					      node_list(node_ident("pid")),
-					      NULL),
-				   node_vlist(node_ident("quantize"),
-					      node_vlist(node_keyword('b', '-'),
-							 node_list(node_ident("time")),
-							 node_ident("t0"),
-							 NULL),
+		node_expr("=",
+			  node_expr("[]",
+				    node_ident("@times"),
+				    node_expr("pid", NULL),
+				    NULL),
+			  node_expr("quantize",
+				    node_expr("-",
+					      node_expr("time", NULL),
+					      node_ident("t0"),
 					      NULL),
-				   NULL)
-			);
+				    NULL),
+			  NULL);
 
 	prog->provider = provider_get("k");
 	prog->provider->probe(prog);