[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
	unsigned int is_retreg:1; // register to return
};

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_fastcall:1;
	unsigned int is_vararg:1;     // vararg func
	unsigned int is_fptr:1;
	unsigned int is_noreturn:1;
	unsigned int is_unresolved:1;
	unsigned int is_userstack:1;
	unsigned int is_arg:1;        // decl in func arg
	unsigned int has_structarg:1;
	unsigned int has_retreg: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 *retreg)
{
	int i = 0, o;

	*retreg = 0;

	if (*p != '<')
		return 0;

	i++;
	if (p[i] == '*') {
		*retreg = 1;
		i++;
	}

	for (o = 0; 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",
	"volatile",
};

static const char *known_ptr_types[] = {
	"FARPROC",
	"WNDPROC",
	"HACCEL",
	"HANDLE",
	"HBITMAP",
	"HCURSOR",
	"HDC",
	"HFONT",
	"HGDIOBJ",
	"HGLOBAL",
	"HICON",
	"HINSTANCE",
	"HIMC", // DWORD in mingw, ptr in wine..
	"HMODULE",
	"HPALETTE",
	"HRGN",
	"HRSRC",
	"HKEY",
	"HMENU",
	"HWAVEOUT",
	"HWND",
	"PBYTE",
	"PCRITICAL_SECTION",
	"PDWORD",
	"PFILETIME",
	"PHKEY",
	"PLONG",
	"PMEMORY_BASIC_INFORMATION",
	"PUINT",
	"PVOID",
	"PCVOID",
	"PWORD",
	"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 is_retreg;
	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 (!strncmp(p, "noreturn ", 9)) {
		pp->is_noreturn = 1;
		p = sskip(p + 9);
	}

	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_fastcall = 1;
		pp->is_stdcall = 1; // sort of..
	}
	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, "__userstack")) {
		pp->is_stdcall = 0; // custom
		pp->is_userstack = 1;
	}
	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, &is_retreg);
	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;
			}
			arg->fptr->is_arg = 1;
			// we don't use actual names right now..
			snprintf(arg->fptr->name,
				sizeof(arg->fptr->name), "a%d", xarg);
			// 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, &is_retreg);
		if (ret > 0) {
			p += ret;
			p = sskip(p);

			arg->reg = strdup(map_reg(regparm));
			arg->type.is_retreg = is_retreg;
			pp->has_retreg |= is_retreg;
		}

		if (strstr(arg->type.name, "int64")
		    || IS(arg->type.name, "double"))
		{
			// hack..
			free(arg->type.name);
			arg->type.name = strdup("int");
			pp_copy_arg(&pp->arg[xarg], arg);
			xarg++;
		}

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

	pp->argc = xarg;

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

	if (pp->argc == 1 && pp->arg[0].reg != NULL
	    && IS(pp->arg[0].reg, "ecx"))
	{
		pp->is_fastcall = 1;
	}
	else if (pp->argc_reg == 2
	  && pp->arg[0].reg != NULL && IS(pp->arg[0].reg, "ecx")
	  && pp->arg[1].reg != NULL && IS(pp->arg[1].reg, "edx"))
	{
		pp->is_fastcall = 1;
	}

	if (pp->is_vararg && (pp->is_stdcall || pp->is_fastcall)) {
		printf("%s:%d: vararg %s?\n", hdrfn, hdrfline, cconv);
		return -1;
	}

	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)
{
	long pos;
	int ret;

	pos = ftell(fhdr);
	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);
	fseek(fhdr, pos, SEEK_SET);
}

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;
	char *p;

	if (pp_cache == NULL)
		build_pp_cache(fhdr);

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

	strcpy(pp_search.name, sym);
	p = strchr(pp_search.name, '@');
	if (p != NULL)
		*p = 0;

	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 int pp_cmp_func(const struct parsed_proto *pp1,
  const struct parsed_proto *pp2)
{
  int i;

  if (pp1->argc != pp2->argc || pp1->argc_reg != pp2->argc_reg)
    return 1;
  else {
    for (i = 0; i < pp1->argc; i++) {
      if ((pp1->arg[i].reg != NULL) != (pp2->arg[i].reg != NULL))
        return 1;

      if ((pp1->arg[i].reg != NULL)
        && !IS(pp1->arg[i].reg, pp2->arg[i].reg))
      {
        return 1;
      }
    }
  }

  return 0;
}

static inline void pp_print(char *buf, size_t buf_size,
  const struct parsed_proto *pp)
{
  size_t l;
  int i;

  snprintf(buf, buf_size, "%s %s(", pp->ret_type.name, pp->name);
  l = strlen(buf);

  for (i = 0; i < pp->argc_reg; i++) {
    snprintf(buf + l, buf_size - l, "%s%s",
      i == 0 ? "" : ", ", pp->arg[i].reg);
    l = strlen(buf);
  }
  if (pp->argc_stack > 0) {
    snprintf(buf + l, buf_size - l, "%s{%d stack}",
      i == 0 ? "" : ", ", pp->argc_stack);
    l = strlen(buf);
  }
  snprintf(buf + l, buf_size - l, ")");
}

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