widl: Prevent NULL pointer de-refs on "void *" types.
[wine] / include / winbase.h
index 121cbe6..fbbbbcd 100644 (file)
 #ifndef __WINE_WINBASE_H
 #define __WINE_WINBASE_H
 
-#ifndef RC_INVOKED
-#include <stdarg.h>
-#endif
-
-#include "basetsd.h"
-#include "windef.h"
-#include "winerror.h"
+#include <winerror.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -145,7 +139,7 @@ typedef struct _OFSTRUCT
     WORD nErrCode;
     WORD Reserved1;
     WORD Reserved2;
-    BYTE szPathName[OFS_MAXPATHNAME];
+    CHAR szPathName[OFS_MAXPATHNAME];
 } OFSTRUCT, *POFSTRUCT, *LPOFSTRUCT;
 
 #define OF_READ               0x0000
@@ -189,7 +183,7 @@ typedef struct _OFSTRUCT
 #define DRIVE_CDROM                5
 #define DRIVE_RAMDISK              6
 
-#define MAX_COMPUTERNAME_LENGTH    31
+#define MAX_COMPUTERNAME_LENGTH    15
 
 /* The security attributes structure */
 typedef struct _SECURITY_ATTRIBUTES
@@ -288,15 +282,15 @@ typedef struct _PROCESS_HEAP_ENTRY
 #define PROCESS_HEAP_ENTRY_MOVEABLE           0x0010
 #define PROCESS_HEAP_ENTRY_DDESHARE           0x0020
 
-#define INVALID_HANDLE_VALUE     ((HANDLE) -1)
-#define INVALID_FILE_SIZE        ((DWORD)0xFFFFFFFF)
-#define INVALID_SET_FILE_POINTER ((DWORD)-1)
-#define INVALID_FILE_ATTRIBUTES  ((DWORD)-1)
+#define INVALID_HANDLE_VALUE     ((HANDLE)~0UL)
+#define INVALID_FILE_SIZE        ((DWORD)~0UL)
+#define INVALID_SET_FILE_POINTER ((DWORD)~0UL)
+#define INVALID_FILE_ATTRIBUTES  ((DWORD)~0UL)
 
 #define LOCKFILE_FAIL_IMMEDIATELY   1
 #define LOCKFILE_EXCLUSIVE_LOCK     2
 
-#define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
+#define TLS_OUT_OF_INDEXES ((DWORD)~0UL)
 
 #define SHUTDOWN_NORETRY 1
 
@@ -356,7 +350,7 @@ typedef struct _PROCESS_HEAP_ENTRY
 
 #define EV_RXCHAR    0x0001
 #define EV_RXFLAG    0x0002
-#define EV_TXEMPT    0x0004
+#define EV_TXEMPTY   0x0004
 #define EV_CTS       0x0008
 #define EV_DSR       0x0010
 #define EV_RLSD      0x0020
@@ -410,8 +404,9 @@ typedef struct _PROCESS_HEAP_ENTRY
 #define LMEM_ZEROINIT       0x0040
 #define LMEM_MODIFY         0x0080
 #define LMEM_DISCARDABLE    0x0F00
-#define LMEM_DISCARDED     0x4000
-#define LMEM_LOCKCOUNT     0x00FF
+#define LMEM_DISCARDED      0x4000
+#define LMEM_INVALID_HANDLE 0x8000
+#define LMEM_LOCKCOUNT      0x00FF
 
 #define LPTR (LMEM_FIXED | LMEM_ZEROINIT)
 #define LHND (LMEM_MOVEABLE | LMEM_ZEROINIT)
@@ -462,17 +457,19 @@ typedef struct tagMEMORYSTATUS
     SIZE_T   dwAvailVirtual;
 } MEMORYSTATUS, *LPMEMORYSTATUS;
 
+#include <pshpack8.h>
 typedef struct tagMEMORYSTATUSEX {
   DWORD dwLength;
   DWORD dwMemoryLoad;
-  DWORDLONG ullTotalPhys;
-  DWORDLONG ullAvailPhys;
-  DWORDLONG ullTotalPageFile;
-  DWORDLONG ullAvailPageFile;
-  DWORDLONG ullTotalVirtual;
-  DWORDLONG ullAvailVirtual;
-  DWORDLONG ullAvailExtendedVirtual;
+  DWORDLONG DECLSPEC_ALIGN(8) ullTotalPhys;
+  DWORDLONG DECLSPEC_ALIGN(8) ullAvailPhys;
+  DWORDLONG DECLSPEC_ALIGN(8) ullTotalPageFile;
+  DWORDLONG DECLSPEC_ALIGN(8) ullAvailPageFile;
+  DWORDLONG DECLSPEC_ALIGN(8) ullTotalVirtual;
+  DWORDLONG DECLSPEC_ALIGN(8) ullAvailVirtual;
+  DWORDLONG DECLSPEC_ALIGN(8) ullAvailExtendedVirtual;
 } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
+#include <poppack.h>
 
 
 typedef struct _SYSTEMTIME{
@@ -489,14 +486,29 @@ typedef struct _SYSTEMTIME{
 /* The 'overlapped' data structure used by async I/O functions.
  */
 typedef struct _OVERLAPPED {
-        DWORD Internal;
-        DWORD InternalHigh;
-        DWORD Offset;
-        DWORD OffsetHigh;
+#ifdef WORDS_BIGENDIAN
+        ULONG_PTR InternalHigh;
+        ULONG_PTR Internal;
+#else
+        ULONG_PTR Internal;
+        ULONG_PTR InternalHigh;
+#endif
+        union {
+            struct {
+#ifdef WORDS_BIGENDIAN
+                DWORD OffsetHigh;
+                DWORD Offset;
+#else
+                DWORD Offset;
+                DWORD OffsetHigh;
+#endif
+            } DUMMYSTRUCTNAME;
+            PVOID Pointer;
+        } DUMMYUNIONNAME;
         HANDLE hEvent;
 } OVERLAPPED, *LPOVERLAPPED;
 
-typedef VOID (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped);
+typedef VOID (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD,DWORD,LPOVERLAPPED);
 
 /* Process startup information.
  */
@@ -591,10 +603,13 @@ typedef struct _TIME_ZONE_INFORMATION{
 #define IDLE_PRIORITY_CLASS         0x00000040
 #define HIGH_PRIORITY_CLASS         0x00000080
 #define REALTIME_PRIORITY_CLASS     0x00000100
+#define BELOW_NORMAL_PRIORITY_CLASS 0x00004000
+#define ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
 #define CREATE_NEW_PROCESS_GROUP    0x00000200
 #define CREATE_UNICODE_ENVIRONMENT  0x00000400
 #define CREATE_SEPARATE_WOW_VDM     0x00000800
 #define CREATE_SHARED_WOW_VDM       0x00001000
+#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
 #define CREATE_DEFAULT_ERROR_MODE   0x04000000
 #define CREATE_NO_WINDOW            0x08000000
 #define PROFILE_USER                0x10000000
@@ -676,7 +691,7 @@ typedef struct _SYSTEM_POWER_STATUS
 } SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS;
 
 
-typedef struct tagSYSTEM_INFO
+typedef struct _SYSTEM_INFO
 {
     union {
        DWORD   dwOemId; /* Obsolete field - do not use */
@@ -696,12 +711,12 @@ typedef struct tagSYSTEM_INFO
     WORD       wProcessorRevision;
 } SYSTEM_INFO, *LPSYSTEM_INFO;
 
-typedef BOOL (CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG);
-typedef BOOL (CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG);
-typedef BOOL (CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG);
-typedef BOOL (CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG);
-typedef BOOL (CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG);
-typedef BOOL (CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG);
+typedef BOOL (CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG_PTR);
+typedef BOOL (CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG_PTR);
+typedef BOOL (CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG_PTR);
+typedef BOOL (CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG_PTR);
+typedef BOOL (CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG_PTR);
+typedef BOOL (CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG_PTR);
 
 DECL_WINELIB_TYPE_AW(ENUMRESTYPEPROC)
 DECL_WINELIB_TYPE_AW(ENUMRESNAMEPROC)
@@ -712,32 +727,7 @@ DECL_WINELIB_TYPE_AW(ENUMRESLANGPROC)
 #define        LOAD_LIBRARY_AS_DATAFILE        0x00000002
 #define        LOAD_WITH_ALTERED_SEARCH_PATH   0x00000008
 
-/* ifdef _x86_ ... */
-typedef struct _LDT_ENTRY {
-    WORD       LimitLow;
-    WORD       BaseLow;
-    union {
-       struct {
-           BYTE        BaseMid;
-           BYTE        Flags1;/*Declare as bytes to avoid alignment problems */
-           BYTE        Flags2;
-           BYTE        BaseHi;
-       } Bytes;
-       struct {
-           unsigned    BaseMid         : 8;
-           unsigned    Type            : 5;
-           unsigned    Dpl             : 2;
-           unsigned    Pres            : 1;
-           unsigned    LimitHi         : 4;
-           unsigned    Sys             : 1;
-           unsigned    Reserved_0      : 1;
-           unsigned    Default_Big     : 1;
-           unsigned    Granularity     : 1;
-           unsigned    BaseHi          : 8;
-       } Bits;
-    } HighWord;
-} LDT_ENTRY, *LPLDT_ENTRY;
-
+typedef PLDT_ENTRY LPLDT_ENTRY;
 
 typedef enum _GET_FILEEX_INFO_LEVELS {
     GetFileExInfoStandard
@@ -777,11 +767,15 @@ typedef DWORD (CALLBACK *LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE
 #define FILE_MAP_WRITE                  0x00000002
 #define FILE_MAP_READ                   0x00000004
 #define FILE_MAP_ALL_ACCESS             0x000f001f
+#define FILE_MAP_EXECUTE                0x00000020
 
 #define MOVEFILE_REPLACE_EXISTING       0x00000001
 #define MOVEFILE_COPY_ALLOWED           0x00000002
 #define MOVEFILE_DELAY_UNTIL_REBOOT     0x00000004
 
+#define REPLACEFILE_WRITE_THROUGH       0x00000001
+#define REPLACEFILE_IGNORE_MERGE_ERRORS 0x00000002
+
 #define FS_CASE_SENSITIVE               FILE_CASE_SENSITIVE_SEARCH
 #define FS_CASE_IS_PRESERVED            FILE_CASE_PRESERVED_NAMES
 #define FS_UNICODE_STORED_ON_DISK       FILE_UNICODE_ON_DISK
@@ -813,9 +807,6 @@ typedef DWORD (CALLBACK *LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE
 #define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
 #define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
 
-#define DUPLICATE_CLOSE_SOURCE         0x00000001
-#define DUPLICATE_SAME_ACCESS          0x00000002
-
 #define HANDLE_FLAG_INHERIT             0x00000001
 #define HANDLE_FLAG_PROTECT_FROM_CLOSE  0x00000002
 
@@ -839,103 +830,108 @@ typedef DWORD (CALLBACK *LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE
 #define        FORMAT_MESSAGE_ARGUMENT_ARRAY   0x00002000
 #define        FORMAT_MESSAGE_MAX_WIDTH_MASK   0x000000FF
 
-#ifdef __WINESRC__
-#define CRITICAL_SECTION_INIT(name) { (void *)(__FILE__ ": " name), -1, 0, 0, 0, 0 }
-#endif
-
-typedef struct {
-       DWORD dwOSVersionInfoSize;
-       DWORD dwMajorVersion;
-       DWORD dwMinorVersion;
-       DWORD dwBuildNumber;
-       DWORD dwPlatformId;
-       CHAR szCSDVersion[128];
-} OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
-
-typedef struct {
-       DWORD dwOSVersionInfoSize;
-       DWORD dwMajorVersion;
-       DWORD dwMinorVersion;
-       DWORD dwBuildNumber;
-       DWORD dwPlatformId;
-       WCHAR szCSDVersion[128];
-} OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW;
-
-DECL_WINELIB_TYPE_AW(OSVERSIONINFO)
-DECL_WINELIB_TYPE_AW(POSVERSIONINFO)
-DECL_WINELIB_TYPE_AW(LPOSVERSIONINFO)
-
-typedef struct {
-       DWORD dwOSVersionInfoSize;
-       DWORD dwMajorVersion;
-       DWORD dwMinorVersion;
-       DWORD dwBuildNumber;
-       DWORD dwPlatformId;
-       CHAR szCSDVersion[128];
-       WORD wServicePackMajor;
-       WORD wServicePackMinor;
-       WORD wSuiteMask;
-       BYTE wProductType;
-       BYTE wReserved;
-} OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
-
-typedef struct {
-       DWORD dwOSVersionInfoSize;
-       DWORD dwMajorVersion;
-       DWORD dwMinorVersion;
-       DWORD dwBuildNumber;
-       DWORD dwPlatformId;
-       WCHAR szCSDVersion[128];
-       WORD wServicePackMajor;
-       WORD wServicePackMinor;
-       WORD wSuiteMask;
-       BYTE wProductType;
-       BYTE wReserved;
-} OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW;
-
-DECL_WINELIB_TYPE_AW(OSVERSIONINFOEX)
-DECL_WINELIB_TYPE_AW(POSVERSIONINFOEX)
-DECL_WINELIB_TYPE_AW(LPOSVERSIONINFOEX)
-
-ULONGLONG WINAPI VerSetConditionMask(ULONGLONG,DWORD,BYTE);
-
-#define VER_SET_CONDITION(_m_,_t_,_c_) ((_m_)=VerSetConditionMask((_m_),(_t_),(_c_)))
-
-#define        VER_PLATFORM_WIN32s                     0
-#define        VER_PLATFORM_WIN32_WINDOWS              1
-#define        VER_PLATFORM_WIN32_NT                   2
-
-#define        VER_MINORVERSION                        0x00000001
-#define        VER_MAJORVERSION                        0x00000002
-#define        VER_BUILDNUMBER                         0x00000004
-#define        VER_PLATFORMID                          0x00000008
-#define        VER_SERVICEPACKMINOR                    0x00000010
-#define        VER_SERVICEPACKMAJOR                    0x00000020
-#define        VER_SUITENAME                           0x00000040
-#define        VER_PRODUCT_TYPE                        0x00000080
-
-#define        VER_NT_WORKSTATION                      1
-#define        VER_NT_DOMAIN_CONTROLLER                2
-#define        VER_NT_SERVER                           3
-
-#define        VER_SUITE_SMALLBUSINESS                 0x00000001
-#define        VER_SUITE_ENTERPRISE                    0x00000002
-#define        VER_SUITE_BACKOFFICE                    0x00000004
-#define        VER_SUITE_COMMUNICATIONS                0x00000008
-#define        VER_SUITE_TERMINAL                      0x00000010
-#define        VER_SUITE_SMALLBUSINESS_RESTRICTED      0x00000020
-#define        VER_SUITE_EMBEDDEDNT                    0x00000040
-#define        VER_SUITE_DATACENTER                    0x00000080
-#define        VER_SUITE_SINGLEUSERTS                  0x00000100
-#define        VER_SUITE_PERSONAL                      0x00000200
-
-#define        VER_EQUAL                               1
-#define        VER_GREATER                             2
-#define        VER_GREATER_EQUAL                       3
-#define        VER_LESS                                4
-#define        VER_LESS_EQUAL                          5
-#define        VER_AND                                 6
-#define        VER_OR                                  7
+/* flags to ACTCTX[AW] */
+#define ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID  (0x00000001)
+#define ACTCTX_FLAG_LANGID_VALID                  (0x00000002)
+#define ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID      (0x00000004)
+#define ACTCTX_FLAG_RESOURCE_NAME_VALID           (0x00000008)
+#define ACTCTX_FLAG_SET_PROCESS_DEFAULT           (0x00000010)
+#define ACTCTX_FLAG_APPLICATION_NAME_VALID        (0x00000020)
+#define ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF         (0x00000040)
+#define ACTCTX_FLAG_HMODULE_VALID                 (0x00000080)
+
+/* flags to DeactiveActCtx */
+#define DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION  (0x00000001)
+
+/* flags to FindActCtxSection{Guid,String[AW]} */
+#define FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX            (0x00000001)
+#define FIND_ACTCTX_SECTION_KEY_RETURN_FLAGS              (0x00000002)
+#define FIND_ACTCTX_SECTION_KEY_RETURN_ASSEMBLY_METADATA  (0x00000004)
+
+/* flags to QueryActCtxW */
+#define QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX  (0x00000004)
+#define QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE  (0x00000008)
+#define QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS  (0x00000010)
+#define QUERY_ACTCTX_FLAG_NO_ADDREF          (0x80000000)
+
+typedef struct tagACTCTXA {
+    ULONG   cbSize;
+    DWORD   dwFlags;
+    LPCSTR  lpSource;
+    USHORT  wProcessorArchitecture;
+    LANGID  wLangId;
+    LPCSTR  lpAssemblyDirectory;
+    LPCSTR  lpResourceName;
+    LPCSTR  lpApplicationName;
+    HMODULE hModule;
+} ACTCTXA, *PACTCTXA;
+
+typedef struct tagACTCTXW {
+    ULONG   cbSize;
+    DWORD   dwFlags;
+    LPCWSTR lpSource;
+    USHORT  wProcessorArchitecture;
+    LANGID  wLangId;
+    LPCWSTR lpAssemblyDirectory;
+    LPCWSTR lpResourceName;
+    LPCWSTR lpApplicationName;
+    HMODULE hModule;
+} ACTCTXW, *PACTCTXW;
+
+DECL_WINELIB_TYPE_AW(ACTCTX)
+DECL_WINELIB_TYPE_AW(PACTCTX)
+
+typedef const ACTCTXA *PCACTCTXA;
+typedef const ACTCTXW *PCACTCTXW;
+DECL_WINELIB_TYPE_AW(PCACTCTX)
+
+typedef struct tagACTCTX_SECTION_KEYED_DATA_2600 {
+    ULONG  cbSize;
+    ULONG  ulDataFormatVersion;
+    PVOID  lpData;
+    ULONG  ulLength;
+    PVOID  lpSectionGlobalData;
+    ULONG  ulSectionGlobalDataLength;
+    PVOID  lpSectionBase;
+    ULONG  ulSectionTotalLength;
+    HANDLE hActCtx;
+    ULONG  ulAssemblyRosterIndex;
+} ACTCTX_SECTION_KEYED_DATA_2600, *PACTCTX_SECTION_KEYED_DATA_2600;
+typedef const ACTCTX_SECTION_KEYED_DATA_2600 *PCACTCTX_SECTION_KEYED_DATA_2600;
+
+typedef struct tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
+    PVOID lpInformation;
+    PVOID lpSectionBase;
+    ULONG ulSectionLength;
+    PVOID lpSectionGlobalDataBase;
+    ULONG ulSectionGlobalDataLength;
+} ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
+typedef const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA *PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
+
+typedef struct tagACTCTX_SECTION_KEYED_DATA {
+    ULONG  cbSize;
+    ULONG  ulDataFormatVersion;
+    PVOID  lpData;
+    ULONG  ulLength;
+    PVOID  lpSectionGlobalData;
+    ULONG  ulSectionGlobalDataLength;
+    PVOID  lpSectionBase;
+    ULONG  ulSectionTotalLength;
+    HANDLE hActCtx;
+    ULONG  ulAssemblyRosterIndex;
+
+    /* Non 2600 extra fields */
+    ULONG ulFlags;
+    ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata;
+} ACTCTX_SECTION_KEYED_DATA, *PACTCTX_SECTION_KEYED_DATA;
+typedef const ACTCTX_SECTION_KEYED_DATA *PCACTCTX_SECTION_KEYED_DATA;
+
+typedef struct _ACTIVATION_CONTEXT_BASIC_INFORMATION {
+    HANDLE hActCtx;
+    DWORD  dwFlags;
+} ACTIVATION_CONTEXT_BASIC_INFORMATION, *PACTIVATION_CONTEXT_BASIC_INFORMATION;
+
+typedef BOOL (WINAPI *PQUERYACTCTXW_FUNC)(DWORD,HANDLE,PVOID,ULONG,PVOID,SIZE_T,SIZE_T *);
 
 typedef struct tagCOMSTAT
 {
@@ -980,6 +976,7 @@ typedef struct tagDCB
     char ErrorChar;
     char EofChar;
     char EvtChar;
+    WORD wReserved1;
 } DCB, *LPDCB;
 
 typedef struct tagCOMMCONFIG {
@@ -1095,6 +1092,11 @@ typedef struct tagCOMMTIMEOUTS {
        DWORD   WriteTotalTimeoutConstant;
 } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
 
+#define GET_TAPE_MEDIA_INFORMATION 0
+#define GET_TAPE_DRIVE_INFORMATION 1
+#define SET_TAPE_MEDIA_INFORMATION 0
+#define SET_TAPE_DRIVE_INFORMATION 1
+
 typedef void (CALLBACK *PAPCFUNC)(ULONG_PTR);
 typedef void (CALLBACK *PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD);
 
@@ -1111,27 +1113,60 @@ typedef enum _COMPUTER_NAME_FORMAT
        ComputerNameMax
 } COMPUTER_NAME_FORMAT;
 
-/*DWORD WINAPI GetVersion( void );*/
-BOOL WINAPI GetVersionExA(OSVERSIONINFOA*);
-BOOL WINAPI GetVersionExW(OSVERSIONINFOW*);
-#define GetVersionEx WINELIB_NAME_AW(GetVersionEx)
+#define HW_PROFILE_GUIDLEN     39
+#define MAX_PROFILE_LEN                80
 
-/*int WinMain(HINSTANCE, HINSTANCE prev, char *cmd, int show);*/
+#define DOCKINFO_UNDOCKED      0x1
+#define DOCKINFO_DOCKED                0x2
+#define DOCKINFO_USER_SUPPLIED 0x4
+#define DOCKINFO_USER_UNDOCKED (DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED)
+#define DOCKINFO_USER_DOCKED   (DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED)
+
+typedef struct tagHW_PROFILE_INFOA {
+    DWORD dwDockInfo;
+    CHAR  szHwProfileGuid[HW_PROFILE_GUIDLEN];
+    CHAR  szHwProfileName[MAX_PROFILE_LEN];
+} HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
+
+typedef struct tagHW_PROFILE_INFOW {
+    DWORD dwDockInfo;
+    WCHAR szHwProfileGuid[HW_PROFILE_GUIDLEN];
+    WCHAR szHwProfileName[MAX_PROFILE_LEN];
+} HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
+
+DECL_WINELIB_TYPE_AW(HW_PROFILE_INFO)
+DECL_WINELIB_TYPE_AW(LPHW_PROFILE_INFO)
+
+/* Stream data structures and defines */
+/*the types of backup data -- WIN32_STREAM_ID.dwStreamId below*/
+#define BACKUP_INVALID        0
+#define BACKUP_DATA           1
+#define BACKUP_EA_DATA        2
+#define BACKUP_SECURITY_DATA  3
+#define BACKUP_ALTERNATE_DATA 4
+#define BACKUP_LINK           5
+#define BACKUP_PROPERTY_DATA  6
+#define BACKUP_OBJECT_ID      7
+#define BACKUP_REPARSE_DATA   8
+#define BACKUP_SPARSE_BLOCK   9
+
+/*flags for WIN32_STREAM_ID.dwStreamAttributes below*/
+#define STREAM_NORMAL_ATTRIBUTE    0
+#define STREAM_MODIFIED_WHEN_READ  1
+#define STREAM_CONTAINS_SECURITY   2
+#define STREAM_CONTAINS_PROPERTIES 4
+#define STREAM_SPARSE_ATTRIBUTE    8
+
+#include <pshpack8.h>
+typedef struct _WIN32_STREAM_ID {
+       DWORD   dwStreamId;
+       DWORD   dwStreamAttributes;
+       LARGE_INTEGER DECLSPEC_ALIGN(8) Size;
+       DWORD   dwStreamNameSize;
+       WCHAR   cStreamName[ANYSIZE_ARRAY];
+} WIN32_STREAM_ID, *LPWIN32_STREAM_ID;
+#include <poppack.h>
 
-void        WINAPI InitializeCriticalSection(CRITICAL_SECTION *lpCrit);
-BOOL        WINAPI InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION *,DWORD);
-void        WINAPI DeleteCriticalSection(CRITICAL_SECTION *lpCrit);
-void        WINAPI EnterCriticalSection(CRITICAL_SECTION *lpCrit);
-BOOL        WINAPI TryEnterCriticalSection(CRITICAL_SECTION *lpCrit);
-void        WINAPI LeaveCriticalSection(CRITICAL_SECTION *lpCrit);
-void        WINAPI MakeCriticalSectionGlobal(CRITICAL_SECTION *lpCrit);
-BOOL        WINAPI GetProcessWorkingSetSize(HANDLE,PSIZE_T,PSIZE_T);
-DWORD       WINAPI QueueUserAPC(PAPCFUNC,HANDLE,ULONG_PTR);
-void        WINAPI RaiseException(DWORD,DWORD,DWORD,const LPDWORD);
-BOOL        WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
-BOOL        WINAPI TerminateProcess(HANDLE,DWORD);
-BOOL        WINAPI TerminateThread(HANDLE,DWORD);
-BOOL        WINAPI GetExitCodeThread(HANDLE,LPDWORD);
 
 /* GetBinaryType return values.
  */
@@ -1142,20 +1177,41 @@ BOOL        WINAPI GetExitCodeThread(HANDLE,LPDWORD);
 #define SCS_PIF_BINARY      3
 #define SCS_POSIX_BINARY    4
 #define SCS_OS216_BINARY    5
+#define SCS_64BIT_BINARY    6
 
-BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
-BOOL WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType );
-#define GetBinaryType WINELIB_NAME_AW(GetBinaryType)
-
-/* Declarations for functions that exist only in Win32 */
+/* flags for DefineDosDevice */
+#define DDD_RAW_TARGET_PATH         0x00000001
+#define DDD_REMOVE_DEFINITION       0x00000002
+#define DDD_EXACT_MATCH_ON_REMOVE   0x00000004
+#define DDD_NO_BROADCAST_SYSTEM     0x00000008
+#define DDD_LUID_BROADCAST_DRIVE    0x00000010
 
+BOOL        WINAPI ActivateActCtx(HANDLE,ULONG_PTR *);
 BOOL        WINAPI AddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
+BOOL        WINAPI AddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
+BOOL        WINAPI AddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
+BOOL        WINAPI AddAccessDeniedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
+BOOL        WINAPI AddAce(PACL,DWORD,DWORD,LPVOID,DWORD);
+ATOM        WINAPI AddAtomA(LPCSTR);
+ATOM        WINAPI AddAtomW(LPCWSTR);
+#define     AddAtom WINELIB_NAME_AW(AddAtom)
+BOOL        WINAPI AddAuditAccessAce(PACL,DWORD,DWORD,PSID,BOOL,BOOL);
+VOID        WINAPI AddRefActCtx(HANDLE);
+PVOID       WINAPI AddVectoredExceptionHandler(ULONG,PVECTORED_EXCEPTION_HANDLER);
+BOOL        WINAPI AdjustTokenGroups(HANDLE,BOOL,PTOKEN_GROUPS,DWORD,PTOKEN_GROUPS,PDWORD);
 BOOL        WINAPI AttachThreadInput(DWORD,DWORD,BOOL);
 BOOL        WINAPI AccessCheck(PSECURITY_DESCRIPTOR,HANDLE,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,LPDWORD,LPDWORD,LPBOOL);
+BOOL        WINAPI AccessCheckAndAuditAlarmA(LPCSTR,LPVOID,LPSTR,LPSTR,PSECURITY_DESCRIPTOR,DWORD,PGENERIC_MAPPING,BOOL,LPDWORD,LPBOOL,LPBOOL);
+BOOL        WINAPI AccessCheckAndAuditAlarmW(LPCWSTR,LPVOID,LPWSTR,LPWSTR,PSECURITY_DESCRIPTOR,DWORD,PGENERIC_MAPPING,BOOL,LPDWORD,LPBOOL,LPBOOL);
+#define     AccessCheckAndAuditAlarm WINELIB_NAME_AW(AccessCheckAndAuditAlarm)
+BOOL        WINAPI AccessCheckByType(PSECURITY_DESCRIPTOR,PSID,HANDLE,DWORD,POBJECT_TYPE_LIST,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,LPDWORD,LPDWORD,LPBOOL);
 BOOL        WINAPI AdjustTokenPrivileges(HANDLE,BOOL,LPVOID,DWORD,LPVOID,LPDWORD);
 BOOL        WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
 BOOL        WINAPI AllocateLocallyUniqueId(PLUID);
+BOOL        WINAPI AreAllAccessesGranted(DWORD,DWORD);
+BOOL        WINAPI AreAnyAccessesGranted(DWORD,DWORD);
 BOOL        WINAPI AreFileApisANSI(void);
+BOOL        WINAPI AssignProcessToJobObject(HANDLE,HANDLE);
 BOOL        WINAPI BackupEventLogA(HANDLE,LPCSTR);
 BOOL        WINAPI BackupEventLogW(HANDLE,LPCWSTR);
 #define     BackupEventLog WINELIB_NAME_AW(BackupEventLog)
@@ -1163,12 +1219,19 @@ BOOL        WINAPI BackupRead(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
 BOOL        WINAPI BackupSeek(HANDLE,DWORD,DWORD,LPDWORD,LPDWORD,LPVOID*);
 BOOL        WINAPI BackupWrite(HANDLE,LPBYTE,DWORD,LPDWORD,BOOL,BOOL,LPVOID*);
 BOOL        WINAPI Beep(DWORD,DWORD);
+HANDLE      WINAPI BeginUpdateResourceA(LPCSTR,BOOL);
+HANDLE      WINAPI BeginUpdateResourceW(LPCWSTR,BOOL);
+#define     BeginUpdateResource WINELIB_NAME_AW(BeginUpdateResource)
+BOOL        WINAPI BindIoCompletionCallback(HANDLE,LPOVERLAPPED_COMPLETION_ROUTINE,ULONG);
 BOOL        WINAPI BuildCommDCBA(LPCSTR,LPDCB);
 BOOL        WINAPI BuildCommDCBW(LPCWSTR,LPDCB);
 #define     BuildCommDCB WINELIB_NAME_AW(BuildCommDCB)
 BOOL        WINAPI BuildCommDCBAndTimeoutsA(LPCSTR,LPDCB,LPCOMMTIMEOUTS);
 BOOL        WINAPI BuildCommDCBAndTimeoutsW(LPCWSTR,LPDCB,LPCOMMTIMEOUTS);
 #define     BuildCommDCBAndTimeouts WINELIB_NAME_AW(BuildCommDCBAndTimeouts)
+BOOL        WINAPI CallNamedPipeA(LPCSTR,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,DWORD);
+BOOL        WINAPI CallNamedPipeW(LPCWSTR,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,DWORD);
+#define     CallNamedPipe WINELIB_NAME_AW(CallNamedPipe)
 BOOL        WINAPI CancelIo(HANDLE);
 BOOL        WINAPI CancelWaitableTimer(HANDLE);
 BOOL        WINAPI CheckTokenMembership(HANDLE,PSID,PBOOL);
@@ -1179,8 +1242,8 @@ BOOL        WINAPI ClearEventLogW(HANDLE,LPCWSTR);
 #define     ClearEventLog WINELIB_NAME_AW(ClearEventLog)
 BOOL        WINAPI CloseEventLog(HANDLE);
 BOOL        WINAPI CloseHandle(HANDLE);
-BOOL        WINAPI CommConfigDialogA(LPCSTR,HANDLE,LPCOMMCONFIG);
-BOOL        WINAPI CommConfigDialogW(LPCWSTR,HANDLE,LPCOMMCONFIG);
+BOOL        WINAPI CommConfigDialogA(LPCSTR,HWND,LPCOMMCONFIG);
+BOOL        WINAPI CommConfigDialogW(LPCWSTR,HWND,LPCOMMCONFIG);
 #define     CommConfigDialog WINELIB_NAME_AW(CommConfigDialog)
 BOOL        WINAPI ConnectNamedPipe(HANDLE,LPOVERLAPPED);
 BOOL        WINAPI ContinueDebugEvent(DWORD,DWORD,DWORD);
@@ -1196,6 +1259,15 @@ INT         WINAPI CompareFileTime(const FILETIME*,const FILETIME*);
 BOOL        WINAPI ConvertFiberToThread(void);
 LPVOID      WINAPI ConvertThreadToFiber(LPVOID);
 LPVOID      WINAPI ConvertThreadToFiberEx(LPVOID,DWORD);
+HANDLE      WINAPI CreateActCtxA(PCACTCTXA);
+HANDLE      WINAPI CreateActCtxW(PCACTCTXW);
+#define     CreateActCtx WINELIB_NAME_AW(CreateActCtx)
+BOOL        WINAPI CreateDirectoryA(LPCSTR,LPSECURITY_ATTRIBUTES);
+BOOL        WINAPI CreateDirectoryW(LPCWSTR,LPSECURITY_ATTRIBUTES);
+#define     CreateDirectory WINELIB_NAME_AW(CreateDirectory)
+BOOL        WINAPI CreateDirectoryExA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
+BOOL        WINAPI CreateDirectoryExW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
+#define     CreateDirectoryEx WINELIB_NAME_AW(CreateDirectoryEx)
 HANDLE      WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
 HANDLE      WINAPI CreateEventW(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCWSTR);
 #define     CreateEvent WINELIB_NAME_AW(CreateEvent)
@@ -1207,6 +1279,13 @@ HANDLE      WINAPI CreateFileW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,D
 HANDLE      WINAPI CreateFileMappingA(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCSTR);
 HANDLE      WINAPI CreateFileMappingW(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCWSTR);
 #define     CreateFileMapping WINELIB_NAME_AW(CreateFileMapping)
+HANDLE      WINAPI CreateIoCompletionPort(HANDLE,HANDLE,ULONG_PTR,DWORD);
+HANDLE      WINAPI CreateJobObjectA(LPSECURITY_ATTRIBUTES,LPCSTR);
+HANDLE      WINAPI CreateJobObjectW(LPSECURITY_ATTRIBUTES,LPCWSTR);
+#define     CreateJobObject WINELIB_NAME_AW(CreateJobObject)
+HANDLE      WINAPI CreateMailslotA(LPCSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
+HANDLE      WINAPI CreateMailslotW(LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
+#define     CreateMailslot WINELIB_NAME_AW(CreateMailslot)
 HANDLE      WINAPI CreateMutexA(LPSECURITY_ATTRIBUTES,BOOL,LPCSTR);
 HANDLE      WINAPI CreateMutexW(LPSECURITY_ATTRIBUTES,BOOL,LPCWSTR);
 #define     CreateMutex WINELIB_NAME_AW(CreateMutex)
@@ -1214,6 +1293,8 @@ HANDLE      WINAPI CreateNamedPipeA(LPCSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,L
 HANDLE      WINAPI CreateNamedPipeW(LPCWSTR,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,LPSECURITY_ATTRIBUTES);
 #define     CreateNamedPipe WINELIB_NAME_AW(CreateNamedPipe)
 BOOL        WINAPI CreatePipe(PHANDLE,PHANDLE,LPSECURITY_ATTRIBUTES,DWORD);
+BOOL        WINAPI CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,
+                                               PSECURITY_DESCRIPTOR*,BOOL,HANDLE,PGENERIC_MAPPING);
 BOOL        WINAPI CreateProcessA(LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,
                                   LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCSTR,
                                   LPSTARTUPINFOA,LPPROCESS_INFORMATION);
@@ -1221,6 +1302,11 @@ BOOL        WINAPI CreateProcessW(LPCWSTR,LPWSTR,LPSECURITY_ATTRIBUTES,
                                   LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCWSTR,
                                   LPSTARTUPINFOW,LPPROCESS_INFORMATION);
 #define     CreateProcess WINELIB_NAME_AW(CreateProcess)
+BOOL        WINAPI CreateProcessAsUserA(HANDLE,LPCSTR,LPSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,
+                                        BOOL,DWORD,LPVOID,LPCSTR,LPSTARTUPINFOA,LPPROCESS_INFORMATION);
+BOOL        WINAPI CreateProcessAsUserW(HANDLE,LPCWSTR,LPWSTR,LPSECURITY_ATTRIBUTES,LPSECURITY_ATTRIBUTES,
+                                        BOOL,DWORD,LPVOID,LPCWSTR,LPSTARTUPINFOW,LPPROCESS_INFORMATION);
+#define     CreateProcessAsUser WINELIB_NAME_AW(CreateProcessAsUser)
 HANDLE      WINAPI CreateRemoteThread(HANDLE,LPSECURITY_ATTRIBUTES,SIZE_T,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
 HANDLE      WINAPI CreateSemaphoreA(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCSTR);
 HANDLE      WINAPI CreateSemaphoreW(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCWSTR);
@@ -1232,15 +1318,33 @@ BOOL        WINAPI CreateTimerQueueTimer(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOI
 HANDLE      WINAPI CreateWaitableTimerA(LPSECURITY_ATTRIBUTES,BOOL,LPCSTR);
 HANDLE      WINAPI CreateWaitableTimerW(LPSECURITY_ATTRIBUTES,BOOL,LPCWSTR);
 #define     CreateWaitableTimer WINELIB_NAME_AW(CreateWaitableTimer)
+BOOL        WINAPI DeactivateActCtx(DWORD,ULONG_PTR);
 BOOL        WINAPI DebugActiveProcess(DWORD);
 BOOL        WINAPI DebugActiveProcessStop(DWORD);
 void        WINAPI DebugBreak(void);
 BOOL        WINAPI DebugBreakProcess(HANDLE);
 BOOL        WINAPI DebugSetProcessKillOnExit(BOOL);
+BOOL        WINAPI DecryptFileA(LPCSTR,DWORD);
+BOOL        WINAPI DecryptFileW(LPCWSTR,DWORD);
+#define     DecryptFile WINELIB_NAME_AW(DecryptFile)
+BOOL        WINAPI DefineDosDeviceA(DWORD,LPCSTR,LPCSTR);
+BOOL        WINAPI DefineDosDeviceW(DWORD,LPCWSTR,LPCWSTR);
+#define     DefineDosDevice WINELIB_NAME_AW(DefineDosDevice)
+#define     DefineHandleTable(w) ((w),TRUE)
+BOOL        WINAPI DeleteAce(PACL,DWORD);
+ATOM        WINAPI DeleteAtom(ATOM);
+void        WINAPI DeleteCriticalSection(CRITICAL_SECTION *lpCrit);
 void        WINAPI DeleteFiber(LPVOID);
+BOOL        WINAPI DeleteFileA(LPCSTR);
+BOOL        WINAPI DeleteFileW(LPCWSTR);
+#define     DeleteFile WINELIB_NAME_AW(DeleteFile)
 BOOL        WINAPI DeleteTimerQueueEx(HANDLE,HANDLE);
 BOOL        WINAPI DeleteTimerQueueTimer(HANDLE,HANDLE,HANDLE);
+BOOL        WINAPI DeleteVolumeMountPointA(LPCSTR);
+BOOL        WINAPI DeleteVolumeMountPointW(LPCWSTR);
+#define     DeleteVolumeMountPoint WINELIB_NAME_AW(DeleteVolumeMountPoint)
 BOOL        WINAPI DeregisterEventSource(HANDLE);
+BOOL        WINAPI DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
 BOOL        WINAPI DeviceIoControl(HANDLE,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPOVERLAPPED);
 BOOL        WINAPI DisableThreadLibraryCalls(HMODULE);
 BOOL        WINAPI DisconnectNamedPipe(HANDLE);
@@ -1249,15 +1353,25 @@ BOOL        WINAPI DnsHostnameToComputerNameW(LPCWSTR,LPWSTR,LPDWORD);
 #define     DnsHostnameToComputerName WINELIB_NAME_AW(DnsHostnameToComputerName)
 BOOL        WINAPI DosDateTimeToFileTime(WORD,WORD,LPFILETIME);
 BOOL        WINAPI DuplicateHandle(HANDLE,HANDLE,HANDLE,HANDLE*,DWORD,BOOL,DWORD);
+BOOL        WINAPI DuplicateToken(HANDLE,SECURITY_IMPERSONATION_LEVEL,PHANDLE);
+BOOL        WINAPI DuplicateTokenEx(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,
+                                    TOKEN_TYPE,PHANDLE);
 BOOL        WINAPI EscapeCommFunction(HANDLE,UINT);
-BOOL        WINAPI EnumResourceLanguagesA(HMODULE,LPCSTR,LPCSTR,ENUMRESLANGPROCA,LONG);
-BOOL        WINAPI EnumResourceLanguagesW(HMODULE,LPCWSTR,LPCWSTR,ENUMRESLANGPROCW,LONG);
+BOOL        WINAPI EncryptFileA(LPCSTR);
+BOOL        WINAPI EncryptFileW(LPCWSTR);
+#define     EncryptFile WINELIB_NAME_AW(EncryptFile)
+BOOL        WINAPI EndUpdateResourceA(HANDLE,BOOL);
+BOOL        WINAPI EndUpdateResourceW(HANDLE,BOOL);
+#define     EndUpdateResource WINELIB_NAME_AW(EndUpdateResource)
+void        WINAPI EnterCriticalSection(CRITICAL_SECTION *lpCrit);
+BOOL        WINAPI EnumResourceLanguagesA(HMODULE,LPCSTR,LPCSTR,ENUMRESLANGPROCA,LONG_PTR);
+BOOL        WINAPI EnumResourceLanguagesW(HMODULE,LPCWSTR,LPCWSTR,ENUMRESLANGPROCW,LONG_PTR);
 #define     EnumResourceLanguages WINELIB_NAME_AW(EnumResourceLanguages)
-BOOL        WINAPI EnumResourceNamesA(HMODULE,LPCSTR,ENUMRESNAMEPROCA,LONG);
-BOOL        WINAPI EnumResourceNamesW(HMODULE,LPCWSTR,ENUMRESNAMEPROCW,LONG);
+BOOL        WINAPI EnumResourceNamesA(HMODULE,LPCSTR,ENUMRESNAMEPROCA,LONG_PTR);
+BOOL        WINAPI EnumResourceNamesW(HMODULE,LPCWSTR,ENUMRESNAMEPROCW,LONG_PTR);
 #define     EnumResourceNames WINELIB_NAME_AW(EnumResourceNames)
-BOOL        WINAPI EnumResourceTypesA(HMODULE,ENUMRESTYPEPROCA,LONG);
-BOOL        WINAPI EnumResourceTypesW(HMODULE,ENUMRESTYPEPROCW,LONG);
+BOOL        WINAPI EnumResourceTypesA(HMODULE,ENUMRESTYPEPROCA,LONG_PTR);
+BOOL        WINAPI EnumResourceTypesW(HMODULE,ENUMRESTYPEPROCW,LONG_PTR);
 #define     EnumResourceTypes WINELIB_NAME_AW(EnumResourceTypes)
 BOOL        WINAPI EqualSid(PSID, PSID);
 BOOL        WINAPI EqualPrefixSid(PSID,PSID);
@@ -1267,18 +1381,58 @@ VOID DECLSPEC_NORETURN WINAPI ExitThread(DWORD);
 DWORD       WINAPI ExpandEnvironmentStringsA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI ExpandEnvironmentStringsW(LPCWSTR,LPWSTR,DWORD);
 #define     ExpandEnvironmentStrings WINELIB_NAME_AW(ExpandEnvironmentStrings)
+void        WINAPI FatalAppExitA(UINT,LPCSTR);
+void        WINAPI FatalAppExitW(UINT,LPCWSTR);
+void        WINAPI FatalExit(int);
+#define     FatalAppExit WINELIB_NAME_AW(FatalAppExit)
 BOOL        WINAPI FileTimeToDosDateTime(const FILETIME*,LPWORD,LPWORD);
 BOOL        WINAPI FileTimeToLocalFileTime(const FILETIME*,LPFILETIME);
 BOOL        WINAPI FileTimeToSystemTime(const FILETIME*,LPSYSTEMTIME);
+BOOL        WINAPI FindActCtxSectionStringA(DWORD,const GUID *,ULONG,LPCSTR,PACTCTX_SECTION_KEYED_DATA);
+BOOL        WINAPI FindActCtxSectionStringW(DWORD,const GUID *,ULONG,LPCWSTR,PACTCTX_SECTION_KEYED_DATA);
+#define     FindActCtxSectionString WINELIB_NAME_AW(FindActCtxSectionString)
+BOOL        WINAPI FindActCtxSectionGuid(DWORD,const GUID *,ULONG,const GUID *,PACTCTX_SECTION_KEYED_DATA);
+ATOM        WINAPI FindAtomA(LPCSTR);
+ATOM        WINAPI FindAtomW(LPCWSTR);
+#define     FindAtom WINELIB_NAME_AW(FindAtom)
+BOOL        WINAPI FindClose(HANDLE);
 HANDLE      WINAPI FindFirstChangeNotificationA(LPCSTR,BOOL,DWORD);
 HANDLE      WINAPI FindFirstChangeNotificationW(LPCWSTR,BOOL,DWORD);
 #define     FindFirstChangeNotification WINELIB_NAME_AW(FindFirstChangeNotification)
+HANDLE      WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
+HANDLE      WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
+#define     FindFirstFile WINELIB_NAME_AW(FindFirstFile)
+HANDLE      WINAPI FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
+HANDLE      WINAPI FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
+#define     FindFirstFileEx WINELIB_NAME_AW(FindFirstFileEx)
+BOOL        WINAPI FindFirstFreeAce(PACL,LPVOID*);
 BOOL        WINAPI FindNextChangeNotification(HANDLE);
+BOOL        WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
+BOOL        WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
+#define     FindNextFile WINELIB_NAME_AW(FindNextFile)
 BOOL        WINAPI FindCloseChangeNotification(HANDLE);
+HRSRC       WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
+HRSRC       WINAPI FindResourceW(HMODULE,LPCWSTR,LPCWSTR);
+#define     FindResource WINELIB_NAME_AW(FindResource)
 HRSRC       WINAPI FindResourceExA(HMODULE,LPCSTR,LPCSTR,WORD);
 HRSRC       WINAPI FindResourceExW(HMODULE,LPCWSTR,LPCWSTR,WORD);
 #define     FindResourceEx WINELIB_NAME_AW(FindResourceEx)
+HANDLE      WINAPI FindFirstVolumeA(LPSTR,DWORD);
+HANDLE      WINAPI FindFirstVolumeW(LPWSTR,DWORD);
+#define     FindFirstVolume WINELIB_NAME_AW(FindFirstVolume)
+HANDLE      WINAPI FindFirstVolumeMountPointA(LPCSTR,LPSTR,DWORD);
+HANDLE      WINAPI FindFirstVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
+#define     FindFirstVolumeMountPoint WINELIB_NAME_AW(FindFirstVolumeMountPoint)
+BOOL        WINAPI FindNextVolumeA(HANDLE,LPSTR,DWORD);
+BOOL        WINAPI FindNextVolumeW(HANDLE,LPWSTR,DWORD);
+#define     FindNextVolume WINELIB_NAME_AW(FindNextVolume)
+BOOL        WINAPI FindNextVolumeMountPointA(HANDLE,LPSTR,DWORD);
+BOOL        WINAPI FindNextVolumeMountPointW(HANDLE,LPWSTR,DWORD);
+#define     FindNextVolumeMountPoint WINELIB_NAME_AW(FindNextVolumeMountPoint)
+BOOL        WINAPI FindVolumeClose(HANDLE);
+BOOL        WINAPI FindVolumeMountPointClose(HANDLE);
 BOOL        WINAPI FlushFileBuffers(HANDLE);
+BOOL        WINAPI FlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
 BOOL        WINAPI FlushViewOfFile(LPCVOID,SIZE_T);
 DWORD       WINAPI FormatMessageA(DWORD,LPCVOID,DWORD,DWORD,LPSTR,DWORD,va_list*);
 DWORD       WINAPI FormatMessageW(DWORD,LPCVOID,DWORD,DWORD,LPWSTR,DWORD,va_list*);
@@ -1286,8 +1440,21 @@ DWORD       WINAPI FormatMessageW(DWORD,LPCVOID,DWORD,DWORD,LPWSTR,DWORD,va_list
 BOOL        WINAPI FreeEnvironmentStringsA(LPSTR);
 BOOL        WINAPI FreeEnvironmentStringsW(LPWSTR);
 #define     FreeEnvironmentStrings WINELIB_NAME_AW(FreeEnvironmentStrings)
+BOOL        WINAPI FreeLibrary(HMODULE);
 VOID        WINAPI FreeLibraryAndExitThread(HINSTANCE,DWORD);
+#define     FreeModule(handle) FreeLibrary(handle)
+#define     FreeProcInstance(proc) /*nothing*/
+BOOL        WINAPI FreeResource(HGLOBAL);
 PVOID       WINAPI FreeSid(PSID);
+BOOL        WINAPI GetAce(PACL,DWORD,LPVOID*);
+BOOL        WINAPI GetAclInformation(PACL,LPVOID,DWORD,ACL_INFORMATION_CLASS);
+UINT        WINAPI GetAtomNameA(ATOM,LPSTR,INT);
+UINT        WINAPI GetAtomNameW(ATOM,LPWSTR,INT);
+#define     GetAtomName WINELIB_NAME_AW(GetAtomName)
+BOOL        WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
+BOOL        WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType );
+#define     GetBinaryType WINELIB_NAME_AW(GetBinaryType)
+BOOL        WINAPI GetCurrentActCtx(HANDLE *);
 BOOL        WINAPI GetCommConfig(HANDLE,LPCOMMCONFIG,LPDWORD);
 BOOL        WINAPI GetCommMask(HANDLE,LPDWORD);
 BOOL        WINAPI GetCommModemStatus(HANDLE,LPDWORD);
@@ -1306,21 +1473,46 @@ BOOL        WINAPI GetComputerNameW(LPWSTR,LPDWORD);
 BOOL        WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT,LPSTR,LPDWORD);
 BOOL        WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT,LPWSTR,LPDWORD);
 #define     GetComputerNameEx WINELIB_NAME_AW(GetComputerNameEx)
+UINT        WINAPI GetCurrentDirectoryA(UINT,LPSTR);
+UINT        WINAPI GetCurrentDirectoryW(UINT,LPWSTR);
+#define     GetCurrentDirectory WINELIB_NAME_AW(GetCurrentDirectory)
+BOOL        WINAPI GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
+BOOL        WINAPI GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
+#define     GetCurrentHwProfile WINELIB_NAME_AW(GetCurrentHwProfile)
 HANDLE      WINAPI GetCurrentProcess(void);
 HANDLE      WINAPI GetCurrentThread(void);
+#define     GetCurrentTime() GetTickCount()
 BOOL        WINAPI GetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,LPDWORD);
 BOOL        WINAPI GetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,LPDWORD);
 #define     GetDefaultCommConfig WINELIB_NAME_AW(GetDefaultCommConfig)
+BOOL        WINAPI GetDevicePowerState(HANDLE,BOOL*);
+BOOL        WINAPI GetDiskFreeSpaceA(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
+BOOL        WINAPI GetDiskFreeSpaceW(LPCWSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
+#define     GetDiskFreeSpace WINELIB_NAME_AW(GetDiskFreeSpace)
+BOOL        WINAPI GetDiskFreeSpaceExA(LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+BOOL        WINAPI GetDiskFreeSpaceExW(LPCWSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+#define     GetDiskFreeSpaceEx WINELIB_NAME_AW(GetDiskFreeSpaceEx)
+DWORD       WINAPI GetDllDirectoryA(DWORD,LPSTR);
+DWORD       WINAPI GetDllDirectoryW(DWORD,LPWSTR);
+#define     GetDllDirectory WINELIB_NAME_AW(GetDllDirectory)
+UINT        WINAPI GetDriveTypeA(LPCSTR);
+UINT        WINAPI GetDriveTypeW(LPCWSTR);
+#define     GetDriveType WINELIB_NAME_AW(GetDriveType)
 LPSTR       WINAPI GetEnvironmentStringsA(void);
 LPWSTR      WINAPI GetEnvironmentStringsW(void);
 #define     GetEnvironmentStrings WINELIB_NAME_AW(GetEnvironmentStrings)
 DWORD       WINAPI GetEnvironmentVariableA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI GetEnvironmentVariableW(LPCWSTR,LPWSTR,DWORD);
 #define     GetEnvironmentVariable WINELIB_NAME_AW(GetEnvironmentVariable)
+BOOL        WINAPI GetExitCodeProcess(HANDLE,LPDWORD);
+BOOL        WINAPI GetExitCodeThread(HANDLE,LPDWORD);
+DWORD       WINAPI GetFileAttributesA(LPCSTR);
+DWORD       WINAPI GetFileAttributesW(LPCWSTR);
+#define     GetFileAttributes WINELIB_NAME_AW(GetFileAttributes)
 BOOL        WINAPI GetFileAttributesExA(LPCSTR,GET_FILEEX_INFO_LEVELS,LPVOID);
 BOOL        WINAPI GetFileAttributesExW(LPCWSTR,GET_FILEEX_INFO_LEVELS,LPVOID);
-#define     GetFileattributesEx WINELIB_NAME_AW(GetFileAttributesEx)
-DWORD       WINAPI GetFileInformationByHandle(HANDLE,BY_HANDLE_FILE_INFORMATION*);
+#define     GetFileAttributesEx WINELIB_NAME_AW(GetFileAttributesEx)
+BOOL        WINAPI GetFileInformationByHandle(HANDLE,BY_HANDLE_FILE_INFORMATION*);
 BOOL        WINAPI GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
 BOOL        WINAPI GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
 #define     GetFileSecurity WINELIB_NAME_AW(GetFileSecurity)
@@ -1328,22 +1520,72 @@ DWORD       WINAPI GetFileSize(HANDLE,LPDWORD);
 BOOL        WINAPI GetFileSizeEx(HANDLE,PLARGE_INTEGER);
 BOOL        WINAPI GetFileTime(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME);
 DWORD       WINAPI GetFileType(HANDLE);
+#define     GetFreeSpace(w) (0x100000L)
 DWORD       WINAPI GetFullPathNameA(LPCSTR,DWORD,LPSTR,LPSTR*);
 DWORD       WINAPI GetFullPathNameW(LPCWSTR,DWORD,LPWSTR,LPWSTR*);
 #define     GetFullPathName WINELIB_NAME_AW(GetFullPathName)
 BOOL        WINAPI GetHandleInformation(HANDLE,LPDWORD);
+BOOL        WINAPI GetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
 DWORD       WINAPI GetLengthSid(PSID);
 VOID        WINAPI GetLocalTime(LPSYSTEMTIME);
 DWORD       WINAPI GetLogicalDrives(void);
+UINT        WINAPI GetLogicalDriveStringsA(UINT,LPSTR);
+UINT        WINAPI GetLogicalDriveStringsW(UINT,LPWSTR);
+#define     GetLogicalDriveStrings WINELIB_NAME_AW(GetLogicalDriveStrings)
 DWORD       WINAPI GetLongPathNameA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI GetLongPathNameW(LPCWSTR,LPWSTR,DWORD);
 #define     GetLongPathName WINELIB_NAME_AW(GetLongPathName)
+BOOL        WINAPI GetMailslotInfo(HANDLE,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
+DWORD       WINAPI GetModuleFileNameA(HMODULE,LPSTR,DWORD);
+DWORD       WINAPI GetModuleFileNameW(HMODULE,LPWSTR,DWORD);
+#define     GetModuleFileName WINELIB_NAME_AW(GetModuleFileName)
+HMODULE     WINAPI GetModuleHandleA(LPCSTR);
+HMODULE     WINAPI GetModuleHandleW(LPCWSTR);
+#define     GetModuleHandle WINELIB_NAME_AW(GetModuleHandle)
+BOOL        WINAPI GetNamedPipeHandleStateA(HANDLE,LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPSTR,DWORD);
+BOOL        WINAPI GetNamedPipeHandleStateW(HANDLE,LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPWSTR,DWORD);
+#define     GetNamedPipeHandleState WINELIB_NAME_AW(GetNamedPipeHandleState)
+BOOL        WINAPI GetNamedPipeInfo(HANDLE,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
 BOOL        WINAPI GetNumberOfEventLogRecords(HANDLE,PDWORD);
 BOOL        WINAPI GetOldestEventLogRecord(HANDLE,PDWORD);
+BOOL        WINAPI GetOverlappedResult(HANDLE,LPOVERLAPPED,LPDWORD,BOOL);
 DWORD       WINAPI GetPriorityClass(HANDLE);
-BOOL        WINAPI GetProcessAffinityMask(HANDLE,PDWORD,PDWORD);
+BOOL        WINAPI GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,PDWORD);
+UINT        WINAPI GetPrivateProfileIntA(LPCSTR,LPCSTR,INT,LPCSTR);
+UINT        WINAPI GetPrivateProfileIntW(LPCWSTR,LPCWSTR,INT,LPCWSTR);
+#define     GetPrivateProfileInt WINELIB_NAME_AW(GetPrivateProfileInt)
+INT         WINAPI GetPrivateProfileSectionA(LPCSTR,LPSTR,DWORD,LPCSTR);
+INT         WINAPI GetPrivateProfileSectionW(LPCWSTR,LPWSTR,DWORD,LPCWSTR);
+#define     GetPrivateProfileSection WINELIB_NAME_AW(GetPrivateProfileSection)
+DWORD       WINAPI GetPrivateProfileSectionNamesA(LPSTR,DWORD,LPCSTR);
+DWORD       WINAPI GetPrivateProfileSectionNamesW(LPWSTR,DWORD,LPCWSTR);
+#define     GetPrivateProfileSectionNames WINELIB_NAME_AW(GetPrivateProfileSectionNames)
+INT         WINAPI GetPrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT,LPCSTR);
+INT         WINAPI GetPrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,UINT,LPCWSTR);
+#define     GetPrivateProfileString WINELIB_NAME_AW(GetPrivateProfileString)
+BOOL        WINAPI GetPrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
+BOOL        WINAPI GetPrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
+#define     GetPrivateProfileStruct WINELIB_NAME_AW(GetPrivateProfileStruct)
+FARPROC     WINAPI GetProcAddress(HMODULE,LPCSTR);
+BOOL        WINAPI GetProcessAffinityMask(HANDLE,PDWORD_PTR,PDWORD_PTR);
+DWORD       WINAPI GetProcessHeaps(DWORD,PHANDLE);
+DWORD       WINAPI GetProcessId(HANDLE);
+BOOL        WINAPI GetProcessIoCounters(HANDLE,PIO_COUNTERS);
+BOOL        WINAPI GetProcessPriorityBoost(HANDLE,PBOOL);
+BOOL        WINAPI GetProcessShutdownParameters(LPDWORD,LPDWORD);
 BOOL        WINAPI GetProcessTimes(HANDLE,LPFILETIME,LPFILETIME,LPFILETIME,LPFILETIME);
 DWORD       WINAPI GetProcessVersion(DWORD);
+BOOL        WINAPI GetProcessWorkingSetSize(HANDLE,PSIZE_T,PSIZE_T);
+UINT        WINAPI GetProfileIntA(LPCSTR,LPCSTR,INT);
+UINT        WINAPI GetProfileIntW(LPCWSTR,LPCWSTR,INT);
+#define     GetProfileInt WINELIB_NAME_AW(GetProfileInt)
+INT         WINAPI GetProfileSectionA(LPCSTR,LPSTR,DWORD);
+INT         WINAPI GetProfileSectionW(LPCWSTR,LPWSTR,DWORD);
+#define     GetProfileSection WINELIB_NAME_AW(GetProfileSection)
+INT         WINAPI GetProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT);
+INT         WINAPI GetProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,UINT);
+#define     GetProfileString WINELIB_NAME_AW(GetProfileString)
+BOOL        WINAPI GetQueuedCompletionStatus(HANDLE,LPDWORD,PULONG_PTR,LPOVERLAPPED*,DWORD);
 BOOL        WINAPI GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
 BOOL        WINAPI GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL *,LPBOOL);
 BOOL        WINAPI GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID *,LPBOOL);
@@ -1357,15 +1599,31 @@ PUCHAR      WINAPI GetSidSubAuthorityCount(PSID);
 DWORD       WINAPI GetShortPathNameA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI GetShortPathNameW(LPCWSTR,LPWSTR,DWORD);
 #define     GetShortPathName WINELIB_NAME_AW(GetShortPathName)
+VOID        WINAPI GetStartupInfoA(LPSTARTUPINFOA);
+VOID        WINAPI GetStartupInfoW(LPSTARTUPINFOW);
+#define     GetStartupInfo WINELIB_NAME_AW(GetStartupInfo)
 HANDLE      WINAPI GetStdHandle(DWORD);
+UINT        WINAPI GetSystemDirectoryA(LPSTR,UINT);
+UINT        WINAPI GetSystemDirectoryW(LPWSTR,UINT);
+#define     GetSystemDirectory WINELIB_NAME_AW(GetSystemDirectory)
 VOID        WINAPI GetSystemInfo(LPSYSTEM_INFO);
 BOOL        WINAPI GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
 VOID        WINAPI GetSystemTime(LPSYSTEMTIME);
 BOOL        WINAPI GetSystemTimeAdjustment(PDWORD,PDWORD,PBOOL);
 VOID        WINAPI GetSystemTimeAsFileTime(LPFILETIME);
+UINT        WINAPI GetSystemWindowsDirectoryA(LPSTR,UINT);
+UINT        WINAPI GetSystemWindowsDirectoryW(LPWSTR,UINT);
+#define     GetSystemWindowsDirectory WINELIB_NAME_AW(GetSystemWindowsDirectory)
 DWORD       WINAPI GetTapeParameters(HANDLE,DWORD,LPDWORD,LPVOID);
 DWORD       WINAPI GetTapePosition(HANDLE,DWORD,LPDWORD,LPDWORD,LPDWORD);
 DWORD       WINAPI GetTapeStatus(HANDLE);
+UINT        WINAPI GetTempFileNameA(LPCSTR,LPCSTR,UINT,LPSTR);
+UINT        WINAPI GetTempFileNameW(LPCWSTR,LPCWSTR,UINT,LPWSTR);
+#define     GetTempFileName WINELIB_NAME_AW(GetTempFileName)
+DWORD       WINAPI GetTempPathA(DWORD,LPSTR);
+DWORD       WINAPI GetTempPathW(DWORD,LPWSTR);
+#define     GetTempPath WINELIB_NAME_AW(GetTempPath)
+DWORD       WINAPI GetTickCount(void);
 DWORD       WINAPI GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
 BOOL        WINAPI GetThreadContext(HANDLE,CONTEXT *);
 INT         WINAPI GetThreadPriority(HANDLE);
@@ -1376,7 +1634,51 @@ BOOL        WINAPI GetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,LPVOID,DWO
 BOOL        WINAPI GetUserNameA(LPSTR,LPDWORD);
 BOOL        WINAPI GetUserNameW(LPWSTR,LPDWORD);
 #define     GetUserName WINELIB_NAME_AW(GetUserName)
+DWORD       WINAPI GetVersion(void);
+BOOL        WINAPI GetVersionExA(OSVERSIONINFOA*);
+BOOL        WINAPI GetVersionExW(OSVERSIONINFOW*);
+#define     GetVersionEx WINELIB_NAME_AW(GetVersionEx)
+BOOL        WINAPI GetVolumeInformationA(LPCSTR,LPSTR,DWORD,LPDWORD,LPDWORD,LPDWORD,LPSTR,DWORD);
+BOOL        WINAPI GetVolumeInformationW(LPCWSTR,LPWSTR,DWORD,LPDWORD,LPDWORD,LPDWORD,LPWSTR,DWORD);
+#define     GetVolumeInformation WINELIB_NAME_AW(GetVolumeInformation)
+BOOL        WINAPI GetVolumeNameForVolumeMountPointA(LPCSTR,LPSTR,DWORD);
+BOOL        WINAPI GetVolumeNameForVolumeMountPointW(LPCWSTR,LPWSTR,DWORD);
+#define     GetVolumeNameForVolumeMountPoint WINELIB_NAME_AW(GetVolumeNameForVolumeMountPoint)
+BOOL        WINAPI GetVolumePathNameA(LPCSTR,LPSTR,DWORD);
+BOOL        WINAPI GetVolumePathNameW(LPCWSTR,LPWSTR,DWORD);
+#define     GetVolumePathName WINELIB_NAME_AW(GetVolumePathName)
+BOOL        WINAPI GetVolumePathNamesForVolumeNameA(LPCSTR,LPSTR,DWORD,PDWORD);
+BOOL        WINAPI GetVolumePathNamesForVolumeNameW(LPCWSTR,LPWSTR,DWORD,PDWORD);
+#define     GetVolumePathNamesForVolumeName WINELIB_NAME_AW(GetVolumePathNamesForVolumeName)
+UINT        WINAPI GetWindowsDirectoryA(LPSTR,UINT);
+UINT        WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
+#define     GetWindowsDirectory WINELIB_NAME_AW(GetWindowsDirectory)
+ATOM        WINAPI GlobalAddAtomA(LPCSTR);
+ATOM        WINAPI GlobalAddAtomW(LPCWSTR);
+#define     GlobalAddAtom WINELIB_NAME_AW(GlobalAddAtom)
+HGLOBAL     WINAPI GlobalAlloc(UINT,SIZE_T);
+SIZE_T      WINAPI GlobalCompact(DWORD);
+ATOM        WINAPI GlobalDeleteAtom(ATOM);
+ATOM        WINAPI GlobalFindAtomA(LPCSTR);
+ATOM        WINAPI GlobalFindAtomW(LPCWSTR);
+#define     GlobalFindAtom WINELIB_NAME_AW(GlobalFindAtom)
+VOID        WINAPI GlobalFix(HGLOBAL);
+UINT        WINAPI GlobalFlags(HGLOBAL);
+HGLOBAL     WINAPI GlobalFree(HGLOBAL);
+UINT        WINAPI GlobalGetAtomNameA(ATOM,LPSTR,INT);
+UINT        WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,INT);
+#define     GlobalGetAtomName WINELIB_NAME_AW(GlobalGetAtomName)
+HGLOBAL     WINAPI GlobalHandle(LPCVOID);
+LPVOID      WINAPI GlobalLock(HGLOBAL);
 VOID        WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
+BOOL        WINAPI GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
+HGLOBAL     WINAPI GlobalReAlloc(HGLOBAL,SIZE_T,UINT);
+SIZE_T      WINAPI GlobalSize(HGLOBAL);
+VOID        WINAPI GlobalUnfix(HGLOBAL);
+BOOL        WINAPI GlobalUnlock(HGLOBAL);
+BOOL        WINAPI GlobalUnWire(HGLOBAL);
+LPVOID      WINAPI GlobalWire(HGLOBAL);
+#define     HasOverlappedCompleted(lpOverlapped) ((lpOverlapped)->Internal != STATUS_PENDING)
 LPVOID      WINAPI HeapAlloc(HANDLE,DWORD,SIZE_T);
 SIZE_T      WINAPI HeapCompact(HANDLE,DWORD);
 HANDLE      WINAPI HeapCreate(DWORD,SIZE_T,SIZE_T);
@@ -1388,25 +1690,79 @@ SIZE_T      WINAPI HeapSize(HANDLE,DWORD,LPVOID);
 BOOL        WINAPI HeapUnlock(HANDLE);
 BOOL        WINAPI HeapValidate(HANDLE,DWORD,LPCVOID);
 BOOL        WINAPI HeapWalk(HANDLE,LPPROCESS_HEAP_ENTRY);
-DWORD       WINAPI InitializeAcl(PACL,DWORD,DWORD);
+BOOL        WINAPI InitAtomTable(DWORD);
+BOOL        WINAPI InitializeAcl(PACL,DWORD,DWORD);
+void        WINAPI InitializeCriticalSection(CRITICAL_SECTION *lpCrit);
+BOOL        WINAPI InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION *,DWORD);
 BOOL        WINAPI InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
 BOOL        WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
-BOOL        WINAPI IsTextUnicode(CONST LPVOID lpBuffer, int cb, LPINT lpi);
+BOOL        WINAPI IsBadCodePtr(FARPROC);
+BOOL        WINAPI IsBadHugeReadPtr(LPCVOID,UINT);
+BOOL        WINAPI IsBadHugeWritePtr(LPVOID,UINT);
+BOOL        WINAPI IsBadReadPtr(LPCVOID,UINT);
+BOOL        WINAPI IsBadStringPtrA(LPCSTR,UINT);
+BOOL        WINAPI IsBadStringPtrW(LPCWSTR,UINT);
+#define     IsBadStringPtr WINELIB_NAME_AW(IsBadStringPtr)
+BOOL        WINAPI IsBadWritePtr(LPVOID,UINT);
+BOOL        WINAPI IsDebuggerPresent(void);
+BOOL        WINAPI IsSystemResumeAutomatic(void);
+BOOL        WINAPI IsTextUnicode(LPCVOID,INT,LPINT);
+BOOL        WINAPI IsTokenRestricted(HANDLE);
+BOOL        WINAPI IsValidAcl(PACL);
 BOOL        WINAPI IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
 BOOL        WINAPI IsValidSid(PSID);
 BOOL        WINAPI ImpersonateLoggedOnUser(HANDLE);
+BOOL        WINAPI ImpersonateNamedPipeClient(HANDLE);
 BOOL        WINAPI ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
 BOOL        WINAPI IsProcessorFeaturePresent(DWORD);
+void        WINAPI LeaveCriticalSection(CRITICAL_SECTION *lpCrit);
+HMODULE     WINAPI LoadLibraryA(LPCSTR);
+HMODULE     WINAPI LoadLibraryW(LPCWSTR);
+#define     LoadLibrary WINELIB_NAME_AW(LoadLibrary)
+HMODULE     WINAPI LoadLibraryExA(LPCSTR,HANDLE,DWORD);
+HMODULE     WINAPI LoadLibraryExW(LPCWSTR,HANDLE,DWORD);
+#define     LoadLibraryEx WINELIB_NAME_AW(LoadLibraryEx)
+HINSTANCE   WINAPI LoadModule(LPCSTR,LPVOID);
+HGLOBAL     WINAPI LoadResource(HMODULE,HRSRC);
+HLOCAL      WINAPI LocalAlloc(UINT,SIZE_T);
+SIZE_T      WINAPI LocalCompact(UINT);
+UINT        WINAPI LocalFlags(HLOCAL);
+HLOCAL      WINAPI LocalFree(HLOCAL);
+HLOCAL      WINAPI LocalHandle(LPCVOID);
+LPVOID      WINAPI LocalLock(HLOCAL);
+HLOCAL      WINAPI LocalReAlloc(HLOCAL,SIZE_T,UINT);
+SIZE_T      WINAPI LocalShrink(HGLOBAL,UINT);
+SIZE_T      WINAPI LocalSize(HLOCAL);
+BOOL        WINAPI LocalUnlock(HLOCAL);
+LPVOID      WINAPI LockResource(HGLOBAL);
+#define     LockSegment(handle) GlobalFix((HANDLE)(handle))
+BOOL        WINAPI LookupAccountNameA(LPCSTR,LPCSTR,PSID,LPDWORD,LPSTR,LPDWORD,PSID_NAME_USE);
+BOOL        WINAPI LookupAccountNameW(LPCWSTR,LPCWSTR,PSID,LPDWORD,LPWSTR,LPDWORD,PSID_NAME_USE);
+#define     LookupAccountName WINELIB_NAME_AW(LookupAccountName)
 BOOL        WINAPI LookupAccountSidA(LPCSTR,PSID,LPSTR,LPDWORD,LPSTR,LPDWORD,PSID_NAME_USE);
 BOOL        WINAPI LookupAccountSidW(LPCWSTR,PSID,LPWSTR,LPDWORD,LPWSTR,LPDWORD,PSID_NAME_USE);
 #define     LookupAccountSid WINELIB_NAME_AW(LookupAccountSid)
 BOOL        WINAPI LocalFileTimeToFileTime(const FILETIME*,LPFILETIME);
 BOOL        WINAPI LockFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
 BOOL        WINAPI LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
+BOOL        WINAPI LogonUserA(LPCSTR,LPCSTR,LPCSTR,DWORD,DWORD,PHANDLE);
+BOOL        WINAPI LogonUserW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,DWORD,PHANDLE);
+#define     LogonUser WINELIB_NAME_AW(LogonUser)
+BOOL        WINAPI LookupPrivilegeDisplayNameA(LPCSTR,LPCSTR,LPSTR,LPDWORD,LPDWORD);
+BOOL        WINAPI LookupPrivilegeDisplayNameW(LPCWSTR,LPCWSTR,LPWSTR,LPDWORD,LPDWORD);
+#define     LookupPrivilegeDisplayName WINELIB_NAME_AW(LookupPrivilegeDisplayName)
+BOOL        WINAPI LookupPrivilegeNameA(LPCSTR,PLUID,LPSTR,LPDWORD);
+BOOL        WINAPI LookupPrivilegeNameW(LPCWSTR,PLUID,LPWSTR,LPDWORD);
+#define     LookupPrivilegeName WINELIB_NAME_AW(LookupPrivilegeName)
 BOOL        WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,PLUID);
 BOOL        WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,PLUID);
 #define     LookupPrivilegeValue WINELIB_NAME_AW(LookupPrivilegeValue)
-BOOL        WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
+BOOL        WINAPI MakeAbsoluteSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD,
+                                  PACL,LPDWORD,PACL,LPDWORD,PSID,LPDWORD,PSID,LPDWORD);
+void        WINAPI MakeCriticalSectionGlobal(CRITICAL_SECTION *lpCrit);
+#define     MakeProcInstance(proc,inst) (proc)
+BOOL        WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
+VOID        WINAPI MapGenericMask(PDWORD,PGENERIC_MAPPING);
 HMODULE     WINAPI MapHModuleSL(WORD);
 WORD        WINAPI MapHModuleLS(HMODULE);
 LPVOID      WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,SIZE_T);
@@ -1417,7 +1773,19 @@ BOOL        WINAPI MoveFileW(LPCWSTR,LPCWSTR);
 BOOL        WINAPI MoveFileExA(LPCSTR,LPCSTR,DWORD);
 BOOL        WINAPI MoveFileExW(LPCWSTR,LPCWSTR,DWORD);
 #define     MoveFileEx WINELIB_NAME_AW(MoveFileEx)
+INT         WINAPI MulDiv(INT,INT,INT);
 BOOL        WINAPI NotifyChangeEventLog(HANDLE,HANDLE);
+BOOL        WINAPI ObjectCloseAuditAlarmA(LPCSTR,LPVOID,BOOL);
+BOOL        WINAPI ObjectCloseAuditAlarmW(LPCWSTR,LPVOID,BOOL);
+#define     ObjectCloseAuditAlarm WINELIB_NAME_AW(ObjectCloseAuditAlarm)
+BOOL        WINAPI ObjectOpenAuditAlarmA(LPCSTR,LPVOID,LPSTR,LPSTR,PSECURITY_DESCRIPTOR,HANDLE,
+                                         DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,LPBOOL);
+BOOL        WINAPI ObjectOpenAuditAlarmW(LPCWSTR,LPVOID,LPWSTR,LPWSTR,PSECURITY_DESCRIPTOR,HANDLE,
+                                         DWORD,DWORD,PPRIVILEGE_SET,BOOL,BOOL,LPBOOL);
+#define     ObjectOpenAuditAlarm WINELIB_NAME_AW(ObjectOpenAuditAlarm)
+BOOL        WINAPI ObjectPrivilegeAuditAlarmA(LPCSTR,LPVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
+BOOL        WINAPI ObjectPrivilegeAuditAlarmW(LPCWSTR,LPVOID,HANDLE,DWORD,PPRIVILEGE_SET,BOOL);
+#define     ObjectPrivilegeAuditAlarm WINELIB_NAME_AW(ObjectPrivilegeAuditAlarm)
 HANDLE      WINAPI OpenBackupEventLogA(LPCSTR,LPCSTR);
 HANDLE      WINAPI OpenBackupEventLogW(LPCWSTR,LPCWSTR);
 #define     OpenBackupEventLog WINELIB_NAME_AW(OpenBackupEventLog)
@@ -1427,6 +1795,7 @@ HANDLE      WINAPI OpenEventW(DWORD,BOOL,LPCWSTR);
 HANDLE      WINAPI OpenEventLogA(LPCSTR,LPCSTR);
 HANDLE      WINAPI OpenEventLogW(LPCWSTR,LPCWSTR);
 #define     OpenEventLog WINELIB_NAME_AW(OpenEventLog)
+HFILE       WINAPI OpenFile(LPCSTR,OFSTRUCT*,UINT);
 HANDLE      WINAPI OpenFileMappingA(DWORD,BOOL,LPCSTR);
 HANDLE      WINAPI OpenFileMappingW(DWORD,BOOL,LPCWSTR);
 #define     OpenFileMapping WINELIB_NAME_AW(OpenFileMapping)
@@ -1443,27 +1812,53 @@ BOOL        WINAPI OpenThreadToken(HANDLE,DWORD,BOOL,PHANDLE);
 HANDLE      WINAPI OpenWaitableTimerA(DWORD,BOOL,LPCSTR);
 HANDLE      WINAPI OpenWaitableTimerW(DWORD,BOOL,LPCWSTR);
 #define     OpenWaitableTimer WINELIB_NAME_AW(OpenWaitableTimer)
+VOID        WINAPI OutputDebugStringA(LPCSTR);
+VOID        WINAPI OutputDebugStringW(LPCWSTR);
+#define     OutputDebugString WINELIB_NAME_AW(OutputDebugString)
 BOOL        WINAPI PeekNamedPipe(HANDLE,PVOID,DWORD,PDWORD,PDWORD,PDWORD);
+BOOL        WINAPI PostQueuedCompletionStatus(HANDLE,DWORD,ULONG_PTR,LPOVERLAPPED);
 DWORD       WINAPI PrepareTape(HANDLE,DWORD,BOOL);
+BOOL        WINAPI ProcessIdToSessionId(DWORD,DWORD*);
+BOOL        WINAPI PrivilegeCheck(HANDLE,PPRIVILEGE_SET,LPBOOL);
+BOOL        WINAPI PrivilegedServiceAuditAlarmA(LPCSTR,LPCSTR,HANDLE,PPRIVILEGE_SET,BOOL);
+BOOL        WINAPI PrivilegedServiceAuditAlarmW(LPCWSTR,LPCWSTR,HANDLE,PPRIVILEGE_SET,BOOL);
+#define     PrivilegedServiceAuditAlarm WINELIB_NAME_AW(PrivilegedServiceAuditAlarm)
 BOOL        WINAPI PulseEvent(HANDLE);
 BOOL        WINAPI PurgeComm(HANDLE,DWORD);
+BOOL        WINAPI QueryActCtxW(DWORD,HANDLE,PVOID,ULONG,PVOID,SIZE_T,SIZE_T *);
 DWORD       WINAPI QueryDosDeviceA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI QueryDosDeviceW(LPCWSTR,LPWSTR,DWORD);
 #define     QueryDosDevice WINELIB_NAME_AW(QueryDosDevice)
 BOOL        WINAPI QueryPerformanceCounter(LARGE_INTEGER*);
 BOOL        WINAPI QueryPerformanceFrequency(LARGE_INTEGER*);
+DWORD       WINAPI QueueUserAPC(PAPCFUNC,HANDLE,ULONG_PTR);
+BOOL        WINAPI QueueUserWorkItem(LPTHREAD_START_ROUTINE,PVOID,ULONG);
+void        WINAPI RaiseException(DWORD,DWORD,DWORD,const ULONG_PTR *);
 BOOL        WINAPI ReadEventLogA(HANDLE,DWORD,DWORD,LPVOID,DWORD,DWORD *,DWORD *);
 BOOL        WINAPI ReadEventLogW(HANDLE,DWORD,DWORD,LPVOID,DWORD,DWORD *,DWORD *);
 #define     ReadEventLog WINELIB_NAME_AW(ReadEventLog)
+BOOL        WINAPI ReadDirectoryChangesW(HANDLE,LPVOID,DWORD,BOOL,DWORD,LPDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
 BOOL        WINAPI ReadFile(HANDLE,LPVOID,DWORD,LPDWORD,LPOVERLAPPED);
 BOOL        WINAPI ReadFileEx(HANDLE,LPVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
+BOOL        WINAPI ReadProcessMemory(HANDLE,LPCVOID,LPVOID,SIZE_T,SIZE_T*);
 HANDLE      WINAPI RegisterEventSourceA(LPCSTR,LPCSTR);
 HANDLE      WINAPI RegisterEventSourceW(LPCWSTR,LPCWSTR);
 #define     RegisterEventSource WINELIB_NAME_AW(RegisterEventSource)
+BOOL        WINAPI RegisterWaitForSingleObject(PHANDLE,HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
+HANDLE      WINAPI RegisterWaitForSingleObjectEx(HANDLE,WAITORTIMERCALLBACK,PVOID,ULONG,ULONG);
+VOID        WINAPI ReleaseActCtx(HANDLE);
 BOOL        WINAPI ReleaseMutex(HANDLE);
 BOOL        WINAPI ReleaseSemaphore(HANDLE,LONG,LPLONG);
+ULONG       WINAPI RemoveVectoredExceptionHandler(PVOID);
+BOOL        WINAPI ReplaceFileA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPVOID,LPVOID);
+BOOL        WINAPI ReplaceFileW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPVOID,LPVOID);
+#define     ReplaceFile WINELIB_NAME_AW(ReplaceFile)
+BOOL        WINAPI RemoveDirectoryA(LPCSTR);
+BOOL        WINAPI RemoveDirectoryW(LPCWSTR);
+#define     RemoveDirectory WINELIB_NAME_AW(RemoveDirectory)
 BOOL        WINAPI ReportEventA(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCSTR *,LPVOID);
 BOOL        WINAPI ReportEventW(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCWSTR *,LPVOID);
+BOOL        WINAPI RequestWakeupLatency(LATENCY_TIME latency);
 #define     ReportEvent WINELIB_NAME_AW(ReportEvent)
 BOOL        WINAPI ResetEvent(HANDLE);
 DWORD       WINAPI ResumeThread(HANDLE);
@@ -1471,6 +1866,7 @@ BOOL        WINAPI RevertToSelf(void);
 DWORD       WINAPI SearchPathA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPSTR,LPSTR*);
 DWORD       WINAPI SearchPathW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPWSTR,LPWSTR*);
 #define     SearchPath WINELIB_NAME_AW(SearchPath)
+BOOL        WINAPI SetAclInformation(PACL,LPVOID,DWORD,ACL_INFORMATION_CLASS);
 BOOL        WINAPI SetCommConfig(HANDLE,LPCOMMCONFIG,DWORD);
 BOOL        WINAPI SetCommBreak(HANDLE);
 BOOL        WINAPI SetCommMask(HANDLE,DWORD);
@@ -1482,33 +1878,57 @@ BOOL        WINAPI SetComputerNameW(LPCWSTR);
 BOOL        WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT,LPCSTR);
 BOOL        WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT,LPCWSTR);
 #define     SetComputerNameEx WINELIB_NAME_AW(SetComputerNameEx)
+DWORD       WINAPI SetCriticalSectionSpinCount(LPCRITICAL_SECTION,DWORD);
+BOOL        WINAPI SetCurrentDirectoryA(LPCSTR);
+BOOL        WINAPI SetCurrentDirectoryW(LPCWSTR);
+#define     SetCurrentDirectory WINELIB_NAME_AW(SetCurrentDirectory)
 BOOL        WINAPI SetDefaultCommConfigA(LPCSTR,LPCOMMCONFIG,DWORD);
 BOOL        WINAPI SetDefaultCommConfigW(LPCWSTR,LPCOMMCONFIG,DWORD);
 #define     SetDefaultCommConfig WINELIB_NAME_AW(SetDefaultCommConfig)
+BOOL        WINAPI SetDllDirectoryA(LPCSTR);
+BOOL        WINAPI SetDllDirectoryW(LPCWSTR);
+#define     SetDllDirectory WINELIB_NAME_AW(SetDllDirectory)
 BOOL        WINAPI SetEndOfFile(HANDLE);
 BOOL        WINAPI SetEnvironmentVariableA(LPCSTR,LPCSTR);
 BOOL        WINAPI SetEnvironmentVariableW(LPCWSTR,LPCWSTR);
 #define     SetEnvironmentVariable WINELIB_NAME_AW(SetEnvironmentVariable)
+UINT        WINAPI SetErrorMode(UINT);
 BOOL        WINAPI SetEvent(HANDLE);
 VOID        WINAPI SetFileApisToANSI(void);
 VOID        WINAPI SetFileApisToOEM(void);
+BOOL        WINAPI SetFileAttributesA(LPCSTR,DWORD);
+BOOL        WINAPI SetFileAttributesW(LPCWSTR,DWORD);
+#define     SetFileAttributes WINELIB_NAME_AW(SetFileAttributes)
 DWORD       WINAPI SetFilePointer(HANDLE,LONG,LPLONG,DWORD);
+BOOL        WINAPI SetFilePointerEx(HANDLE,LARGE_INTEGER,LARGE_INTEGER*,DWORD);
 BOOL        WINAPI SetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 BOOL        WINAPI SetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 #define     SetFileSecurity WINELIB_NAME_AW(SetFileSecurity)
 BOOL        WINAPI SetFileTime(HANDLE,const FILETIME*,const FILETIME*,const FILETIME*);
+UINT        WINAPI SetHandleCount(UINT);
 BOOL        WINAPI SetHandleInformation(HANDLE,DWORD,DWORD);
 BOOL        WINAPI SetKernelObjectSecurity(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
+BOOL        WINAPI SetLocalTime(const SYSTEMTIME*);
+BOOL        WINAPI SetMailslotInfo(HANDLE,DWORD);
 BOOL        WINAPI SetNamedPipeHandleState(HANDLE,LPDWORD,LPDWORD,LPDWORD);
 BOOL        WINAPI SetPriorityClass(HANDLE,DWORD);
-BOOL        WINAPI SetLocalTime(const SYSTEMTIME*);
+BOOL        WINAPI SetPrivateObjectSecurity(SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,
+                                            PSECURITY_DESCRIPTOR*,PGENERIC_MAPPING,HANDLE);
+BOOL        WINAPI SetProcessAffinityMask(HANDLE,DWORD_PTR);
+BOOL        WINAPI SetProcessPriorityBoost(HANDLE,BOOL);
+BOOL        WINAPI SetProcessShutdownParameters(DWORD,DWORD);
+BOOL        WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
+BOOL        WINAPI SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,SECURITY_DESCRIPTOR_CONTROL,
+                                                SECURITY_DESCRIPTOR_CONTROL);
 BOOL        WINAPI SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
 BOOL        WINAPI SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID,BOOL);
 BOOL        WINAPI SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID,BOOL);
 BOOL        WINAPI SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
 BOOL        WINAPI SetStdHandle(DWORD,HANDLE);
+#define     SetSwapAreaSize(w) (w)
 BOOL        WINAPI SetSystemPowerState(BOOL,BOOL);
 BOOL        WINAPI SetSystemTime(const SYSTEMTIME*);
+BOOL        WINAPI SetSystemTimeAdjustment(DWORD,BOOL);
 DWORD       WINAPI SetTapeParameters(HANDLE,DWORD,LPVOID);
 DWORD       WINAPI SetTapePosition(HANDLE,DWORD,DWORD,DWORD,DWORD,BOOL);
 DWORD       WINAPI SetThreadAffinityMask(HANDLE,DWORD);
@@ -1518,24 +1938,44 @@ DWORD       WINAPI SetThreadIdealProcessor(HANDLE,DWORD);
 BOOL        WINAPI SetThreadPriority(HANDLE,INT);
 BOOL        WINAPI SetThreadPriorityBoost(HANDLE,BOOL);
 BOOL        WINAPI SetThreadToken(PHANDLE,HANDLE);
-BOOL        WINAPI SetTimeZoneInformation(const LPTIME_ZONE_INFORMATION);
+BOOL        WINAPI SetTimeZoneInformation(const TIME_ZONE_INFORMATION *);
+BOOL        WINAPI SetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,LPVOID,DWORD);
+BOOL        WINAPI SetVolumeLabelA(LPCSTR,LPCSTR);
+BOOL        WINAPI SetVolumeLabelW(LPCWSTR,LPCWSTR);
+#define     SetVolumeLabel WINELIB_NAME_AW(SetVolumeLabel)
+BOOL        WINAPI SetVolumeMountPointA(LPCSTR,LPCSTR);
+BOOL        WINAPI SetVolumeMountPointW(LPCSTR,LPCSTR);
+#define     SetVolumeMountPoint WINELIB_NAME_AW(SetVolumeMountPoint)
 BOOL        WINAPI SetWaitableTimer(HANDLE,const LARGE_INTEGER*,LONG,PTIMERAPCROUTINE,LPVOID,BOOL);
 BOOL        WINAPI SetupComm(HANDLE,DWORD,DWORD);
 DWORD       WINAPI SignalObjectAndWait(HANDLE,HANDLE,DWORD,BOOL);
+DWORD       WINAPI SizeofResource(HMODULE,HRSRC);
 VOID        WINAPI Sleep(DWORD);
 DWORD       WINAPI SleepEx(DWORD,BOOL);
 DWORD       WINAPI SuspendThread(HANDLE);
 void        WINAPI SwitchToFiber(LPVOID);
 BOOL        WINAPI SwitchToThread(void);
 BOOL        WINAPI SystemTimeToFileTime(const SYSTEMTIME*,LPFILETIME);
+BOOL        WINAPI SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION,LPSYSTEMTIME,LPSYSTEMTIME);
+BOOL        WINAPI TerminateProcess(HANDLE,DWORD);
+BOOL        WINAPI TerminateThread(HANDLE,DWORD);
 DWORD       WINAPI TlsAlloc(void);
 BOOL        WINAPI TlsFree(DWORD);
 LPVOID      WINAPI TlsGetValue(DWORD);
 BOOL        WINAPI TlsSetValue(DWORD,LPVOID);
+BOOL        WINAPI TransactNamedPipe(HANDLE,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPOVERLAPPED);
 BOOL        WINAPI TransmitCommChar(HANDLE,CHAR);
+BOOL        WINAPI TryEnterCriticalSection(CRITICAL_SECTION *lpCrit);
+BOOL        WINAPI TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION,LPSYSTEMTIME,LPSYSTEMTIME);
 BOOL        WINAPI UnlockFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
 BOOL        WINAPI UnlockFileEx(HANDLE,DWORD,DWORD,DWORD,LPOVERLAPPED);
+#define     UnlockSegment(handle) GlobalUnfix((HANDLE)(handle))
 BOOL        WINAPI UnmapViewOfFile(LPVOID);
+BOOL        WINAPI UnregisterWait(HANDLE);
+BOOL        WINAPI UnregisterWaitEx(HANDLE,HANDLE);
+BOOL        WINAPI UpdateResourceA(HANDLE,LPCSTR,LPCSTR,WORD,LPVOID,DWORD);
+BOOL        WINAPI UpdateResourceW(HANDLE,LPCWSTR,LPCWSTR,WORD,LPVOID,DWORD);
+#define     UpdateResource WINELIB_NAME_AW(UpdateResource)
 BOOL        WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA,DWORD,DWORDLONG);
 BOOL        WINAPI VerifyVersionInfoW(LPOSVERSIONINFOEXW,DWORD,DWORDLONG);
 #define     VerifyVersionInfo WINELIB_NAME_AW(VerifyVersionInfo)
@@ -1558,232 +1998,120 @@ DWORD       WINAPI WaitForSingleObjectEx(HANDLE,DWORD,BOOL);
 BOOL        WINAPI WaitNamedPipeA(LPCSTR,DWORD);
 BOOL        WINAPI WaitNamedPipeW(LPCWSTR,DWORD);
 #define     WaitNamedPipe WINELIB_NAME_AW(WaitNamedPipe)
+UINT        WINAPI WinExec(LPCSTR,UINT);
 BOOL        WINAPI WriteFile(HANDLE,LPCVOID,DWORD,LPDWORD,LPOVERLAPPED);
 BOOL        WINAPI WriteFileEx(HANDLE,LPCVOID,DWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
-DWORD       WINAPI WriteTapemark(HANDLE,DWORD,DWORD,BOOL);
-ATOM        WINAPI AddAtomA(LPCSTR);
-ATOM        WINAPI AddAtomW(LPCWSTR);
-#define     AddAtom WINELIB_NAME_AW(AddAtom)
-BOOL        WINAPI CreateDirectoryA(LPCSTR,LPSECURITY_ATTRIBUTES);
-BOOL        WINAPI CreateDirectoryW(LPCWSTR,LPSECURITY_ATTRIBUTES);
-#define     CreateDirectory WINELIB_NAME_AW(CreateDirectory)
-BOOL        WINAPI CreateDirectoryExA(LPCSTR,LPCSTR,LPSECURITY_ATTRIBUTES);
-BOOL        WINAPI CreateDirectoryExW(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
-#define     CreateDirectoryEx WINELIB_NAME_AW(CreateDirectoryEx)
-BOOL        WINAPI DefineDosDeviceA(DWORD,LPCSTR,LPCSTR);
-#define     DefineHandleTable(w) ((w),TRUE)
-ATOM        WINAPI DeleteAtom(ATOM);
-BOOL        WINAPI DeleteFileA(LPCSTR);
-BOOL        WINAPI DeleteFileW(LPCWSTR);
-#define     DeleteFile WINELIB_NAME_AW(DeleteFile)
-void        WINAPI FatalAppExitA(UINT,LPCSTR);
-void        WINAPI FatalAppExitW(UINT,LPCWSTR);
-void        WINAPI FatalExit(int);
-#define     FatalAppExit WINELIB_NAME_AW(FatalAppExit)
-ATOM        WINAPI FindAtomA(LPCSTR);
-ATOM        WINAPI FindAtomW(LPCWSTR);
-#define     FindAtom WINELIB_NAME_AW(FindAtom)
-BOOL        WINAPI FindClose(HANDLE);
-HANDLE      WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
-HANDLE      WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
-#define     FindFirstFile WINELIB_NAME_AW(FindFirstFile)
-HANDLE      WINAPI FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
-HANDLE      WINAPI FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
-#define     FindFirstFileEx WINELIB_NAME_AW(FindFirstFileEx)
-BOOL        WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
-BOOL        WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
-#define     FindNextFile WINELIB_NAME_AW(FindNextFile)
-HRSRC       WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
-HRSRC       WINAPI FindResourceW(HMODULE,LPCWSTR,LPCWSTR);
-#define     FindResource WINELIB_NAME_AW(FindResource)
-BOOL        WINAPI FlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
-BOOL        WINAPI FreeLibrary(HMODULE);
-#define     FreeModule(handle) FreeLibrary(handle)
-#define     FreeProcInstance(proc) /*nothing*/
-BOOL        WINAPI FreeResource(HGLOBAL);
-UINT        WINAPI GetAtomNameA(ATOM,LPSTR,INT);
-UINT        WINAPI GetAtomNameW(ATOM,LPWSTR,INT);
-#define     GetAtomName WINELIB_NAME_AW(GetAtomName)
-UINT        WINAPI GetCurrentDirectoryA(UINT,LPSTR);
-UINT        WINAPI GetCurrentDirectoryW(UINT,LPWSTR);
-#define     GetCurrentDirectory WINELIB_NAME_AW(GetCurrentDirectory)
-#define     GetCurrentTime() GetTickCount()
-BOOL        WINAPI GetDiskFreeSpaceA(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
-BOOL        WINAPI GetDiskFreeSpaceW(LPCWSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
-#define     GetDiskFreeSpace WINELIB_NAME_AW(GetDiskFreeSpace)
-BOOL        WINAPI GetDiskFreeSpaceExA(LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
-BOOL        WINAPI GetDiskFreeSpaceExW(LPCWSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
-#define     GetDiskFreeSpaceEx WINELIB_NAME_AW(GetDiskFreeSpaceEx)
-UINT        WINAPI GetDriveTypeA(LPCSTR);
-UINT        WINAPI GetDriveTypeW(LPCWSTR);
-#define     GetDriveType WINELIB_NAME_AW(GetDriveType)
-BOOL        WINAPI GetExitCodeProcess(HANDLE,LPDWORD);
-DWORD       WINAPI GetFileAttributesA(LPCSTR);
-DWORD       WINAPI GetFileAttributesW(LPCWSTR);
-#define     GetFileAttributes WINELIB_NAME_AW(GetFileAttributes)
-#define     GetFreeSpace(w) (0x100000L)
-UINT        WINAPI GetLogicalDriveStringsA(UINT,LPSTR);
-UINT        WINAPI GetLogicalDriveStringsW(UINT,LPWSTR);
-#define     GetLogicalDriveStrings WINELIB_NAME_AW(GetLogicalDriveStrings)
-DWORD       WINAPI GetModuleFileNameA(HMODULE,LPSTR,DWORD);
-DWORD       WINAPI GetModuleFileNameW(HMODULE,LPWSTR,DWORD);
-#define     GetModuleFileName WINELIB_NAME_AW(GetModuleFileName)
-HMODULE     WINAPI GetModuleHandleA(LPCSTR);
-HMODULE     WINAPI GetModuleHandleW(LPCWSTR);
-#define     GetModuleHandle WINELIB_NAME_AW(GetModuleHandle)
-BOOL        WINAPI GetOverlappedResult(HANDLE,LPOVERLAPPED,LPDWORD,BOOL);
-UINT        WINAPI GetPrivateProfileIntA(LPCSTR,LPCSTR,INT,LPCSTR);
-UINT        WINAPI GetPrivateProfileIntW(LPCWSTR,LPCWSTR,INT,LPCWSTR);
-#define     GetPrivateProfileInt WINELIB_NAME_AW(GetPrivateProfileInt)
-INT         WINAPI GetPrivateProfileSectionA(LPCSTR,LPSTR,DWORD,LPCSTR);
-INT         WINAPI GetPrivateProfileSectionW(LPCWSTR,LPWSTR,DWORD,LPCWSTR);
-#define     GetPrivateProfileSection WINELIB_NAME_AW(GetPrivateProfileSection)
-DWORD       WINAPI GetPrivateProfileSectionNamesA(LPSTR,DWORD,LPCSTR);
-DWORD       WINAPI GetPrivateProfileSectionNamesW(LPWSTR,DWORD,LPCWSTR);
-#define     GetPrivateProfileSectionNames WINELIB_NAME_AW(GetPrivateProfileSectionNames)
-INT         WINAPI GetPrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT,LPCSTR);
-INT         WINAPI GetPrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,UINT,LPCWSTR);
-#define     GetPrivateProfileString WINELIB_NAME_AW(GetPrivateProfileString)
-BOOL        WINAPI GetPrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
-BOOL        WINAPI GetPrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
-#define     GetPrivateProfileStruct WINELIB_NAME_AW(GetPrivateProfileStruct)
-FARPROC     WINAPI GetProcAddress(HMODULE,LPCSTR);
-UINT        WINAPI GetProfileIntA(LPCSTR,LPCSTR,INT);
-UINT        WINAPI GetProfileIntW(LPCWSTR,LPCWSTR,INT);
-#define     GetProfileInt WINELIB_NAME_AW(GetProfileInt)
-INT         WINAPI GetProfileSectionA(LPCSTR,LPSTR,DWORD);
-INT         WINAPI GetProfileSectionW(LPCWSTR,LPWSTR,DWORD);
-#define     GetProfileSection WINELIB_NAME_AW(GetProfileSection)
-INT         WINAPI GetProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT);
-INT         WINAPI GetProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPWSTR,UINT);
-#define     GetProfileString WINELIB_NAME_AW(GetProfileString)
-VOID        WINAPI GetStartupInfoA(LPSTARTUPINFOA);
-VOID        WINAPI GetStartupInfoW(LPSTARTUPINFOW);
-#define     GetStartupInfo WINELIB_NAME_AW(GetStartupInfo)
-UINT        WINAPI GetSystemDirectoryA(LPSTR,UINT);
-UINT        WINAPI GetSystemDirectoryW(LPWSTR,UINT);
-#define     GetSystemDirectory WINELIB_NAME_AW(GetSystemDirectory)
-DWORD       WINAPI GetTickCount(void);
-UINT        WINAPI GetTempFileNameA(LPCSTR,LPCSTR,UINT,LPSTR);
-UINT        WINAPI GetTempFileNameW(LPCWSTR,LPCWSTR,UINT,LPWSTR);
-#define     GetTempFileName WINELIB_NAME_AW(GetTempFileName)
-UINT        WINAPI GetTempPathA(UINT,LPSTR);
-UINT        WINAPI GetTempPathW(UINT,LPWSTR);
-#define     GetTempPath WINELIB_NAME_AW(GetTempPath)
-LONG        WINAPI GetVersion(void);
-BOOL        WINAPI GetVolumeInformationA(LPCSTR,LPSTR,DWORD,LPDWORD,LPDWORD,LPDWORD,LPSTR,DWORD);
-BOOL        WINAPI GetVolumeInformationW(LPCWSTR,LPWSTR,DWORD,LPDWORD,LPDWORD,LPDWORD,LPWSTR,DWORD);
-#define     GetVolumeInformation WINELIB_NAME_AW(GetVolumeInformation)
-UINT        WINAPI GetWindowsDirectoryA(LPSTR,UINT);
-UINT        WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
-#define     GetWindowsDirectory WINELIB_NAME_AW(GetWindowsDirectory)
-ATOM        WINAPI GlobalAddAtomA(LPCSTR);
-ATOM        WINAPI GlobalAddAtomW(LPCWSTR);
-#define     GlobalAddAtom WINELIB_NAME_AW(GlobalAddAtom)
-HGLOBAL     WINAPI GlobalAlloc(UINT,SIZE_T);
-SIZE_T      WINAPI GlobalCompact(DWORD);
-ATOM        WINAPI GlobalDeleteAtom(ATOM);
-ATOM        WINAPI GlobalFindAtomA(LPCSTR);
-ATOM        WINAPI GlobalFindAtomW(LPCWSTR);
-#define     GlobalFindAtom WINELIB_NAME_AW(GlobalFindAtom)
-UINT        WINAPI GlobalFlags(HGLOBAL);
-HGLOBAL     WINAPI GlobalFree(HGLOBAL);
-UINT        WINAPI GlobalGetAtomNameA(ATOM,LPSTR,INT);
-UINT        WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,INT);
-#define     GlobalGetAtomName WINELIB_NAME_AW(GlobalGetAtomName)
-HGLOBAL     WINAPI GlobalHandle(LPCVOID);
-VOID        WINAPI GlobalFix(HGLOBAL);
-LPVOID      WINAPI GlobalLock(HGLOBAL);
-HGLOBAL     WINAPI GlobalReAlloc(HGLOBAL,SIZE_T,UINT);
-SIZE_T      WINAPI GlobalSize(HGLOBAL);
-VOID        WINAPI GlobalUnfix(HGLOBAL);
-BOOL        WINAPI GlobalUnlock(HGLOBAL);
-BOOL        WINAPI GlobalUnWire(HGLOBAL);
-LPVOID      WINAPI GlobalWire(HGLOBAL);
-#define     HasOverlappedCompleted(lpOverlapped) ((lpOverlapped)->Internal != STATUS_PENDING)
-BOOL        WINAPI InitAtomTable(DWORD);
-BOOL        WINAPI IsBadCodePtr(FARPROC);
-BOOL        WINAPI IsBadHugeReadPtr(LPCVOID,UINT);
-BOOL        WINAPI IsBadHugeWritePtr(LPVOID,UINT);
-BOOL        WINAPI IsBadReadPtr(LPCVOID,UINT);
-BOOL        WINAPI IsBadStringPtrA(LPCSTR,UINT);
-BOOL        WINAPI IsBadStringPtrW(LPCWSTR,UINT);
-#define     IsBadStringPtr WINELIB_NAME_AW(IsBadStringPtr)
-BOOL        WINAPI IsBadWritePtr(LPVOID,UINT);
-BOOL        WINAPI IsDebuggerPresent(void);
-HMODULE     WINAPI LoadLibraryA(LPCSTR);
-HMODULE     WINAPI LoadLibraryW(LPCWSTR);
-#define     LoadLibrary WINELIB_NAME_AW(LoadLibrary)
-HMODULE     WINAPI LoadLibraryExA(LPCSTR,HANDLE,DWORD);
-HMODULE     WINAPI LoadLibraryExW(LPCWSTR,HANDLE,DWORD);
-#define     LoadLibraryEx WINELIB_NAME_AW(LoadLibraryEx)
-HINSTANCE   WINAPI LoadModule(LPCSTR,LPVOID);
-HGLOBAL     WINAPI LoadResource(HMODULE,HRSRC);
-HLOCAL      WINAPI LocalAlloc(UINT,SIZE_T);
-SIZE_T      WINAPI LocalCompact(UINT);
-UINT        WINAPI LocalFlags(HLOCAL);
-HLOCAL      WINAPI LocalFree(HLOCAL);
-HLOCAL      WINAPI LocalHandle(LPCVOID);
-LPVOID      WINAPI LocalLock(HLOCAL);
-HLOCAL      WINAPI LocalReAlloc(HLOCAL,SIZE_T,UINT);
-SIZE_T      WINAPI LocalShrink(HGLOBAL,UINT);
-SIZE_T      WINAPI LocalSize(HLOCAL);
-BOOL        WINAPI LocalUnlock(HLOCAL);
-LPVOID      WINAPI LockResource(HGLOBAL);
-#define     LockSegment(handle) GlobalFix((HANDLE)(handle))
-#define     MakeProcInstance(proc,inst) (proc)
-HFILE       WINAPI OpenFile(LPCSTR,OFSTRUCT*,UINT);
-VOID        WINAPI OutputDebugStringA(LPCSTR);
-VOID        WINAPI OutputDebugStringW(LPCWSTR);
-#define     OutputDebugString WINELIB_NAME_AW(OutputDebugString)
-BOOL        WINAPI ReadProcessMemory(HANDLE,LPCVOID,LPVOID,SIZE_T,SIZE_T*);
-BOOL        WINAPI RemoveDirectoryA(LPCSTR);
-BOOL        WINAPI RemoveDirectoryW(LPCWSTR);
-#define     RemoveDirectory WINELIB_NAME_AW(RemoveDirectory)
-BOOL        WINAPI SetCurrentDirectoryA(LPCSTR);
-BOOL        WINAPI SetCurrentDirectoryW(LPCWSTR);
-#define     SetCurrentDirectory WINELIB_NAME_AW(SetCurrentDirectory)
-UINT        WINAPI SetErrorMode(UINT);
-BOOL        WINAPI SetFileAttributesA(LPCSTR,DWORD);
-BOOL        WINAPI SetFileAttributesW(LPCWSTR,DWORD);
-#define     SetFileAttributes WINELIB_NAME_AW(SetFileAttributes)
-UINT        WINAPI SetHandleCount(UINT);
-#define     SetSwapAreaSize(w) (w)
-BOOL        WINAPI SetVolumeLabelA(LPCSTR,LPCSTR);
-BOOL        WINAPI SetVolumeLabelW(LPCWSTR,LPCWSTR);
-#define     SetVolumeLabel WINELIB_NAME_AW(SetVolumeLabel)
-DWORD       WINAPI SizeofResource(HMODULE,HRSRC);
-#define     UnlockSegment(handle) GlobalUnfix((HANDLE)(handle))
 BOOL        WINAPI WritePrivateProfileSectionA(LPCSTR,LPCSTR,LPCSTR);
 BOOL        WINAPI WritePrivateProfileSectionW(LPCWSTR,LPCWSTR,LPCWSTR);
 #define     WritePrivateProfileSection WINELIB_NAME_AW(WritePrivateProfileSection)
 BOOL        WINAPI WritePrivateProfileStringA(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
 BOOL        WINAPI WritePrivateProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR);
 #define     WritePrivateProfileString WINELIB_NAME_AW(WritePrivateProfileString)
-BOOL        WINAPI WriteProfileSectionA(LPCSTR,LPCSTR);
-BOOL        WINAPI WriteProfileSectionW(LPCWSTR,LPCWSTR);
-#define     WritePrivateProfileSection WINELIB_NAME_AW(WritePrivateProfileSection)
 BOOL        WINAPI WritePrivateProfileStructA(LPCSTR,LPCSTR,LPVOID,UINT,LPCSTR);
 BOOL        WINAPI WritePrivateProfileStructW(LPCWSTR,LPCWSTR,LPVOID,UINT,LPCWSTR);
 #define     WritePrivateProfileStruct WINELIB_NAME_AW(WritePrivateProfileStruct)
 BOOL        WINAPI WriteProcessMemory(HANDLE,LPVOID,LPCVOID,SIZE_T,SIZE_T*);
+BOOL        WINAPI WriteProfileSectionA(LPCSTR,LPCSTR);
+BOOL        WINAPI WriteProfileSectionW(LPCWSTR,LPCWSTR);
+#define     WritePrivateProfileSection WINELIB_NAME_AW(WritePrivateProfileSection)
 BOOL        WINAPI WriteProfileStringA(LPCSTR,LPCSTR,LPCSTR);
 BOOL        WINAPI WriteProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR);
 #define     WriteProfileString WINELIB_NAME_AW(WriteProfileString)
+DWORD       WINAPI WriteTapemark(HANDLE,DWORD,DWORD,BOOL);
 #define     Yield()
+BOOL        WINAPI ZombifyActCtx(HANDLE);
+
 LPSTR       WINAPI lstrcatA(LPSTR,LPCSTR);
 LPWSTR      WINAPI lstrcatW(LPWSTR,LPCWSTR);
-#define     lstrcat WINELIB_NAME_AW(lstrcat)
 LPSTR       WINAPI lstrcpyA(LPSTR,LPCSTR);
 LPWSTR      WINAPI lstrcpyW(LPWSTR,LPCWSTR);
-#define     lstrcpy WINELIB_NAME_AW(lstrcpy)
 LPSTR       WINAPI lstrcpynA(LPSTR,LPCSTR,INT);
 LPWSTR      WINAPI lstrcpynW(LPWSTR,LPCWSTR,INT);
-#define     lstrcpyn WINELIB_NAME_AW(lstrcpyn)
 INT         WINAPI lstrlenA(LPCSTR);
 INT         WINAPI lstrlenW(LPCWSTR);
+
+#if !defined(WINE_NO_INLINE_STRING) && defined(__WINESRC__)
+
+/* string functions without the exception handler */
+
+extern inline LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
+{
+    LPWSTR d = dst;
+    LPCWSTR s = src;
+    UINT count = n;
+
+    while ((count > 1) && *s)
+    {
+        count--;
+        *d++ = *s++;
+    }
+    if (count) *d = 0;
+    return dst;
+}
+
+extern inline LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
+{
+    LPSTR d = dst;
+    LPCSTR s = src;
+    UINT count = n;
+
+    while ((count > 1) && *s)
+    {
+        count--;
+        *d++ = *s++;
+    }
+    if (count) *d = 0;
+    return dst;
+}
+
+extern inline INT WINAPI lstrlenW( LPCWSTR str )
+{
+    const WCHAR *s = str;
+    while (*s) s++;
+    return s - str;
+}
+
+extern inline INT WINAPI lstrlenA( LPCSTR str )
+{
+    return strlen( str );
+}
+
+extern inline LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
+{
+    WCHAR *p = dst;
+    while ((*p++ = *src++));
+    return dst;
+}
+
+extern inline LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
+{
+    return strcpy( dst, src );
+}
+
+extern inline LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
+{
+    WCHAR *p = dst;
+    while (*p) p++;
+    while ((*p++ = *src++));
+    return dst;
+}
+
+extern inline LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
+{
+    return strcat( dst, src );
+}
+
+/* strncpy doesn't do what you think, don't use it */
+#undef strncpy
+#define strncpy(d,s,n) error do_not_use_strncpy_use_lstrcpynA_or_memcpy_instead
+
+#endif /* !defined(WINE_NO_INLINE_STRING) && defined(__WINESRC__) */
+
+#define     lstrcat WINELIB_NAME_AW(lstrcat)
+#define     lstrcpy WINELIB_NAME_AW(lstrcpy)
+#define     lstrcpyn WINELIB_NAME_AW(lstrcpyn)
 #define     lstrlen WINELIB_NAME_AW(lstrlen)
-UINT        WINAPI WinExec(LPCSTR,UINT);
+
 LONG        WINAPI _hread(HFILE,LPVOID,LONG);
 LONG        WINAPI _hwrite(HFILE,LPCSTR,LONG);
 HFILE       WINAPI _lcreat(LPCSTR,INT);
@@ -1835,11 +2163,9 @@ HANDLE      WINAPI DosFileHandleToWin32Handle(HFILE);
 DWORD       WINAPI GetProcessDword(DWORD,INT);
 VOID        WINAPI GetpWin16Lock(SYSLEVEL**);
 DWORD       WINAPI MapLS(LPCVOID);
-DWORD       WINAPI MapProcessHandle(HANDLE);
 LPVOID      WINAPI MapSL(DWORD);
 VOID        WINAPI ReleaseThunkLock(DWORD*);
 VOID        WINAPI RestoreThunkLock(DWORD);
-void        WINAPI SetProcessDword(DWORD,INT,DWORD);
 VOID        WINAPI UnMapLS(DWORD);
 HFILE       WINAPI Win32HandleToDosFileHandle(HANDLE);
 VOID        WINAPI _CheckNotSysLevel(SYSLEVEL *lock);
@@ -1851,15 +2177,16 @@ VOID        WINAPI _LeaveSysLevel(SYSLEVEL*);
 
 /* Wine internal functions */
 
-BOOL        WINAPI wine_get_unix_file_name( LPCSTR dos, LPSTR buffer, DWORD len );
+extern char *wine_get_unix_file_name( LPCWSTR dos );
+extern WCHAR *wine_get_dos_file_name( LPCSTR str );
 
 
 /* a few optimizations for i386/gcc */
 
-#if defined(__i386__) && defined(__GNUC__)
+#if defined(__i386__) && defined(__GNUC__) && defined(__WINESRC__) && !defined(_NTSYSTEM_)
 
-extern inline LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare );
-extern inline LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare )
+extern inline LONG WINAPI InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare );
+extern inline LONG WINAPI InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
 {
     LONG ret;
     __asm__ __volatile__( "lock; cmpxchgl %2,(%1)"
@@ -1867,8 +2194,8 @@ extern inline LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LON
     return ret;
 }
 
-extern inline LONG WINAPI InterlockedExchange( PLONG dest, LONG val );
-extern inline LONG WINAPI InterlockedExchange( PLONG dest, LONG val )
+extern inline LONG WINAPI InterlockedExchange( LONG volatile *dest, LONG val );
+extern inline LONG WINAPI InterlockedExchange( LONG volatile *dest, LONG val )
 {
     LONG ret;
     __asm__ __volatile__( "lock; xchgl %0,(%1)"
@@ -1876,8 +2203,8 @@ extern inline LONG WINAPI InterlockedExchange( PLONG dest, LONG val )
     return ret;
 }
 
-extern inline LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr );
-extern inline LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr )
+extern inline LONG WINAPI InterlockedExchangeAdd( LONG volatile *dest, LONG incr );
+extern inline LONG WINAPI InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
 {
     LONG ret;
     __asm__ __volatile__( "lock; xaddl %0,(%1)"
@@ -1885,14 +2212,14 @@ extern inline LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr )
     return ret;
 }
 
-extern inline LONG WINAPI InterlockedIncrement( PLONG dest );
-extern inline LONG WINAPI InterlockedIncrement( PLONG dest )
+extern inline LONG WINAPI InterlockedIncrement( LONG volatile *dest );
+extern inline LONG WINAPI InterlockedIncrement( LONG volatile *dest )
 {
     return InterlockedExchangeAdd( dest, 1 ) + 1;
 }
 
-extern inline LONG WINAPI InterlockedDecrement( PLONG dest );
-extern inline LONG WINAPI InterlockedDecrement( PLONG dest )
+extern inline LONG WINAPI InterlockedDecrement( LONG volatile *dest );
+extern inline LONG WINAPI InterlockedDecrement( LONG volatile *dest )
 {
     return InterlockedExchangeAdd( dest, -1 ) - 1;
 }
@@ -1901,7 +2228,7 @@ extern inline DWORD WINAPI GetLastError(void);
 extern inline DWORD WINAPI GetLastError(void)
 {
     DWORD ret;
-    __asm__ __volatile__( ".byte 0x64\n\tmovl 0x60,%0" : "=r" (ret) );
+    __asm__ __volatile__( ".byte 0x64\n\tmovl 0x34,%0" : "=r" (ret) );
     return ret;
 }
 
@@ -1924,7 +2251,7 @@ extern inline DWORD WINAPI GetCurrentThreadId(void)
 extern inline void WINAPI SetLastError( DWORD err );
 extern inline void WINAPI SetLastError( DWORD err )
 {
-    __asm__ __volatile__( ".byte 0x64\n\tmovl %0,0x60" : : "r" (err) : "memory" );
+    __asm__ __volatile__( ".byte 0x64\n\tmovl %0,0x34" : : "r" (err) : "memory" );
 }
 
 extern inline HANDLE WINAPI GetProcessHeap(void);
@@ -1935,28 +2262,43 @@ extern inline HANDLE WINAPI GetProcessHeap(void)
     return pdb[0x18 / sizeof(HANDLE)];  /* get dword at offset 0x18 in pdb */
 }
 
-#else  /* __i386__ && __GNUC__ */
+#else  /* __i386__ && __GNUC__ && __WINESRC__ && !_NTSYSTEM_ */
+
 DWORD       WINAPI GetCurrentProcessId(void);
 DWORD       WINAPI GetCurrentThreadId(void);
 DWORD       WINAPI GetLastError(void);
 HANDLE      WINAPI GetProcessHeap(void);
-LONG        WINAPI InterlockedCompareExchange(LONG*,LONG,LONG);
-LONG        WINAPI InterlockedDecrement(PLONG);
-LONG        WINAPI InterlockedExchange(PLONG,LONG);
-LONG        WINAPI InterlockedExchangeAdd(PLONG,LONG);
-LONG        WINAPI InterlockedIncrement(PLONG);
+LONG        WINAPI InterlockedCompareExchange(LONG volatile*,LONG,LONG);
+LONG        WINAPI InterlockedDecrement(LONG volatile*);
+LONG        WINAPI InterlockedExchange(LONG volatile*,LONG);
+LONG        WINAPI InterlockedExchangeAdd(LONG volatile*,LONG);
+LONG        WINAPI InterlockedIncrement(LONG volatile*);
 VOID        WINAPI SetLastError(DWORD);
-#endif  /* __i386__ && __GNUC__ */
 
-/* FIXME: should handle platforms where sizeof(void*) != sizeof(long) */
-static inline PVOID WINAPI InterlockedCompareExchangePointer( PVOID *dest, PVOID xchg, PVOID compare )
+#endif  /* __i386__ && __GNUC__ && __WINESRC__ && !_NTSYSTEM_ */
+
+static inline PVOID WINAPI InterlockedCompareExchangePointer( PVOID volatile *dest, PVOID xchg, PVOID compare )
 {
-    return (PVOID)InterlockedCompareExchange( (PLONG)dest, (LONG)xchg, (LONG)compare );
+#if defined(__x86_64__) && defined(__GNUC__)
+    PVOID ret;
+    __asm__ __volatile__( "lock; cmpxchgq %2,(%1)"
+                          : "=a" (ret) : "r" (dest), "r" (xchg), "0" (compare) : "memory" );
+    return ret;
+#else
+    return (PVOID)InterlockedCompareExchange( (LONG volatile*)dest, (LONG)xchg, (LONG)compare );
+#endif
 }
 
-static inline PVOID WINAPI InterlockedExchangePointer( PVOID *dest, PVOID val )
+static inline PVOID WINAPI InterlockedExchangePointer( PVOID volatile *dest, PVOID val )
 {
-    return (PVOID)InterlockedExchange( (PLONG)dest, (LONG)val );
+#if defined(__x86_64__) && defined(__GNUC__)
+    PVOID ret;
+    __asm__ __volatile__( "lock; xchgq %0,(%1)"
+                          : "=r" (ret) :"r" (dest), "0" (val) : "memory" );
+    return ret;
+#else
+    return (PVOID)InterlockedExchange( (LONG volatile*)dest, (LONG)val );
+#endif
 }
 
 #ifdef __WINESRC__
@@ -1968,58 +2310,6 @@ static inline PVOID WINAPI InterlockedExchangePointer( PVOID *dest, PVOID val )
 /* If this is not declared, we cannot compile many sources written with C++. */
 int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int);
 
-#define HW_PROFILE_GUIDLEN     39
-#define MAX_PROFILE_LEN                80
-
-#define DOCKINFO_UNDOCKED      0x1
-#define DOCKINFO_DOCKED                0x2
-#define DOCKINFO_USER_SUPPLIED 0x4
-#define DOCKINFO_USER_UNDOCKED (DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED)
-#define DOCKINFO_USER_DOCKED   (DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED)
-
-typedef struct tagHW_PROFILE_INFOA {
-    DWORD dwDockInfo;
-    CHAR  szHwProfileGuid[HW_PROFILE_GUIDLEN];
-    CHAR  szHwProfileName[MAX_PROFILE_LEN];
-} HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
-
-typedef struct tagHW_PROFILE_INFOW {
-    DWORD dwDockInfo;
-    WCHAR szHwProfileGuid[HW_PROFILE_GUIDLEN];
-    WCHAR szHwProfileName[MAX_PROFILE_LEN];
-} HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
-
-DECL_WINELIB_TYPE_AW(HW_PROFILE_INFO)
-DECL_WINELIB_TYPE_AW(LPHW_PROFILE_INFO)
-
-/* Stream data structures and defines */
-/*the types of backup data -- WIN32_STREAM_ID.dwStreamId below*/
-#define BACKUP_INVALID        0
-#define BACKUP_DATA           1
-#define BACKUP_EA_DATA        2
-#define BACKUP_SECURITY_DATA  3
-#define BACKUP_ALTERNATE_DATA 4
-#define BACKUP_LINK           5
-#define BACKUP_PROPERTY_DATA  6
-#define BACKUP_OBJECT_ID      7
-#define BACKUP_REPARSE_DATA   8
-#define BACKUP_SPARSE_BLOCK   9
-
-/*flags for WIN32_STREAM_ID.dwStreamAttributes below*/
-#define STREAM_NORMAL_ATTRIBUTE    0
-#define STREAM_MODIFIED_WHEN_READ  1
-#define STREAM_CONTAINS_SECURITY   2
-#define STREAM_CONTAINS_PROPERTIES 4
-#define STREAM_SPARSE_ATTRIBUTE    8
-
-typedef struct _WIN32_STREAM_ID {
-       DWORD   dwStreamId;
-       DWORD   dwStreamAttributes;
-       LARGE_INTEGER Size;
-       DWORD   dwStreamNameSize;
-       WCHAR   cStreamName[ANYSIZE_ARRAY];
-} WIN32_STREAM_ID, *LPWIN32_STREAM_ID;
-
 #ifdef __cplusplus
 }
 #endif