translate: suppress a warning

[ia32rtools.git] / tools / protoparse.h

diff --git a/tools/protoparse.h b/tools/protoparse.h
index 3981588..037c3f4 100644 (file)
--- a/tools/protoparse.h
+++ b/tools/protoparse.h
@@ -6,6 +6,7 @@ struct parsed_type {
        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 {
@@ -27,11 +28,15 @@ struct parsed_proto {
        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_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;
@@ -111,14 +116,22 @@ static int do_protostrs(FILE *fhdr, const char *fname)
        return -1;
 }
 
-static int get_regparm(char *dst, size_t dlen, char *p)
+static int get_regparm(char *dst, size_t dlen, char *p, int *retreg)
 {
-       int i, o;
+       int i = 0, o;
+
+       *retreg = 0;
 
        if (*p != '<')
                return 0;
 
-       for (o = 0, i = 1; o < dlen; i++) {
+       i++;
+       if (p[i] == '*') {
+               *retreg = 1;
+               i++;
+       }
+
+       for (o = 0; o < dlen; i++) {
                if (p[i] == 0)
                        return 0;
                if (p[i] == '>')
@@ -137,10 +150,12 @@ static const char *known_type_mod[] = {
        "struct",
        "enum",
        "CONST",
+       "volatile",
 };
 
 static const char *known_ptr_types[] = {
        "FARPROC",
+       "WNDPROC",
        "HACCEL",
        "HANDLE",
        "HBITMAP",
@@ -151,22 +166,26 @@ static const char *known_ptr_types[] = {
        "HGLOBAL",
        "HICON",
        "HINSTANCE",
-       //"HIMC", // DWORD
+       "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",
@@ -294,6 +313,7 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
        char regparm[16];
        char buf[256];
        char cconv[32];
+       int is_retreg;
        int xarg = 0;
        char *p, *p1;
        int i, l;
@@ -372,14 +392,20 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                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"))
                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 {
@@ -410,7 +436,7 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
        }
        strcpy(pp->name, buf);
 
-       ret = get_regparm(regparm, sizeof(regparm), p);
+       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"))
@@ -504,6 +530,10 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                                        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;
@@ -522,12 +552,24 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
 #endif
                arg->reg = NULL;
 
-               ret = get_regparm(regparm, sizeof(regparm), p);
+               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);
@@ -559,11 +601,6 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                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++) {
@@ -573,6 +610,23 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                        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;
 }
 
@@ -629,6 +683,7 @@ static const struct parsed_proto *proto_parse(FILE *fhdr, const char *sym,
 {
        const struct parsed_proto *pp_ret;
        struct parsed_proto pp_search;
+       char *p;
 
        if (pp_cache == NULL)
                build_pp_cache(fhdr);
@@ -637,6 +692,10 @@ static const struct parsed_proto *proto_parse(FILE *fhdr, const char *sym,
                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)
@@ -683,6 +742,52 @@ struct parsed_proto *proto_clone(const struct parsed_proto *pp_c)
        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;