ply/ply.c

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ply.h"

struct providers {
	provider_t **prov;
	size_t len;
} providers;

provider_t *provider_get(const char *name)
{
	size_t i;

	for (i = 0; i < providers.len; i++) {
		if (strstr(providers.prov[i]->name, name)
		    == providers.prov[i]->name)
			return providers.prov[i];
	}

	return NULL;
}

void provider_register(provider_t *prov)
{
	assert(prov);
	assert(prov->probe);
	assert(prov->resolve);

	providers.prov = realloc(providers.prov,
				 ++providers.len * sizeof(*providers.prov));

	providers.prov[providers.len - 1] = prov;
}

typedef struct pass pass_t;
struct pass {
	int (*run)(pass_t *, prog_t *);
	walk_fn pre;
	walk_fn post;
};


symtab_t globals = { .sym = NULL, .len = 0 };
symtab_t locals = { .sym = NULL, .len = 0 };

prog_t *prog_get(void)
{
	prog_t *prog;

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

	prog->locals = &locals;
	prog->globals = &globals;

	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))
			      )
			);

	prog->provider = provider_get("k");
	prog->provider->probe(prog);
	return prog;
}

int symtab_populate(node_t *n, void *_prog)
{
	prog_t *prog = _prog;
	provider_t *global = provider_get(":");
	node_t *op;
	int err;

	if (n->ntype != N_IDENT)
		return 0;

	/* .IDENT/->IDENT is a struct/union member, skip */
	op = ncar(nup(nup(n)));
	if (op && nop_is(op, '.'))
		return 0;

	err = prog->provider->resolve(prog, n);
	if (!err || (err != -ENOENT))
		return err;

	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 nwalk(prog->ast, pass->pre, pass->post, prog);
}

pass_t passes[] = {
	{ .run = pass_walk, .pre = symtab_populate },

	{ NULL }
};

int main(void)
{
	ndump_info_t info = {
		.indent = 2,
		.fp = stdout,
	};

	prog_t *prog = prog_get();
	pass_t *pass;
	int err;

	for (pass = passes; pass->run; pass++) {
		err = pass->run(pass, prog);
		if (err)
			break;
	}

	printf("AST\n===\n");
	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); */
	return err;
}