ply/global.c

#include <errno.h>
#include <string.h>

#include "ply.h"

/* pid */

type_t t_pid_t = {
	.ttype = T_TYPEDEF,

	.t.tdef = {
		.name = "__ply_pid_t",
		.type = &t_u32,
	},
};

type_t t_pid_func = {
	.ttype = T_FUNC,

	.t.func = {
		.name = "pid",
		.type = &t_pid_t,
		.args = NULL,
	},
};

type_t *ts_pid[] = { &t_pid_t, &t_pid_func, NULL };


/* quantize */

type_t t_u64_64 = {
	.ttype = T_ARRAY,
	.t.array = {
		.type = &t_u64,
		.len = 64,
	},
};

type_t t_quantize_t = {
	.ttype = T_TYPEDEF,

	.t.tdef = {
		.name = "__ply_quantize_t",
		.type = &t_u64_64,
	},
};

field_t f_quantize_args[] = {
	{ .type = &t_s64 },
	{ .type = NULL }
};

type_t t_quantize_func = {
	.ttype = T_FUNC,

	.t.func = {
		.name = "quantize",
		.type = &t_quantize_t,
		.args = f_quantize_args,
	},
};

type_t *ts_quantize[] = { &t_u64_64, &t_quantize_t, &t_quantize_func, NULL };


/* time */

type_t t_time_t = {
	.ttype = T_TYPEDEF,

	.t.tdef = {
		.name = "__ply_time_t",
		.type = &t_u32,
	},
};

type_t t_time_func = {
	.ttype = T_FUNC,

	.t.func = {
		.name = "time",
		.type = &t_time_t,
		.args = NULL,
	},
};

type_t *ts_time[] = { &t_time_t, &t_time_func, NULL };


int global_resolve(prog_t *prog, node_t *n)
{
	type_t **ts = NULL;
	type_t *t;
	int err;

	if (!strcmp(n->ident, "pid")) {
		ts = ts_pid;
		t = &t_pid_func;
	} else if (!strcmp(n->ident, "quantize")) {
		ts = ts_quantize;
		t = &t_quantize_func;
	} else if (!strcmp(n->ident, "time")) {
		ts = ts_time;
		t = &t_time_func;
	} else {
		return -ENOENT;
	}

	if (ts) {
		err = type_add_list(ts);
		if (err)
			return err;
	}

	n->type = t;
	return sym_add(prog->locals, n->ident, t, &n->sym);
}

int global_probe(prog_t *prog)
{
	return 0;
}

provider_t global = {
	.name = ":",

	.resolve = global_resolve,
	.probe = global_probe,
};

__attribute__((constructor))
static void global_init(void)
{
	provider_register(&global);
}