put the LIS in LISP

node.c

 #include <assert.h>
 #include <ctype.h>
 #include <inttypes.h>
+#include <search.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "node.h"
 
-void nprint(node_t *n, FILE *fp)
+void node_print(node_t *n, FILE *fp)
 {
 	switch (n->ntype) {
-	case N_CONS:
-		fputs("<CONS>", fp);
-		break;
-	case N_OP:
-		fputc(n->op, fp);
+	case N_LIST:
+		fputs("()", fp);
 		break;
 	case N_IDENT:
 		fputs(n->ident, fp);
 	default:
 		fputs("<INVALID>", fp);
 	}
+
+	/* if (n->type) { */
+	/* 	fputc(' ', fp); */
+	/* 	type_dump(n->type, fp); */
+	/* } */
 }
 
+struct node_dump_info {
+	FILE *fp;
+	int indent;
+};
+
 int __node_dump_pre(node_t *n, void *_info)
 {
-	ndump_info_t *info = _info;
+	struct node_dump_info *info = _info;
 
 	switch (n->ntype) {
-	case N_CONS:
+	case N_LIST:
+		fprintf(info->fp, "%s%*s(",
+			info->indent? "\n" : "",
+			info->indent, "");
 		info->indent += 2;
 		break;
 
 	default:
-		fprintf(info->fp, "%*s", info->indent, "");
-		nprint(n, info->fp);
-		fputc('\n', info->fp);
+		if (n->prev) {
+			node_t *c;
+
+			for (c = n->next; c; c = c->next) {
+				if (c->ntype == N_LIST) {
+					fprintf(info->fp, "\n%*s",
+						info->indent, "");
+					break;
+				}
+			}
+
+			if (!c)
+				fputc(' ', info->fp);
+		}
+
+		node_print(n, info->fp);
 	}
 
 	return 0;
 
 int __node_dump_post(node_t *n, void *_info)
 {
-	ndump_info_t *info = _info;
-	node_t *next;
+	struct node_dump_info *info = _info;
+	node_t *c;
+
+	
+	if (n->ntype != N_LIST)
+		return 0;
 
-	if (n->ntype == N_CONS)
-		info->indent -= 2;
+	info->indent -= 2;
 
+	for (c = n->list; c; c = c->next) {
+		if (c->ntype == N_LIST) {
+			fprintf(info->fp, "\n%*s)", info->indent, "");
+			return 0;
+		}
+	}
+
+	fputc(')', info->fp);
 	return 0;
 }
 
-void ndump(node_t *n, ndump_info_t *info)
+void node_dump(node_t *n, FILE *fp)
 {
+	struct node_dump_info info = {
+		.fp = fp,
+	};
 
-	nwalk(n, __node_dump_pre, __node_dump_post, info);
+	node_walk(n, __node_dump_pre, __node_dump_post, &info);
 }
 
 
-int nwalk(node_t *n,
-	  int (*pre)(node_t *, void *),
-	  int (*post)(node_t *, void *),
-	  void *ctx)
+int node_walk(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_CONS) {
-		err = ncar(n) ? nwalk(ncar(n), pre, post, ctx) : 0;
-		if (err)
-			return err;
+	if (n->ntype == N_LIST) {
+		node_t *c;
 
-		err = ncdr(n) ? nwalk(ncdr(n), pre, post, ctx) : 0;
-		if (err)
-			return err;
+		for (c = n->list; c; c = c->next) {
+			err = node_walk(c, pre, post, ctx);
+			if (err)
+				return err;
+		}
 	}
 
 	if (post && (err = post(n, ctx)))
 }
 
 
-/* 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 */
+/* constructors */
 
 static node_t *__node(ntype_t ntype)
 {
 	return n;
 }
 
-node_t *ncons(node_t *car, node_t *cdr)
+node_t *node_list(node_t *head)
 {
-	node_t *n = __node(N_CONS);
-
-	assert(car);
-	car->up = n;
+	node_t *n = __node(N_LIST);
 
-	if (cdr)
-		cdr->up = n;
-
-	n->cons.car = car;
-	n->cons.cdr = cdr;
+	n->list = head;
 	return n;
 }
 
-node_t *nop(op_t op)
+node_t *node_vlist(node_t *head, ...)
 {
-	node_t *n = __node(N_OP);
-	n->op = op;
+        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);
+		head = next;
+        }
+        va_end(ap);
+
 	return n;
 }
 
-node_t *nident(char *name)
+node_t *node_ident(char *name)
 {
 	node_t *n = __node(N_IDENT);
 	n->ident = name;
 	return n;
 }
 
-node_t *nnum(int64_t num)
+node_t *node_num(int64_t num)
 {
 	node_t *n = __node(N_NUM);
 	n->num = num;
 	return n;
 }
 
-node_t *nstring(char *string)
+node_t *node_string(char *string)
 {
 	node_t *n = __node(N_STRING);
 	n->string = string;

node.h

 
 typedef struct node node_t;
 
-struct cons {
-	node_t *car;
-	node_t *cdr;
-};
-
-typedef enum op {
-	OP_AGG = '@',
-	OP_CALL = '(',
-	OP_DEREF = '*',
-	OP_DOT = '.',
-	OP_MAP = '{',
-} op_t;
-
 typedef enum ntype {
-	N_CONS,
-
-	N_OP,
+	N_LIST,
 	N_IDENT,
 	N_NUM,
 	N_STRING,
 } ntype_t;
 
 struct node {
-	ntype_t ntype;
+	node_t *next, *prev;
 
+	ntype_t ntype;
 	union {
-		/* atom_t atom; */
-		struct cons cons;
-
-		op_t op;
+		node_t *list;
 		char *ident;
 		int64_t num;
 		char *string;
 	};
 
-	node_t *up;
 	type_t *type;
 };
 
 /* debug */
-typedef struct ndump_info {
-	FILE *fp;
-	int indent;
-} ndump_info_t;
-
-void ndump(node_t *n, ndump_info_t *info);
-
+void node_dump(node_t *n, FILE *fp);
 
 typedef int (*walk_fn)(node_t *, void *);
-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);
+int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
 
 
-/* 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);
+/* constructors */
+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);
 
-/* utilities */
-
-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)
+static inline node_t *node_head(node_t *n)
 {
-	if (!n || (n->ntype != N_CONS))
+	if (!n)
 		return NULL;
 
-	return n->cons.car;
-}
+	for (; n->prev; n = n->prev);
 
-static inline node_t *ncdr(node_t *n)
-{
-	if (!n || (n->ntype != N_CONS))
-		return NULL;
-
-	return n->cons.cdr;
+	return n;
 }
 
-static inline node_t *nup(node_t *n)
+static inline node_t *node_prev(node_t *n)
 {
-
-	return n? n->up : NULL;
+	return n ? n->prev : 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) } */
 	prog->ast =
-		ncons(nop('@'),
-		      ncons(
-			      nmap("reads", ncons(ncall("pid", NULL), NULL)),
-			      ncall("quantize", ncons(nident("arg2"), NULL))
-			      )
+		node_list(
+			node_vlist(node_ident("@"),
+				   node_vlist(node_ident("{"),
+					      node_ident("reads"),
+					      node_list(node_ident("pid"))
+					      , NULL),
+				   node_vlist(node_ident("quantize"),
+					      node_ident("arg2")
+					      , NULL)
+				   , NULL)
 			);
 
 	prog->provider = provider_get("k");
 	return prog;
 }
 
-int symtab_resolve(node_t *n, void *_prog)
+int is_builtin(char *ident)
+{
+	if (!strcmp("@", ident) ||
+	    !strcmp("{", ident))
+		return 1;
+
+	return 0;
+}
+
+int symbol_resolve(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 = ncar(nup(nup(n)));
-	if (op && nop_is(op, '.'))
+	op = node_prev(node_prev(n));
+	if (op && (op->ntype == N_IDENT) && !strcmp(".", op->ident))
+		return 0;
+
+	if (is_builtin(n->ident))
 		return 0;
 
 	err = prog->provider->resolve(prog, n);
 	return sym_add(prog->globals, n->ident, NULL);
 }
 
+/* int symbol_infer(node_t *n, void *_prog) */
+/* { */
+/* 	return 0; */
+/* } */
+
 int pass_walk(pass_t *pass, prog_t *prog)
 {
-	return nwalk(prog->ast, pass->pre, pass->post, prog);
+	return node_walk(prog->ast, pass->pre, pass->post, prog);
 }
 
 pass_t passes[] = {
-	{ .run = pass_walk, .pre = symtab_resolve },
+	{ .run = pass_walk, .pre = symbol_resolve },
+	/* { .run = pass_walk, .pre = symbol_infer }, */
 
 	{ NULL }
 };
 
 int main(void)
 {
-	ndump_info_t info = {
-		.indent = 2,
-		.fp = stdout,
-	};
-
 	prog_t *prog = prog_get();
 	pass_t *pass;
 	int err;
 	}
 
 	printf("AST\n===\n");
-	ndump(prog->ast, &info);
+	node_dump(prog->ast, stdout);
 	printf("\nLOCALS\n======\n");
 	symtab_dump(prog->locals, stdout);
 	printf("\nGLOBALS\n=======\n");