rename base types, start on validation

arch-x86_64.c

 		.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);
+type_t t_s8 = arch_typedef(s8, &t_char);
+type_t t_u8 = arch_typedef(u8, &t_uchar);
+type_t t_s16 = arch_typedef(s16, &t_short);
+type_t t_u16 = arch_typedef(u16, &t_ushort);
+type_t t_s32 = arch_typedef(s32, &t_int);
+type_t t_u32 = arch_typedef(u32, &t_uint);
+type_t t_s64 = arch_typedef(s64, &t_long);
+type_t t_u64 = arch_typedef(u64, &t_ulong);
 
 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 },
+	{ .name = "r15",      .type = &t_ulong },
+	{ .name = "r14",      .type = &t_ulong },
+	{ .name = "r13",      .type = &t_ulong },
+	{ .name = "r12",      .type = &t_ulong },
+	{ .name = "rbp",      .type = &t_ulong },
+	{ .name = "rbx",      .type = &t_ulong },
+	{ .name = "r11",      .type = &t_ulong },
+	{ .name = "r10",      .type = &t_ulong },
+	{ .name = "r9",       .type = &t_ulong },
+	{ .name = "r8",       .type = &t_ulong },
+	{ .name = "rax",      .type = &t_ulong },
+	{ .name = "rcx",      .type = &t_ulong },
+	{ .name = "rdx",      .type = &t_ulong },
+	{ .name = "rsi",      .type = &t_ulong },
+	{ .name = "rdi",      .type = &t_ulong },
+	{ .name = "orig_rax", .type = &t_ulong },
+	{ .name = "rip",      .type = &t_ulong },
+	{ .name = "cs",       .type = &t_ulong },
+	{ .name = "eflags",   .type = &t_ulong },
+	{ .name = "rsp",      .type = &t_ulong },
+	{ .name = "ss",       .type = &t_ulong },
 
 	{ .type = NULL }
 };
 	},
 };
 
-type_t t_pt_regsp = {
-	.ttype = T_POINTER,
-	.t.pointer = {
-		.type = &t_pt_regs,
-	}
-};
-
 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_s8, &t_u8,
+	&t_s16, &t_u16,
+	&t_s32, &t_u32,
+	&t_s64, &t_u64,
 	&t_pt_regs,
 
 	NULL

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;
-extern type_t t_pt_regsp;
 
 #endif	/* _PLY_ARCH_H */

kprobe.c

 	type_t *t;
 
 	if (is_arg(n->ident))
-		t = &t_ul;
+		t = &t_ulong;
 	else if (!strcmp(n->ident, "ctx"))
-		t = &t_pt_regsp;
+		t = type_ptr_of(&t_pt_regs);
 	else
 		return -ENOENT;
 

node.c

 		break;
 	case N_KEYWORD:
 		fputs("\e[31m", fp);
-		fputc(n->keyword, fp);
+		fputc(n->keyword.class, fp);
+		if (n->keyword.op)
+			fputc(n->keyword.op, fp);
 		fputs("\e[0m", fp);
 		break;
 	case N_IDENT:
 	return n;
 }
 
-node_t *node_keyword(keyword_t keyword)
+node_t *node_keyword(kwclass_t class, int op)
 {
 	node_t *n = __node(N_KEYWORD);
-	n->keyword = keyword;
+	n->keyword.class = class;
+	n->keyword.op    = op;
 	return n;
 }
 
 	n->string = string;
 
 	/* TODO: string type like dtrace? */
-	n->type = &t_cp;
+	n->type = type_ptr_of(&t_char);
 	return n;
 }

node.h

 
 typedef struct node node_t;
 
-typedef enum keyword {
+typedef enum kwclass {
 	KW_SUBSCRIPT = '[',
 	KW_ASSIGN = '=',
+	KW_ARITH = 'a',
+} kwclass_t;
+
+typedef enum kwarith {
 	KW_ADD = '+',
 	KW_SUB = '-',
 	KW_MUL = '*',
 	KW_DIV = '/',
+} kwarith_t;
+
+typedef struct keyword {
+	kwclass_t class;
+	int op;
 } keyword_t;
 
 typedef enum ntype {
 node_t *node_list  (node_t *head);
 node_t *node_vlist (node_t *head, ...);
 
-node_t *node_keyword(keyword_t keyword);
+node_t *node_keyword(kwclass_t class, int op);
 node_t *node_ident  (char *name);
 node_t *node_num    (int64_t num);
 node_t *node_string (char *string);

ply.c

 	/* { t0 = time(); @reads[pid()] = quantize(arg2) } */
 	prog->ast =
 		node_vlist(
-			node_vlist(node_keyword('='),
+			node_vlist(node_keyword('=', 0),
 				   node_ident("t0"),
 				   node_list(node_ident("time")),
 				   NULL),
-			node_vlist(node_keyword('='),
-				   node_vlist(node_keyword('['),
+			node_vlist(node_keyword('=', 0),
+				   node_vlist(node_keyword('[', 0),
 					      node_ident("@reads"),
 					      node_list(node_ident("pid")),
 					      NULL),
 	/* { @times[pid()] = quantize(time() - t0) } */
 	prog->ast =
 		node_list(
-			node_vlist(node_keyword('='),
-				   node_vlist(node_keyword('['),
+			node_vlist(node_keyword('=', 0),
+				   node_vlist(node_keyword('[', 0),
 					      node_ident("@times"),
 					      node_list(node_ident("pid")),
 					      NULL),
 				   node_vlist(node_ident("quantize"),
-					      node_vlist(node_keyword('-'),
+					      node_vlist(node_keyword('a', '-'),
 							 node_list(node_ident("time")),
 							 node_ident("t0"),
 							 NULL),
 
 	/* list of lists (code block) => void */
 	if (n->list->ntype == N_LIST) {
-		n->type = &t_v;
+		n->type = &t_void;
 		return 0;
 	}
 
 {
 	node_t *dst, *src;
 
-	switch (n->keyword) {
+	switch (n->keyword.class) {
 	case KW_ASSIGN:
 		dst = node_next(n);
 		src = node_next(dst);
 
 		/* TODO: assignment is statement for now. do we need
 		 * c-style assignment expressions? e.g `a = b = 2;` */
-		n->type = &t_v;
+		n->type = &t_void;
 
 		if (dst->type)
 			return 0;
 
 		return sym_add(dst->sym->st, dst->ident, dst->type, NULL);
 
-	case KW_ADD:
-	case KW_SUB:
-	case KW_MUL:
-	case KW_DIV:
+	case KW_ARITH:
 		dst = node_next(n);
 		src = node_next(dst);
 		assert(dst && src);
 		return 0;
 
 	default:
+		n->type = &t_void;
 		return 0;
 	}
 
 	 * means the type of the map itself is also known. */
 	if (parent && parent->type
 	    && (parent->list->ntype == N_KEYWORD)
-	    && (parent->list->keyword == KW_SUBSCRIPT)
+	    && (parent->list->keyword.class == KW_SUBSCRIPT)
 	    && key && key->type) {
-		n->type = type_get_map_of(key->type, parent->type);
+		n->type = type_map_of(key->type, parent->type);
 
 		return sym_add(n->sym->st, n->ident, n->type, NULL);
 	}
 	return 0;
 }
 
-/* int pass_walk(pass_t *pass, prog_t *prog) */
-/* { */
-/* 	return node_walk(prog->ast, pass->pre, pass->post, prog); */
-/* } */
+int validate_func(node_t *n)
+{
+	return 0;
+}
 
 int pass_validate_types(node_t *n, void *_prog)
 {
 	prog_t *prog = _prog;
 
-	
-	return 0;
+	if (!n->type) {
+		node_print(n, stderr);
+		fputs(": is of unknown type\n", stderr);
+		return -EINVAL;
+	}
+
+	if (n->ntype != N_LIST)
+		return 0;
+
+	if (n->list->ntype != N_IDENT)
+		return 0;
+
+	assert(n->list->type->ttype == T_FUNC);
+	return validate_func(n->list);
 }
 
 int pass_walk(pass_t *pass, ctx_t *ctx)

sym.c

 
 void sym_dump(sym_t *sym, FILE *fp)
 {
+	fputs("\e[2m", fp);
 	type_dump(sym->type, fp);
-	fputc(' ', fp);
+	fputs("\e[0m ", fp);
 	fputs(sym->name, fp);
 }
 

type.c

 		.t = { .scalar = { .name = #_t } },	\
 	}
 
-#define builtin_pointer(_t) {				\
-		.ttype = T_POINTER,			\
-		.t = { .pointer = { .type = _t } },	\
-	}
-
-type_t t_v    = builtin_scalar(void);
-type_t t_vp   = builtin_pointer(&t_v);
+type_t t_void = builtin_scalar(void);
 
-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_char  = builtin_scalar(char);
+type_t t_uchar = builtin_scalar(unsigned char);
 
-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_short  = builtin_scalar(short);
+type_t t_ushort = builtin_scalar(unsigned short);
 
-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_int  = builtin_scalar(int);
+type_t t_uint = builtin_scalar(unsigned int);
 
-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_long  = builtin_scalar(long);
+type_t t_ulong = builtin_scalar(unsigned long);
 
-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);
+type_t t_llong  = builtin_scalar(long long);
+type_t t_ullong = builtin_scalar(unsigned long long);
 
 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,
+	&t_void,
+	&t_char,  &t_uchar,
+	&t_short, &t_ushort,
+	&t_int,   &t_uint,
+	&t_long,  &t_ulong,
+	&t_llong, &t_ullong,
 
 	NULL
 };
 	}
 }
 
-type_t *type_get_map_of(type_t *ktype, type_t *vtype)
+type_t *type_map_of(type_t *ktype, type_t *vtype)
 {
 	type_t *t;
 	size_t i;
 	return t;
 }
 
+type_t *type_ptr_of(type_t *type)
+{
+	type_t *t;
+	size_t i;
+
+	for (i = 0; i < types.len; i++) {
+		t = types.type[i];
+		if ((t->ttype == T_POINTER)
+		    && (t->t.pointer.type == type))
+			return t;
+	}
+
+	t = calloc(1, sizeof(*t));
+	t->ttype = T_POINTER;
+	t->t.pointer.type = type;
+	type_add(t);
+	return t;
+}
+
 int type_equal(type_t *a, type_t *b)
 {
 	/* TODO */

type.h

 	} t;
 };
 
-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;
-
-type_t *type_get_map_of(type_t *ktype, type_t *vtype);
+extern type_t t_void;
+
+extern type_t t_char;
+extern type_t t_uchar;
+extern type_t t_short;
+extern type_t t_ushort;
+extern type_t t_int;
+extern type_t t_uint;
+extern type_t t_long;
+extern type_t t_ulong;
+extern type_t t_llong;
+extern type_t t_ullong;
+
+type_t *type_map_of(type_t *ktype, type_t *vtype);
+type_t *type_ptr_of(type_t *type);
 
 int type_equal(type_t *a, type_t *b);
 int type_add(type_t *t);