ply/ply.c

#include <stdio.h>
#include <stdlib.h>

#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 {
	const char *probe;
	provider_t *prov;
	node_t *ast;
	symtab_t *st;
} prog_t;

symtab_t symbols = { .sym = NULL, .len = 0 };

prog_t *prog_get(void)
{
	prog_t *p;

	p = calloc(1, sizeof(*p));

	p->st = &symbols,

	/* reads{pid()} @ quantize(arg2) */
	p->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")
						    )
					  )
				  )
			);

	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 = {
		.indent = 2,
		.fp = stdout,
	};

	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);
	symtab_dump(p->st, stdout);
	return err;
}