initial add

.gitignore

@@ -0,0 +1,5 @@
+*~
+*.o
+
+ply
+.gdb_history

Makefile

@@ -0,0 +1,3 @@
+CFLAGS ?= -Wall -Wextra -Werror -Wno-unused -O0 -g
+
+ply: node.o type.o sym.o

node.c

@@ -0,0 +1,172 @@
+#include <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "node.h"
+
+void node_print_atom(node_t *n, FILE *fp)
+{
+	switch (n->atom.atype) {
+	case A_IDENT:
+		fputs(n->atom.ident, fp);
+		break;
+	case A_NUM:
+		fprintf(fp, "%#"PRIx64, n->atom.num);
+		break;
+	case A_STRING:
+		fprintf(fp, "\"%s\"", n->atom.string);
+		break;
+
+	default:
+		fputs("INVALID_ATOM", fp);
+	}
+}
+
+void node_print_expr(node_t *n, FILE *fp)
+{
+	if (!isprint(n->expr.etype)) {
+		fputs("INVALID_EXPR", fp);
+		return;
+	}
+
+	fputc(n->expr.etype, fp);
+}
+
+void node_print(node_t *n, FILE *fp)
+{
+	switch (n->ntype) {
+	case N_ATOM:
+		node_print_atom(n, fp);
+		break;
+	case N_EXPR:
+		node_print_expr(n, fp);
+		break;
+
+	default:
+		fputs("INVALID_NODE", fp);
+	}
+}
+
+int __node_dump_pre(node_t *n, void *_info)
+{
+	node_dump_info_t *info = _info;
+
+	fprintf(info->fp, "%*s", info->indent, "");
+	node_print(n, info->fp);
+	fputc('\n', info->fp);
+
+	if (n->ntype == N_EXPR) {
+		info->indent += 2;
+	}
+	return 0;
+}
+
+int __node_dump_post(node_t *n, void *_info)
+{
+	node_dump_info_t *info = _info;
+	node_t *next;
+
+	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;
+}
+
+void node_dump(node_t *n, node_dump_info_t *info)
+{
+
+	node_walk(n, __node_dump_pre, __node_dump_post, info);
+}
+
+int node_walk(node_t *n,
+	      int (*pre)(node_t *, void *),
+	      int (*post)(node_t *, void *),
+	      void *ctx)
+{
+	int err = 0;
+	
+	if (pre && (err = pre(n, ctx)))
+		return err;
+
+	if (n->ntype == N_EXPR) {
+		err = node_walk(n->expr.arg, pre, post, ctx);
+		if (err)
+			return err;
+	}
+
+	if (post && (err = post(n, ctx)))
+		return err;
+
+	return 0;
+}
+
+static node_t *__node(ntype_t ntype)
+{
+	node_t *n = calloc(1, sizeof(*n));
+	assert(n);
+
+	n->ntype = ntype;
+	return n;
+}
+
+node_t *node_ident(char *name)
+{
+	node_t *n = __node(N_ATOM);
+
+	n->atom.atype = A_IDENT;
+	n->atom.ident = name;
+	return n;
+}
+
+node_t *node_num(int64_t num)
+{
+	node_t *n = __node(N_ATOM);
+
+	n->atom.atype = A_NUM;
+	n->atom.num = num;
+	return n;
+}
+
+node_t *node_string(char *string)
+{
+	node_t *n = __node(N_ATOM);
+
+	n->atom.atype = A_STRING;
+	n->atom.string = string;
+	return n;
+}
+
+node_t *node_expr(etype_t etype, node_t *arg)
+{
+	node_t *n = __node(N_EXPR);
+	node_t *next;
+
+	n->expr.etype = etype;
+	n->expr.arg = arg;
+
+	for (next = arg; next; next = next->next)
+		next->up = n;
+
+	return n;
+}
+
+node_t *node_cons(node_t *head, node_t *tail)
+{
+	node_t *next;
+
+	assert(!head->next);
+	head->next = tail;
+
+	for (next = tail; next; next = next->next)
+		next->up = head->up;
+
+	return head;
+}

node.h

@@ -0,0 +1,85 @@
+#ifndef _PLY_NODE_H
+#define _PLY_NODE_H
+
+#include <stdint.h>
+
+typedef struct atom atom_t;
+typedef struct expr expr_t;
+typedef struct node node_t;
+
+typedef enum atype {
+	A_INVALID,
+	A_IDENT,
+	A_NUM,
+	A_STRING,
+} atype_t;
+
+struct atom {
+	atype_t atype;
+
+	union {
+		char *ident;
+		int64_t num;
+		char *string;
+	};
+};
+
+typedef enum etype {
+	E_INVALID = '\0',
+
+	E_AGG = '@',
+	E_CALL = '(',
+	E_DEREF = '*',
+	E_DOT = '.',
+	E_MAP = 'm',
+	E_SCOPE = '{',
+	
+} etype_t;
+
+struct expr {
+	etype_t etype;
+	node_t *arg;
+};
+
+typedef enum ntype {
+	N_INVALID,
+	N_ATOM,
+	N_EXPR,
+} ntype_t;
+
+struct node {
+	ntype_t ntype;
+	node_t *up;
+	node_t *next;
+
+	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);
+
+
+/* node constructors */
+
+node_t *node_ident (char *name);
+node_t *node_num   (int64_t num);
+node_t *node_string(char *string);
+node_t *node_expr  (etype_t etype, node_t *arg);
+node_t *node_cons  (node_t *head, node_t *tail);
+
+
+/* debug */
+
+typedef struct node_dump_info {
+	FILE *fp;
+	int indent;
+} node_dump_info_t;
+
+void node_dump(node_t *n, node_dump_info_t *info);
+
+#endif	/* _PLY_NODE_H */

ply.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "node.h"
+#include "sym.h"
+
+typedef struct prog {
+	char *probe;
+	node_t *ast;
+
+	symtab_t locals;
+	symtab_t *globals;
+} prog_t;
+
+symtab_t globals = { .sym = NULL, .len = 0 };
+
+prog_t *prog_get(void)
+{
+	prog_t *p;
+
+	p = calloc(1, sizeof(*p));
+
+	p->globals = &globals,
+
+	/* 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 main(void)
+{
+	node_dump_info_t info = {
+		.indent = 2,
+		.fp = stdout,
+	};
+
+	prog_t *p = prog_get();
+
+	node_dump(p->ast, &info);
+	return 0;
+}

sym.c

@@ -0,0 +1,49 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sym.h"
+
+sym_t *sym_get(symtab_t *st, const char *name)
+{
+	size_t i;
+
+	for (i = 0; i < st->len; i++) {
+		if (!strcmp(st->sym[i].name, name))
+			return &st->sym[i];
+	}
+
+	return NULL;
+}
+
+int sym_add(symtab_t *st, const char *name, tid_t tid, sym_t **new)
+{
+	sym_t *sym;
+
+	sym = sym_get(st, name);
+	if (sym) {
+		/* if there is no type info, accept anything */
+		if (!sym->tid)
+			sym->tid = tid;
+		/* otherwise, if specified, it must match */
+		else if (tid && (sym->tid != tid))
+			return -EINVAL;
+
+		goto found;
+	}
+
+	st->sym = realloc(st->sym, ++st->len * sizeof(*st->sym));
+	assert(st->sym);
+
+	sym = &st->sym[st->len-1];
+	sym->name = name;
+	sym->tid = tid;
+
+found:
+	if (new)
+		*new = sym;
+
+	return 0;
+}

sym.h

@@ -0,0 +1,16 @@
+#ifndef _PLY_SYM_H
+#define _PLY_SYM_H
+
+#include "type.h"
+
+typedef struct sym {
+	const char *name;
+	tid_t tid;
+} sym_t;
+
+typedef struct symtab {
+	sym_t *sym;
+	size_t len;
+} symtab_t;
+
+#endif	/* _PLY_SYM_H */

type.c

@@ -0,0 +1,144 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "type.h"
+
+const type_t builtin_types[] = {
+	{ .type = T_NONE },
+#define SCALAR(_tid, _, _type) [_tid] = {			\
+		.tid = _tid,					\
+		.size = sizeof(_type),				\
+		.type = T_SCALAR,				\
+		.t = {						\
+			.scalar = {				\
+				.name = #_type,			\
+			},					\
+		},						\
+	},
+#define POINTER(_tid, _, _base) [_tid] = {			\
+		.tid = _tid,					\
+		.size = sizeof(void *),				\
+		.type = T_POINTER,				\
+		.t = {						\
+			.pointer = {				\
+				.type = _base,			\
+			},					\
+		},						\
+	},
+BUILTIN_TYPES
+#undef SCALAR
+#undef POINTER
+
+	{ .type = T_INVALID }
+};
+
+const type_t arch_builtin_types[] = {
+	{ .type = T_ALIAS, .t = { .alias = { .type = tid_c, .name = "s8" } } },
+	{ .type = T_ALIAS, .t = { .alias = { .type = tid_uc, .name = "u8" } } },
+
+	{ .type = T_INVALID }
+};
+
+static types_t types = {
+	.types = NULL,
+	.next = 0,
+};
+
+type_t *type_info(tid_t tid)
+{
+	assert(tid < types.next);
+	return &types.types[tid];
+}
+
+void type_dump(type_t *t, FILE *fp)
+{
+	switch (t->type){
+	case T_ALIAS:
+		fputs(t->t.alias.name, fp);
+		break;
+	case T_SCALAR:
+		fputs(t->t.scalar.name, fp);
+		break;
+	case T_POINTER:
+		type_dump(type_info(t->t.pointer.type), fp);
+		fputs(" *", fp);
+		break;
+	case T_ARRAY:
+		type_dump(type_info(t->t.array.type), fp);
+		fprintf(fp, "[%zu]", t->t.array.len);
+		break;
+
+	default:
+		assert(0);
+	}
+}
+
+void type_dump_cdecl(type_t *t, FILE *fp)
+{
+	switch (t->type) {
+	case T_ALIAS:
+		fputs("typedef ", fp);
+		type_dump(type_info(t->t.alias.type), fp);
+		fprintf(fp, " %s", t->t.alias.name);
+		break;
+	case T_SCALAR:
+	case T_POINTER:
+	case T_ARRAY:
+		type_dump(t, fp);
+		break;
+
+	default:
+		assert(0);
+	}
+}
+
+tid_t type_add(const type_t *type)
+{
+	tid_t tid = types.next++;
+
+	types.types = realloc(types.types, types.next * sizeof(type_t));
+	assert(types.types);
+
+	types.types[tid] = *type;
+	types.types[tid].tid = tid;
+	return tid;
+}
+
+tid_t type_add_list(const type_t *type)
+{
+	tid_t first = 0;
+
+	for (; type->type; type++) {
+		if (!first)
+			first = type_add(type);
+		else
+			type_add(type);
+	}
+
+	return first;
+}
+
+__attribute__((constructor))
+static void type_init(void)
+{
+	type_add_list(builtin_types);
+	type_add_list(arch_builtin_types);
+}
+
+/* int main(void) */
+/* { */
+/* 	tid_t tid; */
+
+/* 	type_init(); */
+
+/* 	for (tid = 0; tid < types.next; tid++) { */
+/* 		type_t *t = type_info(tid); */
+
+/* 		printf("tid:%3d sz:%2zx  ", t->tid, t->size);  */
+/* 		type_dump_cdecl(t, stdout); */
+/* 		putchar('\n'); */
+/* 	} */
+
+/* 	return 0; */
+/* } */

type.h

@@ -0,0 +1,112 @@
+#ifndef _PLY_TYPE_H
+#define _PLY_TYPE_H
+
+typedef unsigned int tid_t;
+
+typedef struct alias {
+	tid_t type;
+	char *name;
+} alias_t;
+
+typedef struct scalar {
+	char *name;
+} scalar_t;
+
+typedef struct pointer {
+	tid_t type;
+} pointer_t;
+
+typedef struct array {
+	tid_t type;
+	size_t len;
+} array_t;
+
+typedef struct map {
+	tid_t type;
+	tid_t ktype;
+	size_t len;
+} map_t;
+
+typedef struct field {
+	struct field *next;
+
+	tid_t type;
+	size_t offset;
+	char *name;
+} field_t;
+
+typedef struct sou {
+	field_t *fields;
+} sou_t;
+
+typedef enum ttype {
+	T_INVALID,
+	T_NONE,
+	T_ALIAS,
+	T_SCALAR,
+	T_POINTER,
+	T_ARRAY,
+	T_MAP,
+	T_SOU,
+} ttype_t;
+
+typedef struct type {
+	tid_t tid;
+
+	size_t size;
+
+	ttype_t type;
+	union {
+		alias_t alias;
+		scalar_t scalar;
+		pointer_t pointer;
+		array_t array;
+		map_t map;
+		sou_t sou;
+	} t;
+} type_t;
+
+typedef struct types {
+	type_t *types;
+	tid_t next;
+} types_t;
+
+#define BUILTIN_TYPES				\
+	SCALAR(1, tid_v, void)			\
+	POINTER(2, tid_vp, 1)			\
+						\
+	SCALAR(3, tid_c, char)			\
+	POINTER(4, tid_cp, 3)			\
+	SCALAR(5, tid_uc, unsigned char)	\
+	POINTER(6, tid_ucp, 5)			\
+						\
+	SCALAR(7, tid_s, short)			\
+	POINTER(8, tid_sp, 7)			\
+	SCALAR(9, tid_us, unsigned short)	\
+	POINTER(10, tid_usp, 9)			\
+						\
+	SCALAR(11, tid_i, int)			\
+	POINTER(12, tid_ip, 11)			\
+	SCALAR(13, tid_ui, unsigned int)	\
+	POINTER(14, tid_uip, 13)		\
+						\
+	SCALAR(15, tid_l, long)			\
+	POINTER(16, tid_lp, 15)			\
+	SCALAR(17, tid_ul, unsigned long)	\
+	POINTER(18, tid_ulp, 17)		\
+						\
+	SCALAR(19, tid_ll, long long)		\
+	POINTER(20, tid_llp, 19)		\
+	SCALAR(21, tid_ull, unsigned long long)	\
+	POINTER(22, tid_ullp, 21)
+
+typedef enum builtin_type {
+	tid_none = 0,
+#define SCALAR(_tid, _name, _) _name = _tid,
+#define POINTER(_tid, _name, _) _name = _tid,
+BUILTIN_TYPES
+#undef SCALAR
+#undef POINTER
+} builtin_type_t;
+
+#endif	/* _PLY_TYPE_H */