get rid of tid

Makefile

@@ -1,3 +1,8 @@
 CFLAGS ?= -Wall -Wextra -Werror -Wno-unused -O0 -g
 
-ply: node.o type.o sym.o
+objs := $(patsubst %.c,%.o,$(wildcard *.c))
+headers := $(wildcard *.c)
+
+$(objs): $(headers)
+
+ply: $(objs)

arch-x86_64.c

@@ -0,0 +1,87 @@
+#include <assert.h>
+#include <linux/ptrace.h>
+
+#include "type.h"
+
+#define arch_typedef(_a, _t) {					\
+		.ttype = T_TYPEDEF,				\
+		.t = { .tdef = { .name = #_a, .type = _t } },	\
+	}
+
+#define arch_pointer(_t) {					\
+		.ttype = T_POINTER,				\
+		.t = { .pointer = { .type = _t } },		\
+	}
+
+type_t t_s8 = arch_typedef(s8, &t_c);
+type_t t_s8p = arch_pointer(&t_s8);
+type_t t_u8 = arch_typedef(u8, &t_uc);
+type_t t_u8p = arch_pointer(&t_u8);
+
+type_t t_s16 = arch_typedef(s16, &t_s);
+type_t t_s16p = arch_pointer(&t_s16);
+type_t t_u16 = arch_typedef(u16, &t_us);
+type_t t_u16p = arch_pointer(&t_u16);
+
+type_t t_s32 = arch_typedef(s32, &t_i);
+type_t t_s32p = arch_pointer(&t_s32);
+type_t t_u32 = arch_typedef(u32, &t_ui);
+type_t t_u32p = arch_pointer(&t_u32);
+
+type_t t_s64 = arch_typedef(s64, &t_l);
+type_t t_s64p = arch_pointer(&t_s64);
+type_t t_u64 = arch_typedef(u64, &t_ul);
+type_t t_u64p = arch_pointer(&t_u64);
+
+field_t f_pt_regs_fields[] = {
+	{ .name = "r15",      .type = &t_ul },
+	{ .name = "r14",      .type = &t_ul },
+	{ .name = "r13",      .type = &t_ul },
+	{ .name = "r12",      .type = &t_ul },
+	{ .name = "rbp",      .type = &t_ul },
+	{ .name = "rbx",      .type = &t_ul },
+	{ .name = "r11",      .type = &t_ul },
+	{ .name = "r10",      .type = &t_ul },
+	{ .name = "r9",       .type = &t_ul },
+	{ .name = "r8",       .type = &t_ul },
+	{ .name = "rax",      .type = &t_ul },
+	{ .name = "rcx",      .type = &t_ul },
+	{ .name = "rdx",      .type = &t_ul },
+	{ .name = "rsi",      .type = &t_ul },
+	{ .name = "rdi",      .type = &t_ul },
+	{ .name = "orig_rax", .type = &t_ul },
+	{ .name = "rip",      .type = &t_ul },
+	{ .name = "cs",       .type = &t_ul },
+	{ .name = "eflags",   .type = &t_ul },
+	{ .name = "rsp",      .type = &t_ul },
+	{ .name = "ss",       .type = &t_ul },
+
+	{ .type = NULL }
+};
+
+type_t t_pt_regs = {
+	.ttype = T_STRUCT,
+
+	.t.sou = {
+		.name = "pt_regs",
+		.fields = f_pt_regs_fields,
+	},
+};
+
+type_t *arch_types[] = {
+	&t_s8, &t_s8p, &t_u8, &t_u8p,
+	&t_s16, &t_s16p, &t_u16, &t_u16p,
+	&t_s32, &t_s32p, &t_u32, &t_u32p,
+	&t_s64, &t_s64p, &t_u64, &t_u64p,
+	&t_pt_regs,
+
+	NULL
+};
+
+__attribute__((constructor))
+static void arch_init(void)
+{
+	type_add_list(arch_types);
+
+	assert(t_pt_regs.size == sizeof(struct pt_regs));
+}

arch.h

@@ -0,0 +1,28 @@
+#ifndef _PLY_ARCH_H
+#define _PLY_ARCH_H
+
+#include "type.h"
+
+extern type_t t_s8;
+extern type_t t_s8p;
+extern type_t t_u8;
+extern type_t t_u8p;
+
+extern type_t t_s16;
+extern type_t t_s16p;
+extern type_t t_u16;
+extern type_t t_u16p;
+
+extern type_t t_s32;
+extern type_t t_s32p;
+extern type_t t_u32;
+extern type_t t_u32p;
+
+extern type_t t_s64;
+extern type_t t_s64p;
+extern type_t t_u64;
+extern type_t t_u64p;
+
+extern type_t t_pt_regs;
+
+#endif	/* _PLY_ARCH_H */

global.c

@@ -0,0 +1,24 @@
+#include "ply.h"
+
+int global_resolve(prog_t *prog, node_t *n)
+{
+	return 0;
+}
+
+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);
+}

kprobe.c

@@ -0,0 +1,61 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <linux/ptrace.h>
+
+#include "ply.h"
+
+struct kprobe {
+};
+
+static inline int is_arg(const char *name)
+{
+	return (strstr(name, "arg") == name)
+		&& (strlen(name) == 4)
+		&& (name[3] >= '0' && name[3] <= '9');
+}
+
+int kprobe_resolve(prog_t *prog, node_t *n)
+{
+	struct kprobe *kp = prog->provider_data;
+	type_t *t;
+	char *name;
+
+	name = n->atom.ident;
+
+	if (is_arg(name))
+		t = &t_ul;
+	else if (!strcmp(name, "ctx"))
+		t = &t_pt_regs;
+	else
+		return -ENOENT;
+
+	n->type = t;
+	return sym_add(prog->locals, name, t);
+}
+
+int kprobe_probe(prog_t *prog)
+{
+	struct kprobe *kp;
+
+	kp = calloc(1, sizeof(*kp));
+	assert(kp);
+
+	prog->provider_data = kp;
+	return 0;
+}
+
+provider_t kprobe = {
+	.name = "kprobe",
+
+	.resolve = kprobe_resolve,
+	.probe = kprobe_probe,
+};
+
+__attribute__((constructor))
+static void kprobe_init(void)
+{
+	provider_register(&kprobe);
+}

node.h

@@ -2,8 +2,9 @@
 #define _PLY_NODE_H
 
 #include <stdint.h>
+#include <stdio.h>
 
-typedef struct sym sym_t;
+#include "type.h"
 
 typedef struct atom atom_t;
 typedef struct expr expr_t;
@@ -54,7 +55,7 @@ struct node {
 	node_t *up;
 	node_t *next;
 
-	sym_t *sym;
+	type_t *type;
 
 	union {
 		atom_t atom;

ply.c

@@ -1,38 +1,63 @@
+#include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
-#include "node.h"
-#include "sym.h"
+#include "ply.h"
 
-typedef struct pass {
-	int (*run)(void *);
+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;
-} 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 };
+symtab_t globals = { .sym = NULL, .len = 0 };
+symtab_t locals = { .sym = NULL, .len = 0 };
 
 prog_t *prog_get(void)
 {
-	prog_t *p;
+	prog_t *prog;
 
-	p = calloc(1, sizeof(*p));
+	prog = calloc(1, sizeof(*prog));
 
-	p->st = &symbols,
+	prog->locals = &locals;
+	prog->globals = &globals;
 
-	/* reads{pid()} @ quantize(arg2) */
-	p->ast =
+	prog->probe = "k:SyS_read"; /* { reads{pid()} @ quantize(arg2) } */
+	prog->ast =
 		node_expr('@',
 			  node_cons(
 				  node_expr('m',
@@ -50,12 +75,16 @@ prog_t *prog_get(void)
 				  )
 			);
 
-	return p;
+	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(":");
+	int err;
 
 	if ((n->ntype != N_ATOM) || (n->atom.atype != A_IDENT))
 		return 0;
@@ -67,19 +96,22 @@ int symtab_populate(node_t *n, void *_prog)
 	    && (n != n->up->expr.arg))
 		return 0;
 
-	return sym_add(prog->st, n->atom.ident, tid_none, &n->sym);
+	err = prog->provider->resolve(prog, n);
+	if (!err || err != -ENOENT)
+		return err;
+
+	return global->resolve(prog, n);
 }
 
-int symtab_resolve(void *_prog)
+int pass_walk(pass_t *pass, prog_t *prog)
 {
-	prog_t *prog = _prog;
-	return 0;
+	return node_walk(prog->ast, pass->pre, pass->post, prog);
 }
 
 pass_t passes[] = {
-	{ .pre = symtab_populate },
-	{ .run = symtab_resolve },
-	{ NULL, NULL, NULL }
+	{ .run = pass_walk, .pre = symtab_populate },
+
+	{ NULL }
 };
 
 int main(void)
@@ -89,19 +121,23 @@ int main(void)
 		.fp = stdout,
 	};
 
-	prog_t *p = prog_get();
+	prog_t *prog = 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);
+	for (pass = passes; pass->run; pass++) {
+		err = pass->run(pass, prog);
 		if (err)
 			break;
 	}
 
-	node_dump(p->ast, &info);
-	symtab_dump(p->st, stdout);
+	printf("AST\n===\n");
+	node_dump(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;
 }

ply.h

@@ -0,0 +1,34 @@
+#ifndef _PLY_H
+#define _PLY_H
+
+#include "node.h"
+#include "sym.h"
+#include "type.h"
+#include "arch.h"
+
+typedef struct prog prog_t;
+typedef struct provider provider_t;
+
+struct prog {
+	const char *probe;
+	node_t *ast;
+
+	symtab_t *locals;
+	symtab_t *globals;
+
+	provider_t *provider;
+	void *provider_data;
+};
+
+
+
+struct provider {
+	const char *name;
+
+	int (*resolve)(prog_t *, node_t *);
+	int (*probe)(prog_t *);
+};
+
+void provider_register(provider_t *prov);
+
+#endif	/* _PLY_H */

sym.c

@@ -18,20 +18,20 @@ sym_t *sym_get(symtab_t *st, const char *name)
 	return NULL;
 }
 
-int sym_add(symtab_t *st, const char *name, tid_t tid, sym_t **new)
+int sym_add(symtab_t *st, const char *name, type_t *type)
 {
 	sym_t *sym;
 
 	sym = sym_get(st, name);
 	if (sym) {
 		/* if there is no type info, accept anything */
-		if (!sym->tid)
-			sym->tid = tid;
+		if (!sym->type)
+			sym->type = type;
 		/* otherwise, if specified, it must match */
-		else if (tid && (sym->tid != tid))
+		else if (type && !type_equal(sym->type, type))
 			return -EINVAL;
 
-		goto found;
+		return 0;
 	}
 
 	st->sym = realloc(st->sym, ++st->len * sizeof(*st->sym));
@@ -39,18 +39,13 @@ int sym_add(symtab_t *st, const char *name, tid_t tid, sym_t **new)
 
 	sym = &st->sym[st->len-1];
 	sym->name = name;
-	sym->tid = tid;
-
-found:
-	if (new)
-		*new = sym;
-
+	sym->type = type;
 	return 0;
 }
 
 void sym_dump(sym_t *sym, FILE *fp)
 {
-	type_dump_cdecl(type_info(sym->tid), fp);
+	type_dump(sym->type, fp);
 	fputc(' ', fp);
 	fputs(sym->name, fp);
 }

sym.h

@@ -5,7 +5,7 @@
 
 typedef struct sym {
 	const char *name;
-	tid_t tid;
+	type_t *type;
 } sym_t;
 
 typedef struct symtab {
@@ -14,7 +14,7 @@ typedef struct symtab {
 } symtab_t;
 
 sym_t *sym_get(symtab_t *st, const char *name);
-int    sym_add(symtab_t *st, const char *name, tid_t tid, sym_t **new);
+int    sym_add(symtab_t *st, const char *name, type_t *type);
 
 void sym_dump(sym_t *sym, FILE *fp);
 void symtab_dump(symtab_t *st, FILE *fp);

type.c

@@ -4,145 +4,255 @@
 
 #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 }
-};
+#define builtin_scalar(_t) {				\
+		.ttype = T_SCALAR,			\
+		.size = sizeof(_t),			\
+		.t = { .scalar = { .name = #_t } },	\
+	}
 
-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" } } },
+#define builtin_pointer(_t) {				\
+		.ttype = T_POINTER,			\
+		.t = { .pointer = { .type = _t } },	\
+	}
 
-	{ .type = T_INVALID }
-};
+type_t t_v    = builtin_scalar(void);
+type_t t_vp   = builtin_pointer(&t_v);
+
+type_t t_c    = builtin_scalar(char);
+type_t t_cp   = builtin_pointer(&t_c);
+type_t t_uc   = builtin_scalar(unsigned char);
+type_t t_ucp  = builtin_pointer(&t_uc);
+
+type_t t_s    = builtin_scalar(short);
+type_t t_sp   = builtin_pointer(&t_s);
+type_t t_us   = builtin_scalar(unsigned short);
+type_t t_usp  = builtin_pointer(&t_us);
+
+type_t t_i    = builtin_scalar(int);
+type_t t_ip   = builtin_pointer(&t_i);
+type_t t_ui   = builtin_scalar(unsigned int);
+type_t t_uip  = builtin_pointer(&t_ui);
+
+type_t t_l    = builtin_scalar(long);
+type_t t_lp   = builtin_pointer(&t_l);
+type_t t_ul   = builtin_scalar(unsigned long);
+type_t t_ulp  = builtin_pointer(&t_ul);
+
+type_t t_ll   = builtin_scalar(long long);
+type_t t_llp  = builtin_pointer(&t_ll);
+type_t t_ull  = builtin_scalar(unsigned long long);
+type_t t_ullp = builtin_pointer(&t_ull);
 
-static types_t types = {
-	.types = NULL,
-	.next = 0,
+type_t *builtin_types[] = {
+	&t_v,  &t_vp,
+	&t_c,  &t_cp,  &t_uc,  &t_ucp,
+	&t_s,  &t_sp,  &t_us,  &t_usp,
+	&t_i,  &t_ip,  &t_ui,  &t_uip,
+	&t_l,  &t_lp,  &t_ul,  &t_ulp,
+	&t_ll, &t_llp, &t_ull, &t_ullp,
+
+	NULL
 };
 
-type_t *type_info(tid_t tid)
+struct type_list {
+	type_t **type;
+	size_t len;
+} types;
+
+
+void type_dump_func(type_t *t, FILE *fp)
 {
-	assert(tid < types.next);
-	return &types.types[tid];
+	field_t *arg;
+
+	type_dump(t->t.func.type, fp);
+	fprintf(fp, " (*%s)(", t->t.func.name);
+
+	for (arg = t->t.func.args; arg->type; arg++) {
+		if (arg != t->t.func.args)
+			fputs(", ", fp);
+
+		type_dump(arg->type, fp);
+	}
+
+	fputc(')', fp);
 }
 
 void type_dump(type_t *t, FILE *fp)
 {
-	switch (t->type){
-	case T_NONE:
-		fputs("<NONE>", fp);
-		break;
-	case T_ALIAS:
-		fputs(t->t.alias.name, fp);
+	switch (t->ttype){
+	case T_TYPEDEF:
+		fputs(t->t.tdef.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);
+		type_dump(t->t.pointer.type, fp);
 		fputs(" *", fp);
 		break;
 	case T_ARRAY:
-		type_dump(type_info(t->t.array.type), fp);
+		type_dump(t->t.array.type, fp);
 		fprintf(fp, "[%zu]", t->t.array.len);
 		break;
-
-	default:
+	case T_STRUCT:
+		fputs("struct ", fp);
+		fputs(t->t.sou.name, fp);
+		break;
+	case T_UNION:
+		fputs("union ", fp);
+		fputs(t->t.sou.name, fp);
+		break;
+	case T_FUNC:
+		type_dump_func(t, fp);
+		break;
+	case T_MAP:
+		/* TODO */
 		assert(0);
+		break;
+	}
+}
+
+void type_dump_cdecl_sou(type_t *t, FILE *fp)
+{
+	field_t *f;
+
+	type_dump(t, fp);
+	fputs(" {\n", fp);
+	for (f = t->t.sou.fields; f->type; f++) {
+		fputc('\t', fp);
+		type_dump(f->type, fp);
+		fprintf(fp, " %s;\n", f->name);
 	}
+	fputs("}", fp);
 }
 
 void type_dump_cdecl(type_t *t, FILE *fp)
 {
-	switch (t->type) {
-	case T_ALIAS:
+	switch (t->ttype) {
+	case T_TYPEDEF:
 		fputs("typedef ", fp);
-		type_dump(type_info(t->t.alias.type), fp);
-		fprintf(fp, " %s", t->t.alias.name);
+		type_dump(t->t.tdef.type, fp);
+		fprintf(fp, " %s", t->t.tdef.name);
+		break;
+
+	case T_STRUCT:
+	case T_UNION:
+		type_dump_cdecl_sou(t, fp);
 		break;
-	case T_NONE:
+
 	case T_SCALAR:
 	case T_POINTER:
 	case T_ARRAY:
+	case T_MAP:
+	case T_FUNC:
 		type_dump(t, fp);
 		break;
-
-	default:
-		assert(0);
 	}
 }
 
-tid_t type_add(const type_t *type)
+void types_dump_cdecl(FILE *fp)
 {
-	tid_t tid = types.next++;
+	size_t i;
 
-	types.types = realloc(types.types, types.next * sizeof(type_t));
-	assert(types.types);
+	for (i = 0; i < types.len; i++) {
+		type_t *t = types.type[i];
 
-	types.types[tid] = *type;
-	types.types[tid].tid = tid;
-	return tid;
+		type_dump_cdecl(t, stdout);
+		printf(" <sz:0x%zx>\n", t->size);
+	}
 }
 
-tid_t type_add_list(const type_t *type)
+int type_equal(type_t *a, type_t *b)
 {
-	tid_t first = 0;
+	/* TODO */
+	return a == b;
+}
 
-	for (; type->type; type++) {
-		if (!first)
-			first = type_add(type);
-		else
-			type_add(type);
+void type_size_set_sou(type_t *t)
+{
+	field_t *f;
+	size_t size = 0;
+
+	if (!t->t.sou.fields)
+		return;
+
+	for (f = t->t.sou.fields; f->name; f++) {
+		/* size of all members is now known yet, abort */
+		if (!f->type->size)
+			return;
+
+		if (!t->t.sou.packed)
+			size += size % f->type->size;
+
+		size += f->type->size;
+		f->offset = size;
 	}
 
-	return first;
+	if (!t->t.sou.packed && size) {
+		/* align complete struct to requirements of first
+		 * member */
+		f = t->t.sou.fields;
+
+		size += size % f->type->size;
+	}
+
+	t->size = size;
 }
 
-__attribute__((constructor))
-static void type_init(void)
+void type_size_set(type_t *t)
 {
-	type_add_list(builtin_types);
-	type_add_list(arch_builtin_types);
+	switch (t->ttype) {
+	case T_TYPEDEF:
+		t->size = t->t.tdef.type->size;
+		break;
+	case T_STRUCT:
+	case T_UNION:
+		type_size_set_sou(t);
+		break;
+	case T_FUNC:
+		t->size = t->t.func.type->size;
+		break;
+	case T_SCALAR:
+		break;
+	case T_POINTER:
+		t->size = sizeof(void *);
+		break;
+	case T_ARRAY:
+		t->size = t->t.array.len * t->t.array.type->size;
+		break;
+
+	case T_MAP:
+		/* TODO */
+		assert(0);
+		break;
+	}
 }
 
-/* int main(void) */
-/* { */
-/* 	tid_t tid; */
 
-/* 	type_init(); */
+int type_add(type_t *t)
+{
+	types.type = realloc(types.type, ++types.len * sizeof(*types.type));
+	types.type[types.len - 1] = t;
 
-/* 	for (tid = 0; tid < types.next; tid++) { */
-/* 		type_t *t = type_info(tid); */
+	type_size_set(t);
+	return 0;
+}
 
-/* 		printf("tid:%3d sz:%2zx  ", t->tid, t->size);  */
-/* 		type_dump_cdecl(t, stdout); */
-/* 		putchar('\n'); */
-/* 	} */
+int type_add_list(type_t **ts)
+{
+	int err;
 
-/* 	return 0; */
-/* } */
+	for (; *ts; ts++) {
+		err = type_add(*ts);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+__attribute__((constructor))
+static void type_init(void)
+{
+	type_add_list(builtin_types);
+}

type.h

@@ -1,118 +1,116 @@
 #ifndef _PLY_TYPE_H
 #define _PLY_TYPE_H
 
-typedef unsigned int tid_t;
+#include <stddef.h>
+#include <stdio.h>
 
-typedef struct alias {
-	tid_t type;
+typedef struct type type_t;
+
+struct t_tdef {
 	char *name;
-} alias_t;
+	type_t *type;
+};
 
-typedef struct scalar {
+struct t_scalar {
 	char *name;
-} scalar_t;
+};
 
-typedef struct pointer {
-	tid_t type;
-} pointer_t;
+struct t_pointer {
+	type_t *type;
+};
 
-typedef struct array {
-	tid_t type;
+struct t_array {
+	type_t *type;
 	size_t len;
-} array_t;
+};
 
-typedef struct map {
-	tid_t type;
-	tid_t ktype;
+struct t_map {
+	type_t *vtype;
+	type_t *ktype;
 	size_t len;
-} map_t;
+};
 
 typedef struct field {
-	struct field *next;
-
-	tid_t type;
-	size_t offset;
 	char *name;
+	type_t *type;
+	size_t offset;
 } field_t;
 
-typedef struct sou {
+struct t_sou {
+	char *name;
+
+	int packed:1;
 	field_t *fields;
-} sou_t;
+};
+
+struct t_func {
+	char *name;
+	type_t *type;
+
+	field_t *args;
+};
 
 typedef enum ttype {
-	T_INVALID,
-	T_NONE,
-	T_ALIAS,
+	T_TYPEDEF,
 	T_SCALAR,
 	T_POINTER,
 	T_ARRAY,
 	T_MAP,
-	T_SOU,
+	T_STRUCT,
+	T_UNION,
+	T_FUNC,
 } ttype_t;
 
-typedef struct type {
-	tid_t tid;
-
+struct type {
 	size_t size;
 
-	ttype_t type;
+	ttype_t ttype;
 	union {
-		alias_t alias;
-		scalar_t scalar;
-		pointer_t pointer;
-		array_t array;
-		map_t map;
-		sou_t sou;
+		struct t_tdef tdef;
+		struct t_scalar scalar;
+		struct t_pointer pointer;
+		struct t_array array;
+		struct t_map map;
+		struct t_sou sou;
+		struct t_func func;
 	} 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;
-
-
-type_t *type_info(tid_t tid);
+};
+
+extern type_t t_v;
+extern type_t t_vp;
+
+extern type_t t_c;
+extern type_t t_cp;
+extern type_t t_uc;
+extern type_t t_ucp;
+
+extern type_t t_s;
+extern type_t t_sp;
+extern type_t t_us;
+extern type_t t_usp;
+
+extern type_t t_i;
+extern type_t t_ip;
+extern type_t t_ui;
+extern type_t t_uip;
+
+extern type_t t_l;
+extern type_t t_lp;
+extern type_t t_ul;
+extern type_t t_ulp;
+
+extern type_t t_ll;
+extern type_t t_llp;
+extern type_t t_ull;
+extern type_t t_ullp;
+
+
+int type_equal(type_t *a, type_t *b);
+int type_add(type_t *t);
+int type_add_list(type_t **ts);
 
 void type_dump      (type_t *t, FILE *fp);
 void type_dump_cdecl(type_t *t, FILE *fp);
+void types_dump_cdecl(FILE *fp);
 
 #endif	/* _PLY_TYPE_H */