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