[ia32rtools.git] / tools / protoparse.h

/*
 * ia32rtools
 * (C) notaz, 2013,2014
 *
 * This work is licensed under the terms of 3-clause BSD license.
 * See COPYING file in the top-level directory.
 */

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 to caller
	unsigned int is_va_list:1;
};

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_oslib:1;      // OS/system library func
	unsigned int is_arg:1;        // declared in some 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, int is_oslib);

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];
	int is_oslib;
	FILE *finc;
	int line = 0;
	int ret;
	char *p;

	hdrfn_saved = hdrfn;
	hdrfn = fname;

	is_oslib = strstr(fname, "stdc.hlist")
		 || strstr(fname, "win32.hlist");

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