int argc_reg;
unsigned int is_func:1;
unsigned int is_stdcall:1;
- unsigned int is_vararg: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_arg:1; // decl in func arg
unsigned int has_structarg:1;
};
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;
if (p != NULL)
*p = 0;
- finc = fopen(finc_name, "r");
+ 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, line, finc_name);
+ fname_inc, line, finc_name);
continue;
}
ret = do_protostrs(finc, finc_name);
"struct",
"enum",
"CONST",
+ "volatile",
};
static const char *known_ptr_types[] = {
+ "FARPROC",
+ "WNDPROC",
"HACCEL",
"HANDLE",
"HBITMAP",
"HFONT",
"HGDIOBJ",
"HGLOBAL",
+ "HICON",
"HINSTANCE",
+ //"HIMC", // DWORD
"HMODULE",
+ "HPALETTE",
"HRGN",
"HRSRC",
"HKEY",
"HMENU",
+ "HWAVEOUT",
"HWND",
- "PLONG",
+ "PBYTE",
+ "PCRITICAL_SECTION",
"PDWORD",
+ "PFILETIME",
+ "PHKEY",
+ "PLONG",
+ "PMEMORY_BASIC_INFORMATION",
+ "PUINT",
"PVOID",
"PCVOID",
+ "PWORD",
"DLGPROC",
+ "TIMERPROC",
+ "WNDENUMPROC",
"va_list",
"__VALIST",
};
ret = n1 - name;
type->name = strndup(name, ret);
+ if (IS(type->name, "VOID"))
+ memcpy(type->name, "void", 4);
+
return ret;
}
}
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);
pp->is_stdcall = 0;
else if (IS(cconv, "__stdcall"))
pp->is_stdcall = 1;
- else if (IS(cconv, "__fastcall"))
- pp->is_stdcall = 1;
+ else if (IS(cconv, "__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"))
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;
arg->reg = strdup(map_reg(regparm));
}
+ 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;
pp->arg[1].reg = strdup("edx");
}
- if (pp->is_vararg && pp->is_stdcall) {
- printf("%s:%d: vararg stdcall?\n", hdrfn, hdrfline);
- return -1;
- }
-
pp->argc = xarg;
for (i = 0; i < pp->argc; i++) {
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 void build_pp_cache(FILE *fhdr)
{
+ long pos;
int ret;
+ pos = ftell(fhdr);
rewind(fhdr);
ret = do_protostrs(fhdr, hdrfn);
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)
+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);
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)
+ if (pp_ret == NULL && !quiet)
printf("%s: sym '%s' is missing\n", hdrfn, sym);
return pp_ret;
return pp;
}
+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;