* We do this in order to get some storage for the locked handle table
* Maybe I'll use some tail item in the irp instead */
#define AFD_HANDLES(x) ((PAFD_HANDLE)(x)->Exclusive)
-#define SET_AFD_HANDLES(x,y) (((x)->Exclusive) = (ULONG)(y))
+#define SET_AFD_HANDLES(x,y) (((x)->Exclusive) = (ULONG_PTR)(y))
typedef struct _AFD_MAPBUF {
PVOID BufferAddress;
HWND WINAPI
CreateToolbarEx(HWND, DWORD, UINT, INT,
- HINSTANCE, UINT, LPCTBBUTTON,
+ HINSTANCE, UINT_PTR, LPCTBBUTTON,
INT, INT, INT, INT, INT, UINT);
HBITMAP WINAPI
#define TVIF_INTEGRAL 0x0080
#define TVIF_DI_SETITEM 0x1000
-#define TVI_ROOT ((HTREEITEM)0xffff0000) /* -65536 */
-#define TVI_FIRST ((HTREEITEM)0xffff0001) /* -65535 */
-#define TVI_LAST ((HTREEITEM)0xffff0002) /* -65534 */
-#define TVI_SORT ((HTREEITEM)0xffff0003) /* -65533 */
+#define TVI_ROOT ((HTREEITEM)(ULONG_PTR)-0x10000) /* -65536 */
+#define TVI_FIRST ((HTREEITEM)(ULONG_PTR)-0x0FFFF) /* -65535 */
+#define TVI_LAST ((HTREEITEM)(ULONG_PTR)-0x0FFFE) /* -65534 */
+#define TVI_SORT ((HTREEITEM)(ULONG_PTR)-0x0FFFD) /* -65533 */
#define TVIS_FOCUSED 0x0001
#define TVIS_SELECTED 0x0002
typedef struct tagCOMBOBOXEXITEMA
{
UINT mask;
- int iItem;
+ INT_PTR iItem;
LPSTR pszText;
int cchTextMax;
int iImage;
typedef struct tagCOMBOBOXEXITEMW
{
UINT mask;
- int iItem;
+ INT_PTR iItem;
LPWSTR pszText;
int cchTextMax;
int iImage;
#ifdef __cplusplus
extern "C" {
#endif
+
+#ifndef _WIN64
#pragma pack(push,1)
+#endif
#define SAVE_DIALOG 1
#define OPEN_DIALOG 2
#define CommDlg_OpenSave_HideControl(d,i) ((void)SNDMSG((d),CDM_HIDECONTROL,(i),0))
#define CommDlg_OpenSave_SetDefExt(d,e) ((void)SNDMSG((d),CDM_SETDEFEXT,0,(LPARAM)(e)))
-typedef UINT (APIENTRY *__CDHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
+typedef UINT_PTR (APIENTRY *__CDHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef __CDHOOKPROC LPCCHOOKPROC;
typedef __CDHOOKPROC LPCFHOOKPROC;
typedef __CDHOOKPROC LPFRHOOKPROC;
#define PrintDlgEx PrintDlgExA
#endif /* WINVER >= 0x0500 */
#endif /* UNICODE */
+#ifndef _WIN64
#pragma pack(pop)
+#endif
#ifdef __cplusplus
}
#endif
typedef struct {
HWAVE hWave;
LPWAVEFORMATEX lpFormat;
- DWORD dwCallback;
- DWORD dwInstance;
+ DWORD_PTR dwCallback;
+ DWORD_PTR dwInstance;
UINT uMappedDeviceID;
- DWORD dnDevNode;
+ DWORD dnDevNode;
} WAVEOPENDESC, *LPWAVEOPENDESC;
typedef struct {
DWORD dnDevNode;
} DRVCONFIGINFOEX,*PDRVCONFIGINFOEX,*LPDRVCONFIGINFOEX;
-typedef LRESULT(CALLBACK* DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
+typedef LRESULT (CALLBACK* DRIVERPROC)(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
typedef void (CALLBACK DRVCALLBACK)(HDRVR,UINT,DWORD,DWORD,DWORD);
typedef DRVCALLBACK *LPDRVCALLBACK;
typedef DRVCALLBACK *PDRVCALLBACK;
LPSTR lpData;
DWORD dwBufferLength;
DWORD dwBytesRecorded;
- DWORD dwUser;
+ DWORD_PTR dwUser;
DWORD dwFlags;
DWORD dwLoops;
struct wavehdr_tag *lpNext;
- DWORD reserved;
+ DWORD_PTR reserved;
} WAVEHDR,*PWAVEHDR,*LPWAVEHDR;
typedef struct tagWAVEOUTCAPSA {
LRESULT WINAPI SendDriverMessage(HDRVR,UINT,LONG,LONG);
HMODULE WINAPI DrvGetModuleHandle(HDRVR);
HMODULE WINAPI GetDriverModuleHandle(HDRVR);
-LRESULT WINAPI DefDriverProc(DWORD,HDRVR,UINT,LPARAM,LPARAM);
+LRESULT WINAPI DefDriverProc(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
UINT WINAPI mmsystemGetVersion(void);
#define OutputDebugStr OutputDebugString
BOOL WINAPI sndPlaySoundA(LPCSTR,UINT);
BOOL WINAPI PlaySoundA(LPCSTR,HMODULE,DWORD);
BOOL WINAPI PlaySoundW(LPCWSTR,HMODULE,DWORD);
UINT WINAPI waveOutGetNumDevs(void);
-MMRESULT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
-MMRESULT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
+MMRESULT WINAPI waveOutGetDevCapsA(UINT_PTR,LPWAVEOUTCAPSA,UINT);
+MMRESULT WINAPI waveOutGetDevCapsW(UINT_PTR,LPWAVEOUTCAPSW,UINT);
MMRESULT WINAPI waveOutGetVolume(HWAVEOUT,PDWORD);
MMRESULT WINAPI waveOutSetVolume(HWAVEOUT,DWORD);
MMRESULT WINAPI waveOutGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI waveOutGetPlaybackRate(HWAVEOUT,PDWORD);
MMRESULT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
MMRESULT WINAPI waveOutGetID(HWAVEOUT,LPUINT);
-MMRESULT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
+#if (WINVER >= 0x030a)
+#ifdef _WIN32
+MMRESULT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD_PTR,DWORD_PTR);
+#else
+DWORD WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
+#endif
+#endif
UINT WINAPI waveInGetNumDevs(void);
-MMRESULT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
-MMRESULT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
+MMRESULT WINAPI waveInGetDevCapsA(UINT_PTR,LPWAVEINCAPSA,UINT);
+MMRESULT WINAPI waveInGetDevCapsW(UINT_PTR,LPWAVEINCAPSW,UINT);
MMRESULT WINAPI waveInGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI waveInGetErrorTextW(MMRESULT,LPWSTR,UINT);
MMRESULT WINAPI waveInOpen(LPHWAVEIN,UINT,LPCWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI waveInReset(HWAVEIN);
MMRESULT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
MMRESULT WINAPI waveInGetID(HWAVEIN,LPUINT);
-MMRESULT WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
+#if (WINVER >= 0x030a)
+#ifdef _WIN32
+MMRESULT WINAPI waveInMessage(HWAVEIN,UINT,DWORD_PTR,DWORD_PTR);
+#else
+DWORD WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
+#endif
+#endif
UINT WINAPI midiOutGetNumDevs(void);
-MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD,DWORD,DWORD);
+MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI midiStreamClose(HMIDISTRM);
MMRESULT WINAPI midiStreamProperty(HMIDISTRM,LPBYTE,DWORD);
MMRESULT WINAPI midiStreamPosition(HMIDISTRM,LPMMTIME,UINT);
MMRESULT WINAPI midiStreamStop(HMIDISTRM);
MMRESULT WINAPI midiConnect(HMIDI,HMIDIOUT,PVOID);
MMRESULT WINAPI midiDisconnect(HMIDI,HMIDIOUT,PVOID);
-MMRESULT WINAPI midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT);
-MMRESULT WINAPI midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT);
+MMRESULT WINAPI midiOutGetDevCapsA(UINT_PTR,LPMIDIOUTCAPSA,UINT);
+MMRESULT WINAPI midiOutGetDevCapsW(UINT_PTR,LPMIDIOUTCAPSW,UINT);
MMRESULT WINAPI midiOutGetVolume(HMIDIOUT,PDWORD);
MMRESULT WINAPI midiOutSetVolume(HMIDIOUT,DWORD);
MMRESULT WINAPI midiOutGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI midiOutGetErrorTextW(MMRESULT,LPWSTR,UINT);
-MMRESULT WINAPI midiOutOpen(LPHMIDIOUT,UINT,DWORD,DWORD,DWORD);
+MMRESULT WINAPI midiOutOpen(LPHMIDIOUT,UINT_PTR,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI midiOutClose(HMIDIOUT);
MMRESULT WINAPI midiOutPrepareHeader(HMIDIOUT,LPMIDIHDR,UINT);
MMRESULT WINAPI midiOutUnprepareHeader(HMIDIOUT,LPMIDIHDR,UINT);
MMRESULT WINAPI midiOutCachePatches(HMIDIOUT,UINT,LPWORD,UINT);
MMRESULT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,LPWORD,UINT);
MMRESULT WINAPI midiOutGetID(HMIDIOUT,LPUINT);
-MMRESULT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
+#if (WINVER >= 0x030a)
+#ifdef _WIN32
+MMRESULT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD_PTR,DWORD_PTR);
+#else
+DWORD WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
+#endif
+#endif
UINT WINAPI midiInGetNumDevs(void);
-MMRESULT WINAPI midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT);
-MMRESULT WINAPI midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT);
+MMRESULT WINAPI midiInGetDevCapsA(UINT_PTR,LPMIDIINCAPSA,UINT);
+MMRESULT WINAPI midiInGetDevCapsW(UINT_PTR,LPMIDIINCAPSW,UINT);
MMRESULT WINAPI midiInGetErrorTextA(MMRESULT,LPSTR,UINT);
MMRESULT WINAPI midiInGetErrorTextW(MMRESULT,LPWSTR,UINT);
-MMRESULT WINAPI midiInOpen(LPHMIDIIN,UINT,DWORD,DWORD,DWORD);
+MMRESULT WINAPI midiInOpen(LPHMIDIIN,UINT_PTR,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI midiInClose(HMIDIIN);
MMRESULT WINAPI midiInPrepareHeader(HMIDIIN,LPMIDIHDR,UINT);
MMRESULT WINAPI midiInUnprepareHeader(HMIDIIN,LPMIDIHDR,UINT);
MMRESULT WINAPI midiInStop(HMIDIIN);
MMRESULT WINAPI midiInReset(HMIDIIN);
MMRESULT WINAPI midiInGetID(HMIDIIN,LPUINT);
-MMRESULT WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
+#if (WINVER >= 0x030a)
+#ifdef _WIN32
+MMRESULT WINAPI midiInMessage(HMIDIIN,UINT,DWORD_PTR,DWORD_PTR);
+#else
+DWORD WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
+#endif
+#endif
UINT WINAPI auxGetNumDevs(void);
-MMRESULT WINAPI auxGetDevCapsA(UINT,LPAUXCAPSA,UINT);
-MMRESULT WINAPI auxGetDevCapsW(UINT,LPAUXCAPSW,UINT);
+MMRESULT WINAPI auxGetDevCapsA(UINT_PTR,LPAUXCAPSA,UINT);
+MMRESULT WINAPI auxGetDevCapsW(UINT_PTR,LPAUXCAPSW,UINT);
MMRESULT WINAPI auxSetVolume(UINT,DWORD);
MMRESULT WINAPI auxGetVolume(UINT,PDWORD);
-MMRESULT WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
+MMRESULT WINAPI auxOutMessage(UINT,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI mixerGetNumDevs(void);
-MMRESULT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
-MMRESULT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
-MMRESULT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
+MMRESULT WINAPI mixerGetDevCapsA(UINT_PTR,LPMIXERCAPSA,UINT);
+MMRESULT WINAPI mixerGetDevCapsW(UINT_PTR,LPMIXERCAPSW,UINT);
+MMRESULT WINAPI mixerOpen(LPHMIXER,UINT,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI mixerClose(HMIXER);
DWORD WINAPI mixerMessage(HMIXER,UINT,DWORD_PTR,DWORD_PTR);
MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
DWORD WINAPI timeGetTime(void);
-MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
+MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD_PTR,UINT);
MMRESULT WINAPI timeKillEvent(UINT);
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
MMRESULT WINAPI timeBeginPeriod(UINT);
MMRESULT WINAPI timeEndPeriod(UINT);
UINT WINAPI joyGetNumDevs(void);
-MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
-MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
+MMRESULT WINAPI joyGetDevCapsA(UINT_PTR,LPJOYCAPSA,UINT);
+MMRESULT WINAPI joyGetDevCapsW(UINT_PTR,LPJOYCAPSW,UINT);
MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
MMRESULT WINAPI joyGetPosEx(UINT,LPJOYINFOEX);
MMRESULT WINAPI joyGetThreshold(UINT,LPUINT);
MMRESULT WINAPI mmioDescend(HMMIO,LPMMCKINFO,const MMCKINFO*,UINT);
MMRESULT WINAPI mmioAscend(HMMIO,LPMMCKINFO,UINT);
MMRESULT WINAPI mmioCreateChunk(HMMIO,LPMMCKINFO,UINT);
-MCIERROR WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD,DWORD);
-MCIERROR WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD,DWORD);
+MCIERROR WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD,DWORD_PTR);
+MCIERROR WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD,DWORD_PTR);
MCIERROR WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
MCIERROR WINAPI mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND);
MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR);
{
DWORD cbStruct;
DWORD fdwStatus;
- DWORD dwUser;
+ DWORD_PTR dwUser;
LPBYTE pbSrc;
DWORD cbSrcLength;
DWORD cbSrcLengthUsed;
typedef struct _editstream
{
DWORD_PTR dwCookie;
- DWORD dwError;
+ DWORD_PTR dwError;
EDITSTREAMCALLBACK pfnCallback;
} EDITSTREAM;
int WINAPI SHFileOperationA(LPSHFILEOPSTRUCTA);
int WINAPI SHFileOperationW(LPSHFILEOPSTRUCTW);
void WINAPI SHFreeNameMappings(HANDLE);
-DWORD WINAPI SHGetFileInfoA(LPCSTR,DWORD,SHFILEINFOA*,UINT,UINT);
-DWORD WINAPI SHGetFileInfoW(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT);
+DWORD_PTR WINAPI SHGetFileInfoA(LPCSTR,DWORD,SHFILEINFOA*,UINT,UINT);
+DWORD_PTR WINAPI SHGetFileInfoW(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT);
BOOL WINAPI SHGetNewLinkInfoA(LPCSTR,LPCSTR,LPSTR,BOOL*,UINT);
BOOL WINAPI SHGetNewLinkInfoW(LPCWSTR,LPCWSTR,LPWSTR,BOOL*,UINT);
HRESULT WINAPI SHQueryRecycleBinA(LPCSTR, LPSHQUERYRBINFO);
BOOL WINAPI Process32NextW(HANDLE,LPPROCESSENTRY32W);
BOOL WINAPI Thread32First(HANDLE,LPTHREADENTRY32);
BOOL WINAPI Thread32Next(HANDLE,LPTHREADENTRY32);
-BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,DWORD,LPDWORD);
+BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,SIZE_T,SIZE_T*);
HANDLE WINAPI CreateToolhelp32Snapshot(DWORD,DWORD);
#ifdef UNICODE
#define LPMODULEENTRY32 LPMODULEENTRY32W
ICGetDefaultQuality(HIC hic)
{
DWORD dwICValue;
- ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
+ ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
return dwICValue;
}
static __inline DWORD
ICGetDefaultKeyFrameRate(HIC hic)
{
DWORD dwICValue;
- ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
+ ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
return dwICValue;
}
static __inline LRESULT
ic.dxDst = dxDst;
ic.dyDst = dyDst;
ic.hicDecompressor = hicDecomp;
- return ICSendMessage(hic,ICM_DRAW_SUGGESTFORMAT,(DWORD)&ic,sizeof(ic));
+ return ICSendMessage(hic,ICM_DRAW_SUGGESTFORMAT,(DWORD_PTR)&ic,sizeof(ic));
}
static __inline LRESULT
ICSetStatusProc(HIC hic,DWORD dwFlags,LRESULT lParam,LONG (CALLBACK *fpfnStatus)(LPARAM,UINT,LONG))
ic.dwFlags = dwFlags;
ic.lParam = lParam;
ic.Status = fpfnStatus;
- return ICSendMessage(hic,ICM_SET_STATUS_PROC,(DWORD)&ic,sizeof(ic));
+ return ICSendMessage(hic,ICM_SET_STATUS_PROC,(DWORD_PTR)&ic,sizeof(ic));
}
static __inline LRESULT
ICDecompressEx(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiSrc,LPVOID lpSrc,INT xSrc,INT ySrc,INT dxSrc,INT dySrc,LPBITMAPINFOHEADER lpbiDst,LPVOID lpDst,INT xDst,INT yDst,INT dxDst,INT dyDst)
ic.yDst = yDst;
ic.dxDst = dxDst;
ic.dyDst = dyDst;
- return ICSendMessage(hic,ICM_DECOMPRESSEX,(DWORD)&ic,sizeof(ic));
+ return ICSendMessage(hic,ICM_DECOMPRESSEX,(DWORD_PTR)&ic,sizeof(ic));
}
static __inline LRESULT
ICDecompressExBegin(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiSrc,LPVOID lpSrc,INT xSrc,INT ySrc,INT dxSrc,INT dySrc,LPBITMAPINFOHEADER lpbiDst,LPVOID lpDst,INT xDst,INT yDst,INT dxDst,INT dyDst)
ic.yDst = yDst;
ic.dxDst = dxDst;
ic.dyDst = dyDst;
- return ICSendMessage(hic,ICM_DECOMPRESSEX_BEGIN,(DWORD)&ic,sizeof(ic));
+ return ICSendMessage(hic,ICM_DECOMPRESSEX_BEGIN,(DWORD_PTR)&ic,sizeof(ic));
}
static __inline LRESULT
ICDecompressExQuery(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiSrc,LPVOID lpSrc,INT xSrc,INT ySrc,INT dxSrc,INT dySrc,LPBITMAPINFOHEADER lpbiDst,LPVOID lpDst,INT xDst,INT yDst,INT dxDst,INT dyDst)
ic.yDst = yDst;
ic.dxDst = dxDst;
ic.dyDst = dyDst;
- return ICSendMessage(hic,ICM_DECOMPRESSEX_QUERY,(DWORD)&ic,sizeof(ic));
+ return ICSendMessage(hic,ICM_DECOMPRESSEX_QUERY,(DWORD_PTR)&ic,sizeof(ic));
}
#ifdef UNICODE
LIST_ENTRY ProcessLocksList;
DWORD EntryCount;
DWORD ContentionCount;
- DWORD Spare [2];
+//#ifdef __WINESRC__ //not all wine code is marked so
+ DWORD_PTR Spare[8/sizeof(DWORD_PTR)];/* in Wine they store a string here */
+//#else
+ //WORD SpareWORD;
+//#endif
} CRITICAL_SECTION_DEBUG,*PCRITICAL_SECTION_DEBUG;
typedef struct _CRITICAL_SECTION {
PCRITICAL_SECTION_DEBUG DebugInfo;
DWORD dwPageSize;
PVOID lpMinimumApplicationAddress;
PVOID lpMaximumApplicationAddress;
- DWORD dwActiveProcessorMask;
+ DWORD_PTR dwActiveProcessorMask;
DWORD dwNumberOfProcessors;
DWORD dwProcessorType;
DWORD dwAllocationGranularity;
BOOL WINAPI GlobalUnWire(HGLOBAL); /* Obsolete: Has no effect. */
PVOID WINAPI GlobalWire(HGLOBAL); /* Obsolete: Has no effect. */
#define HasOverlappedIoCompleted(lpOverlapped) ((lpOverlapped)->Internal != STATUS_PENDING)
-PVOID WINAPI HeapAlloc(HANDLE,DWORD,DWORD);
+PVOID WINAPI HeapAlloc(HANDLE,DWORD,SIZE_T);
SIZE_T WINAPI HeapCompact(HANDLE,DWORD);
HANDLE WINAPI HeapCreate(DWORD,DWORD,DWORD);
BOOL WINAPI HeapDestroy(HANDLE);
BOOL WINAPI SetNamedPipeHandleState(HANDLE,PDWORD,PDWORD,PDWORD);
BOOL WINAPI SetPriorityClass(HANDLE,DWORD);
BOOL WINAPI SetPrivateObjectSecurity(SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR *,PGENERIC_MAPPING,HANDLE);
-BOOL WINAPI SetProcessAffinityMask(HANDLE,DWORD);
+BOOL WINAPI SetProcessAffinityMask(HANDLE,DWORD_PTR);
BOOL WINAPI SetProcessPriorityBoost(HANDLE,BOOL);
BOOL WINAPI SetProcessShutdownParameters(DWORD,DWORD);
BOOL WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
WINADVAPI BOOL WINAPI CryptHashData (HCRYPTHASH, CONST BYTE *, DWORD, DWORD);
WINADVAPI BOOL WINAPI CryptHashSessionKey (HCRYPTHASH, HCRYPTKEY, DWORD);
WINADVAPI BOOL WINAPI CryptImportKey (HCRYPTPROV, CONST BYTE *, DWORD, HCRYPTKEY, DWORD, HCRYPTKEY *);
-WINADVAPI BOOL WINAPI CryptReleaseContext (HCRYPTPROV, ULONG_PTR);
+WINADVAPI BOOL WINAPI CryptReleaseContext (HCRYPTPROV, DWORD);
WINADVAPI BOOL WINAPI CryptSetHashParam (HCRYPTHASH, DWORD, CONST BYTE *, DWORD);
WINADVAPI BOOL WINAPI CryptSetKeyParam (HCRYPTKEY, DWORD, CONST BYTE *, DWORD);
WINADVAPI BOOL WINAPI CryptSetProviderA (LPCSTR, DWORD);
typedef int HFILE;
typedef HICON HCURSOR;
typedef DWORD COLORREF;
-typedef int (WINAPI *FARPROC)();
-typedef int (WINAPI *NEARPROC)();
+#ifdef _WIN64
+typedef INT_PTR (FAR WINAPI *FARPROC)();
+typedef INT_PTR (NEAR WINAPI *NEARPROC)();
+typedef INT_PTR (WINAPI *PROC)();
+#else
+typedef int (FAR WINAPI *FARPROC)();
+typedef int (NEAR WINAPI *NEARPROC)();
typedef int (WINAPI *PROC)();
+#endif
typedef struct tagRECT {
LONG left;
LONG top;
#define RUNTIME_FUNCTION_INDIRECT 0x1
- typedef struct _RUNTIME_FUNCTION {
+typedef struct _RUNTIME_FUNCTION {
DWORD BeginAddress;
DWORD EndAddress;
DWORD UnwindData;
- } RUNTIME_FUNCTION,*PRUNTIME_FUNCTION;
+} RUNTIME_FUNCTION,*PRUNTIME_FUNCTION;
- typedef PRUNTIME_FUNCTION (*PGET_RUNTIME_FUNCTION_CALLBACK)(DWORD64 ControlPc,PVOID Context);
- typedef DWORD (*POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK)(HANDLE Process,PVOID TableAddress,PDWORD Entries,PRUNTIME_FUNCTION *Functions);
+#define UNWIND_HISTORY_TABLE_SIZE 12
- #define OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME "OutOfProcessFunctionTableCallback"
+typedef struct _UNWIND_HISTORY_TABLE_ENTRY
+{
+ ULONG64 ImageBase;
+ PRUNTIME_FUNCTION FunctionEntry;
+} UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY;
+
+typedef struct _UNWIND_HISTORY_TABLE
+{
+ ULONG Count;
+ UCHAR Search;
+ ULONG64 LowAddress;
+ ULONG64 HighAddress;
+ UNWIND_HISTORY_TABLE_ENTRY Entry[UNWIND_HISTORY_TABLE_SIZE];
+} UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE;
+
+typedef PRUNTIME_FUNCTION (*PGET_RUNTIME_FUNCTION_CALLBACK)(DWORD64 ControlPc,PVOID Context);
+typedef DWORD (*POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK)(HANDLE Process,PVOID TableAddress,PDWORD Entries,PRUNTIME_FUNCTION *Functions);
+
+#define OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME "OutOfProcessFunctionTableCallback"
NTSYSAPI
VOID
#elif defined (_M_AMD64)
FORCEINLINE PVOID GetCurrentFiber(VOID)
{
+ #ifdef NONAMELESSUNION
+ return (PVOID)__readgsqword(FIELD_OFFSET(NT_TIB, DUMMYUNIONNAME.FiberData));
+ #else
return (PVOID)__readgsqword(FIELD_OFFSET(NT_TIB, FiberData));
+ #endif
}
#elif defined (_M_ARM)
PVOID WINAPI GetCurrentFiber(VOID);
}
#endif
#elif defined (_M_AMD64)
-#define MemoryBarrier()
+#define MemoryBarrier __faststorefence
#elif defined(_M_PPC)
#define MemoryBarrier()
#elif defined(_M_ARM)
#endif
#define _BSDTYPES_DEFINED
#endif /* !defined _BSDTYPES_DEFINED */
-typedef u_int SOCKET;
+typedef UINT_PTR SOCKET;
#ifndef FD_SETSIZE
#define FD_SETSIZE 64
#endif
#endif
#define _BSDTYPES_DEFINED
#endif /* ! def _BSDTYPES_DEFINED */
-typedef u_int SOCKET;
+typedef UINT_PTR SOCKET;
#ifndef FD_SETSIZE
#define FD_SETSIZE 64
#endif
#define RT_RCDATA MAKEINTRESOURCE(10)
#define RT_MESSAGETABLE MAKEINTRESOURCE(11)
#define DIFFERENCE 11
-#define RT_GROUP_CURSOR MAKEINTRESOURCE((DWORD)RT_CURSOR+DIFFERENCE)
-#define RT_GROUP_ICON MAKEINTRESOURCE((DWORD)RT_ICON+DIFFERENCE)
+#define RT_GROUP_CURSOR MAKEINTRESOURCE((ULONG_PTR)RT_CURSOR+DIFFERENCE)
+#define RT_GROUP_ICON MAKEINTRESOURCE((ULONG_PTR)RT_ICON+DIFFERENCE)
#define RT_VERSION MAKEINTRESOURCE(16)
#define RT_DLGINCLUDE MAKEINTRESOURCE(17)
#define RT_PLUGPLAY MAKEINTRESOURCE(19)
UINT CtlID;
HWND hwndItem;
UINT itemID1;
- DWORD itemData1;
+ ULONG_PTR itemData1;
UINT itemID2;
- DWORD itemData2;
+ ULONG_PTR itemData2;
DWORD dwLocaleId;
} COMPAREITEMSTRUCT,*LPCOMPAREITEMSTRUCT;
typedef struct tagCOPYDATASTRUCT {
- DWORD dwData;
+ ULONG_PTR dwData;
DWORD cbData;
PVOID lpData;
} COPYDATASTRUCT,*PCOPYDATASTRUCT;
UINT CtlID;
UINT itemID;
HWND hwndItem;
- UINT itemData;
+ ULONG_PTR itemData;
} DELETEITEMSTRUCT,*PDELETEITEMSTRUCT,*LPDELETEITEMSTRUCT;
#pragma pack(push,2)
typedef struct {
HWND hwndItem;
HDC hDC;
RECT rcItem;
- DWORD itemData;
+ ULONG_PTR itemData;
} DRAWITEMSTRUCT,*LPDRAWITEMSTRUCT,*PDRAWITEMSTRUCT;
typedef struct {
UINT cbSize;
} ICONINFO,*PICONINFO;
typedef struct tagNMHDR {
HWND hwndFrom;
- UINT idFrom;
+ UINT_PTR idFrom;
UINT code;
} NMHDR,*LPNMHDR;
typedef struct _WNDCLASSA {
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
- DWORD dwItemData;
+ ULONG_PTR dwItemData;
LPSTR dwTypeData;
UINT cch;
#if (_WIN32_WINNT >= 0x0500)
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
- DWORD dwItemData;
+ ULONG_PTR dwItemData;
LPWSTR dwTypeData;
UINT cch;
#if (_WIN32_WINNT >= 0x0500)
int iContextType;
int iCtrlId;
HANDLE hItemHandle;
- DWORD dwContextId;
+ DWORD_PTR dwContextId;
POINT MousePos;
} HELPINFO,*LPHELPINFO;
typedef void(CALLBACK *MSGBOXCALLBACK)(LPHELPINFO);
LPCSTR lpszCaption;
DWORD dwStyle;
LPCSTR lpszIcon;
- DWORD dwContextHelpId;
+ DWORD_PTR dwContextHelpId;
MSGBOXCALLBACK lpfnMsgBoxCallback;
DWORD dwLanguageId;
} MSGBOXPARAMSA,*PMSGBOXPARAMSA,*LPMSGBOXPARAMSA;
LPCWSTR lpszCaption;
DWORD dwStyle;
LPCWSTR lpszIcon;
- DWORD dwContextHelpId;
+ DWORD_PTR dwContextHelpId;
MSGBOXCALLBACK lpfnMsgBoxCallback;
DWORD dwLanguageId;
} MSGBOXPARAMSW,*PMSGBOXPARAMSW,*LPMSGBOXPARAMSW;
POINT pt;
HWND hwnd;
UINT wHitTestCode;
- DWORD dwExtraInfo;
+ ULONG_PTR dwExtraInfo;
} MOUSEHOOKSTRUCT,*LPMOUSEHOOKSTRUCT,*PMOUSEHOOKSTRUCT;
#if ( _WIN32_WINNT >= 0x0500 )
#ifdef __cplusplus
UINT itemID;
UINT itemWidth;
UINT itemHeight;
- DWORD itemData;
+ ULONG_PTR itemData;
} MEASUREITEMSTRUCT,*PMEASUREITEMSTRUCT,*LPMEASUREITEMSTRUCT;
typedef struct tagDROPSTRUCT {
HWND hwndSource;
HWND hwndSink;
DWORD wFmt;
- DWORD dwData;
+ ULONG_PTR dwData;
POINT ptDrop;
DWORD dwControlData;
} DROPSTRUCT,*PDROPSTRUCT,*LPDROPSTRUCT;
DWORD scanCode;
DWORD flags;
DWORD time;
- DWORD dwExtraInfo;
+ ULONG_PTR dwExtraInfo;
} KBDLLHOOKSTRUCT,*LPKBDLLHOOKSTRUCT,*PKBDLLHOOKSTRUCT;
typedef struct tagMSLLHOOKSTRUCT
{
#define DialogBoxW(i,t,p,f) DialogBoxParamW(i,t,p,f,0)
#define DialogBoxIndirectA(i,t,p,f) DialogBoxIndirectParamA(i,t,p,f,0)
#define DialogBoxIndirectW(i,t,p,f) DialogBoxIndirectParamW(i,t,p,f,0)
-int WINAPI DialogBoxIndirectParamA(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
-int WINAPI DialogBoxIndirectParamW(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
-int WINAPI DialogBoxParamA(HINSTANCE,LPCSTR,HWND,DLGPROC,LPARAM);
-int WINAPI DialogBoxParamW(HINSTANCE,LPCWSTR,HWND,DLGPROC,LPARAM);
-LONG WINAPI DispatchMessageA(const MSG*);
-LONG WINAPI DispatchMessageW(const MSG*);
+INT_PTR WINAPI DialogBoxIndirectParamA(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
+INT_PTR WINAPI DialogBoxIndirectParamW(HINSTANCE,LPCDLGTEMPLATE,HWND,DLGPROC,LPARAM);
+INT_PTR WINAPI DialogBoxParamA(HINSTANCE,LPCSTR,HWND,DLGPROC,LPARAM);
+INT_PTR WINAPI DialogBoxParamW(HINSTANCE,LPCWSTR,HWND,DLGPROC,LPARAM);
+LRESULT WINAPI DispatchMessageA(const MSG*);
+LRESULT WINAPI DispatchMessageW(const MSG*);
int WINAPI DlgDirListA(HWND,LPSTR,int,int,UINT);
int WINAPI DlgDirListW(HWND,LPWSTR,int,int,UINT);
int WINAPI DlgDirListComboBoxA(HWND,LPSTR,int,int,UINT);
BOOL WINAPI DlgDirSelectExA(HWND,LPSTR,int,int);
BOOL WINAPI DlgDirSelectExW(HWND,LPWSTR,int,int);
BOOL WINAPI DragDetect(HWND,POINT);
-DWORD WINAPI DragObject(HWND,HWND,UINT,DWORD,HCURSOR);
+DWORD WINAPI DragObject(HWND,HWND,UINT,ULONG_PTR,HCURSOR);
BOOL WINAPI DrawAnimatedRects(HWND,int,LPCRECT,LPCRECT);
BOOL WINAPI DrawCaption(HWND,HDC,LPCRECT,UINT);
BOOL WINAPI DrawCaptionTempA(HWND,HDC,const RECT*,HFONT,HICON,LPCSTR,UINT);
BOOL WINAPI EnableScrollBar(HWND,UINT,UINT);
BOOL WINAPI EnableWindow(HWND,BOOL);
BOOL WINAPI EndDeferWindowPos(HDWP);
-BOOL WINAPI EndDialog(HWND,int);
+BOOL WINAPI EndDialog(HWND,INT_PTR);
BOOL WINAPI EndMenu(void);
BOOL WINAPI EndPaint(HWND,const PAINTSTRUCT*);
#if (_WIN32_WINNT >= 0x0500)
DWORD WINAPI GetClassLongA(HWND,int);
DWORD WINAPI GetClassLongW(HWND,int);
#ifdef _WIN64
-LONG_PTR WINAPI GetClassLongPtrA(HWND,int);
-LONG_PTR WINAPI GetClassLongPtrW(HWND,int);
+ULONG_PTR WINAPI GetClassLongPtrA(HWND,int);
+ULONG_PTR WINAPI GetClassLongPtrW(HWND,int);
#else
#define GetClassLongPtrA GetClassLongA
#define GetClassLongPtrW GetClassLongW
int WINAPI GetMenuStringW(HMENU,UINT,LPWSTR,int,UINT);
BOOL WINAPI GetMessageA(LPMSG,HWND,UINT,UINT);
BOOL WINAPI GetMessageW(LPMSG,HWND,UINT,UINT);
-LONG WINAPI GetMessageExtraInfo(void);
+LPARAM WINAPI GetMessageExtraInfo(void);
DWORD WINAPI GetMessagePos(void);
LONG WINAPI GetMessageTime(void);
#if (_WIN32_WINNT >= 0x0500 || _WIN32_WINDOWS >= 0x0490)
#if (_WIN32_WINNT >= 0x0500 || _WIN32_WINDOWS >= 0x0410)
DWORD WINAPI InSendMessageEx(LPVOID);
#endif
-BOOL WINAPI InsertMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
-BOOL WINAPI InsertMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
+BOOL WINAPI InsertMenuA(HMENU,UINT,UINT,UINT_PTR,LPCSTR);
+BOOL WINAPI InsertMenuW(HMENU,UINT,UINT,UINT_PTR,LPCWSTR);
BOOL WINAPI InsertMenuItemA(HMENU,UINT,BOOL,LPCMENUITEMINFOA);
BOOL WINAPI InsertMenuItemW(HMENU,UINT,BOOL,LPCMENUITEMINFOW);
INT WINAPI InternalGetWindowText(HWND,LPWSTR,INT);
BOOL WINAPI IsWinEventHookInstalled(DWORD);
#endif
BOOL WINAPI IsZoomed(HWND);
-VOID WINAPI keybd_event(BYTE,BYTE,DWORD,DWORD);
-BOOL WINAPI KillTimer(HWND,UINT);
+VOID WINAPI keybd_event(BYTE,BYTE,DWORD,ULONG_PTR);
+BOOL WINAPI KillTimer(HWND,UINT_PTR);
HACCEL WINAPI LoadAcceleratorsA(HINSTANCE,LPCSTR);
HACCEL WINAPI LoadAcceleratorsW(HINSTANCE,LPCWSTR);
HBITMAP WINAPI LoadBitmapA(HINSTANCE,LPCSTR);
int WINAPI MessageBoxExW(HWND,LPCWSTR,LPCWSTR,UINT,WORD);
int WINAPI MessageBoxIndirectA(CONST MSGBOXPARAMSA*);
int WINAPI MessageBoxIndirectW(CONST MSGBOXPARAMSW*);
-BOOL WINAPI ModifyMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
-BOOL WINAPI ModifyMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
+BOOL WINAPI ModifyMenuA(HMENU,UINT,UINT,UINT_PTR,LPCSTR);
+BOOL WINAPI ModifyMenuW(HMENU,UINT,UINT,UINT_PTR,LPCWSTR);
HMONITOR WINAPI MonitorFromPoint(POINT,DWORD);
HMONITOR WINAPI MonitorFromRect(LPCRECT,DWORD);
HMONITOR WINAPI MonitorFromWindow(HWND,DWORD);
BOOL WINAPI ScrollDC(HDC,int,int,LPCRECT,LPCRECT,HRGN,LPRECT);
BOOL WINAPI ScrollWindow(HWND,int,int,LPCRECT,LPCRECT);
int WINAPI ScrollWindowEx(HWND,int,int,LPCRECT,LPCRECT,HRGN,LPRECT,UINT);
-LONG WINAPI SendDlgItemMessageA(HWND,int,UINT,WPARAM,LPARAM);
-LONG WINAPI SendDlgItemMessageW(HWND,int,UINT,WPARAM,LPARAM);
+LRESULT WINAPI SendDlgItemMessageA(HWND,int,UINT,WPARAM,LPARAM);
+LRESULT WINAPI SendDlgItemMessageW(HWND,int,UINT,WPARAM,LPARAM);
#if (_WIN32_WINNT >= 0x0403)
UINT WINAPI SendInput(UINT,LPINPUT,int);
#endif
LRESULT WINAPI SendMessageA(HWND,UINT,WPARAM,LPARAM);
-BOOL WINAPI SendMessageCallbackA(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,DWORD);
-BOOL WINAPI SendMessageCallbackW(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,DWORD);
+BOOL WINAPI SendMessageCallbackA(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,ULONG_PTR);
+BOOL WINAPI SendMessageCallbackW(HWND,UINT,WPARAM,LPARAM,SENDASYNCPROC,ULONG_PTR);
LRESULT WINAPI SendMessageTimeoutA(HWND,UINT,WPARAM,LPARAM,UINT,UINT,PDWORD_PTR);
LRESULT WINAPI SendMessageTimeoutW(HWND,UINT,WPARAM,LPARAM,UINT,UINT,PDWORD_PTR);
LRESULT WINAPI SendMessageW(HWND,UINT,WPARAM,LPARAM);
#define SetSysModalWindow(h) (NULL)
BOOL WINAPI SetSystemCursor(HCURSOR,DWORD);
BOOL WINAPI SetThreadDesktop(HDESK);
-UINT WINAPI SetTimer(HWND,UINT,UINT,TIMERPROC);
+UINT_PTR WINAPI SetTimer(HWND,UINT_PTR,UINT,TIMERPROC);
BOOL WINAPI SetUserObjectInformationA(HANDLE,int,PVOID,DWORD);
BOOL WINAPI SetUserObjectInformationW(HANDLE,int,PVOID,DWORD);
BOOL WINAPI SetUserObjectSecurity(HANDLE,PSECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
HWND WINAPI WindowFromDC(HDC hDC);
HWND WINAPI WindowFromPoint(POINT);
UINT WINAPI WinExec(LPCSTR,UINT);
-BOOL WINAPI WinHelpA(HWND,LPCSTR,UINT,DWORD);
-BOOL WINAPI WinHelpW(HWND,LPCWSTR,UINT,DWORD);
+BOOL WINAPI WinHelpA(HWND,LPCSTR,UINT,ULONG_PTR);
+BOOL WINAPI WinHelpW(HWND,LPCWSTR,UINT,ULONG_PTR);
int WINAPIV wsprintfA(LPSTR,LPCSTR,...);
int WINAPIV wsprintfW(LPWSTR,LPCWSTR,...);
int WINAPI wvsprintfA(LPSTR,LPCSTR,va_list arglist);
typedef struct _AFD_POLL_INFO {
LARGE_INTEGER Timeout;
ULONG HandleCount;
- ULONG Exclusive;
+ ULONG_PTR Exclusive;
AFD_HANDLE Handles[1];
} AFD_POLL_INFO, *PAFD_POLL_INFO;