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;

	/* (@ ('{' reads ((pid))) (quantize arg2)) */
	prog->probe = "k:SyS_read"; /* { reads{pid()} @ quantize(arg2) } */
	prog->ast =
		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");
	prog->provider->probe(prog);
	return 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(":");
	node_t *op;
	int err;

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

	/* .IDENT/->IDENT is a struct/union member, skip */
	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);
	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 symbol_infer(node_t *n, void *_prog) */
/* { */
/* 	return 0; */
/* } */

int pass_walk(pass_t *pass, prog_t *prog)
{
	return node_walk(prog->ast, pass->pre, pass->post, prog);
}

pass_t passes[] = {
	{ .run = pass_walk, .pre = symbol_resolve },
	/* { .run = pass_walk, .pre = symbol_infer }, */

	{ NULL }
};

int main(void)
{
	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");
	node_dump(prog->ast, stdout);
	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;
}