[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",
};

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