[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 is_unresolved: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];
	char path[256];
	char fname_inc[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;

			path[0] = 0;
			p = strrchr(hdrfn_saved, '/');
			if (p) {
				memcpy(path, hdrfn_saved,
					p - hdrfn_saved + 1);
				path[p - hdrfn_saved + 1] = 0;
			}
			snprintf(fname_inc, sizeof(fname_inc), "%s%s", 
				path, finc_name);
			finc = fopen(fname_inc, "r");
			if (finc == NULL) {
				printf("%s:%d: can't open '%s'\n",
					fname_inc, 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",
	"HIMC",
	"HMODULE",
	"HRGN",
	"HRSRC",
	"HKEY",
	"HMENU",
	"HWND",
	"PCRITICAL_SECTION",
	"PDWORD",
	"PHKEY",
	"PLONG",
	"PMEMORY_BASIC_INFORMATION",
	"PUINT",
	"PVOID",
	"PCVOID",
	"DLGPROC",
	"TIMERPROC",
	"WNDENUMPROC",
	"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);
	if (IS(type->name, "VOID"))
		memcpy(type->name, "void", 4);

	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);
	}
	else if (!strncmp(p, "noreturn ", 9)) {
		pp->is_noreturn = 1;
		p = sskip(p + 9);
	}

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