[ia32rtools.git] / tools / protoparse.h


struct parsed_proto;

struct parsed_type {
	char *name;
	unsigned int is_array:1;
	unsigned int is_ptr:1;
	unsigned int is_struct:1; // split for args
};

struct parsed_proto_arg {
	char *reg;
	struct parsed_type type;
	struct parsed_proto *fptr;
	void *datap;
};

struct parsed_proto {
	char name[256];
	union {
		struct parsed_type ret_type;
		struct parsed_type type;
	};
	struct parsed_proto_arg arg[16];
	int argc;
	int argc_stack;
	int argc_reg;
	unsigned int is_func:1;
	unsigned int is_stdcall:1;
	unsigned int is_vararg:1;
	unsigned int is_fptr:1;
	unsigned int is_noreturn:1;
	unsigned int has_structarg:1;
};

static const char *hdrfn;
static int hdrfline = 0;

static void pp_copy_arg(struct parsed_proto_arg *d,
	const struct parsed_proto_arg *s);

static int b_pp_c_handler(char *proto, const char *fname);

static int do_protostrs(FILE *fhdr, const char *fname)
{
	const char *finc_name;
	const char *hdrfn_saved;
	char protostr[256];
	FILE *finc;
	int line = 0;
	int ret;
	char *p;

	hdrfn_saved = hdrfn;
	hdrfn = fname;

	while (fgets(protostr, sizeof(protostr), fhdr))
	{
		line++;
		if (strncmp(protostr, "//#include ", 11) == 0) {
			finc_name = protostr + 11;
			p = strpbrk(finc_name, "\r\n ");
			if (p != NULL)
				*p = 0;

			finc = fopen(finc_name, "r");
			if (finc == NULL) {
				printf("%s:%d: can't open '%s'\n",
					fname, line, finc_name);
				continue;
			}
			ret = do_protostrs(finc, finc_name);
			fclose(finc);
			if (ret < 0)
				break;
			continue;
		}
		if (strncmp(sskip(protostr), "//", 2) == 0)
			continue;

		p = protostr + strlen(protostr);
		for (p--; p >= protostr && my_isblank(*p); --p)
			*p = 0;
		if (p < protostr)
			continue;

		hdrfline = line;

		ret = b_pp_c_handler(protostr, hdrfn);
		if (ret < 0)
			break;
	}

	hdrfn = hdrfn_saved;

	if (feof(fhdr))
		return 0;

	return -1;
}

static int get_regparm(char *dst, size_t dlen, char *p)
{
	int i, o;

	if (*p != '<')
		return 0;

	for (o = 0, i = 1; o < dlen; i++) {
		if (p[i] == 0)
			return 0;
		if (p[i] == '>')
			break;
		dst[o++] = p[i];
	}
	dst[o] = 0;
	return i + 1;
}

// hmh..
static const char *known_type_mod[] = {
	"const",
	"signed",
	"unsigned",
	"struct",
	"enum",
	"CONST",
};

static const char *known_ptr_types[] = {
	"HACCEL",
	"HANDLE",
	"HBITMAP",
	"HCURSOR",
	"HDC",
	"HFONT",
	"HGDIOBJ",
	"HGLOBAL",
	"HINSTANCE",
	"HMODULE",
	"HRGN",
	"HRSRC",
	"HKEY",
	"HMENU",
	"HWND",
	"PLONG",
	"PDWORD",
	"PVOID",
	"PCVOID",
	"DLGPROC",
	"va_list",
	"__VALIST",
};

static const char *ignored_keywords[] = {
	"extern",
	"WINBASEAPI",
	"WINUSERAPI",
	"WINGDIAPI",
	"WINADVAPI",
};

// returns ptr to char after type ends
static int typecmp(const char *n, const char *t)
{
	for (; *t != 0; n++, t++) {
		while (n[0] == ' ' && (n[1] == ' ' || n[1] == '*'))
			n++;
		while (t[0] == ' ' && (t[1] == ' ' || t[1] == '*'))
			t++;
		if (*n != *t)
			return *n - *t;
	}

	return 0;
}

static const char *skip_type_mod(const char *n)
{
	int len;
	int i;

	for (i = 0; i < ARRAY_SIZE(known_type_mod); i++) {
		len = strlen(known_type_mod[i]);
		if (strncmp(n, known_type_mod[i], len) != 0)
			continue;
		if (!my_isblank(n[len]))
			continue;

		n += len;
		while (my_isblank(*n))
			n++;
		i = 0;
	}

	return n;
}

static int check_type(const char *name, struct parsed_type *type)
{
	const char *n, *n1;
	int ret = -1;
	int i;

	n = skip_type_mod(name);

	for (i = 0; i < ARRAY_SIZE(known_ptr_types); i++) {
		if (typecmp(n, known_ptr_types[i]))
			continue;

		type->is_ptr = 1;
		break;
	}

	if (n[0] == 'L' && n[1] == 'P' && strncmp(n, "LPARAM", 6))
		type->is_ptr = 1;

	// assume single word
	while (!my_isblank(*n) && !my_issep(*n))
		n++;

	while (1) {
		n1 = n;
		while (my_isblank(*n))
			n++;
		if (*n == '*') {
			type->is_ptr = 1;
			n++;
			continue;
		}
		break;
	}

	ret = n1 - name;
	type->name = strndup(name, ret);
	return ret;
}

/* args are always expanded to 32bit */
static const char *map_reg(const char *reg)
{
	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	const char *regs_w[] = { "ax",  "bx",  "cx",  "dx",  "si",  "di" };
	const char *regs_b[] = { "al",  "bl",  "cl",  "dl" };
	int i;

	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
		if (IS(reg, regs_w[i]))
			return regs_f[i];

	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
		if (IS(reg, regs_b[i]))
			return regs_f[i];

	return reg;
}

static int check_struct_arg(struct parsed_proto_arg *arg)
{
	if (IS(arg->type.name, "POINT"))
		return 2 - 1;

	return 0;
}

static int parse_protostr(char *protostr, struct parsed_proto *pp)
{
	struct parsed_proto_arg *arg;
	char regparm[16];
	char buf[256];
	char cconv[32];
	int xarg = 0;
	char *p, *p1;
	int i, l;
	int ret;

	p = sskip(protostr);
	if (p[0] == '/' && p[1] == '/') {
		printf("%s:%d: commented out?\n", hdrfn, hdrfline);
		p = sskip(p + 2);
	}

	// strip unneeded stuff
	for (p1 = p; p1[0] != 0 && p1[1] != 0; p1++) {
		if ((p1[0] == '/' && p1[1] == '*')
		 || (p1[0] == '*' && p1[1] == '/'))
			p1[0] = p1[1] = ' ';
	}

	if (!strncmp(p, "DECLSPEC_NORETURN ", 18)) {
		pp->is_noreturn = 1;
		p = sskip(p + 18);
	}

	for (i = 0; i < ARRAY_SIZE(ignored_keywords); i++) {
		l = strlen(ignored_keywords[i]);
		if (!strncmp(p, ignored_keywords[i], l) && my_isblank(p[l]))
			p = sskip(p + l + 1);
	}

	ret = check_type(p, &pp->ret_type);
	if (ret <= 0) {
		printf("%s:%d:%zd: unhandled return in '%s'\n",
			hdrfn, hdrfline, (p - protostr) + 1, protostr);
		return -1;
	}
	p = sskip(p + ret);

	if (!strchr(p, ')')) {
		p = next_idt(buf, sizeof(buf), p);
		p = sskip(p);
		if (buf[0] == 0) {
			printf("%s:%d:%zd: var name missing\n",
				hdrfn, hdrfline, (p - protostr) + 1);
			return -1;
		}
		strcpy(pp->name, buf);

		p1 = strchr(p, ']');
		if (p1 != NULL) {
			p = p1 + 1;
			pp->ret_type.is_array = 1;
		}
		return p - protostr;
	}

	pp->is_func = 1;

	if (*p == '(') {
		pp->is_fptr = 1;
		p = sskip(p + 1);
	}

	p = next_word(cconv, sizeof(cconv), p);
	p = sskip(p);
	if (cconv[0] == 0) {
		printf("%s:%d:%zd: cconv missing\n",
			hdrfn, hdrfline, (p - protostr) + 1);
		return -1;
	}
	if      (IS(cconv, "__cdecl"))
		pp->is_stdcall = 0;
	else if (IS(cconv, "__stdcall"))
		pp->is_stdcall = 1;
	else if (IS(cconv, "__fastcall"))
		pp->is_stdcall = 1;
	else if (IS(cconv, "__thiscall"))
		pp->is_stdcall = 1;
	else if (IS(cconv, "__userpurge"))
		pp->is_stdcall = 1; // IDA
	else if (IS(cconv, "__usercall"))
		pp->is_stdcall = 0; // IDA
	else if (IS(cconv, "WINAPI"))
		pp->is_stdcall = 1;
	else {
		printf("%s:%d:%zd: unhandled cconv: '%s'\n",
			hdrfn, hdrfline, (p - protostr) + 1, cconv);
		return -1;
	}

	if (pp->is_fptr) {
		if (*p != '*') {
			printf("%s:%d:%zd: '*' expected\n",
				hdrfn, hdrfline, (p - protostr) + 1);
			return -1;
		}
		p++;
		// XXX: skipping extra asterisks, for now
		while (*p == '*')
			p++;
		p = sskip(p);
	}

	p = next_idt(buf, sizeof(buf), p);
	p = sskip(p);
	if (buf[0] == 0) {
		//printf("%s:%d:%zd: func name missing\n",
		//	hdrfn, hdrfline, (p - protostr) + 1);
		//return -1;
	}
	strcpy(pp->name, buf);

	ret = get_regparm(regparm, sizeof(regparm), p);
	if (ret > 0) {
		if (!IS(regparm, "eax") && !IS(regparm, "ax")
		 && !IS(regparm, "al") && !IS(regparm, "edx:eax"))
		{
			printf("%s:%d:%zd: bad regparm: %s\n",
				hdrfn, hdrfline, (p - protostr) + 1, regparm);
			return -1;
		}
		p += ret;
		p = sskip(p);
	}

	if (pp->is_fptr) {
		if (*p == '[') {
			// not really ret_type is array, but ohwell
			pp->ret_type.is_array = 1;
			p = strchr(p + 1, ']');
			if (p == NULL) {
				printf("%s:%d:%zd: ']' expected\n",
				 hdrfn, hdrfline, (p - protostr) + 1);
				return -1;
			}
			p = sskip(p + 1);
		}
		if (*p != ')') {
			printf("%s:%d:%zd: ')' expected\n",
				hdrfn, hdrfline, (p - protostr) + 1);
			return -1;
		}
		p = sskip(p + 1);
	}

	if (*p != '(') {
		printf("%s:%d:%zd: '(' expected, got '%c'\n",
				hdrfn, hdrfline, (p - protostr) + 1, *p);
		return -1;
	}
	p++;

	// check for x(void)
	p = sskip(p);
	if ((!strncmp(p, "void", 4) || !strncmp(p, "VOID", 4))
	   && *sskip(p + 4) == ')')
		p += 4;

	while (1) {
		p = sskip(p);
		if (*p == ')') {
			p++;
			break;
		}
		if (xarg > 0) {
			if (*p != ',') {
				printf("%s:%d:%zd: ',' expected\n",
				 hdrfn, hdrfline, (p - protostr) + 1);
				return -1;
			}
			p = sskip(p + 1);
		}

		if (!strncmp(p, "...", 3)) {
			pp->is_vararg = 1;
			p = sskip(p + 3);
			if (*p == ')') {
				p++;
				break;
			}
			printf("%s:%d:%zd: ')' expected\n",
				hdrfn, hdrfline, (p - protostr) + 1);
			return -1;
		}

		arg = &pp->arg[xarg];
		xarg++;

		p1 = p;
		ret = check_type(p, &arg->type);
		if (ret <= 0) {
			printf("%s:%d:%zd: unhandled type for arg%d\n",
				hdrfn, hdrfline, (p - protostr) + 1, xarg);
			return -1;
		}
		p = sskip(p + ret);

		if (*p == '(') {
			// func ptr
			arg->fptr = calloc(1, sizeof(*arg->fptr));
			ret = parse_protostr(p1, arg->fptr);
			if (ret < 0) {
				printf("%s:%d:%zd: funcarg parse failed\n",
					hdrfn, hdrfline, p1 - protostr);
				return -1;
			}
			// we'll treat it as void * for non-calls
			arg->type.name = strdup("void *");
			arg->type.is_ptr = 1;

			p = p1 + ret;
		}

		p = next_idt(buf, sizeof(buf), p);
		p = sskip(p);
#if 0
		if (buf[0] == 0) {
			printf("%s:%d:%zd: idt missing for arg%d\n",
				hdrfn, hdrfline, (p - protostr) + 1, xarg);
			return -1;
		}
#endif
		arg->reg = NULL;

		ret = get_regparm(regparm, sizeof(regparm), p);
		if (ret > 0) {
			p += ret;
			p = sskip(p);

			arg->reg = strdup(map_reg(regparm));
		}

		ret = check_struct_arg(arg);
		if (ret > 0) {
			pp->has_structarg = 1;
			arg->type.is_struct = 1;
			free(arg->type.name);
			arg->type.name = strdup("int");
			for (l = 0; l < ret; l++) {
				pp_copy_arg(&pp->arg[xarg], arg);
				xarg++;
			}
		}
	}

	if (xarg > 0 && (IS(cconv, "__fastcall") || IS(cconv, "__thiscall"))) {
		if (pp->arg[0].reg != NULL) {
			printf("%s:%d: %s with arg1 spec %s?\n",
				hdrfn, hdrfline, cconv, pp->arg[0].reg);
		}
		pp->arg[0].reg = strdup("ecx");
	}

	if (xarg > 1 && IS(cconv, "__fastcall")) {
		if (pp->arg[1].reg != NULL) {
			printf("%s:%d: %s with arg2 spec %s?\n",
				hdrfn, hdrfline, cconv, pp->arg[1].reg);
		}
		pp->arg[1].reg = strdup("edx");
	}

	if (pp->is_vararg && pp->is_stdcall) {
		printf("%s:%d: vararg stdcall?\n", hdrfn, hdrfline);
		return -1;
	}

	pp->argc = xarg;

	for (i = 0; i < pp->argc; i++) {
		if (pp->arg[i].reg == NULL)
			pp->argc_stack++;
		else
			pp->argc_reg++;
	}

	return p - protostr;
}

static int pp_name_cmp(const void *p1, const void *p2)
{
	const struct parsed_proto *pp1 = p1, *pp2 = p2;
	return strcmp(pp1->name, pp2->name);
}

static struct parsed_proto *pp_cache;
static int pp_cache_size;
static int pp_cache_alloc;

static int b_pp_c_handler(char *proto, const char *fname)
{
	int ret;

	if (pp_cache_size >= pp_cache_alloc) {
		pp_cache_alloc = pp_cache_alloc * 2 + 64;
		pp_cache = realloc(pp_cache, pp_cache_alloc
				* sizeof(pp_cache[0]));
		my_assert_not(pp_cache, NULL);
		memset(pp_cache + pp_cache_size, 0,
			(pp_cache_alloc - pp_cache_size)
			 * sizeof(pp_cache[0]));
	}

	ret = parse_protostr(proto, &pp_cache[pp_cache_size]);
	if (ret < 0)
		return -1;

	pp_cache_size++;
	return 0;
}

static void build_pp_cache(FILE *fhdr)
{
	int ret;

	rewind(fhdr);

	ret = do_protostrs(fhdr, hdrfn);
	if (ret < 0)
		exit(1);

	qsort(pp_cache, pp_cache_size, sizeof(pp_cache[0]), pp_name_cmp);
}

static const struct parsed_proto *proto_parse(FILE *fhdr, const char *sym)
{
	const struct parsed_proto *pp_ret;
	struct parsed_proto pp_search;

	if (pp_cache == NULL)
		build_pp_cache(fhdr);

	if (sym[0] == '_') // && strncmp(fname, "stdc", 4) == 0)
		sym++;

	strcpy(pp_search.name, sym);
	pp_ret = bsearch(&pp_search, pp_cache, pp_cache_size,
			sizeof(pp_cache[0]), pp_name_cmp);
	if (pp_ret == NULL)
		printf("%s: sym '%s' is missing\n", hdrfn, sym);

	return pp_ret;
}

static void pp_copy_arg(struct parsed_proto_arg *d,
	const struct parsed_proto_arg *s)
{
	memcpy(d, s, sizeof(*d));

	if (s->reg != NULL) {
		d->reg = strdup(s->reg);
		my_assert_not(d->reg, NULL);
	}
	if (s->type.name != NULL) {
		d->type.name = strdup(s->type.name);
		my_assert_not(d->type.name, NULL);
	}
	if (s->fptr != NULL) {
		d->fptr = malloc(sizeof(*d->fptr));
		my_assert_not(d->fptr, NULL);
		memcpy(d->fptr, s->fptr, sizeof(*d->fptr));
	}
}

struct parsed_proto *proto_clone(const struct parsed_proto *pp_c)
{
	struct parsed_proto *pp;
	int i;

	pp = malloc(sizeof(*pp));
	my_assert_not(pp, NULL);
	memcpy(pp, pp_c, sizeof(*pp)); // lazy..

	// do the actual deep copy..
	for (i = 0; i < pp_c->argc; i++)
		pp_copy_arg(&pp->arg[i], &pp_c->arg[i]);
	if (pp_c->ret_type.name != NULL)
		pp->ret_type.name = strdup(pp_c->ret_type.name);

	return pp;
}

static inline void proto_release(struct parsed_proto *pp)
{
	int i;

	for (i = 0; i < pp->argc; i++) {
		if (pp->arg[i].reg != NULL)
			free(pp->arg[i].reg);
		if (pp->arg[i].type.name != NULL)
			free(pp->arg[i].type.name);
		if (pp->arg[i].fptr != NULL)
			free(pp->arg[i].fptr);
	}
	if (pp->ret_type.name != NULL)
		free(pp->ret_type.name);
	free(pp);
}
Commit	Line	Data
	1
	2	struct parsed_proto;
	3
	4	struct parsed_type {
	5	char *name;
	6	unsigned int is_array:1;
	7	unsigned int is_ptr:1;
	8	unsigned int is_struct:1; // split for args
	9	};
	10
	11	struct parsed_proto_arg {
	12	char *reg;
	13	struct parsed_type type;
	14	struct parsed_proto *fptr;
	15	void *datap;
	16	};
	17
	18	struct parsed_proto {
	19	char name[256];
	20	union {
	21	struct parsed_type ret_type;
	22	struct parsed_type type;
	23	};
	24	struct parsed_proto_arg arg[16];
	25	int argc;
	26	int argc_stack;
	27	int argc_reg;
	28	unsigned int is_func:1;
	29	unsigned int is_stdcall:1;
	30	unsigned int is_vararg:1;
	31	unsigned int is_fptr:1;
	32	unsigned int is_noreturn:1;
	33	unsigned int has_structarg:1;
	34	};
	35
	36	static const char *hdrfn;
	37	static int hdrfline = 0;
	38
	39	static void pp_copy_arg(struct parsed_proto_arg *d,
	40	const struct parsed_proto_arg *s);
	41
	42	static int b_pp_c_handler(char proto, const char fname);
	43
	44	static int do_protostrs(FILE fhdr, const char fname)
	45	{
	46	const char *finc_name;
	47	const char *hdrfn_saved;
	48	char protostr[256];
	49	FILE *finc;
	50	int line = 0;
	51	int ret;
	52	char *p;
	53
	54	hdrfn_saved = hdrfn;
	55	hdrfn = fname;
	56
	57	while (fgets(protostr, sizeof(protostr), fhdr))
	58	{
	59	line++;
	60	if (strncmp(protostr, "//#include ", 11) == 0) {
	61	finc_name = protostr + 11;
	62	p = strpbrk(finc_name, "\r\n ");
	63	if (p != NULL)
	64	*p = 0;
	65
	66	finc = fopen(finc_name, "r");
	67	if (finc == NULL) {
	68	printf("%s:%d: can't open '%s'\n",
	69	fname, line, finc_name);
	70	continue;
	71	}
	72	ret = do_protostrs(finc, finc_name);
	73	fclose(finc);
	74	if (ret < 0)
	75	break;
	76	continue;
	77	}
	78	if (strncmp(sskip(protostr), "//", 2) == 0)
	79	continue;
	80
	81	p = protostr + strlen(protostr);
	82	for (p--; p >= protostr && my_isblank(*p); --p)
	83	*p = 0;
	84	if (p < protostr)
	85	continue;
	86
	87	hdrfline = line;
	88
	89	ret = b_pp_c_handler(protostr, hdrfn);
	90	if (ret < 0)
	91	break;
	92	}
	93
	94	hdrfn = hdrfn_saved;
	95
	96	if (feof(fhdr))
	97	return 0;
	98
	99	return -1;
	100	}
	101
	102	static int get_regparm(char dst, size_t dlen, char p)
	103	{
	104	int i, o;
	105
	106	if (*p != '<')
	107	return 0;
	108
	109	for (o = 0, i = 1; o < dlen; i++) {
	110	if (p[i] == 0)
	111	return 0;
	112	if (p[i] == '>')
	113	break;
	114	dst[o++] = p[i];
	115	}
	116	dst[o] = 0;
	117	return i + 1;
	118	}
	119
	120	// hmh..
	121	static const char *known_type_mod[] = {
	122	"const",
	123	"signed",
	124	"unsigned",
	125	"struct",
	126	"enum",
	127	"CONST",
	128	};
	129
	130	static const char *known_ptr_types[] = {
	131	"HACCEL",
	132	"HANDLE",
	133	"HBITMAP",
	134	"HCURSOR",
	135	"HDC",
	136	"HFONT",
	137	"HGDIOBJ",
	138	"HGLOBAL",
	139	"HINSTANCE",
	140	"HMODULE",
	141	"HRGN",
	142	"HRSRC",
	143	"HKEY",
	144	"HMENU",
	145	"HWND",
	146	"PLONG",
	147	"PDWORD",
	148	"PVOID",
	149	"PCVOID",
	150	"DLGPROC",
	151	"va_list",
	152	"__VALIST",
	153	};
	154
	155	static const char *ignored_keywords[] = {
	156	"extern",
	157	"WINBASEAPI",
	158	"WINUSERAPI",
	159	"WINGDIAPI",
	160	"WINADVAPI",
	161	};
	162
	163	// returns ptr to char after type ends
	164	static int typecmp(const char n, const char t)
	165	{
	166	for (; *t != 0; n++, t++) {
	167	while (n[0] == ' ' && (n[1] == ' ' \|\| n[1] == '*'))
	168	n++;
	169	while (t[0] == ' ' && (t[1] == ' ' \|\| t[1] == '*'))
	170	t++;
	171	if (n != t)
	172	return n - t;
	173	}
	174
	175	return 0;
	176	}
	177
	178	static const char skip_type_mod(const char n)
	179	{
	180	int len;
	181	int i;
	182
	183	for (i = 0; i < ARRAY_SIZE(known_type_mod); i++) {
	184	len = strlen(known_type_mod[i]);
	185	if (strncmp(n, known_type_mod[i], len) != 0)
	186	continue;
	187	if (!my_isblank(n[len]))
	188	continue;
	189
	190	n += len;
	191	while (my_isblank(*n))
	192	n++;
	193	i = 0;
	194	}
	195
	196	return n;
	197	}
	198
	199	static int check_type(const char name, struct parsed_type type)
	200	{
	201	const char n, n1;
	202	int ret = -1;
	203	int i;
	204
	205	n = skip_type_mod(name);
	206
	207	for (i = 0; i < ARRAY_SIZE(known_ptr_types); i++) {
	208	if (typecmp(n, known_ptr_types[i]))
	209	continue;
	210
	211	type->is_ptr = 1;
	212	break;
	213	}
	214
	215	if (n[0] == 'L' && n[1] == 'P' && strncmp(n, "LPARAM", 6))
	216	type->is_ptr = 1;
	217
	218	// assume single word
	219	while (!my_isblank(n) && !my_issep(n))
	220	n++;
	221
	222	while (1) {
	223	n1 = n;
	224	while (my_isblank(*n))
	225	n++;
	226	if (n == '') {
	227	type->is_ptr = 1;
	228	n++;
	229	continue;
	230	}
	231	break;
	232	}
	233
	234	ret = n1 - name;
	235	type->name = strndup(name, ret);
	236	return ret;
	237	}
	238
	239	/* args are always expanded to 32bit */
	240	static const char map_reg(const char reg)
	241	{
	242	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	243	const char *regs_w[] = { "ax", "bx", "cx", "dx", "si", "di" };
	244	const char *regs_b[] = { "al", "bl", "cl", "dl" };
	245	int i;
	246
	247	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
	248	if (IS(reg, regs_w[i]))
	249	return regs_f[i];
	250
	251	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
	252	if (IS(reg, regs_b[i]))
	253	return regs_f[i];
	254
	255	return reg;
	256	}
	257
	258	static int check_struct_arg(struct parsed_proto_arg *arg)
	259	{
	260	if (IS(arg->type.name, "POINT"))
	261	return 2 - 1;
	262
	263	return 0;
	264	}
	265
	266	static int parse_protostr(char protostr, struct parsed_proto pp)
	267	{
	268	struct parsed_proto_arg *arg;
	269	char regparm[16];
	270	char buf[256];
	271	char cconv[32];
	272	int xarg = 0;
	273	char p, p1;
	274	int i, l;
	275	int ret;
	276
	277	p = sskip(protostr);
	278	if (p[0] == '/' && p[1] == '/') {
	279	printf("%s:%d: commented out?\n", hdrfn, hdrfline);
	280	p = sskip(p + 2);
	281	}
	282
	283	// strip unneeded stuff
	284	for (p1 = p; p1[0] != 0 && p1[1] != 0; p1++) {
	285	if ((p1[0] == '/' && p1[1] == '*')
	286	\|\| (p1[0] == '*' && p1[1] == '/'))
	287	p1[0] = p1[1] = ' ';
	288	}
	289
	290	if (!strncmp(p, "DECLSPEC_NORETURN ", 18)) {
	291	pp->is_noreturn = 1;
	292	p = sskip(p + 18);
	293	}
	294
	295	for (i = 0; i < ARRAY_SIZE(ignored_keywords); i++) {
	296	l = strlen(ignored_keywords[i]);
	297	if (!strncmp(p, ignored_keywords[i], l) && my_isblank(p[l]))
	298	p = sskip(p + l + 1);
	299	}
	300
	301	ret = check_type(p, &pp->ret_type);
	302	if (ret <= 0) {
	303	printf("%s:%d:%zd: unhandled return in '%s'\n",
	304	hdrfn, hdrfline, (p - protostr) + 1, protostr);
	305	return -1;
	306	}
	307	p = sskip(p + ret);
	308
	309	if (!strchr(p, ')')) {
	310	p = next_idt(buf, sizeof(buf), p);
	311	p = sskip(p);
	312	if (buf[0] == 0) {
	313	printf("%s:%d:%zd: var name missing\n",
	314	hdrfn, hdrfline, (p - protostr) + 1);
	315	return -1;
	316	}
	317	strcpy(pp->name, buf);
	318
	319	p1 = strchr(p, ']');
	320	if (p1 != NULL) {
	321	p = p1 + 1;
	322	pp->ret_type.is_array = 1;
	323	}
	324	return p - protostr;
	325	}
	326
	327	pp->is_func = 1;
	328
	329	if (*p == '(') {
	330	pp->is_fptr = 1;
	331	p = sskip(p + 1);
	332	}
	333
	334	p = next_word(cconv, sizeof(cconv), p);
	335	p = sskip(p);
	336	if (cconv[0] == 0) {
	337	printf("%s:%d:%zd: cconv missing\n",
	338	hdrfn, hdrfline, (p - protostr) + 1);
	339	return -1;
	340	}
	341	if (IS(cconv, "__cdecl"))
	342	pp->is_stdcall = 0;
	343	else if (IS(cconv, "__stdcall"))
	344	pp->is_stdcall = 1;
	345	else if (IS(cconv, "__fastcall"))
	346	pp->is_stdcall = 1;
	347	else if (IS(cconv, "__thiscall"))
	348	pp->is_stdcall = 1;
	349	else if (IS(cconv, "__userpurge"))
	350	pp->is_stdcall = 1; // IDA
	351	else if (IS(cconv, "__usercall"))
	352	pp->is_stdcall = 0; // IDA
	353	else if (IS(cconv, "WINAPI"))
	354	pp->is_stdcall = 1;
	355	else {
	356	printf("%s:%d:%zd: unhandled cconv: '%s'\n",
	357	hdrfn, hdrfline, (p - protostr) + 1, cconv);
	358	return -1;
	359	}
	360
	361	if (pp->is_fptr) {
	362	if (p != '') {
	363	printf("%s:%d:%zd: '*' expected\n",
	364	hdrfn, hdrfline, (p - protostr) + 1);
	365	return -1;
	366	}
	367	p++;
	368	// XXX: skipping extra asterisks, for now
	369	while (p == '')
	370	p++;
	371	p = sskip(p);
	372	}
	373
	374	p = next_idt(buf, sizeof(buf), p);
	375	p = sskip(p);
	376	if (buf[0] == 0) {
	377	//printf("%s:%d:%zd: func name missing\n",
	378	// hdrfn, hdrfline, (p - protostr) + 1);
	379	//return -1;
	380	}
	381	strcpy(pp->name, buf);
	382
	383	ret = get_regparm(regparm, sizeof(regparm), p);
	384	if (ret > 0) {
	385	if (!IS(regparm, "eax") && !IS(regparm, "ax")
	386	&& !IS(regparm, "al") && !IS(regparm, "edx:eax"))
	387	{
	388	printf("%s:%d:%zd: bad regparm: %s\n",
	389	hdrfn, hdrfline, (p - protostr) + 1, regparm);
	390	return -1;
	391	}
	392	p += ret;
	393	p = sskip(p);
	394	}
	395
	396	if (pp->is_fptr) {
	397	if (*p == '[') {
	398	// not really ret_type is array, but ohwell
	399	pp->ret_type.is_array = 1;
	400	p = strchr(p + 1, ']');
	401	if (p == NULL) {
	402	printf("%s:%d:%zd: ']' expected\n",
	403	hdrfn, hdrfline, (p - protostr) + 1);
	404	return -1;
	405	}
	406	p = sskip(p + 1);
	407	}
	408	if (*p != ')') {
	409	printf("%s:%d:%zd: ')' expected\n",
	410	hdrfn, hdrfline, (p - protostr) + 1);
	411	return -1;
	412	}
	413	p = sskip(p + 1);
	414	}
	415
	416	if (*p != '(') {
	417	printf("%s:%d:%zd: '(' expected, got '%c'\n",
	418	hdrfn, hdrfline, (p - protostr) + 1, *p);
	419	return -1;
	420	}
	421	p++;
	422
	423	// check for x(void)
	424	p = sskip(p);
	425	if ((!strncmp(p, "void", 4) \|\| !strncmp(p, "VOID", 4))
	426	&& *sskip(p + 4) == ')')
	427	p += 4;
	428
	429	while (1) {
	430	p = sskip(p);
	431	if (*p == ')') {
	432	p++;
	433	break;
	434	}
	435	if (xarg > 0) {
	436	if (*p != ',') {
	437	printf("%s:%d:%zd: ',' expected\n",
	438	hdrfn, hdrfline, (p - protostr) + 1);
	439	return -1;
	440	}
	441	p = sskip(p + 1);
	442	}
	443
	444	if (!strncmp(p, "...", 3)) {
	445	pp->is_vararg = 1;
	446	p = sskip(p + 3);
	447	if (*p == ')') {
	448	p++;
	449	break;
	450	}
	451	printf("%s:%d:%zd: ')' expected\n",
	452	hdrfn, hdrfline, (p - protostr) + 1);
	453	return -1;
	454	}
	455
	456	arg = &pp->arg[xarg];
	457	xarg++;
	458
	459	p1 = p;
	460	ret = check_type(p, &arg->type);
	461	if (ret <= 0) {
	462	printf("%s:%d:%zd: unhandled type for arg%d\n",
	463	hdrfn, hdrfline, (p - protostr) + 1, xarg);
	464	return -1;
	465	}
	466	p = sskip(p + ret);
	467
	468	if (*p == '(') {
	469	// func ptr
	470	arg->fptr = calloc(1, sizeof(*arg->fptr));
	471	ret = parse_protostr(p1, arg->fptr);
	472	if (ret < 0) {
	473	printf("%s:%d:%zd: funcarg parse failed\n",
	474	hdrfn, hdrfline, p1 - protostr);
	475	return -1;
	476	}
	477	// we'll treat it as void * for non-calls
	478	arg->type.name = strdup("void *");
	479	arg->type.is_ptr = 1;
	480
	481	p = p1 + ret;
	482	}
	483
	484	p = next_idt(buf, sizeof(buf), p);
	485	p = sskip(p);
	486	#if 0
	487	if (buf[0] == 0) {
	488	printf("%s:%d:%zd: idt missing for arg%d\n",
	489	hdrfn, hdrfline, (p - protostr) + 1, xarg);
	490	return -1;
	491	}
	492	#endif
	493	arg->reg = NULL;
	494
	495	ret = get_regparm(regparm, sizeof(regparm), p);
	496	if (ret > 0) {
	497	p += ret;
	498	p = sskip(p);
	499
	500	arg->reg = strdup(map_reg(regparm));
	501	}
	502
	503	ret = check_struct_arg(arg);
	504	if (ret > 0) {
	505	pp->has_structarg = 1;
	506	arg->type.is_struct = 1;
	507	free(arg->type.name);
	508	arg->type.name = strdup("int");
	509	for (l = 0; l < ret; l++) {
	510	pp_copy_arg(&pp->arg[xarg], arg);
	511	xarg++;
	512	}
	513	}
	514	}
	515
	516	if (xarg > 0 && (IS(cconv, "__fastcall") \|\| IS(cconv, "__thiscall"))) {
	517	if (pp->arg[0].reg != NULL) {
	518	printf("%s:%d: %s with arg1 spec %s?\n",
	519	hdrfn, hdrfline, cconv, pp->arg[0].reg);
	520	}
	521	pp->arg[0].reg = strdup("ecx");
	522	}
	523
	524	if (xarg > 1 && IS(cconv, "__fastcall")) {
	525	if (pp->arg[1].reg != NULL) {
	526	printf("%s:%d: %s with arg2 spec %s?\n",
	527	hdrfn, hdrfline, cconv, pp->arg[1].reg);
	528	}
	529	pp->arg[1].reg = strdup("edx");
	530	}
	531
	532	if (pp->is_vararg && pp->is_stdcall) {
	533	printf("%s:%d: vararg stdcall?\n", hdrfn, hdrfline);
	534	return -1;
	535	}
	536
	537	pp->argc = xarg;
	538
	539	for (i = 0; i < pp->argc; i++) {
	540	if (pp->arg[i].reg == NULL)
	541	pp->argc_stack++;
	542	else
	543	pp->argc_reg++;
	544	}
	545
	546	return p - protostr;
	547	}
	548
	549	static int pp_name_cmp(const void p1, const void p2)
	550	{
	551	const struct parsed_proto pp1 = p1, pp2 = p2;
	552	return strcmp(pp1->name, pp2->name);
	553	}
	554
	555	static struct parsed_proto *pp_cache;
	556	static int pp_cache_size;
	557	static int pp_cache_alloc;
	558
	559	static int b_pp_c_handler(char proto, const char fname)
	560	{
	561	int ret;
	562
	563	if (pp_cache_size >= pp_cache_alloc) {
	564	pp_cache_alloc = pp_cache_alloc * 2 + 64;
	565	pp_cache = realloc(pp_cache, pp_cache_alloc
	566	* sizeof(pp_cache[0]));
	567	my_assert_not(pp_cache, NULL);
	568	memset(pp_cache + pp_cache_size, 0,
	569	(pp_cache_alloc - pp_cache_size)
	570	* sizeof(pp_cache[0]));
	571	}
	572
	573	ret = parse_protostr(proto, &pp_cache[pp_cache_size]);
	574	if (ret < 0)
	575	return -1;
	576
	577	pp_cache_size++;
	578	return 0;
	579	}
	580
	581	static void build_pp_cache(FILE *fhdr)
	582	{
	583	int ret;
	584
	585	rewind(fhdr);
	586
	587	ret = do_protostrs(fhdr, hdrfn);
	588	if (ret < 0)
	589	exit(1);
	590
	591	qsort(pp_cache, pp_cache_size, sizeof(pp_cache[0]), pp_name_cmp);
	592	}
	593
	594	static const struct parsed_proto proto_parse(FILE fhdr, const char *sym)
	595	{
	596	const struct parsed_proto *pp_ret;
	597	struct parsed_proto pp_search;
	598
	599	if (pp_cache == NULL)
	600	build_pp_cache(fhdr);
	601
	602	if (sym[0] == '_') // && strncmp(fname, "stdc", 4) == 0)
	603	sym++;
	604
	605	strcpy(pp_search.name, sym);
	606	pp_ret = bsearch(&pp_search, pp_cache, pp_cache_size,
	607	sizeof(pp_cache[0]), pp_name_cmp);
	608	if (pp_ret == NULL)
	609	printf("%s: sym '%s' is missing\n", hdrfn, sym);
	610
	611	return pp_ret;
	612	}
	613
	614	static void pp_copy_arg(struct parsed_proto_arg *d,
	615	const struct parsed_proto_arg *s)
	616	{
	617	memcpy(d, s, sizeof(*d));
	618
	619	if (s->reg != NULL) {
	620	d->reg = strdup(s->reg);
	621	my_assert_not(d->reg, NULL);
	622	}
	623	if (s->type.name != NULL) {
	624	d->type.name = strdup(s->type.name);
	625	my_assert_not(d->type.name, NULL);
	626	}
	627	if (s->fptr != NULL) {
	628	d->fptr = malloc(sizeof(*d->fptr));
	629	my_assert_not(d->fptr, NULL);
	630	memcpy(d->fptr, s->fptr, sizeof(*d->fptr));
	631	}
	632	}
	633
	634	struct parsed_proto proto_clone(const struct parsed_proto pp_c)
	635	{
	636	struct parsed_proto *pp;
	637	int i;
	638
	639	pp = malloc(sizeof(*pp));
	640	my_assert_not(pp, NULL);
	641	memcpy(pp, pp_c, sizeof(*pp)); // lazy..
	642
	643	// do the actual deep copy..
	644	for (i = 0; i < pp_c->argc; i++)
	645	pp_copy_arg(&pp->arg[i], &pp_c->arg[i]);
	646	if (pp_c->ret_type.name != NULL)
	647	pp->ret_type.name = strdup(pp_c->ret_type.name);
	648
	649	return pp;
	650	}
	651
	652	static inline void proto_release(struct parsed_proto *pp)
	653	{
	654	int i;
	655
	656	for (i = 0; i < pp->argc; i++) {
	657	if (pp->arg[i].reg != NULL)
	658	free(pp->arg[i].reg);
	659	if (pp->arg[i].type.name != NULL)
	660	free(pp->arg[i].type.name);
	661	if (pp->arg[i].fptr != NULL)
	662	free(pp->arg[i].fptr);
	663	}
	664	if (pp->ret_type.name != NULL)
	665	free(pp->ret_type.name);
	666	free(pp);
	667	}