[ia32rtools.git] / tools / protoparse.h


struct parsed_proto {
	struct {
		char *reg;
		const char *type;
		void *datap;
	} arg[16];
	const char *ret_type;
	int is_stdcall;
	int argc;
	int argc_stack;
	int argc_reg;
};

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

static int find_protostr(char *dst, size_t dlen, FILE *fhdr, const char *sym)
{
	int line = 0;
	char *p;

	rewind(fhdr);

	while (fgets(dst, dlen, fhdr))
	{
		line++;
		if (strstr(dst, sym) != NULL)
			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_types[] = {
	"const void *",
	"void *",
	"char *",
	"FILE *",
	"int *",
	"unsigned __int8",
	"unsigned __int16",
	"unsigned int",
	"signed int",
	"char",
	"__int8",
	"__int16",
	"int",
	"bool",
	"void",
	"BYTE",
	"WORD",
	"DWORD",
	"_DWORD",
	"HMODULE",
	"HANDLE",
	"HWND",
	"LPCSTR",
	"size_t",
};

static const char *check_type(const char *name)
{
	int i, l;

	for (i = 0; i < ARRAY_SIZE(known_types); i++) {
		l = strlen(known_types[i]);
		if (strncmp(known_types[i], name, l) == 0)
			return known_types[i];
	}

	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)
{
	char regparm[16];
	char buf[256];
	char cconv[32];
	const char *kt;
	int xarg = 0;
	int ret;
	char *p;
	int i;

	p = protostr;
	if (p[0] == '/' && p[1] == '/') {
		//printf("warning: decl for sym '%s' is commented out\n", sym);
		p = sskip(p + 2);
	}

	kt = check_type(p);
	if (kt == NULL) {
		printf("%s:%d:%ld: unhandled return in '%s'\n",
			hdrfn, hdrfline, (p - protostr) + 1, protostr);
		return 1;
	}
	pp->ret_type = kt;
	p += strlen(kt);
	p = sskip(p);

	p = next_word(cconv, sizeof(cconv), p);
	p = sskip(p);
	if (cconv[0] == 0) {
		printf("%s:%d:%ld: 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 {
		printf("%s:%d:%ld: unhandled cconv: '%s'\n",
			hdrfn, hdrfline, (p - protostr) + 1, cconv);
		return 1;
	}

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

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

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

	while (1) {
		p = sskip(p);
		if (*p == ')')
			break;
		if (*p == ',')
			p = sskip(p + 1);

		xarg++;

		kt = check_type(p);
		if (kt == NULL) {
			printf("%s:%d:%ld: unhandled type for arg%d\n",
				hdrfn, hdrfline, (p - protostr) + 1, xarg);
			return 1;
		}
		pp->arg[xarg - 1].type = kt;
		p += strlen(kt);
		p = sskip(p);

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

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

			pp->arg[xarg - 1].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");
	}

	pp->argc = xarg;

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

	return 0;
}

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, sym);
	if (ret != 0) {
		printf("%s: sym '%s' is missing\n", hdrfn, sym);
		return ret;
	}

	return parse_protostr(protostr, pp);
}

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);
	}
}
Commit	Line	Data
	1
	2	struct parsed_proto {
	3	struct {
	4	char *reg;
	5	const char *type;
	6	void *datap;
	7	} arg[16];
	8	const char *ret_type;
	9	int is_stdcall;
	10	int argc;
	11	int argc_stack;
	12	int argc_reg;
	13	};
	14
	15	static const char *hdrfn;
	16	static int hdrfline = 0;
	17
	18	static int find_protostr(char dst, size_t dlen, FILE fhdr, const char *sym)
	19	{
	20	int line = 0;
	21	char *p;
	22
	23	rewind(fhdr);
	24
	25	while (fgets(dst, dlen, fhdr))
	26	{
	27	line++;
	28	if (strstr(dst, sym) != NULL)
	29	break;
	30	}
	31	hdrfline = line;
	32
	33	if (feof(fhdr))
	34	return -1;
	35
	36	p = dst + strlen(dst);
	37	for (p--; p > dst && my_isblank(*p); --p)
	38	*p = 0;
	39
	40	return 0;
	41	}
	42
	43	static int get_regparm(char dst, size_t dlen, char p)
	44	{
	45	int i, o;
	46
	47	if (*p != '<')
	48	return 0;
	49
	50	for (o = 0, i = 1; o < dlen; i++) {
	51	if (p[i] == 0)
	52	return 0;
	53	if (p[i] == '>')
	54	break;
	55	dst[o++] = p[i];
	56	}
	57	dst[o] = 0;
	58	return i + 1;
	59	}
	60
	61	// hmh..
	62	static const char *known_types[] = {
	63	"const void *",
	64	"void *",
	65	"char *",
	66	"FILE *",
	67	"int *",
	68	"unsigned __int8",
	69	"unsigned __int16",
	70	"unsigned int",
	71	"signed int",
	72	"char",
	73	"__int8",
	74	"__int16",
	75	"int",
	76	"bool",
	77	"void",
	78	"BYTE",
	79	"WORD",
	80	"DWORD",
	81	"_DWORD",
	82	"HMODULE",
	83	"HANDLE",
	84	"HWND",
	85	"LPCSTR",
	86	"size_t",
	87	};
	88
	89	static const char check_type(const char name)
	90	{
	91	int i, l;
	92
	93	for (i = 0; i < ARRAY_SIZE(known_types); i++) {
	94	l = strlen(known_types[i]);
	95	if (strncmp(known_types[i], name, l) == 0)
	96	return known_types[i];
	97	}
	98
	99	return NULL;
	100	}
	101
	102	/* args are always expanded to 32bit */
	103	static const char map_reg(const char reg)
	104	{
	105	const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
	106	const char *regs_w[] = { "ax", "bx", "cx", "dx", "si", "di" };
	107	const char *regs_b[] = { "al", "bl", "cl", "dl" };
	108	int i;
	109
	110	for (i = 0; i < ARRAY_SIZE(regs_w); i++)
	111	if (IS(reg, regs_w[i]))
	112	return regs_f[i];
	113
	114	for (i = 0; i < ARRAY_SIZE(regs_b); i++)
	115	if (IS(reg, regs_b[i]))
	116	return regs_f[i];
	117
	118	return reg;
	119	}
	120
	121	static int parse_protostr(char protostr, struct parsed_proto pp)
	122	{
	123	char regparm[16];
	124	char buf[256];
	125	char cconv[32];
	126	const char *kt;
	127	int xarg = 0;
	128	int ret;
	129	char *p;
	130	int i;
	131
	132	p = protostr;
	133	if (p[0] == '/' && p[1] == '/') {
	134	//printf("warning: decl for sym '%s' is commented out\n", sym);
	135	p = sskip(p + 2);
	136	}
	137
	138	kt = check_type(p);
	139	if (kt == NULL) {
	140	printf("%s:%d:%ld: unhandled return in '%s'\n",
	141	hdrfn, hdrfline, (p - protostr) + 1, protostr);
	142	return 1;
	143	}
	144	pp->ret_type = kt;
	145	p += strlen(kt);
	146	p = sskip(p);
	147
	148	p = next_word(cconv, sizeof(cconv), p);
	149	p = sskip(p);
	150	if (cconv[0] == 0) {
	151	printf("%s:%d:%ld: cconv missing\n",
	152	hdrfn, hdrfline, (p - protostr) + 1);
	153	return 1;
	154	}
	155	if (IS(cconv, "__cdecl"))
	156	pp->is_stdcall = 0;
	157	else if (IS(cconv, "__stdcall"))
	158	pp->is_stdcall = 1;
	159	else if (IS(cconv, "__fastcall"))
	160	pp->is_stdcall = 1;
	161	else if (IS(cconv, "__thiscall"))
	162	pp->is_stdcall = 1;
	163	else if (IS(cconv, "__userpurge"))
	164	pp->is_stdcall = 1; // in all cases seen..
	165	else if (IS(cconv, "__usercall"))
	166	pp->is_stdcall = 0; // ..or is it?
	167	else {
	168	printf("%s:%d:%ld: unhandled cconv: '%s'\n",
	169	hdrfn, hdrfline, (p - protostr) + 1, cconv);
	170	return 1;
	171	}
	172
	173	p = next_idt(buf, sizeof(buf), p);
	174	p = sskip(p);
	175	if (buf[0] == 0) {
	176	printf("%s:%d:%ld: func name missing\n",
	177	hdrfn, hdrfline, (p - protostr) + 1);
	178	return 1;
	179	}
	180
	181	ret = get_regparm(regparm, sizeof(regparm), p);
	182	if (ret > 0) {
	183	if (!IS(regparm, "eax") && !IS(regparm, "ax")
	184	&& !IS(regparm, "al"))
	185	{
	186	printf("%s:%d:%ld: bad regparm: %s\n",
	187	hdrfn, hdrfline, (p - protostr) + 1, regparm);
	188	return 1;
	189	}
	190	p += ret;
	191	p = sskip(p);
	192	}
	193
	194	if (*p != '(') {
	195	printf("%s:%d:%ld: '(' expected, got '%c'\n",
	196	hdrfn, hdrfline, (p - protostr) + 1, *p);
	197	return 1;
	198	}
	199	p++;
	200
	201	while (1) {
	202	p = sskip(p);
	203	if (*p == ')')
	204	break;
	205	if (*p == ',')
	206	p = sskip(p + 1);
	207
	208	xarg++;
	209
	210	kt = check_type(p);
	211	if (kt == NULL) {
	212	printf("%s:%d:%ld: unhandled type for arg%d\n",
	213	hdrfn, hdrfline, (p - protostr) + 1, xarg);
	214	return 1;
	215	}
	216	pp->arg[xarg - 1].type = kt;
	217	p += strlen(kt);
	218	p = sskip(p);
	219
	220	p = next_idt(buf, sizeof(buf), p);
	221	p = sskip(p);
	222	#if 0
	223	if (buf[0] == 0) {
	224	printf("%s:%d:%ld: idt missing for arg%d\n",
	225	hdrfn, hdrfline, (p - protostr) + 1, xarg);
	226	return 1;
	227	}
	228	#endif
	229	pp->arg[xarg - 1].reg = NULL;
	230
	231	ret = get_regparm(regparm, sizeof(regparm), p);
	232	if (ret > 0) {
	233	p += ret;
	234	p = sskip(p);
	235
	236	pp->arg[xarg - 1].reg = strdup(map_reg(regparm));
	237	}
	238	}
	239
	240	if (xarg > 0 && (IS(cconv, "__fastcall") \|\| IS(cconv, "__thiscall"))) {
	241	if (pp->arg[0].reg != NULL) {
	242	printf("%s:%d: %s with arg1 spec %s?\n",
	243	hdrfn, hdrfline, cconv, pp->arg[0].reg);
	244	}
	245	pp->arg[0].reg = strdup("ecx");
	246	}
	247
	248	if (xarg > 1 && IS(cconv, "__fastcall")) {
	249	if (pp->arg[1].reg != NULL) {
	250	printf("%s:%d: %s with arg2 spec %s?\n",
	251	hdrfn, hdrfline, cconv, pp->arg[1].reg);
	252	}
	253	pp->arg[1].reg = strdup("edx");
	254	}
	255
	256	pp->argc = xarg;
	257
	258	for (i = 0; i < pp->argc; i++) {
	259	if (pp->arg[i].reg == NULL)
	260	pp->argc_stack++;
	261	else
	262	pp->argc_reg++;
	263	}
	264
	265	return 0;
	266	}
	267
	268	static int proto_parse(FILE fhdr, const char sym, struct parsed_proto *pp)
	269	{
	270	char protostr[256];
	271	int ret;
	272
	273	memset(pp, 0, sizeof(*pp));
	274
	275	ret = find_protostr(protostr, sizeof(protostr), fhdr, sym);
	276	if (ret != 0) {
	277	printf("%s: sym '%s' is missing\n", hdrfn, sym);
	278	return ret;
	279	}
	280
	281	return parse_protostr(protostr, pp);
	282	}
	283
	284	static void proto_release(struct parsed_proto *pp)
	285	{
	286	int i;
	287
	288	for (i = 0; i < pp->argc; i++) {
	289	if (pp->arg[i].reg == NULL)
	290	free(pp->arg[i].reg);
	291	}
	292	}