fix node_walk, add symtab_populate pass

node.c

 	if (n->ntype == N_EXPR)
 		info->indent -= 2;
 
-	if (n->up && n->up->ntype == N_EXPR && n->up->expr.arg == n) {
-		for (next = n->next; next; next = next->next) {
-			node_dump(next, info);
-		}
-	}
-
 	return 0;
 }
 
 		return err;
 
 	if (n->ntype == N_EXPR) {
-		err = node_walk(n->expr.arg, pre, post, ctx);
-		if (err)
-			return err;
+		node_t *a = n->expr.arg;
+
+		for (a = n->expr.arg; a; a = a->next) {
+			err = node_walk(a, pre, post, ctx);
+			if (err)
+				return err;
+		}
 	}
 
 	if (post && (err = post(n, ctx)))

node.h

 
 #include <stdint.h>
 
+typedef struct sym sym_t;
+
 typedef struct atom atom_t;
 typedef struct expr expr_t;
 typedef struct node node_t;
 	node_t *up;
 	node_t *next;
 
+	sym_t *sym;
+
 	union {
 		atom_t atom;
 		expr_t expr;
 	};
 };
 
-int node_walk(node_t *n,
-	      int (*pre)(node_t *, void *),
-	      int (*post)(node_t *, void *),
-	      void *ctx);
+/* walk a node tree */
+
+typedef int (*walk_fn)(node_t *, void *);
+int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
 
 
 /* node constructors */

ply.c

 #include "node.h"
 #include "sym.h"
 
+typedef struct pass {
+	int (*run)(void *);
+	walk_fn pre;
+	walk_fn post;
+} pass_t;
+
+typedef struct provider {
+	
+} provider_t;
+
 typedef struct prog {
-	char *probe;
+	const char *probe;
+	provider_t *prov;
 	node_t *ast;
-
-	symtab_t locals;
-	symtab_t *globals;
+	symtab_t *st;
 } prog_t;
 
-symtab_t globals = { .sym = NULL, .len = 0 };
+symtab_t symbols = { .sym = NULL, .len = 0 };
 
 prog_t *prog_get(void)
 {
 
 	p = calloc(1, sizeof(*p));
 
-	p->globals = &globals,
+	p->st = &symbols,
 
 	/* reads{pid()} @ quantize(arg2) */
 	p->ast =
 	return p;
 }
 
+int symtab_populate(node_t *n, void *_prog)
+{
+	prog_t *prog = _prog;
+
+	if ((n->ntype != N_ATOM) || (n->atom.atype != A_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))
+		return 0;
+
+	return sym_add(prog->st, n->atom.ident, tid_none, &n->sym);
+}
+
+int symtab_resolve(void *_prog)
+{
+	prog_t *prog = _prog;
+	return 0;
+}
+
+pass_t passes[] = {
+	{ .pre = symtab_populate },
+	{ .run = symtab_resolve },
+	{ NULL, NULL, NULL }
+};
+
 int main(void)
 {
 	node_dump_info_t info = {
 	};
 
 	prog_t *p = prog_get();
+	pass_t *pass;
+	int err;
+
+	for (pass = passes; pass->run, pass->pre || pass->post; pass++) {
+		err = pass->run ?
+			pass->run(p) :
+			node_walk(p->ast, pass->pre, pass->post, p);
+		if (err)
+			break;
+	}
 
 	node_dump(p->ast, &info);
-	return 0;
+	symtab_dump(p->st, stdout);
+	return err;
 }

sym.c

 
 	return 0;
 }
+
+void sym_dump(sym_t *sym, FILE *fp)
+{
+	type_dump_cdecl(type_info(sym->tid), fp);
+	fputc(' ', fp);
+	fputs(sym->name, fp);
+}
+
+void symtab_dump(symtab_t *st, FILE *fp)
+{
+	size_t i;
+
+	for (i = 0; i < st->len; i++) {
+		sym_dump(&st->sym[i], fp);
+		fputc('\n', fp);
+	}
+}

sym.h

 	size_t len;
 } symtab_t;
 
+sym_t *sym_get(symtab_t *st, const char *name);
+int    sym_add(symtab_t *st, const char *name, tid_t tid, sym_t **new);
+
+void sym_dump(sym_t *sym, FILE *fp);
+void symtab_dump(symtab_t *st, FILE *fp);
+
 #endif	/* _PLY_SYM_H */

type.c

 void type_dump(type_t *t, FILE *fp)
 {
 	switch (t->type){
+	case T_NONE:
+		fputs("<NONE>", fp);
+		break;
 	case T_ALIAS:
 		fputs(t->t.alias.name, fp);
 		break;
 		type_dump(type_info(t->t.alias.type), fp);
 		fprintf(fp, " %s", t->t.alias.name);
 		break;
+	case T_NONE:
 	case T_SCALAR:
 	case T_POINTER:
 	case T_ARRAY:

type.h

 #undef POINTER
 } builtin_type_t;
 
+
+type_t *type_info(tid_t tid);
+
+void type_dump      (type_t *t, FILE *fp);
+void type_dump_cdecl(type_t *t, FILE *fp);
+
 #endif	/* _PLY_TYPE_H */