drink the LISP koolaid

arch-x86_64.c

 	},
 };
 
+type_t t_pt_regsp = {
+	.ttype = T_POINTER,
+	.t.pointer = {
+		.type = &t_pt_regs,
+	}
+};
+
 type_t *arch_types[] = {
 	&t_s8, &t_s8p, &t_u8, &t_u8p,
 	&t_s16, &t_s16p, &t_u16, &t_u16p,

arch.h

 extern type_t t_u64p;
 
 extern type_t t_pt_regs;
+extern type_t t_pt_regsp;
 
 #endif	/* _PLY_ARCH_H */

global.c

+#include <errno.h>
+#include <string.h>
+
 #include "ply.h"
 
+/* pid */
+
+type_t t_pid_t = {
+	.ttype = T_TYPEDEF,
+
+	.t.tdef = {
+		.name = "__ply_pid_t",
+		.type = &t_u32,
+	},
+};
+
+type_t t_pid_func = {
+	.ttype = T_FUNC,
+
+	.t.func = {
+		.name = "pid",
+		.type = &t_pid_t,
+		.args = NULL,
+	},
+};
+
+type_t *ts_pid[] = { &t_pid_t, &t_pid_func, NULL };
+
+
+/* quantize */
+
+type_t t_u64_64 = {
+	.ttype = T_ARRAY,
+	.t.array = {
+		.type = &t_u64,
+		.len = 64,
+	},
+};
+
+type_t t_quantize_t = {
+	.ttype = T_TYPEDEF,
+
+	.t.tdef = {
+		.name = "__ply_quantize_t",
+		.type = &t_u64_64,
+	},
+};
+
+field_t f_quantize_args[] = {
+	{ .type = &t_s64 },
+	{ .type = NULL }
+};
+
+type_t t_quantize_func = {
+	.ttype = T_FUNC,
+
+	.t.func = {
+		.name = "quantize",
+		.type = &t_quantize_t,
+		.args = f_quantize_args,
+	},
+};
+
+type_t *ts_quantize[] = { &t_u64_64, &t_quantize_t, &t_quantize_func, NULL };
+
 int global_resolve(prog_t *prog, node_t *n)
 {
-	return 0;
+	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 {
+		return -ENOENT;
+	}
+
+	if (ts) {
+		err = type_add_list(ts);
+		if (err)
+			return err;
+	}
+
+	n->type = t;
+	return sym_add(prog->locals, n->ident, t);
 }
 
 int global_probe(prog_t *prog)

kprobe.c

 
 int kprobe_resolve(prog_t *prog, node_t *n)
 {
-	struct kprobe *kp = prog->provider_data;
 	type_t *t;
-	char *name;
 
-	name = n->atom.ident;
-
-	if (is_arg(name))
+	if (is_arg(n->ident))
 		t = &t_ul;
-	else if (!strcmp(name, "ctx"))
-		t = &t_pt_regs;
+	else if (!strcmp(n->ident, "ctx"))
+		t = &t_pt_regsp;
 	else
 		return -ENOENT;
 
 	n->type = t;
-	return sym_add(prog->locals, name, t);
+	return sym_add(prog->locals, n->ident, t);
 }
 
 int kprobe_probe(prog_t *prog)

node.c

 
 #include "node.h"
 
-void node_print_atom(node_t *n, FILE *fp)
+void nprint(node_t *n, FILE *fp)
 {
-	switch (n->atom.atype) {
-	case A_IDENT:
-		fputs(n->atom.ident, fp);
+	switch (n->ntype) {
+	case N_CONS:
+		fputs("<CONS>", fp);
+		break;
+	case N_OP:
+		fputc(n->op, fp);
+		break;
+	case N_IDENT:
+		fputs(n->ident, fp);
 		break;
-	case A_NUM:
-		fprintf(fp, "%#"PRIx64, n->atom.num);
+	case N_NUM:
+		fprintf(fp, "%#"PRIx64, n->num);
 		break;
-	case A_STRING:
-		fprintf(fp, "\"%s\"", n->atom.string);
+	case N_STRING:
+		fprintf(fp, "\"%s\"", n->string);
 		break;
 
 	default:
-		fputs("INVALID_ATOM", fp);
+		fputs("<INVALID>", fp);
 	}
 }
 
-void node_print_expr(node_t *n, FILE *fp)
+int __node_dump_pre(node_t *n, void *_info)
 {
-	if (!isprint(n->expr.etype)) {
-		fputs("INVALID_EXPR", fp);
-		return;
-	}
+	ndump_info_t *info = _info;
 
-	fputc(n->expr.etype, fp);
-}
-
-void node_print(node_t *n, FILE *fp)
-{
 	switch (n->ntype) {
-	case N_ATOM:
-		node_print_atom(n, fp);
-		break;
-	case N_EXPR:
-		node_print_expr(n, fp);
+	case N_CONS:
+		info->indent += 2;
 		break;
 
 	default:
-		fputs("INVALID_NODE", fp);
+		fprintf(info->fp, "%*s", info->indent, "");
+		nprint(n, info->fp);
+		fputc('\n', info->fp);
 	}
-}
-
-int __node_dump_pre(node_t *n, void *_info)
-{
-	node_dump_info_t *info = _info;
-
-	fprintf(info->fp, "%*s", info->indent, "");
-	node_print(n, info->fp);
-	fputc('\n', info->fp);
 
-	if (n->ntype == N_EXPR) {
-		info->indent += 2;
-	}
 	return 0;
 }
 
 int __node_dump_post(node_t *n, void *_info)
 {
-	node_dump_info_t *info = _info;
+	ndump_info_t *info = _info;
 	node_t *next;
 
-	if (n->ntype == N_EXPR)
+	if (n->ntype == N_CONS)
 		info->indent -= 2;
 
 	return 0;
 }
 
-void node_dump(node_t *n, node_dump_info_t *info)
+void ndump(node_t *n, ndump_info_t *info)
 {
 
-	node_walk(n, __node_dump_pre, __node_dump_post, info);
+	nwalk(n, __node_dump_pre, __node_dump_post, info);
 }
 
-int node_walk(node_t *n,
-	      int (*pre)(node_t *, void *),
-	      int (*post)(node_t *, void *),
-	      void *ctx)
+
+int nwalk(node_t *n,
+	  int (*pre)(node_t *, void *),
+	  int (*post)(node_t *, void *),
+	  void *ctx)
 {
 	int err = 0;
 	
 	if (pre && (err = pre(n, ctx)))
 		return err;
 
-	if (n->ntype == N_EXPR) {
-		node_t *a = n->expr.arg;
+	if (n->ntype == N_CONS) {
+		err = ncar(n) ? nwalk(ncar(n), pre, post, ctx) : 0;
+		if (err)
+			return err;
 
-		for (a = n->expr.arg; a; a = a->next) {
-			err = node_walk(a, pre, post, ctx);
-			if (err)
-				return err;
-		}
+		err = ncdr(n) ? nwalk(ncdr(n), pre, post, ctx) : 0;
+		if (err)
+			return err;
 	}
 
 	if (post && (err = post(n, ctx)))
 	return 0;
 }
 
+
+/* high-level constructors */
+
+node_t *ncall(char *name, node_t *args)
+{
+	return ncons(nop('('), ncons(nident(name), args));
+}
+
+node_t *nmap(char *name, node_t *key)
+{
+	return ncons(nop('{'), ncons(nident(name), key));
+}
+
+/* basic constructors */
+
 static node_t *__node(ntype_t ntype)
 {
 	node_t *n = calloc(1, sizeof(*n));
 	return n;
 }
 
-node_t *node_ident(char *name)
+node_t *ncons(node_t *car, node_t *cdr)
 {
-	node_t *n = __node(N_ATOM);
+	node_t *n = __node(N_CONS);
+
+	assert(car);
+	car->up = n;
 
-	n->atom.atype = A_IDENT;
-	n->atom.ident = name;
+	if (cdr)
+		cdr->up = n;
+
+	n->cons.car = car;
+	n->cons.cdr = cdr;
 	return n;
 }
 
-node_t *node_num(int64_t num)
+node_t *nop(op_t op)
 {
-	node_t *n = __node(N_ATOM);
-
-	n->atom.atype = A_NUM;
-	n->atom.num = num;
+	node_t *n = __node(N_OP);
+	n->op = op;
 	return n;
 }
 
-node_t *node_string(char *string)
+node_t *nident(char *name)
 {
-	node_t *n = __node(N_ATOM);
-
-	n->atom.atype = A_STRING;
-	n->atom.string = string;
+	node_t *n = __node(N_IDENT);
+	n->ident = name;
 	return n;
 }
 
-node_t *node_expr(etype_t etype, node_t *arg)
+node_t *nnum(int64_t num)
 {
-	node_t *n = __node(N_EXPR);
-	node_t *next;
-
-	n->expr.etype = etype;
-	n->expr.arg = arg;
-
-	for (next = arg; next; next = next->next)
-		next->up = n;
-
+	node_t *n = __node(N_NUM);
+	n->num = num;
 	return n;
 }
 
-node_t *node_cons(node_t *head, node_t *tail)
+node_t *nstring(char *string)
 {
-	node_t *next;
-
-	assert(!head->next);
-	head->next = tail;
-
-	for (next = tail; next; next = next->next)
-		next->up = head->up;
-
-	return head;
+	node_t *n = __node(N_STRING);
+	n->string = string;
+	return n;
 }

node.h

 
 #include "type.h"
 
-typedef struct atom atom_t;
-typedef struct expr expr_t;
 typedef struct node node_t;
 
-typedef enum atype {
-	A_INVALID,
-	A_IDENT,
-	A_NUM,
-	A_STRING,
-} atype_t;
-
-struct atom {
-	atype_t atype;
-
-	union {
-		char *ident;
-		int64_t num;
-		char *string;
-	};
+struct cons {
+	node_t *car;
+	node_t *cdr;
 };
 
-typedef enum etype {
-	E_INVALID = '\0',
-
-	E_AGG = '@',
-	E_CALL = '(',
-	E_DEREF = '*',
-	E_DOT = '.',
-	E_MAP = 'm',
-	E_SCOPE = '{',
-	
-} etype_t;
-
-struct expr {
-	etype_t etype;
-	node_t *arg;
-};
+typedef enum op {
+	OP_AGG = '@',
+	OP_CALL = '(',
+	OP_DEREF = '*',
+	OP_DOT = '.',
+	OP_MAP = '{',
+} op_t;
 
 typedef enum ntype {
-	N_INVALID,
-	N_ATOM,
-	N_EXPR,
+	N_CONS,
+
+	N_OP,
+	N_IDENT,
+	N_NUM,
+	N_STRING,
 } ntype_t;
 
 struct node {
 	ntype_t ntype;
-	node_t *up;
-	node_t *next;
-
-	type_t *type;
 
 	union {
-		atom_t atom;
-		expr_t expr;
+		/* atom_t atom; */
+		struct cons cons;
+
+		op_t op;
+		char *ident;
+		int64_t num;
+		char *string;
 	};
+
+	node_t *up;
+	type_t *type;
 };
 
-/* walk a node tree */
+/* debug */
+typedef struct ndump_info {
+	FILE *fp;
+	int indent;
+} ndump_info_t;
+
+void ndump(node_t *n, ndump_info_t *info);
+
 
 typedef int (*walk_fn)(node_t *, void *);
-int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
+int nwalk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
 
+/* high-level constructors */
+node_t *ncall(char *name, node_t *args);
+node_t *nmap (char *name, node_t *key);
 
-/* node constructors */
 
-node_t *node_ident (char *name);
-node_t *node_num   (int64_t num);
-node_t *node_string(char *string);
-node_t *node_expr  (etype_t etype, node_t *arg);
-node_t *node_cons  (node_t *head, node_t *tail);
+/* basic constructors */
+node_t *ncons  (node_t *car, node_t *cdr);
+node_t *nop    (op_t op);
+node_t *nident (char *name);
+node_t *nnum   (int64_t num);
+node_t *nstring(char *string);
 
 
-/* debug */
+/* utilities */
 
-typedef struct node_dump_info {
-	FILE *fp;
-	int indent;
-} node_dump_info_t;
+static inline int nop_is(node_t *n, op_t op)
+{
+	if (!n || (n->ntype != N_OP))
+		return 0;
+
+	return n->op == op;
+}
+
+static inline node_t *ncar(node_t *n)
+{
+	if (!n || (n->ntype != N_CONS))
+		return NULL;
+
+	return n->cons.car;
+}
+
+static inline node_t *ncdr(node_t *n)
+{
+	if (!n || (n->ntype != N_CONS))
+		return NULL;
+
+	return n->cons.cdr;
+}
+
+static inline node_t *nup(node_t *n)
+{
 
-void node_dump(node_t *n, node_dump_info_t *info);
+	return n? n->up : NULL;
+}
 
 #endif	/* _PLY_NODE_H */

ply.c

 
 	prog->probe = "k:SyS_read"; /* { reads{pid()} @ quantize(arg2) } */
 	prog->ast =
-		node_expr('@',
-			  node_cons(
-				  node_expr('m',
-					    node_cons(
-						    node_ident("reads"),
-						    node_expr('(', node_ident("pid"))
-						    )
-					  ),
-				  node_expr('(',
-					    node_cons(
-						    node_ident("quantize"),
-						    node_ident("arg2")
-						    )
-					  )
-				  )
+		ncons(nop('@'),
+		      ncons(
+			      nmap("reads", ncons(ncall("pid", NULL), NULL)),
+			      ncall("quantize", ncons(nident("arg2"), NULL))
+			      )
 			);
 
 	prog->provider = provider_get("k");
 {
 	prog_t *prog = _prog;
 	provider_t *global = provider_get(":");
+	node_t *op;
 	int err;
 
-	if ((n->ntype != N_ATOM) || (n->atom.atype != A_IDENT))
+	if (n->ntype != N_IDENT)
 		return 0;
 
 	/* .IDENT/->IDENT is a struct/union member, skip */
-	if (n->up
-	    && (n->up->ntype == N_EXPR)
-	    && ((n->up->expr.etype == E_DOT) || (n->up->expr.etype == E_DEREF))
-	    && (n != n->up->expr.arg))
+	op = ncar(nup(nup(n)));
+	if (op && nop_is(op, '.'))
 		return 0;
 
 	err = prog->provider->resolve(prog, n);
-	if (!err || err != -ENOENT)
+	if (!err || (err != -ENOENT))
 		return err;
 
-	return global->resolve(prog, n);
+	err = global->resolve(prog, n);
+	if (!err || (err != -ENOENT))
+		return err;
+
+	/* neither provider identifier nor global ditto => user
+	 * variable, add it as a global symbol of unknown type. */
+	return sym_add(prog->globals, n->ident, NULL);
 }
 
 int pass_walk(pass_t *pass, prog_t *prog)
 {
-	return node_walk(prog->ast, pass->pre, pass->post, prog);
+	return nwalk(prog->ast, pass->pre, pass->post, prog);
 }
 
 pass_t passes[] = {
 
 int main(void)
 {
-	node_dump_info_t info = {
+	ndump_info_t info = {
 		.indent = 2,
 		.fp = stdout,
 	};
 	}
 
 	printf("AST\n===\n");
-	node_dump(prog->ast, &info);
+	ndump(prog->ast, &info);
 	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);
+	/* printf("\nTYPES\n=====\n"); */
+	/* types_dump_cdecl(stdout); */
 	return err;
 }

type.c

 	field_t *arg;
 
 	type_dump(t->t.func.type, fp);
-	fprintf(fp, " (*%s)(", t->t.func.name);
+	fprintf(fp, " (*%s)(", t->t.func.name ? : "");
+
+	if (!t->t.func.args) {
+		fputs("void)", fp);
+		return;
+	}
 
 	for (arg = t->t.func.args; arg->type; arg++) {
 		if (arg != t->t.func.args)
 
 void type_dump(type_t *t, FILE *fp)
 {
+	if (!t) {
+		fputs("<NONE>", fp);
+		return;
+	}
+
 	switch (t->ttype){
 	case T_TYPEDEF:
 		fputs(t->t.tdef.name, fp);
 	}
 }
 
+int type_cmp(const void *_a, const void *_b)
+{
+	const type_t *a = *((type_t **)_a);
+	const type_t *b = *((type_t **)_b);
+
+	return a - b;
+}
 
 int type_add(type_t *t)
 {
+	if (bsearch(t, types.type, types.len, sizeof(*types.type), type_cmp))
+		return 0;
+
+	type_size_set(t);
+
 	types.type = realloc(types.type, ++types.len * sizeof(*types.type));
 	types.type[types.len - 1] = t;
+	qsort(types.type, types.len, sizeof(*types.type), type_cmp);
 
-	type_size_set(t);
 	return 0;
 }