[ia32rtools.git] / tools / protoparse.h


struct parsed_proto;

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

struct parsed_proto {
	char name[256];
	char *ret_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_array:1;
};

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

static int find_protostr(char *dst, size_t dlen, FILE *fhdr,
	const char *fname, const char *sym_)
{
	const char *sym = sym_;
	const char *finc_name;
	FILE *finc;
	int symlen;
	int line = 0;
	int ret;
	char *p;

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

	rewind(fhdr);

	while (fgets(dst, dlen, fhdr))
	{
		line++;
		if (strncmp(dst, "//#include ", 11) == 0) {
			finc_name = dst + 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 = find_protostr(dst, dlen, finc,
				finc_name, sym_);
			fclose(finc);
			if (ret == 0)
				break;
			continue;
		}
		if (strncmp(sskip(dst), "//", 2) == 0)
			continue;

		p = strstr(dst, sym);
		if (p != NULL && p > dst
		   && (my_isblank(p[-1]) || my_issep(p[-1]))
		   && (my_isblank(p[symlen]) || my_issep(p[symlen])))
			break;
	}
	hdrfline = line;

	if (feof(fhdr))
		return -1;

	p = dst + strlen(dst);
	for (p--; p > dst && my_isblank(*p); --p)
		*p = 0;

	return 0;
}

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

static const char *known_types[] = {
	"void *",
	"char *",
	"FILE *",
	"int *",
	"__int8 *",
	"__int16 *",
	"char",
	"__int8",
	"__int16",
	"__int32",
	"int",
	"bool",
	"void",
	"BYTE",
	"WORD",
	"BOOL",
	"DWORD",
	"_DWORD",
	"HMODULE",
	"HANDLE",
	"HWND",
	"LANGID",
	"LPCSTR",
	"size_t",
};

// returns ptr to char after type ends
static const char *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 NULL;
	}

	return n;
}

static char *check_type(const char *name, int *len_out)
{
	const char *n = name, *n1;
	int len;
	int i;

	*len_out = 0;

	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;

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

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

		*len_out = n1 - name;
		return strndup(name, *len_out);
	}

	return NULL;
}

/* 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];
	char *kt;
	int xarg = 0;
	char *p, *p1;
	int ret;
	int i;

	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, "extern ", 7) == 0)
		p = sskip(p + 7);
	if (strncmp(p, "WINBASEAPI ", 11) == 0)
		p = sskip(p + 11);

	kt = check_type(p, &ret);
	if (kt == NULL) {
		printf("%s:%d:%zd: unhandled return in '%s'\n",
			hdrfn, hdrfline, (p - protostr) + 1, protostr);
		return -1;
	}
	pp->ret_type = kt;
	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->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; // in all cases seen..
	else if (IS(cconv, "__usercall"))
		pp->is_stdcall = 0; // ..or is it?
	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 = sskip(p + 1);
	}

	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"))
		{
			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 != ')') {
			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;
		kt = check_type(p, &ret);
		if (kt == NULL) {
			printf("%s:%d:%zd: unhandled type for arg%d\n",
				hdrfn, hdrfline, (p - protostr) + 1, xarg);
			return -1;
		}
		arg->type = kt;
		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 = "void *";

			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 proto_parse(FILE *fhdr, const char *sym, struct parsed_proto *pp)
{
	char protostr[256];
	int ret;

	memset(pp, 0, sizeof(*pp));

	ret = find_protostr(protostr, sizeof(protostr), fhdr, hdrfn, sym);
	if (ret != 0) {
		printf("%s: sym '%s' is missing\n", hdrfn, sym);
		return ret;
	}

	return parse_protostr(protostr, pp) < 0 ? -1 : 0;
}

static 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 != NULL)
			free(pp->arg[i].type);
		if (pp->arg[i].fptr != NULL)
			free(pp->arg[i].fptr);
	}
	if (pp->ret_type != NULL)
		free(pp->ret_type);
}
Commit	Line	Data
c36e914d	1
39b168b8	2	struct parsed_proto;
	3
	4	struct parsed_proto_arg {
	5	char *reg;
64c59faf	6	char *type;
39b168b8	7	struct parsed_proto *fptr;
	8	void *datap;
	9	};
	10
c36e914d	11	struct parsed_proto {
39b168b8	12	char name[256];
64c59faf	13	char *ret_type;
39b168b8	14	struct parsed_proto_arg arg[16];
c36e914d	15	int argc;
	16	int argc_stack;
	17	int argc_reg;
06c5d854	18	unsigned int is_func:1;
39b168b8	19	unsigned int is_stdcall:1;
7ba45c34	20	unsigned int is_vararg:1;
39b168b8	21	unsigned int is_fptr:1;
06c5d854	22	unsigned int is_array:1;
c36e914d	23	};
	24
	25	static const char *hdrfn;
	26	static int hdrfline = 0;
	27
39b168b8	28	static int find_protostr(char dst, size_t dlen, FILE fhdr,
39b168b8	29	const char fname, const char sym_)
c36e914d	30	{
39b168b8	31	const char *sym = sym_;
06c5d854	32	const char *finc_name;
39b168b8	33	FILE *finc;
39b168b8	34	int symlen;
c36e914d	35	int line = 0;
39b168b8	36	int ret;
c36e914d	37	char *p;
c36e914d	38
39b168b8	39	if (sym[0] == '_' && strncmp(fname, "stdc", 4) == 0)
	40	sym++;
	41	symlen = strlen(sym);
	42
c36e914d	43	rewind(fhdr);
	44
	45	while (fgets(dst, dlen, fhdr))
	46	{
	47	line++;
06c5d854	48	if (strncmp(dst, "//#include ", 11) == 0) {
	49	finc_name = dst + 11;
	50	p = strpbrk(finc_name, "\r\n ");
39b168b8	51	if (p != NULL)
	52	*p = 0;
	53
06c5d854	54	finc = fopen(finc_name, "r");
39b168b8	55	if (finc == NULL) {
39b168b8	56	printf("%s:%d: can't open '%s'\n",
06c5d854	57	fname, line, finc_name);
39b168b8	58	continue;
	59	}
	60	ret = find_protostr(dst, dlen, finc,
06c5d854	61	finc_name, sym_);
39b168b8	62	fclose(finc);
	63	if (ret == 0)
	64	break;
	65	continue;
	66	}
06c5d854	67	if (strncmp(sskip(dst), "//", 2) == 0)
06c5d854	68	continue;
39b168b8	69
39b168b8	70	p = strstr(dst, sym);
06c5d854	71	if (p != NULL && p > dst
06c5d854	72	&& (my_isblank(p[-1]) \|\| my_issep(p[-1]))
39b168b8	73	&& (my_isblank(p[symlen]) \|\| my_issep(p[symlen])))
c36e914d	74	break;
	75	}
	76	hdrfline = line;
	77
	78	if (feof(fhdr))
	79	return -1;
	80
	81	p = dst + strlen(dst);
	82	for (p--; p > dst && my_isblank(*p); --p)
	83	*p = 0;
	84
	85	return 0;
	86	}
	87
	88	static int get_regparm(char dst, size_t dlen, char p)
	89	{
	90	int i, o;
	91
	92	if (*p != '<')
	93	return 0;
	94
	95	for (o = 0, i = 1; o < dlen; i++) {
	96	if (p[i] == 0)
	97	return 0;
	98	if (p[i] == '>')
	99	break;
	100	dst[o++] = p[i];
	101	}
	102	dst[o] = 0;
	103	return i + 1;
	104	}
	105
	106	// hmh..
64c59faf	107	static const char *known_type_mod[] = {
	108	"const",
	109	"signed",
	110	"unsigned",
	111	};
	112
c36e914d	113	static const char *known_types[] = {
c36e914d	114	"void *",
	115	"char *",
	116	"FILE *",
f3d05b09	117	"int *",
64c59faf	118	"__int8 *",
64c59faf	119	"__int16 *",
c36e914d	120	"char",
	121	"__int8",
	122	"__int16",
64c59faf	123	"__int32",
c36e914d	124	"int",
	125	"bool",
	126	"void",
	127	"BYTE",
	128	"WORD",
64c59faf	129	"BOOL",
c36e914d	130	"DWORD",
91977a1c	131	"_DWORD",
c36e914d	132	"HMODULE",
	133	"HANDLE",
	134	"HWND",
64c59faf	135	"LANGID",
c36e914d	136	"LPCSTR",
	137	"size_t",
	138	};
	139
64c59faf	140	// returns ptr to char after type ends
64c59faf	141	static const char typecmp(const char n, const char *t)
39b168b8	142	{
	143	for (; *t != 0; n++, t++) {
	144	while (n[0] == ' ' && (n[1] == ' ' \|\| n[1] == '*'))
	145	n++;
	146	while (t[0] == ' ' && (t[1] == ' ' \|\| t[1] == '*'))
	147	t++;
	148	if (n != t)
64c59faf	149	return NULL;
39b168b8	150	}
39b168b8	151
64c59faf	152	return n;
39b168b8	153	}
39b168b8	154
64c59faf	155	static char check_type(const char name, int *len_out)
c36e914d	156	{
64c59faf	157	const char n = name, n1;
64c59faf	158	int len;
39b168b8	159	int i;
c36e914d	160
64c59faf	161	*len_out = 0;
	162
	163	for (i = 0; i < ARRAY_SIZE(known_type_mod); i++) {
	164	len = strlen(known_type_mod[i]);
	165	if (strncmp(n, known_type_mod[i], len) != 0)
	166	continue;
	167
	168	n += len;
	169	while (my_isblank(*n))
	170	n++;
	171	i = 0;
	172	}
	173
c36e914d	174	for (i = 0; i < ARRAY_SIZE(known_types); i++) {
64c59faf	175	n1 = typecmp(n, known_types[i]);
	176	if (n1 == NULL)
	177	continue;
	178
	179	*len_out = n1 - name;
	180	return strndup(name, *len_out);
c36e914d	181	}
	182
	183	return NULL;
	184	}
	185
	186	/* args are always expanded to 32bit */
	187	static const char map_reg(const char reg)
	188	{
	189	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	190	const char *regs_w[] = { "ax", "bx", "cx", "dx", "si", "di" };
	191	const char *regs_b[] = { "al", "bl", "cl", "dl" };
	192	int i;
	193
	194	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
	195	if (IS(reg, regs_w[i]))
	196	return regs_f[i];
	197
	198	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
	199	if (IS(reg, regs_b[i]))
	200	return regs_f[i];
	201
	202	return reg;
	203	}
	204
	205	static int parse_protostr(char protostr, struct parsed_proto pp)
	206	{
39b168b8	207	struct parsed_proto_arg *arg;
c36e914d	208	char regparm[16];
	209	char buf[256];
	210	char cconv[32];
64c59faf	211	char *kt;
c36e914d	212	int xarg = 0;
39b168b8	213	char p, p1;
c36e914d	214	int ret;
c36e914d	215	int i;
c36e914d	216
06c5d854	217	p = sskip(protostr);
c36e914d	218	if (p[0] == '/' && p[1] == '/') {
06c5d854	219	printf("%s:%d: commented out?\n", hdrfn, hdrfline);
c36e914d	220	p = sskip(p + 2);
	221	}
	222
06c5d854	223	// strip unneeded stuff
	224	for (p1 = p; p1[0] != 0 && p1[1] != 0; p1++) {
	225	if ((p1[0] == '/' && p1[1] == '*')
	226	\|\| (p1[0] == '*' && p1[1] == '/'))
	227	p1[0] = p1[1] = ' ';
	228	}
	229
	230	if (strncmp(p, "extern ", 7) == 0)
	231	p = sskip(p + 7);
64c59faf	232	if (strncmp(p, "WINBASEAPI ", 11) == 0)
64c59faf	233	p = sskip(p + 11);
06c5d854	234
64c59faf	235	kt = check_type(p, &ret);
c36e914d	236	if (kt == NULL) {
63df67be	237	printf("%s:%d:%zd: unhandled return in '%s'\n",
c36e914d	238	hdrfn, hdrfline, (p - protostr) + 1, protostr);
39b168b8	239	return -1;
c36e914d	240	}
c36e914d	241	pp->ret_type = kt;
64c59faf	242	p = sskip(p + ret);
c36e914d	243
06c5d854	244	if (!strchr(p, ')')) {
	245	p = next_idt(buf, sizeof(buf), p);
	246	p = sskip(p);
	247	if (buf[0] == 0) {
63df67be	248	printf("%s:%d:%zd: var name missing\n",
06c5d854	249	hdrfn, hdrfline, (p - protostr) + 1);
	250	return -1;
	251	}
	252	strcpy(pp->name, buf);
	253
	254	p1 = strchr(p, ']');
	255	if (p1 != NULL) {
	256	p = p1 + 1;
	257	pp->is_array = 1;
	258	}
	259	return p - protostr;
	260	}
	261
	262	pp->is_func = 1;
	263
39b168b8	264	if (*p == '(') {
	265	pp->is_fptr = 1;
	266	p = sskip(p + 1);
	267	}
	268
c36e914d	269	p = next_word(cconv, sizeof(cconv), p);
	270	p = sskip(p);
	271	if (cconv[0] == 0) {
63df67be	272	printf("%s:%d:%zd: cconv missing\n",
c36e914d	273	hdrfn, hdrfline, (p - protostr) + 1);
39b168b8	274	return -1;
c36e914d	275	}
	276	if (IS(cconv, "__cdecl"))
	277	pp->is_stdcall = 0;
	278	else if (IS(cconv, "__stdcall"))
	279	pp->is_stdcall = 1;
	280	else if (IS(cconv, "__fastcall"))
	281	pp->is_stdcall = 1;
	282	else if (IS(cconv, "__thiscall"))
	283	pp->is_stdcall = 1;
	284	else if (IS(cconv, "__userpurge"))
	285	pp->is_stdcall = 1; // in all cases seen..
	286	else if (IS(cconv, "__usercall"))
	287	pp->is_stdcall = 0; // ..or is it?
64c59faf	288	else if (IS(cconv, "WINAPI"))
64c59faf	289	pp->is_stdcall = 1;
c36e914d	290	else {
63df67be	291	printf("%s:%d:%zd: unhandled cconv: '%s'\n",
c36e914d	292	hdrfn, hdrfline, (p - protostr) + 1, cconv);
39b168b8	293	return -1;
	294	}
	295
	296	if (pp->is_fptr) {
	297	if (p != '') {
63df67be	298	printf("%s:%d:%zd: '*' expected\n",
39b168b8	299	hdrfn, hdrfline, (p - protostr) + 1);
	300	return -1;
	301	}
	302	p = sskip(p + 1);
c36e914d	303	}
	304
	305	p = next_idt(buf, sizeof(buf), p);
	306	p = sskip(p);
	307	if (buf[0] == 0) {
63df67be	308	printf("%s:%d:%zd: func name missing\n",
39b168b8	309	hdrfn, hdrfline, (p - protostr) + 1);
39b168b8	310	return -1;
c36e914d	311	}
39b168b8	312	strcpy(pp->name, buf);
c36e914d	313
	314	ret = get_regparm(regparm, sizeof(regparm), p);
	315	if (ret > 0) {
	316	if (!IS(regparm, "eax") && !IS(regparm, "ax")
	317	&& !IS(regparm, "al"))
	318	{
63df67be	319	printf("%s:%d:%zd: bad regparm: %s\n",
c36e914d	320	hdrfn, hdrfline, (p - protostr) + 1, regparm);
39b168b8	321	return -1;
c36e914d	322	}
	323	p += ret;
	324	p = sskip(p);
	325	}
	326
39b168b8	327	if (pp->is_fptr) {
39b168b8	328	if (*p != ')') {
63df67be	329	printf("%s:%d:%zd: ')' expected\n",
39b168b8	330	hdrfn, hdrfline, (p - protostr) + 1);
	331	return -1;
	332	}
	333	p = sskip(p + 1);
	334	}
	335
c36e914d	336	if (*p != '(') {
63df67be	337	printf("%s:%d:%zd: '(' expected, got '%c'\n",
c36e914d	338	hdrfn, hdrfline, (p - protostr) + 1, *p);
39b168b8	339	return -1;
c36e914d	340	}
	341	p++;
	342
39b168b8	343	// check for x(void)
39b168b8	344	p = sskip(p);
06c5d854	345	if ((!strncmp(p, "void", 4) \|\| !strncmp(p, "VOID", 4))
06c5d854	346	&& *sskip(p + 4) == ')')
39b168b8	347	p += 4;
39b168b8	348
c36e914d	349	while (1) {
c36e914d	350	p = sskip(p);
39b168b8	351	if (*p == ')') {
39b168b8	352	p++;
c36e914d	353	break;
39b168b8	354	}
c36e914d	355	if (*p == ',')
	356	p = sskip(p + 1);
	357
7ba45c34	358	if (!strncmp(p, "...", 3)) {
	359	pp->is_vararg = 1;
	360	p = sskip(p + 3);
	361	if (*p == ')') {
	362	p++;
	363	break;
	364	}
63df67be	365	printf("%s:%d:%zd: ')' expected\n",
7ba45c34	366	hdrfn, hdrfline, (p - protostr) + 1);
	367	return -1;
	368	}
	369
39b168b8	370	arg = &pp->arg[xarg];
c36e914d	371	xarg++;
c36e914d	372
39b168b8	373	p1 = p;
64c59faf	374	kt = check_type(p, &ret);
c36e914d	375	if (kt == NULL) {
63df67be	376	printf("%s:%d:%zd: unhandled type for arg%d\n",
c36e914d	377	hdrfn, hdrfline, (p - protostr) + 1, xarg);
39b168b8	378	return -1;
c36e914d	379	}
39b168b8	380	arg->type = kt;
64c59faf	381	p = sskip(p + ret);
c36e914d	382
39b168b8	383	if (*p == '(') {
	384	// func ptr
	385	arg->fptr = calloc(1, sizeof(*arg->fptr));
	386	ret = parse_protostr(p1, arg->fptr);
	387	if (ret < 0) {
63df67be	388	printf("%s:%d:%zd: funcarg parse failed\n",
39b168b8	389	hdrfn, hdrfline, p1 - protostr);
	390	return -1;
	391	}
	392	// we'll treat it as void * for non-calls
	393	arg->type = "void *";
	394
	395	p = p1 + ret;
	396	}
	397
c36e914d	398	p = next_idt(buf, sizeof(buf), p);
	399	p = sskip(p);
	400	#if 0
	401	if (buf[0] == 0) {
63df67be	402	printf("%s:%d:%zd: idt missing for arg%d\n",
c36e914d	403	hdrfn, hdrfline, (p - protostr) + 1, xarg);
39b168b8	404	return -1;
c36e914d	405	}
c36e914d	406	#endif
39b168b8	407	arg->reg = NULL;
c36e914d	408
	409	ret = get_regparm(regparm, sizeof(regparm), p);
	410	if (ret > 0) {
	411	p += ret;
	412	p = sskip(p);
	413
39b168b8	414	arg->reg = strdup(map_reg(regparm));
c36e914d	415	}
	416	}
	417
	418	if (xarg > 0 && (IS(cconv, "__fastcall") \|\| IS(cconv, "__thiscall"))) {
	419	if (pp->arg[0].reg != NULL) {
	420	printf("%s:%d: %s with arg1 spec %s?\n",
	421	hdrfn, hdrfline, cconv, pp->arg[0].reg);
	422	}
	423	pp->arg[0].reg = strdup("ecx");
	424	}
	425
	426	if (xarg > 1 && IS(cconv, "__fastcall")) {
	427	if (pp->arg[1].reg != NULL) {
	428	printf("%s:%d: %s with arg2 spec %s?\n",
	429	hdrfn, hdrfline, cconv, pp->arg[1].reg);
	430	}
	431	pp->arg[1].reg = strdup("edx");
	432	}
	433
7ba45c34	434	if (pp->is_vararg && pp->is_stdcall) {
	435	printf("%s:%d: vararg stdcall?\n", hdrfn, hdrfline);
	436	return -1;
	437	}
	438
c36e914d	439	pp->argc = xarg;
	440
	441	for (i = 0; i < pp->argc; i++) {
	442	if (pp->arg[i].reg == NULL)
	443	pp->argc_stack++;
	444	else
	445	pp->argc_reg++;
	446	}
	447
39b168b8	448	return p - protostr;
c36e914d	449	}
	450
	451	static int proto_parse(FILE fhdr, const char sym, struct parsed_proto *pp)
	452	{
	453	char protostr[256];
	454	int ret;
	455
	456	memset(pp, 0, sizeof(*pp));
	457
39b168b8	458	ret = find_protostr(protostr, sizeof(protostr), fhdr, hdrfn, sym);
c36e914d	459	if (ret != 0) {
	460	printf("%s: sym '%s' is missing\n", hdrfn, sym);
	461	return ret;
	462	}
	463
39b168b8	464	return parse_protostr(protostr, pp) < 0 ? -1 : 0;
c36e914d	465	}
	466
	467	static void proto_release(struct parsed_proto *pp)
	468	{
	469	int i;
	470
	471	for (i = 0; i < pp->argc; i++) {
39b168b8	472	if (pp->arg[i].reg != NULL)
c36e914d	473	free(pp->arg[i].reg);
64c59faf	474	if (pp->arg[i].type != NULL)
64c59faf	475	free(pp->arg[i].type);
39b168b8	476	if (pp->arg[i].fptr != NULL)
39b168b8	477	free(pp->arg[i].fptr);
c36e914d	478	}
64c59faf	479	if (pp->ret_type != NULL)
64c59faf	480	free(pp->ret_type);
c36e914d	481	}