win32.hlist, more types, fixes

diff --git a/tools/protoparse.h b/tools/protoparse.h
index 5ef8b4b..01f2e09 100644 (file)
--- a/tools/protoparse.h
+++ b/tools/protoparse.h
@@ -3,14 +3,14 @@ struct parsed_proto;
 
 struct parsed_proto_arg {
        char *reg;
-       const char *type;
+       char *type;
        struct parsed_proto *fptr;
        void *datap;
 };
 
 struct parsed_proto {
        char name[256];
-       const char *ret_type;
+       char *ret_type;
        struct parsed_proto_arg arg[16];
        int argc;
        int argc_stack;
@@ -103,34 +103,41 @@ static int get_regparm(char *dst, size_t dlen, char *p)
 }
 
 // hmh..
+static const char *known_type_mod[] = {
+       "const",
+       "signed",
+       "unsigned",
+};
+
 static const char *known_types[] = {
-       "const void *",
        "void *",
        "char *",
        "FILE *",
        "int *",
-       "unsigned __int8",
-       "unsigned __int16",
-       "unsigned int",
-       "signed int",
+       "__int8 *",
+       "__int16 *",
        "char",
        "__int8",
        "__int16",
+       "__int32",
        "int",
        "bool",
        "void",
        "BYTE",
        "WORD",
+       "BOOL",
        "DWORD",
        "_DWORD",
        "HMODULE",
        "HANDLE",
        "HWND",
+       "LANGID",
        "LPCSTR",
        "size_t",
 };
 
-static int typecmp(const char *n, const char *t)
+// returns ptr to char after type ends
+static const char *typecmp(const char *n, const char *t)
 {
        for (; *t != 0; n++, t++) {
                while (n[0] == ' ' && (n[1] == ' ' || n[1] == '*'))
@@ -138,19 +145,38 @@ static int typecmp(const char *n, const char *t)
                while (t[0] == ' ' && (t[1] == ' ' || t[1] == '*'))
                        t++;
                if (*n != *t)
-                       return *n - *t;
+                       return NULL;
        }
 
-       return 0;
+       return n;
 }
 
-static const char *check_type(const char *name)
+static char *check_type(const char *name, int *len_out)
 {
+       const char *n = name, *n1;
+       int len;
        int i;
 
+       *len_out = 0;
+
+       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;
+
+               n += len;
+               while (my_isblank(*n))
+                       n++;
+               i = 0;
+       }
+
        for (i = 0; i < ARRAY_SIZE(known_types); i++) {
-               if (typecmp(name, known_types[i]) == 0)
-                       return known_types[i];
+               n1 = typecmp(n, known_types[i]);
+               if (n1 == NULL)
+                       continue;
+
+               *len_out = n1 - name;
+               return strndup(name, *len_out);
        }
 
        return NULL;
@@ -181,7 +207,7 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
        char regparm[16];
        char buf[256];
        char cconv[32];
-       const char *kt;
+       char *kt;
        int xarg = 0;
        char *p, *p1;
        int ret;
@@ -202,16 +228,17 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
 
        if (strncmp(p, "extern ", 7) == 0)
                p = sskip(p + 7);
+       if (strncmp(p, "WINBASEAPI ", 11) == 0)
+               p = sskip(p + 11);
 
-       kt = check_type(p);
+       kt = check_type(p, &ret);
        if (kt == NULL) {
                printf("%s:%d:%ld: unhandled return in '%s'\n",
                        hdrfn, hdrfline, (p - protostr) + 1, protostr);
                return -1;
        }
        pp->ret_type = kt;
-       p += strlen(kt);
-       p = sskip(p);
+       p = sskip(p + ret);
 
        if (!strchr(p, ')')) {
                p = next_idt(buf, sizeof(buf), p);
@@ -257,6 +284,8 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                pp->is_stdcall = 1; // in all cases seen..
        else if (IS(cconv, "__usercall"))
                pp->is_stdcall = 0; // ..or is it?
+       else if (IS(cconv, "WINAPI"))
+               pp->is_stdcall = 1;
        else {
                printf("%s:%d:%ld: unhandled cconv: '%s'\n",
                        hdrfn, hdrfline, (p - protostr) + 1, cconv);
@@ -329,15 +358,14 @@ static int parse_protostr(char *protostr, struct parsed_proto *pp)
                xarg++;
 
                p1 = p;
-               kt = check_type(p);
+               kt = check_type(p, &ret);
                if (kt == NULL) {
                        printf("%s:%d:%ld: unhandled type for arg%d\n",
                                hdrfn, hdrfline, (p - protostr) + 1, xarg);
                        return -1;
                }
                arg->type = kt;
-               p += strlen(kt);
-               p = sskip(p);
+               p = sskip(p + ret);
 
                if (*p == '(') {
                        // func ptr
@@ -425,7 +453,11 @@ static void proto_release(struct parsed_proto *pp)
        for (i = 0; i < pp->argc; i++) {
                if (pp->arg[i].reg != NULL)
                        free(pp->arg[i].reg);
+               if (pp->arg[i].type != NULL)
+                       free(pp->arg[i].type);
                if (pp->arg[i].fptr != NULL)
                        free(pp->arg[i].fptr);
        }
+       if (pp->ret_type != NULL)
+               free(pp->ret_type);
 }

diff --git a/tools/translate.c b/tools/translate.c
index e7f4bdd..208a337 100644 (file)
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -604,6 +604,7 @@ static int parse_operand(struct parsed_opr *opr,
     else if (opr->lmod == OPLM_UNSPEC)
       guess_lmod_from_c_type(opr, pp.ret_type);
   }
+  proto_release(&pp);
 
   if (opr->lmod == OPLM_UNSPEC)
     guess_lmod_from_name(opr);
@@ -1635,6 +1636,24 @@ static int scan_for_cdq_edx(int i)
   return -1;
 }
 
+static int scan_for_reg_clear(int i, int reg)
+{
+  for (; i >= 0; i--) {
+    if (ops[i].op == OP_XOR
+     && ops[i].operand[0].lmod == OPLM_DWORD
+     && ops[i].operand[0].reg == ops[i].operand[1].reg
+     && ops[i].operand[0].reg == reg)
+      return i;
+
+    if (ops[i].regmask_dst & (1 << reg))
+      return -1;
+    if (g_labels[i][0] != 0)
+      return -1;
+  }
+
+  return -1;
+}
+
 // scan for positive, constant esp adjust
 static int scan_for_esp_adjust(int i, int opcnt, int *adj)
 {
@@ -1674,6 +1693,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   int regmask_arg = 0;
   int regmask = 0;
   int pfomask = 0;
+  int found = 0;
   int depth = 0;
   int no_output;
   int dummy;
@@ -1724,11 +1744,15 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       }
     }
 
+    found = 0;
     i = 2;
     do {
       for (; i < opcnt; i++)
         if (ops[i].op == OP_RET)
           break;
+      if (i == opcnt && (ops[i - 1].flags & OPF_JMP) && found)
+        break;
+
       if (ops[i - 1].op != OP_POP || !IS(opr_name(&ops[i - 1], 0), "ebp"))
         ferr(&ops[i - 1], "'pop ebp' expected\n");
       ops[i - 1].flags |= OPF_RMD;
@@ -1749,6 +1773,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
       }
 
+      found = 1;
       i++;
     } while (i < opcnt);
   }
@@ -1833,10 +1858,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         j /= 4;
         if (j > ARRAY_SIZE(pp->arg))
           ferr(po, "esp adjust too large?\n");
-        pp->ret_type = "int";
+        pp->ret_type = strdup("int");
         pp->argc = pp->argc_stack = j;
         for (arg = 0; arg < pp->argc; arg++)
-          pp->arg[arg].type = "int";
+          pp->arg[arg].type = strdup("int");
       }
       else {
         ret = proto_parse(fhdr, tmpname, pp);
@@ -1917,7 +1942,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
       }
       if (arg < pp->argc)
-        ferr(po, "arg collect failed for '%s'\n", tmpname);
+        ferr(po, "arg collect failed for '%s': %d/%d\n",
+          tmpname, arg, pp->argc);
       po->datap = pp;
     }
   }
@@ -2386,7 +2412,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           ferr(po, "unhandled lmod %d\n", po->operand[0].lmod);
 
         // 32bit division is common, look for it
-        if (scan_for_cdq_edx(i - 1) >= 0) {
+        if (po->op == OP_DIV)
+          ret = scan_for_reg_clear(i - 1, xDX);
+        else
+          ret = scan_for_cdq_edx(i - 1);
+        if (ret >= 0) {
           out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
           strcpy(buf2, lmod_cast(po, po->operand[0].lmod,
             po->op == OP_IDIV));

diff --git a/win32.hlist b/win32.hlist
new file mode 100644 (file)
index 0000000..0387d29
--- /dev/null
+++ b/win32.hlist
@@ -0,0 +1,446 @@
+WINBASEAPI BOOL WINAPI AddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
+WINBASEAPI BOOL WINAPI AddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
+WINBASEAPI BOOL WINAPI AddAccessDeniedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
+WINBASEAPI BOOL WINAPI AddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
+WINBASEAPI BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID*);
+WINBASEAPI BOOL WINAPI CloseHandle(HANDLE);
+WINBASEAPI LONG WINAPI CompareFileTime(CONST FILETIME*,CONST FILETIME*);
+WINBASEAPI BOOL WINAPI CreateDirectoryA(LPCSTR,LPSECURITY_ATTRIBUTES);
+WINBASEAPI BOOL WINAPI CreateDirectoryW(LPCWSTR,LPSECURITY_ATTRIBUTES);
+WINBASEAPI BOOL WINAPI CreateDirectoryExA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
+WINBASEAPI BOOL WINAPI CreateDirectoryExW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
+WINBASEAPI HANDLE WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
+WINBASEAPI HANDLE WINAPI CreateEventW(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCWSTR);
+WINBASEAPI LPVOID WINAPI CreateFiber(SIZE_T,LPFIBER_START_ROUTINE,LPVOID);
+#if (_WIN32_WINNT >= 0x0400)
+WINBASEAPI LPVOID WINAPI CreateFiberEx(SIZE_T,SIZE_T,DWORD,LPFIBER_START_ROUTINE,LPVOID);
+#endif
+WINBASEAPI HANDLE WINAPI CreateFileA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
+WINBASEAPI HANDLE WINAPI CreateFileW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
+WINBASEAPI BOOL WINAPI CreateProcessA(LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,PVOID,LPCSTR,LPSTARTUPINFOA,LPPROCESS_INFORMATION);
+WINBASEAPI HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,PVOID,DWORD,PDWORD);
+WINBASEAPI void WINAPI DeleteCriticalSection(PCRITICAL_SECTION);
+WINBASEAPI void WINAPI DeleteFiber(PVOID);
+WINBASEAPI BOOL WINAPI DeleteFileA(LPCSTR);
+WINBASEAPI BOOL WINAPI DeleteFileW(LPCWSTR);
+WINBASEAPI void WINAPI EnterCriticalSection(LPCRITICAL_SECTION);
+DECLSPEC_NORETURN WINBASEAPI void WINAPI ExitProcess(UINT);
+DECLSPEC_NORETURN WINBASEAPI void WINAPI ExitThread(DWORD);
+WINBASEAPI BOOL WINAPI FileTimeToDosDateTime(CONST FILETIME *,LPWORD,LPWORD);
+WINBASEAPI BOOL WINAPI FileTimeToLocalFileTime(CONST FILETIME *,LPFILETIME);
+WINBASEAPI BOOL WINAPI FileTimeToSystemTime(CONST FILETIME *,LPSYSTEMTIME);
+WINBASEAPI BOOL WINAPI FindClose(HANDLE);
+WINBASEAPI BOOL WINAPI FindCloseChangeNotification(HANDLE);
+WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationA(LPCSTR,BOOL,DWORD);
+WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationW(LPCWSTR,BOOL,DWORD);
+WINBASEAPI HANDLE WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
+WINBASEAPI HANDLE WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
+WINBASEAPI HANDLE WINAPI FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
+WINBASEAPI HANDLE WINAPI FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,PVOID,FINDEX_SEARCH_OPS,PVOID,DWORD);
+WINBASEAPI HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
+WINBASEAPI HRSRC WINAPI FindResourceW(HINSTANCE,LPCWSTR,LPCWSTR);
+WINBASEAPI HRSRC WINAPI FindResourceExA(HINSTANCE,LPCSTR,LPCSTR,WORD);
+WINBASEAPI HRSRC WINAPI FindResourceExW(HINSTANCE,LPCWSTR,LPCWSTR,WORD);
+WINBASEAPI BOOL WINAPI FlushFileBuffers(HANDLE);
+WINBASEAPI BOOL WINAPI FlushInstructionCache(HANDLE,PCVOID,DWORD);
+WINBASEAPI BOOL WINAPI FlushViewOfFile(PCVOID,DWORD);
+WINBASEAPI DWORD WINAPI FormatMessageA(DWORD,PCVOID,DWORD,DWORD,LPSTR,DWORD,va_list*);
+WINBASEAPI DWORD WINAPI FormatMessageW(DWORD,PCVOID,DWORD,DWORD,LPWSTR,DWORD,va_list*);
+WINBASEAPI BOOL WINAPI FreeEnvironmentStringsA(LPSTR);
+WINBASEAPI BOOL WINAPI FreeEnvironmentStringsW(LPWSTR);
+WINBASEAPI BOOL WINAPI FreeLibrary(HMODULE);
+WINBASEAPI PVOID WINAPI FreeSid(PSID);
+WINBASEAPI BOOL WINAPI GetAce(PACL,DWORD,LPVOID*);
+WINBASEAPI BOOL WINAPI GetAclInformation(PACL,PVOID,DWORD,ACL_INFORMATION_CLASS);
+WINBASEAPI UINT WINAPI GetAtomNameA(ATOM,LPSTR,int);
+WINBASEAPI UINT WINAPI GetAtomNameW(ATOM,LPWSTR,int);
+WINBASEAPI BOOL WINAPI GetBinaryTypeA(LPCSTR,PDWORD);
+WINBASEAPI BOOL WINAPI GetBinaryTypeW(LPCWSTR,PDWORD);
+WINBASEAPI LPSTR WINAPI GetCommandLineA(VOID);
+WINBASEAPI LPWSTR WINAPI GetCommandLineW(VOID);
+WINBASEAPI BOOL WINAPI GetCommConfig(HANDLE,LPCOMMCONFIG,PDWORD);
+WINBASEAPI BOOL WINAPI GetCommMask(HANDLE,PDWORD);
+WINBASEAPI BOOL WINAPI GetCommModemStatus(HANDLE,PDWORD);
+WINBASEAPI BOOL WINAPI GetCommProperties(HANDLE,LPCOMMPROP);
+WINBASEAPI BOOL WINAPI GetCommState(HANDLE,LPDCB);
+WINBASEAPI BOOL WINAPI GetCommTimeouts(HANDLE,LPCOMMTIMEOUTS);
+WINBASEAPI DWORD WINAPI GetCompressedFileSizeA(LPCSTR,PDWORD);
+WINBASEAPI DWORD WINAPI GetCompressedFileSizeW(LPCWSTR,PDWORD);
+WINBASEAPI BOOL WINAPI GetComputerNameA(LPSTR,PDWORD);
+WINBASEAPI BOOL WINAPI GetComputerNameW(LPWSTR,PDWORD);
+WINBASEAPI BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT,LPSTR,LPDWORD);
+WINBASEAPI BOOL WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT,LPWSTR,LPDWORD);
+WINBASEAPI BOOL WINAPI GetCurrentActCtx(HANDLE*);
+WINBASEAPI DWORD WINAPI GetCurrentDirectoryA(DWORD,LPSTR);
+WINBASEAPI DWORD WINAPI GetCurrentDirectoryW(DWORD,LPWSTR);
+WINBASEAPI BOOL WINAPI GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
+WINBASEAPI BOOL WINAPI GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
+WINBASEAPI HANDLE WINAPI GetCurrentProcess(void);
+WINBASEAPI DWORD WINAPI GetCurrentProcessId(void);
+WINBASEAPI HANDLE WINAPI GetCurrentThread(void);
+WINBASEAPI DWORD WINAPI GetCurrentThreadId(void);
+WINBASEAPI BOOL WINAPI GetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,PDWORD);
+WINBASEAPI BOOL WINAPI GetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,PDWORD);
+WINBASEAPI BOOL WINAPI GetDevicePowerState(HANDLE, BOOL*);
+WINBASEAPI BOOL WINAPI GetDiskFreeSpaceA(LPCSTR,PDWORD,PDWORD,PDWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetDiskFreeSpaceW(LPCWSTR,PDWORD,PDWORD,PDWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExA(LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExW(LPCWSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+WINBASEAPI DWORD WINAPI GetDllDirectoryA(DWORD,LPSTR);
+WINBASEAPI DWORD WINAPI GetDllDirectoryW(DWORD,LPWSTR);
+WINBASEAPI UINT WINAPI GetDriveTypeA(LPCSTR);
+WINBASEAPI UINT WINAPI GetDriveTypeW(LPCWSTR);
+WINBASEAPI LPSTR WINAPI GetEnvironmentStrings(void);
+WINBASEAPI LPSTR WINAPI GetEnvironmentStringsA(void);
+WINBASEAPI LPWSTR WINAPI GetEnvironmentStringsW(void);
+WINBASEAPI DWORD WINAPI GetEnvironmentVariableA(LPCSTR,LPSTR,DWORD);
+WINBASEAPI DWORD WINAPI GetEnvironmentVariableW(LPCWSTR,LPWSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetExitCodeProcess(HANDLE,PDWORD);
+WINBASEAPI BOOL WINAPI GetExitCodeThread(HANDLE,PDWORD);
+WINBASEAPI DWORD WINAPI GetFileAttributesA(LPCSTR);
+WINBASEAPI DWORD WINAPI GetFileAttributesW(LPCWSTR);
+WINBASEAPI BOOL WINAPI GetFileAttributesExA(LPCSTR,GET_FILEEX_INFO_LEVELS,PVOID);
+WINBASEAPI BOOL WINAPI GetFileAttributesExW(LPCWSTR,GET_FILEEX_INFO_LEVELS,PVOID);
+WINBASEAPI BOOL WINAPI GetFileInformationByHandle(HANDLE,LPBY_HANDLE_FILE_INFORMATION);
+WINBASEAPI BOOL WINAPI GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
+WINBASEAPI DWORD WINAPI GetFileSize(HANDLE,PDWORD);
+WINBASEAPI BOOL WINAPI GetFileSizeEx(HANDLE,PLARGE_INTEGER);
+WINBASEAPI BOOL WINAPI GetFileTime(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME);
+WINBASEAPI DWORD WINAPI GetFileType(HANDLE);
+WINBASEAPI DWORD WINAPI GetFullPathNameA(LPCSTR,DWORD,LPSTR,LPSTR*);
+WINBASEAPI DWORD WINAPI GetFullPathNameW(LPCWSTR,DWORD,LPWSTR,LPWSTR*);
+WINBASEAPI BOOL WINAPI GetHandleInformation(HANDLE,PDWORD);
+WINBASEAPI BOOL WINAPI GetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
+WINBASEAPI DWORD WINAPI GetLastError(void);
+WINBASEAPI DWORD WINAPI GetLengthSid(PSID);
+WINBASEAPI void WINAPI GetLocalTime(LPSYSTEMTIME);
+WINBASEAPI DWORD WINAPI GetLogicalDrives(void);
+WINBASEAPI DWORD WINAPI GetLogicalDriveStringsA(DWORD,LPSTR);
+WINBASEAPI DWORD WINAPI GetLogicalDriveStringsW(DWORD,LPWSTR);
+WINBASEAPI DWORD WINAPI GetLongPathNameA(LPCSTR,LPSTR,DWORD);
+WINBASEAPI DWORD WINAPI GetLongPathNameW(LPCWSTR,LPWSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetMailslotInfo(HANDLE,PDWORD,PDWORD,PDWORD,PDWORD);
+WINBASEAPI DWORD WINAPI GetModuleFileNameA(HINSTANCE,LPSTR,DWORD);
+WINBASEAPI DWORD WINAPI GetModuleFileNameW(HINSTANCE,LPWSTR,DWORD);
+WINBASEAPI HMODULE WINAPI GetModuleHandleA(LPCSTR);
+WINBASEAPI HMODULE WINAPI GetModuleHandleW(LPCWSTR);
+WINBASEAPI BOOL WINAPI GetModuleHandleExA(DWORD,LPCSTR,HMODULE*);
+WINBASEAPI BOOL WINAPI GetModuleHandleExW(DWORD,LPCWSTR,HMODULE*);
+WINBASEAPI FARPROC WINAPI GetProcAddress(HINSTANCE,LPCSTR);
+WINBASEAPI BOOL WINAPI GetProcessAffinityMask(HANDLE,PDWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetProcessDEPPolicy (HANDLE, LPDWORD, PBOOL);
+WINBASEAPI BOOL WINAPI GetProcessHandleCount(HANDLE,PDWORD);
+WINBASEAPI HANDLE WINAPI GetProcessHeap(VOID);
+WINBASEAPI DWORD WINAPI GetProcessHeaps(DWORD,PHANDLE);
+WINBASEAPI DWORD WINAPI GetProcessId(HANDLE);
+WINBASEAPI BOOL WINAPI GetProcessIoCounters(HANDLE,PIO_COUNTERS);
+WINBASEAPI BOOL WINAPI GetProcessPriorityBoost(HANDLE,PBOOL);
+WINBASEAPI BOOL WINAPI GetProcessShutdownParameters(PDWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetProcessTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
+WINBASEAPI DWORD WINAPI GetProcessVersion(DWORD);
+WINBASEAPI HWINSTA WINAPI GetProcessWindowStation(void);
+WINBASEAPI BOOL WINAPI GetProcessWorkingSetSize(HANDLE,PSIZE_T,PSIZE_T);
+WINBASEAPI DWORD WINAPI GetShortPathNameA(LPCSTR,LPSTR,DWORD);
+WINBASEAPI DWORD WINAPI GetShortPathNameW(LPCWSTR,LPWSTR,DWORD);
+WINBASEAPI PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
+WINBASEAPI DWORD WINAPI GetSidLengthRequired(UCHAR);
+WINBASEAPI PDWORD WINAPI GetSidSubAuthority(PSID,DWORD);
+WINBASEAPI PUCHAR WINAPI GetSidSubAuthorityCount(PSID);
+WINBASEAPI VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA);
+WINBASEAPI VOID WINAPI GetStartupInfoW(LPSTARTUPINFOW);
+WINBASEAPI HANDLE WINAPI GetStdHandle(DWORD);
+WINBASEAPI UINT WINAPI GetSystemDirectoryA(LPSTR,UINT);
+WINBASEAPI UINT WINAPI GetSystemDirectoryW(LPWSTR,UINT);
+WINBASEAPI VOID WINAPI GetSystemInfo(LPSYSTEM_INFO);
+WINBASEAPI BOOL WINAPI GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
+WINBASEAPI VOID WINAPI GetSystemTime(LPSYSTEMTIME);
+WINBASEAPI BOOL WINAPI GetSystemTimes(LPFILETIME,LPFILETIME,LPFILETIME);
+WINBASEAPI BOOL WINAPI GetSystemTimeAdjustment(PDWORD,PDWORD,PBOOL);
+WINBASEAPI void WINAPI GetSystemTimeAsFileTime(LPFILETIME);
+WINBASEAPI UINT WINAPI GetSystemWindowsDirectoryA(LPSTR,UINT);
+WINBASEAPI UINT WINAPI GetSystemWindowsDirectoryW(LPWSTR,UINT);
+WINBASEAPI UINT WINAPI GetSystemWow64DirectoryA(LPSTR,UINT);
+WINBASEAPI UINT WINAPI GetSystemWow64DirectoryW(LPWSTR,UINT);
+WINBASEAPI DWORD WINAPI GetTapeParameters(HANDLE,DWORD,PDWORD,PVOID);
+WINBASEAPI DWORD WINAPI GetTapePosition(HANDLE,DWORD,PDWORD,PDWORD,PDWORD);
+WINBASEAPI DWORD WINAPI GetTapeStatus(HANDLE);
+WINBASEAPI UINT WINAPI GetTempFileNameA(LPCSTR,LPCSTR,UINT,LPSTR);
+WINBASEAPI UINT WINAPI GetTempFileNameW(LPCWSTR,LPCWSTR,UINT,LPWSTR);
+WINBASEAPI DWORD WINAPI GetTempPathA(DWORD,LPSTR);
+WINBASEAPI DWORD WINAPI GetTempPathW(DWORD,LPWSTR);
+WINBASEAPI BOOL WINAPI GetThreadContext(HANDLE,LPCONTEXT);
+WINBASEAPI BOOL WINAPI GetThreadIOPendingFlag(HANDLE,PBOOL);
+WINBASEAPI int WINAPI GetThreadPriority(HANDLE);
+WINBASEAPI BOOL WINAPI GetThreadPriorityBoost(HANDLE,PBOOL);
+WINBASEAPI BOOL WINAPI GetThreadSelectorEntry(HANDLE,DWORD,LPLDT_ENTRY);
+WINBASEAPI BOOL WINAPI GetThreadTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
+WINBASEAPI DWORD WINAPI GetTickCount(VOID);
+WINBASEAPI DWORD WINAPI GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
+WINBASEAPI BOOL WINAPI GetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,PVOID,DWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetUserNameA (LPSTR,PDWORD);
+WINBASEAPI BOOL WINAPI GetUserNameW(LPWSTR,PDWORD);
+WINBASEAPI DWORD WINAPI GetVersion(void);
+WINBASEAPI BOOL WINAPI GetVersionExA(LPOSVERSIONINFOA);
+WINBASEAPI BOOL WINAPI GetVersionExW(LPOSVERSIONINFOW);
+WINBASEAPI BOOL WINAPI GetVolumeInformationA(LPCSTR,LPSTR,DWORD,PDWORD,PDWORD,PDWORD,LPSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumeInformationW(LPCWSTR,LPWSTR,DWORD,PDWORD,PDWORD,PDWORD,LPWSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumeNameForVolumeMountPointA(LPCSTR,LPSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumeNameForVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumePathNameA(LPCSTR,LPSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumePathNameW(LPCWSTR,LPWSTR,DWORD);
+WINBASEAPI BOOL WINAPI GetVolumePathNamesForVolumeNameA(LPCSTR,LPSTR,DWORD,PDWORD);
+WINBASEAPI BOOL WINAPI GetVolumePathNamesForVolumeNameW(LPCWSTR,LPWSTR,DWORD,PDWORD);
+WINBASEAPI UINT WINAPI GetWindowsDirectoryA(LPSTR,UINT);
+WINBASEAPI UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
+WINBASEAPI DWORD WINAPI GetWindowThreadProcessId(HWND,PDWORD);
+WINBASEAPI UINT WINAPI GetWriteWatch(DWORD,PVOID,SIZE_T,PVOID*,PULONG_PTR,PULONG);
+WINBASEAPI VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
+WINBASEAPI BOOL WINAPI HeapDestroy(HANDLE);
+WINBASEAPI BOOL WINAPI HeapFree(HANDLE,DWORD,PVOID);
+WINBASEAPI BOOL WINAPI InitializeAcl(PACL,DWORD,DWORD);
+WINBASEAPI BOOL WINAPI InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION,DWORD);
+WINBASEAPI BOOL WINAPI IsBadReadPtr(PCVOID,UINT);
+WINBASEAPI BOOL WINAPI IsBadWritePtr(PVOID,UINT);
+WINBASEAPI BOOL WINAPI OpenProcessToken(HANDLE,DWORD,PHANDLE);
+WINBASEAPI BOOL WINAPI QueryPerformanceCounter(PLARGE_INTEGER);
+WINBASEAPI BOOL WINAPI ReadFileEx(HANDLE,PVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
+WINBASEAPI BOOL WINAPI ReadFile(HANDLE,PVOID,DWORD,PDWORD,LPOVERLAPPED);
+WINBASEAPI BOOL WINAPI ReadFileScatter(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
+WINBASEAPI BOOL WINAPI RegisterWaitForSingleObject(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
+WINBASEAPI BOOL WINAPI ResetEvent(HANDLE);
+WINBASEAPI BOOL WINAPI SetEndOfFile(HANDLE);
+WINBASEAPI BOOL WINAPI SetEnvironmentVariableA(LPCSTR,LPCSTR);
+WINBASEAPI BOOL WINAPI SetEvent(HANDLE);
+WINBASEAPI BOOL WINAPI SetFileAttributesA(LPCSTR,DWORD);
+WINBASEAPI BOOL WINAPI SetFilePointerEx(HANDLE,LARGE_INTEGER,PLARGE_INTEGER,DWORD);
+WINBASEAPI BOOL WINAPI SetStdHandle(DWORD,HANDLE);
+WINBASEAPI BOOL WINAPI TerminateProcess(HANDLE,UINT);
+WINBASEAPI BOOL WINAPI TlsFree(DWORD);
+WINBASEAPI BOOL WINAPI TlsSetValue(DWORD,PVOID);
+WINBASEAPI BOOL WINAPI TryEnterCriticalSection(LPCRITICAL_SECTION);
+WINBASEAPI BOOL WINAPI VirtualFreeEx(HANDLE,PVOID,DWORD,DWORD);
+WINBASEAPI BOOL WINAPI VirtualFree(PVOID,DWORD,DWORD);
+WINBASEAPI BOOL WINAPI VirtualProtectEx(HANDLE,PVOID,DWORD,DWORD,PDWORD);
+WINBASEAPI BOOL WINAPI VirtualProtect(PVOID,DWORD,DWORD,PDWORD);
+WINBASEAPI BOOL WINAPI WriteFileEx(HANDLE,PCVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
+WINBASEAPI BOOL WINAPI WriteFileGather(HANDLE,FILE_SEGMENT_ELEMENT*,DWORD,LPDWORD,LPOVERLAPPED);
+WINBASEAPI BOOL WINAPI WriteFile(HANDLE,PCVOID,DWORD,PDWORD,LPOVERLAPPED);
+WINBASEAPI DWORD WINAPI HeapSize(HANDLE,DWORD,PCVOID);
+WINBASEAPI DWORD WINAPI SetFilePointer(HANDLE,LONG,PLONG,DWORD);
+WINBASEAPI DWORD WINAPI SizeofResource(HINSTANCE,HRSRC);
+WINBASEAPI DWORD WINAPI SleepEx(DWORD,BOOL);
+WINBASEAPI DWORD WINAPI TlsAlloc(VOID);
+WINBASEAPI DWORD WINAPI VirtualQueryEx(HANDLE,LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
+WINBASEAPI DWORD WINAPI VirtualQuery(LPCVOID,PMEMORY_BASIC_INFORMATION,DWORD);
+WINBASEAPI DWORD WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
+WINBASEAPI DWORD WINAPI WaitForMultipleObjectsEx(DWORD,const HANDLE*,BOOL,DWORD,BOOL);
+WINBASEAPI DWORD WINAPI WaitForSingleObjectEx(HANDLE,DWORD,BOOL);
+WINBASEAPI DWORD WINAPI WaitForSingleObject(HANDLE,DWORD);
+WINBASEAPI FARPROC WINAPI GetProcAddress(HINSTANCE,LPCSTR);
+WINBASEAPI HANDLE WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
+WINBASEAPI HANDLE WINAPI CreateFileA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
+WINBASEAPI HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,PVOID,DWORD,PDWORD);
+WINBASEAPI HANDLE WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
+WINBASEAPI HANDLE WINAPI GetCurrentProcess(void);
+WINBASEAPI HANDLE WINAPI GetStdHandle(DWORD);
+WINBASEAPI HANDLE WINAPI HeapCreate(DWORD,DWORD,DWORD);
+WINBASEAPI HANDLE WINAPI RegisterWaitForSingleObjectEx(HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
+WINBASEAPI HGLOBAL WINAPI LoadResource(HINSTANCE,HRSRC);
+WINBASEAPI HINSTANCE WINAPI LoadLibraryA(LPCSTR);
+WINBASEAPI HMODULE WINAPI GetModuleHandleA(LPCSTR);
+WINBASEAPI HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
+WINBASEAPI int WINAPI MulDiv(int,int,int);
+WINBASEAPI LONG WINAPI CompareFileTime(CONST FILETIME*,CONST FILETIME*);
+WINBASEAPI LONG WINAPI UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
+WINBASEAPI LPSTR WINAPI GetCommandLineA(VOID);
+WINBASEAPI LPSTR WINAPI GetEnvironmentStringsA(void);
+WINBASEAPI LPSTR WINAPI GetEnvironmentStrings(void);
+WINBASEAPI LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
+WINBASEAPI LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
+WINBASEAPI LPWSTR WINAPI GetEnvironmentStringsW(void);
+WINBASEAPI LPWSTR WINAPI GetEnvironmentStringsW(void);
+WINBASEAPI PVOID WINAPI FreeSid(PSID);
+WINBASEAPI PVOID WINAPI HeapAlloc(HANDLE,DWORD,DWORD);
+WINBASEAPI PVOID WINAPI HeapReAlloc(HANDLE,DWORD,PVOID,DWORD);
+WINBASEAPI PVOID WINAPI LockResource(HGLOBAL);
+WINBASEAPI PVOID WINAPI TlsGetValue(DWORD);
+WINBASEAPI PVOID WINAPI VirtualAllocEx(HANDLE,PVOID,DWORD,DWORD,DWORD);
+WINBASEAPI PVOID WINAPI VirtualAlloc(PVOID,DWORD,DWORD,DWORD);
+WINBASEAPI UINT WINAPI GetDriveTypeA(LPCSTR);
+WINBASEAPI UINT WINAPI GetWindowsDirectoryA(LPSTR,UINT);
+WINBASEAPI UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
+WINBASEAPI UINT WINAPI SetHandleCount(UINT);
+WINBASEAPI void WINAPI DeleteCriticalSection(PCRITICAL_SECTION);
+WINBASEAPI void WINAPI EnterCriticalSection(LPCRITICAL_SECTION);
+WINBASEAPI void WINAPI GetLocalTime(LPSYSTEMTIME);
+WINBASEAPI VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA);
+WINBASEAPI VOID WINAPI GetSystemInfo(LPSYSTEM_INFO);
+WINBASEAPI void WINAPI GetSystemTimeAsFileTime(LPFILETIME);
+WINBASEAPI VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
+WINBASEAPI VOID WINAPI InitializeCriticalSection(LPCRITICAL_SECTION);
+WINBASEAPI void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION);
+WINBASEAPI void WINAPI RaiseException(DWORD,DWORD,DWORD,const DWORD*);
+WINBASEAPI void WINAPI SetLastError(DWORD);
+WINBASEAPI void WINAPI SetLastErrorEx(DWORD,DWORD);
+WINBASEAPI void WINAPI Sleep(DWORD);
+WINGDIAPI BOOL WINAPI DeleteDC(HDC);
+WINGDIAPI BOOL WINAPI DeleteObject(HGDIOBJ);
+WINGDIAPI BOOL WINAPI ExtTextOutA(HDC,int,int,UINT,LPCRECT,LPCSTR,UINT,const INT*);
+WINGDIAPI BOOL WINAPI ExtTextOutA(HDC,int,int,UINT,LPCRECT,LPCSTR,UINT,const INT*);
+WINGDIAPI BOOL WINAPI GetDCOrgEx(HDC,LPPOINT);
+WINGDIAPI BOOL WINAPI GetTextExtentExPointA(HDC,LPCSTR,int,int,LPINT,LPINT,LPSIZE);
+WINGDIAPI BOOL WINAPI GetTextExtentPoint32A(HDC,LPCSTR,int,LPSIZE);
+WINGDIAPI BOOL WINAPI GetTextMetricsA(HDC,LPTEXTMETRICA);
+WINGDIAPI BOOL WINAPI GetWindowExtEx(HDC,LPSIZE);
+WINGDIAPI BOOL WINAPI GetWindowOrgEx(HDC,LPPOINT);
+WINGDIAPI BOOL WINAPI MoveToEx(HDC,int,int,LPPOINT);
+WINGDIAPI BOOL WINAPI PolyTextOutA(HDC,const POLYTEXTA*,int);
+WINGDIAPI BOOL WINAPI Rectangle(HDC,int,int,int,int);
+WINGDIAPI BOOL WINAPI SetRectRgn(HRGN,int,int,int,int);
+WINGDIAPI BOOL WINAPI TextOutA(HDC,int,int,LPCSTR,int);
+WINGDIAPI COLORREF WINAPI GetDCBrushColor(HDC);
+WINGDIAPI COLORREF WINAPI GetDCPenColor(HDC);
+WINGDIAPI COLORREF WINAPI SetBkColor(HDC,COLORREF);
+WINGDIAPI COLORREF WINAPI SetTextColor(HDC,COLORREF);
+WINGDIAPI HBITMAP WINAPI CreateCompatibleBitmap(HDC,int,int);
+WINGDIAPI HDC WINAPI CreateCompatibleDC(HDC);
+WINGDIAPI HFONT WINAPI CreateFontA(int,int,int,int,int,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPCSTR);
+WINGDIAPI HFONT WINAPI CreateFontIndirectA(const LOGFONTA*);
+WINGDIAPI HGDIOBJ WINAPI GetStockObject(int);
+WINGDIAPI HGDIOBJ WINAPI SelectObject(HDC,HGDIOBJ);
+WINGDIAPI int WINAPI GetDeviceCaps(HDC,int);
+WINGDIAPI int WINAPI GetObjectA(HGDIOBJ,int,PVOID);
+WINGDIAPI int WINAPI SetBkMode(HDC,int);
+WINGDIAPI LONG WINAPI GetBitmapBits(HBITMAP,LONG,PVOID);
+WINGDIAPI PROC WINAPI wglGetProcAddress(LPCSTR);
+WINGDIAPI UINT WINAPI GetPaletteEntries(HPALETTE,UINT,UINT,LPPALETTEENTRY);
+WINGDIAPI UINT WINAPI SetTextAlign(HDC,UINT);
+WINBASEAPI BOOL WINAPI GetCPInfoExA(UINT,DWORD,LPCPINFOEXA);
+WINBASEAPI BOOL WINAPI GetCPInfoExW(UINT,DWORD,LPCPINFOEXW);
+WINBASEAPI BOOL WINAPI GetCPInfo(UINT,LPCPINFO);
+WINBASEAPI BOOL WINAPI GetStringTypeA(LCID,DWORD,LPCSTR,int,LPWORD);
+WINBASEAPI BOOL WINAPI GetStringTypeW(DWORD,LPCWSTR,int,LPWORD);
+WINBASEAPI BOOL WINAPI IsDBCSLeadByte(BYTE);
+WINBASEAPI BOOL WINAPI IsDBCSLeadByteEx(UINT,BYTE);
+WINBASEAPI int WINAPI CompareStringA(LCID,DWORD,LPCSTR,int,LPCSTR,int);
+WINBASEAPI int WINAPI CompareStringW(LCID,DWORD,LPCWSTR,int,LPCWSTR,int);
+WINBASEAPI int WINAPI GetDateFormatA(LCID,DWORD,const SYSTEMTIME*,LPCSTR,LPSTR,int);
+WINBASEAPI int WINAPI GetLocaleInfoA(LCID,LCTYPE,LPSTR,int);
+WINBASEAPI int WINAPI GetTimeFormatA(LCID,DWORD,const SYSTEMTIME*,LPCSTR,LPSTR,int);
+WINBASEAPI int WINAPI LCMapStringA(LCID,DWORD,LPCSTR,int,LPSTR,int);
+WINBASEAPI int WINAPI LCMapStringW(LCID,DWORD,LPCWSTR,int,LPWSTR,int);
+WINBASEAPI int WINAPI MultiByteToWideChar(UINT,DWORD,LPCSTR,int,LPWSTR,int);
+WINBASEAPI int WINAPI WideCharToMultiByte(UINT,DWORD,LPCWSTR,int,LPSTR,int,LPCSTR,LPBOOL);
+WINBASEAPI LANGID WINAPI GetUserDefaultLangID(void);
+WINBASEAPI UINT WINAPI GetACP(void);
+WINBASEAPI UINT WINAPI GetOEMCP(void);
+WINADVAPI LONG WINAPI RegDeleteValueA(HKEY,LPCSTR);
+WINADVAPI LONG WINAPI RegOpenKeyExA(HKEY,LPCSTR,DWORD,REGSAM,PHKEY);
+SNMPAPI_STATUS WINSNMPAPI SnmpGetLastError(HSNMP_SESSION);
+WINUSERAPI ATOM WINAPI RegisterClassExA(CONST WNDCLASSEXA*);
+WINUSERAPI BOOL WINAPI AllowSetForegroundWindow(DWORD);
+WINUSERAPI BOOL WINAPI ClientToScreen(HWND,LPPOINT);
+WINUSERAPI BOOL WINAPI ClipCursor(LPCRECT);
+WINUSERAPI BOOL WINAPI DestroyAcceleratorTable(HACCEL);
+WINUSERAPI BOOL WINAPI EnableWindow(HWND,BOOL);
+WINUSERAPI BOOL WINAPI EndDialog(HWND,int);
+WINUSERAPI BOOL WINAPI EndPaint(HWND,const PAINTSTRUCT*);
+WINUSERAPI BOOL WINAPI EnumWindows(WNDENUMPROC,LPARAM);
+WINUSERAPI BOOL WINAPI GetClientRect(HWND,LPRECT);
+WINUSERAPI BOOL WINAPI GetClipCursor(LPRECT);
+WINUSERAPI BOOL WINAPI GetCursorPos(LPPOINT);
+WINUSERAPI BOOL WINAPI GetMessageA(LPMSG,HWND,UINT,UINT);
+WINUSERAPI BOOL WINAPI GetWindowInfo(HWND,PWINDOWINFO);
+WINUSERAPI BOOL WINAPI GetWindowPlacement(HWND,WINDOWPLACEMENT*);
+WINUSERAPI BOOL WINAPI GetWindowRect(HWND,LPRECT);
+WINUSERAPI BOOL WINAPI GetWindowRect(HWND,LPRECT);
+WINUSERAPI BOOL WINAPI InvalidateRect(HWND,LPCRECT,BOOL);
+WINUSERAPI BOOL WINAPI IsIconic(HWND);
+WINUSERAPI BOOL WINAPI KillTimer(HWND,UINT);
+WINUSERAPI BOOL WINAPI LockSetForegroundWindow(UINT);
+WINUSERAPI BOOL WINAPI OffsetRect(LPRECT,int,int);
+WINUSERAPI BOOL WINAPI PeekMessageA(LPMSG,HWND,UINT,UINT,UINT);
+WINUSERAPI BOOL WINAPI PostMessageA(HWND,UINT,WPARAM,LPARAM);
+WINUSERAPI BOOL WINAPI PtInRect(LPCRECT,POINT);
+WINUSERAPI BOOL WINAPI ReleaseCapture(void);
+WINUSERAPI BOOL WINAPI ScreenToClient(HWND,LPPOINT);
+WINUSERAPI BOOL WINAPI SetCursorPos(int,int);
+WINUSERAPI BOOL WINAPI SetCursorPos(int,int);
+WINUSERAPI BOOL WINAPI SetDlgItemTextA(HWND,int,LPCSTR);
+WINUSERAPI BOOL WINAPI SetForegroundWindow(HWND);
+WINUSERAPI BOOL WINAPI SetRectEmpty(LPRECT);
+WINUSERAPI BOOL WINAPI SetRect(LPRECT,int,int,int,int);
+WINUSERAPI BOOL WINAPI SetWindowPos(HWND,HWND,int,int,int,int,UINT);
+WINUSERAPI BOOL WINAPI SetWindowTextA(HWND,LPCSTR);
+WINUSERAPI BOOL WINAPI ShowWindowAsync(HWND,int);
+WINUSERAPI BOOL WINAPI ShowWindow(HWND,int);
+WINUSERAPI BOOL WINAPI TranslateMessage(const MSG*);
+WINUSERAPI BOOL WINAPI UpdateWindow(HWND);
+WINUSERAPI DWORD WINAPI GetSysColor(int);
+WINUSERAPI DWORD WINAPI GetWindowContextHelpId(HWND);
+WINUSERAPI DWORD WINAPI MsgWaitForMultipleObjects(DWORD,CONST HANDLE*,BOOL,DWORD,DWORD);
+WINUSERAPI DWORD WINAPI MsgWaitForMultipleObjectsEx(DWORD,CONST HANDLE*,DWORD,DWORD,DWORD);
+WINUSERAPI DWORD WINAPI WaitForInputIdle(HANDLE,DWORD);
+WINUSERAPI HACCEL WINAPI CreateAcceleratorTableA(LPACCEL,int);
+WINUSERAPI HACCEL WINAPI LoadAcceleratorsA(HINSTANCE,LPCSTR);
+WINUSERAPI HANDLE WINAPI LoadImageA(HINSTANCE,LPCSTR,UINT,int,int,UINT);
+WINUSERAPI HBRUSH WINAPI GetSysColorBrush(int);
+WINUSERAPI HCURSOR WINAPI LoadCursorA(HINSTANCE,LPCSTR);
+WINUSERAPI HCURSOR WINAPI SetCursor(HCURSOR);
+WINUSERAPI HDC WINAPI BeginPaint(HWND,LPPAINTSTRUCT);
+WINUSERAPI HDC WINAPI GetDCEx(HWND,HRGN,DWORD);
+WINUSERAPI HDC WINAPI GetDC(HWND);
+WINUSERAPI HDC WINAPI GetWindowDC(HWND);
+WINUSERAPI HICON WINAPI LoadIconA(HINSTANCE,LPCSTR);
+WINUSERAPI HWND WINAPI CreateWindowExA(DWORD,LPCSTR,LPCSTR,DWORD,int,int,int,int,HWND,HMENU,HINSTANCE,LPVOID);
+WINUSERAPI HWND WINAPI FindWindowA(LPCSTR,LPCSTR);
+WINUSERAPI HWND WINAPI GetActiveWindow(void);
+WINUSERAPI HWND WINAPI GetDesktopWindow(void);
+WINUSERAPI HWND WINAPI GetDlgItem(HWND,int);
+WINUSERAPI HWND WINAPI GetFocus(void);
+WINUSERAPI HWND WINAPI GetForegroundWindow(void);
+WINUSERAPI HWND WINAPI GetLastActivePopup(HWND);
+WINUSERAPI HWND WINAPI GetParent(HWND);
+WINUSERAPI HWND WINAPI GetTopWindow(HWND);
+WINUSERAPI HWND WINAPI GetWindow(HWND,UINT);
+WINUSERAPI HWND WINAPI SetActiveWindow(HWND);
+WINUSERAPI HWND WINAPI SetCapture(HWND hWnd);
+WINUSERAPI HWND WINAPI SetFocus(HWND);
+WINUSERAPI int WINAPI CopyAcceleratorTableA(HACCEL,LPACCEL,int);
+WINUSERAPI int WINAPI DialogBoxParamA(HINSTANCE,LPCSTR,HWND,DLGPROC,LPARAM);
+WINUSERAPI int WINAPI DrawTextA(HDC,LPCSTR,int,LPRECT,UINT);
+WINUSERAPI int WINAPI GetClassNameA(HWND,LPSTR,int);
+WINUSERAPI int WINAPI GetSystemMetrics(int);
+WINUSERAPI int WINAPI GetWindowRgn(HWND,HRGN);
+WINUSERAPI int WINAPI GetWindowTextA(HWND,LPSTR,int);
+WINUSERAPI int WINAPI GetWindowTextLengthA(HWND);
+WINUSERAPI int WINAPI GetWindowTextLengthW(HWND);
+WINUSERAPI int WINAPI GetWindowTextW(HWND,LPWSTR,int);
+WINUSERAPI INT WINAPI InternalGetWindowText(HWND,LPWSTR,INT);
+WINUSERAPI int WINAPI LoadStringA(HINSTANCE,UINT,LPSTR,int);
+WINUSERAPI int WINAPI MessageBoxA(HWND,LPCSTR,LPCSTR,UINT);
+WINUSERAPI int WINAPI ReleaseDC(HWND,HDC);
+WINUSERAPI int WINAPI ShowCursor(BOOL);
+WINUSERAPI int WINAPI TranslateAcceleratorA(HWND,HACCEL,LPMSG);
+WINUSERAPI LONG_PTR WINAPI GetWindowLongPtrA(HWND,int);
+WINUSERAPI LONG_PTR WINAPI GetWindowLongPtrW(HWND,int);
+WINUSERAPI LONG WINAPI DispatchMessageA(const MSG*);
+WINUSERAPI LONG WINAPI GetWindowLongA(HWND,int);
+WINUSERAPI LONG WINAPI GetWindowLongA(HWND,int);
+WINUSERAPI LONG WINAPI GetWindowLongW(HWND,int);
+WINUSERAPI LONG WINAPI SendDlgItemMessageA(HWND,int,UINT,WPARAM,LPARAM);
+WINUSERAPI LONG WINAPI SetWindowLongA(HWND,int,LONG);
+WINUSERAPI LONG WINAPI TabbedTextOutA(HDC,int,int,LPCSTR,int,int,LPINT,int);
+WINUSERAPI LRESULT WINAPI DefWindowProcA(HWND,UINT,WPARAM,LPARAM);
+WINUSERAPI LRESULT WINAPI SendMessageA(HWND,UINT,WPARAM,LPARAM);
+WINUSERAPI SHORT WINAPI GetKeyState(int);
+WINUSERAPI UINT WINAPI GetDlgItemInt(HWND,int,PBOOL,BOOL);
+WINUSERAPI UINT WINAPI GetDlgItemTextA(HWND,int,LPSTR,int);
+WINUSERAPI UINT WINAPI GetDlgItemTextW(HWND,int,LPWSTR,int);
+WINUSERAPI UINT WINAPI GetWindowModuleFileNameA(HWND,LPSTR,UINT);
+WINUSERAPI UINT WINAPI GetWindowModuleFileNameW(HWND,LPWSTR,UINT);
+WINUSERAPI UINT WINAPI RealGetWindowClassA(HWND,LPSTR,UINT);
+WINUSERAPI UINT WINAPI RealGetWindowClassW(HWND,LPWSTR,UINT);
+WINUSERAPI UINT WINAPI SetTimer(HWND,UINT,UINT,TIMERPROC);
+WINUSERAPI WORD WINAPI GetWindowWord(HWND,int);