[ia32rtools.git] / tools / protoparse.h


struct parsed_proto;

struct parsed_type {
	char *name;
	unsigned int is_array:1;
	unsigned int is_ptr:1;
};

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;
};

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

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",
	"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')
		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 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 = "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));
		}
	}

	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;
}

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