marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Correct SIZE_T size according to MS SDK. 

Change some types to SIZE_T according to MS SDK definitions.
oldstable
Dmitry Timoshkov 2002-09-21 01:21:00 +00:00 committed by Alexandre Julliard
parent b1658d40c5
commit 472d016859
11 changed files with 94 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
controls/edit.c
View File

@ -2616,7 +2616,7 @@ static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es)
hLocal = es->hloc32A;
}
TRACE("Returning %04X, LocalSize() = %d\n", hLocal, LocalSize(hLocal));
TRACE("Returning %04X, LocalSize() = %ld\n", hLocal, LocalSize(hLocal));
return hLocal;
}

2
dlls/winedos/dosvm.c
View File

@ -415,7 +415,7 @@ DWORD WINAPI DOSVM_Loop( HANDLE hThread )
/* (sort of like APC, but we signal the completion) */
{
DOS_SPC *spc = (DOS_SPC *)msg.lParam;
TRACE_(int)("calling %p with arg %08x\n", spc->proc, spc->arg);
TRACE_(int)("calling %p with arg %08lx\n", spc->proc, spc->arg);
(spc->proc)(spc->arg);
TRACE_(int)("done, signalling event %d\n", msg.wParam);
SetEvent(msg.wParam);

10
include/basetsd.h
View File

@ -86,10 +86,10 @@ typedef unsigned __int32 UHALF_PTR, *PUHALF_PTR;
#else /* FIXME: defined(_WIN32) */
typedef signed __int32 INT_PTR, *PINT_PTR;
typedef signed __int32 LONG_PTR, *PLONG_PTR;
typedef long LONG_PTR, *PLONG_PTR;
typedef unsigned __int32 UINT_PTR, *PUINT_PTR;
typedef unsigned __int32 ULONG_PTR, *PULONG_PTR;
typedef unsigned __int32 DWORD_PTR, *PDWORD_PTR;
typedef unsigned long ULONG_PTR, *PULONG_PTR;
typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
#define MAXINT_PTR 0x7fffffff
#define MININT_PTR 0x80000000
@ -104,8 +104,8 @@ typedef unsigned __int16 UHALF_PTR, *PUHALF_PTR;
#endif /* defined(_WIN64) || defined(_WIN32) */
typedef INT_PTR SSIZE_T, *PSSIZE_T;
typedef UINT_PTR SIZE_T, *PSIZE_T;
typedef LONG_PTR SSIZE_T, *PSSIZE_T;
typedef ULONG_PTR SIZE_T, *PSIZE_T;
/* Some Wine-specific definitions */

90
include/winbase.h
View File

@ -446,12 +446,12 @@ typedef struct tagMEMORYSTATUS
{
DWORD dwLength;
DWORD dwMemoryLoad;
DWORD dwTotalPhys;
DWORD dwAvailPhys;
DWORD dwTotalPageFile;
DWORD dwAvailPageFile;
DWORD dwTotalVirtual;
DWORD dwAvailVirtual;
SIZE_T dwTotalPhys;
SIZE_T dwAvailPhys;
SIZE_T dwTotalPageFile;
SIZE_T dwAvailPageFile;
SIZE_T dwTotalVirtual;
SIZE_T dwAvailVirtual;
} MEMORYSTATUS, *LPMEMORYSTATUS;
@ -1094,10 +1094,6 @@ BOOL WINAPI GetVersionExW(OSVERSIONINFOW*);
/*int WinMain(HINSTANCE, HINSTANCE prev, char *cmd, int show);*/
LPVOID WINAPI HeapAlloc(HANDLE,DWORD,DWORD);
BOOL WINAPI HeapFree(HANDLE,DWORD,LPVOID);
LPVOID WINAPI HeapReAlloc(HANDLE,DWORD,LPVOID,DWORD);
DWORD WINAPI HeapSize(HANDLE,DWORD,LPVOID);
void WINAPI InitializeCriticalSection(CRITICAL_SECTION *lpCrit);
BOOL WINAPI InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION *,DWORD);
void WINAPI DeleteCriticalSection(CRITICAL_SECTION *lpCrit);
@ -1105,10 +1101,10 @@ 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,LPDWORD,LPDWORD);
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,DWORD,DWORD);
BOOL WINAPI SetProcessWorkingSetSize(HANDLE,SIZE_T,SIZE_T);
BOOL WINAPI TerminateProcess(HANDLE,DWORD);
BOOL WINAPI TerminateThread(HANDLE,DWORD);
BOOL WINAPI GetExitCodeThread(HANDLE,LPDWORD);
@ -1200,12 +1196,12 @@ BOOL WINAPI CreateProcessW(LPCWSTR,LPWSTR,LPSECURITY_ATTRIBUTES,
LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCWSTR,
LPSTARTUPINFOW,LPPROCESS_INFORMATION);
#define CreateProcess WINELIB_NAME_AW(CreateProcess)
HANDLE WINAPI CreateRemoteThread(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
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);
#define CreateSemaphore WINELIB_NAME_AW(CreateSemaphore)
DWORD WINAPI CreateTapePartition(HANDLE,DWORD,DWORD,DWORD);
HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES,SIZE_T,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
HANDLE WINAPI CreateWaitableTimerA(LPSECURITY_ATTRIBUTES,BOOL,LPCSTR);
HANDLE WINAPI CreateWaitableTimerW(LPSECURITY_ATTRIBUTES,BOOL,LPCWSTR);
#define CreateWaitableTimer WINELIB_NAME_AW(CreateWaitableTimer)
@ -1254,7 +1250,7 @@ HRSRC WINAPI FindResourceExA(HMODULE,LPCSTR,LPCSTR,WORD);
HRSRC WINAPI FindResourceExW(HMODULE,LPCWSTR,LPCWSTR,WORD);
#define FindResourceEx WINELIB_NAME_AW(FindResourceEx)
BOOL WINAPI FlushFileBuffers(HANDLE);
BOOL WINAPI FlushViewOfFile(LPCVOID, DWORD);
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*);
#define FormatMessage WINELIB_NAME_AW(FormatMessage)
@ -1348,12 +1344,16 @@ BOOL WINAPI GetUserNameA(LPSTR,LPDWORD);
BOOL WINAPI GetUserNameW(LPWSTR,LPDWORD);
#define GetUserName WINELIB_NAME_AW(GetUserName)
VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
DWORD WINAPI HeapCompact(HANDLE,DWORD);
HANDLE WINAPI HeapCreate(DWORD,DWORD,DWORD);
BOOL WINAPI HeapDestroy(HANDLE);
BOOL WINAPI HeapLock(HANDLE);
BOOL WINAPI HeapUnlock(HANDLE);
BOOL WINAPI HeapValidate(HANDLE,DWORD,LPCVOID);
LPVOID WINAPI HeapAlloc(HANDLE,DWORD,SIZE_T);
SIZE_T WINAPI HeapCompact(HANDLE,DWORD);
HANDLE WINAPI HeapCreate(DWORD,SIZE_T,SIZE_T);
BOOL WINAPI HeapDestroy(HANDLE);
BOOL WINAPI HeapFree(HANDLE,DWORD,LPVOID);
BOOL WINAPI HeapLock(HANDLE);
LPVOID WINAPI HeapReAlloc(HANDLE,DWORD,LPVOID,SIZE_T);
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 InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
@ -1376,8 +1376,8 @@ BOOL WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,LPVOID);
BOOL WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
HMODULE WINAPI MapHModuleSL(WORD);
WORD WINAPI MapHModuleLS(HMODULE);
LPVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
LPVOID WINAPI MapViewOfFileEx(HANDLE,DWORD,DWORD,DWORD,DWORD,LPVOID);
LPVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,SIZE_T);
LPVOID WINAPI MapViewOfFileEx(HANDLE,DWORD,DWORD,DWORD,SIZE_T,LPVOID);
BOOL WINAPI MoveFileA(LPCSTR,LPCSTR);
BOOL WINAPI MoveFileW(LPCWSTR,LPCWSTR);
#define MoveFile WINELIB_NAME_AW(MoveFile)
@ -1498,16 +1498,16 @@ BOOL WINAPI UnmapViewOfFile(LPVOID);
BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA,DWORD,DWORDLONG);
BOOL WINAPI VerifyVersionInfoW(LPOSVERSIONINFOEXW,DWORD,DWORDLONG);
#define VerifyVersionInfo WINELIB_NAME_AW(VerifyVersionInfo)
LPVOID WINAPI VirtualAlloc(LPVOID,DWORD,DWORD,DWORD);
LPVOID WINAPI VirtualAllocEx(HANDLE,LPVOID,DWORD,DWORD,DWORD);
BOOL WINAPI VirtualFree(LPVOID,DWORD,DWORD);
BOOL WINAPI VirtualFreeEx(HANDLE,LPVOID,DWORD,DWORD);
BOOL WINAPI VirtualLock(LPVOID,DWORD);
BOOL WINAPI VirtualProtect(LPVOID,DWORD,DWORD,LPDWORD);
BOOL WINAPI VirtualProtectEx(HANDLE,LPVOID,DWORD,DWORD,LPDWORD);
DWORD WINAPI VirtualQuery(LPCVOID,LPMEMORY_BASIC_INFORMATION,DWORD);
DWORD WINAPI VirtualQueryEx(HANDLE,LPCVOID,LPMEMORY_BASIC_INFORMATION,DWORD);
BOOL WINAPI VirtualUnlock(LPVOID,DWORD);
LPVOID WINAPI VirtualAlloc(LPVOID,SIZE_T,DWORD,DWORD);
LPVOID WINAPI VirtualAllocEx(HANDLE,LPVOID,SIZE_T,DWORD,DWORD);
BOOL WINAPI VirtualFree(LPVOID,SIZE_T,DWORD);
BOOL WINAPI VirtualFreeEx(HANDLE,LPVOID,SIZE_T,DWORD);
BOOL WINAPI VirtualLock(LPVOID,SIZE_T);
BOOL WINAPI VirtualProtect(LPVOID,SIZE_T,DWORD,LPDWORD);
BOOL WINAPI VirtualProtectEx(HANDLE,LPVOID,SIZE_T,DWORD,LPDWORD);
SIZE_T WINAPI VirtualQuery(LPCVOID,LPMEMORY_BASIC_INFORMATION,SIZE_T);
SIZE_T WINAPI VirtualQueryEx(HANDLE,LPCVOID,LPMEMORY_BASIC_INFORMATION,SIZE_T);
BOOL WINAPI VirtualUnlock(LPVOID,SIZE_T);
BOOL WINAPI WaitCommEvent(HANDLE,LPDWORD,LPOVERLAPPED);
BOOL WINAPI WaitForDebugEvent(LPDEBUG_EVENT,DWORD);
DWORD WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
@ -1554,7 +1554,7 @@ BOOL WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
HRSRC WINAPI FindResourceW(HMODULE,LPCWSTR,LPCWSTR);
#define FindResource WINELIB_NAME_AW(FindResource)
BOOL WINAPI FlushInstructionCache(HANDLE,LPCVOID,DWORD);
BOOL WINAPI FlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
BOOL WINAPI FreeLibrary(HMODULE);
#define FreeModule(handle) FreeLibrary(handle)
#define FreeProcInstance(proc) /*nothing*/
@ -1638,8 +1638,8 @@ UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
ATOM WINAPI GlobalAddAtomA(LPCSTR);
ATOM WINAPI GlobalAddAtomW(LPCWSTR);
#define GlobalAddAtom WINELIB_NAME_AW(GlobalAddAtom)
HGLOBAL WINAPI GlobalAlloc(UINT,DWORD);
DWORD WINAPI GlobalCompact(DWORD);
HGLOBAL WINAPI GlobalAlloc(UINT,SIZE_T);
SIZE_T WINAPI GlobalCompact(DWORD);
ATOM WINAPI GlobalDeleteAtom(ATOM);
ATOM WINAPI GlobalFindAtomA(LPCSTR);
ATOM WINAPI GlobalFindAtomW(LPCWSTR);
@ -1652,8 +1652,8 @@ UINT WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,INT);
HGLOBAL WINAPI GlobalHandle(LPCVOID);
VOID WINAPI GlobalFix(HGLOBAL);
LPVOID WINAPI GlobalLock(HGLOBAL);
HGLOBAL WINAPI GlobalReAlloc(HGLOBAL,DWORD,UINT);
DWORD WINAPI GlobalSize(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);
@ -1677,15 +1677,15 @@ 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,DWORD);
UINT WINAPI LocalCompact(UINT);
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,DWORD,UINT);
UINT WINAPI LocalShrink(HGLOBAL,UINT);
UINT WINAPI LocalSize(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))
@ -1694,7 +1694,7 @@ 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, DWORD, LPDWORD);
BOOL WINAPI ReadProcessMemory(HANDLE,LPCVOID,LPVOID,SIZE_T,SIZE_T*);
BOOL WINAPI RemoveDirectoryA(LPCSTR);
BOOL WINAPI RemoveDirectoryW(LPCWSTR);
#define RemoveDirectory WINELIB_NAME_AW(RemoveDirectory)
@ -1724,7 +1724,7 @@ BOOL WINAPI WriteProfileSectionW(LPCWSTR,LPCWSTR);
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,DWORD,LPDWORD);
BOOL WINAPI WriteProcessMemory(HANDLE,LPVOID,LPCVOID,SIZE_T,SIZE_T*);
BOOL WINAPI WriteProfileStringA(LPCSTR,LPCSTR,LPCSTR);
BOOL WINAPI WriteProfileStringW(LPCWSTR,LPCWSTR,LPCWSTR);
#define WriteProfileString WINELIB_NAME_AW(WriteProfileString)

8
memory/global.c
View File

@ -1046,7 +1046,7 @@ typedef struct __GLOBAL32_INTERN
*/
HGLOBAL WINAPI GlobalAlloc(
UINT flags, /* [in] Object allocation attributes */
DWORD size /* [in] Number of bytes to allocate */
SIZE_T size /* [in] Number of bytes to allocate */
) {
PGLOBAL32_INTERN pintern;
DWORD hpflags;
@ -1239,7 +1239,7 @@ HGLOBAL WINAPI GlobalHandle(
*/
HGLOBAL WINAPI GlobalReAlloc(
HGLOBAL hmem, /* [in] Handle of global memory object */
DWORD size, /* [in] New size of block */
SIZE_T size, /* [in] New size of block */
UINT flags /* [in] How to reallocate object */
) {
LPVOID palloc;
@ -1395,7 +1395,7 @@ HGLOBAL WINAPI GlobalFree(
* Size in bytes of the global memory object
* 0: Failure
*/
DWORD WINAPI GlobalSize(
SIZE_T WINAPI GlobalSize(
HGLOBAL hmem /* [in] Handle of global memory object */
) {
DWORD retval;
@ -1512,7 +1512,7 @@ UINT WINAPI GlobalFlags(
/***********************************************************************
* GlobalCompact (KERNEL32.@)
*/
DWORD WINAPI GlobalCompact( DWORD minfree )
SIZE_T WINAPI GlobalCompact( DWORD minfree )
{
return 0; /* GlobalCompact does nothing in Win32 */
}

12
memory/heap.c
View File

@ -135,8 +135,8 @@ inline static HANDLE HEAP_CreateSystemHeap(void)
*/
HANDLE WINAPI HeapCreate(
DWORD flags, /* [in] Heap allocation flag */
DWORD initialSize, /* [in] Initial heap size */
DWORD maxSize /* [in] Maximum heap size */
SIZE_T initialSize, /* [in] Initial heap size */
SIZE_T maxSize /* [in] Maximum heap size */
) {
HANDLE ret;
@ -176,7 +176,7 @@ BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
/***********************************************************************
* HeapCompact (KERNEL32.@)
*/
DWORD WINAPI HeapCompact( HANDLE heap, DWORD flags )
SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags )
{
return RtlCompactHeap( heap, flags );
}
@ -782,7 +782,7 @@ BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry )
/* FIXME: these functions are needed for dlls that aren't properly separated yet */
LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, DWORD size )
LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
{
return RtlAllocateHeap( heap, flags, size );
}
@ -792,12 +792,12 @@ BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
return RtlFreeHeap( heap, flags, ptr );
}
LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, DWORD size )
LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
{
return RtlReAllocateHeap( heap, flags, ptr, size );
}
DWORD WINAPI HeapSize( HANDLE heap, DWORD flags, LPVOID ptr )
SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPVOID ptr )
{
return RtlSizeHeap( heap, flags, ptr );
}

10
memory/local.c
View File

@ -1834,7 +1834,7 @@ BOOL16 WINAPI LocalNext16( LOCALENTRY *pLocalEntry )
*/
HLOCAL WINAPI LocalAlloc(
UINT flags, /* [in] Allocation attributes */
DWORD size /* [in] Number of bytes to allocate */
SIZE_T size /* [in] Number of bytes to allocate */
) {
return (HLOCAL)GlobalAlloc( flags, size );
}
@ -1843,7 +1843,7 @@ HLOCAL WINAPI LocalAlloc(
/***********************************************************************
* LocalCompact (KERNEL32.@)
*/
UINT WINAPI LocalCompact( UINT minfree )
SIZE_T WINAPI LocalCompact( UINT minfree )
{
return 0; /* LocalCompact does nothing in Win32 */
}
@ -1912,7 +1912,7 @@ LPVOID WINAPI LocalLock(
*/
HLOCAL WINAPI LocalReAlloc(
HLOCAL handle, /* [in] Handle of memory object */
DWORD size, /* [in] New size of block */
SIZE_T size, /* [in] New size of block */
UINT flags /* [in] How to reallocate object */
) {
return (HLOCAL)GlobalReAlloc( (HGLOBAL)handle, size, flags );
@ -1922,7 +1922,7 @@ HLOCAL WINAPI LocalReAlloc(
/***********************************************************************
* LocalShrink (KERNEL32.@)
*/
UINT WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
{
return 0; /* LocalShrink does nothing in Win32 */
}
@ -1934,7 +1934,7 @@ UINT WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
* Size: Success
* 0: Failure
*/
UINT WINAPI LocalSize(
SIZE_T WINAPI LocalSize(
HLOCAL handle /* [in] Handle of memory object */
) {
return GlobalSize( (HGLOBAL)handle );

30
memory/virtual.c
View File

@ -60,7 +60,7 @@ static WINE_EXCEPTION_FILTER(page_fault)
*/
LPVOID WINAPI VirtualAlloc(
LPVOID addr, /* [in] Address of region to reserve or commit */
DWORD size, /* [in] Size of region */
SIZE_T size, /* [in] Size of region */
DWORD type, /* [in] Type of allocation */
DWORD protect)/* [in] Type of access protection */
{
@ -76,7 +76,7 @@ LPVOID WINAPI VirtualAlloc(
LPVOID WINAPI VirtualAllocEx(
HANDLE hProcess, /* [in] Handle of process to do mem operation */
LPVOID addr, /* [in] Address of region to reserve or commit */
DWORD size, /* [in] Size of region */
SIZE_T size, /* [in] Size of region */
DWORD type, /* [in] Type of allocation */
DWORD protect ) /* [in] Type of access protection */
{
@ -102,7 +102,7 @@ LPVOID WINAPI VirtualAllocEx(
*/
BOOL WINAPI VirtualFree(
LPVOID addr, /* [in] Address of region of committed pages */
DWORD size, /* [in] Size of region */
SIZE_T size, /* [in] Size of region */
DWORD type /* [in] Type of operation */
) {
return VirtualFreeEx( GetCurrentProcess(), addr, size, type );
@ -117,7 +117,7 @@ BOOL WINAPI VirtualFree(
* TRUE: Success
* FALSE: Failure
*/
BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, DWORD size, DWORD type )
BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, SIZE_T size, DWORD type )
{
NTSTATUS status = NtFreeVirtualMemory( process, &addr, &size, type );
if (status) SetLastError( RtlNtStatusToDosError(status) );
@ -137,7 +137,7 @@ BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, DWORD size, DWORD type )
* FALSE: Failure
*/
BOOL WINAPI VirtualLock( LPVOID addr, /* [in] Address of first byte of range to lock */
DWORD size ) /* [in] Number of bytes in range to lock */
SIZE_T size ) /* [in] Number of bytes in range to lock */
{
NTSTATUS status = NtLockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
if (status) SetLastError( RtlNtStatusToDosError(status) );
@ -157,7 +157,7 @@ BOOL WINAPI VirtualLock( LPVOID addr, /* [in] Address of first byte of range to
* FALSE: Failure
*/
BOOL WINAPI VirtualUnlock( LPVOID addr, /* [in] Address of first byte of range */
DWORD size ) /* [in] Number of bytes in range */
SIZE_T size ) /* [in] Number of bytes in range */
{
NTSTATUS status = NtUnlockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
if (status) SetLastError( RtlNtStatusToDosError(status) );
@ -175,7 +175,7 @@ BOOL WINAPI VirtualUnlock( LPVOID addr, /* [in] Address of first byte of range *
*/
BOOL WINAPI VirtualProtect(
LPVOID addr, /* [in] Address of region of committed pages */
DWORD size, /* [in] Size of region */
SIZE_T size, /* [in] Size of region */
DWORD new_prot, /* [in] Desired access protection */
LPDWORD old_prot /* [out] Address of variable to get old protection */
) {
@ -195,7 +195,7 @@ BOOL WINAPI VirtualProtect(
BOOL WINAPI VirtualProtectEx(
HANDLE process, /* [in] Handle of process */
LPVOID addr, /* [in] Address of region of committed pages */
DWORD size, /* [in] Size of region */
SIZE_T size, /* [in] Size of region */
DWORD new_prot, /* [in] Desired access protection */
LPDWORD old_prot /* [out] Address of variable to get old protection */ )
{
@ -213,10 +213,10 @@ BOOL WINAPI VirtualProtectEx(
* Number of bytes returned in information buffer
* or 0 if addr is >= 0xc0000000 (kernel space).
*/
DWORD WINAPI VirtualQuery(
SIZE_T WINAPI VirtualQuery(
LPCVOID addr, /* [in] Address of region */
LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
DWORD len /* [in] Size of buffer */
SIZE_T len /* [in] Size of buffer */
) {
return VirtualQueryEx( GetCurrentProcess(), addr, info, len );
}
@ -230,11 +230,11 @@ DWORD WINAPI VirtualQuery(
* RETURNS
* Number of bytes returned in information buffer
*/
DWORD WINAPI VirtualQueryEx(
SIZE_T WINAPI VirtualQueryEx(
HANDLE process, /* [in] Handle of process */
LPCVOID addr, /* [in] Address of region */
LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
DWORD len /* [in] Size of buffer */ )
SIZE_T len /* [in] Size of buffer */ )
{
DWORD ret;
NTSTATUS status;
@ -420,7 +420,7 @@ LPVOID WINAPI MapViewOfFile(
DWORD access, /* [in] Access mode */
DWORD offset_high, /* [in] High-order 32 bits of file offset */
DWORD offset_low, /* [in] Low-order 32 bits of file offset */
DWORD count /* [in] Number of bytes to map */
SIZE_T count /* [in] Number of bytes to map */
) {
return MapViewOfFileEx( mapping, access, offset_high,
offset_low, count, NULL );
@ -440,7 +440,7 @@ LPVOID WINAPI MapViewOfFileEx(
DWORD access, /* [in] Access mode */
DWORD offset_high, /* [in] High-order 32 bits of file offset */
DWORD offset_low, /* [in] Low-order 32 bits of file offset */
DWORD count, /* [in] Number of bytes to map */
SIZE_T count, /* [in] Number of bytes to map */
LPVOID addr /* [in] Suggested starting address for mapped view */
) {
NTSTATUS status;
@ -493,7 +493,7 @@ BOOL WINAPI UnmapViewOfFile( LPVOID addr ) /* [in] Address where mapped view beg
* FALSE: Failure
*/
BOOL WINAPI FlushViewOfFile( LPCVOID base, /* [in] Start address of byte range to flush */
DWORD size ) /* [in] Number of bytes in range */
SIZE_T size ) /* [in] Number of bytes in range */
{
NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
if (status)

20
scheduler/process.c
View File

@ -1625,11 +1625,11 @@ DWORD WINAPI GetProcessFlags( DWORD processid )
*
* RETURNS STD
*/
BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,DWORD minset,
DWORD maxset)
BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T minset,
SIZE_T maxset)
{
FIXME("(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
if(( minset == (DWORD)-1) && (maxset == (DWORD)-1)) {
if(( minset == (SIZE_T)-1) && (maxset == (SIZE_T)-1)) {
/* Trim the working set to zero */
/* Swap the process out of physical RAM */
}
@ -1639,8 +1639,8 @@ BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,DWORD minset,
/***********************************************************************
* GetProcessWorkingSetSize (KERNEL32.@)
*/
BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess,LPDWORD minset,
LPDWORD maxset)
BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T minset,
PSIZE_T maxset)
{
FIXME("(0x%08x,%p,%p): stub\n",hProcess,minset,maxset);
/* 32 MB working set size */
@ -1693,8 +1693,8 @@ BOOL WINAPI SetProcessPriorityBoost(HANDLE hprocess,BOOL disableboost)
/***********************************************************************
* ReadProcessMemory (KERNEL32.@)
*/
BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, DWORD size,
LPDWORD bytes_read )
BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, SIZE_T size,
SIZE_T *bytes_read )
{
DWORD res;
@ -1714,8 +1714,8 @@ BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, DWOR
/***********************************************************************
* WriteProcessMemory (KERNEL32.@)
*/
BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPCVOID buffer, DWORD size,
LPDWORD bytes_written )
BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPCVOID buffer, SIZE_T size,
SIZE_T *bytes_written )
{
static const int zero;
unsigned int first_offset, last_offset, first_mask, last_mask;
@ -1753,7 +1753,7 @@ BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPCVOID buffer, DWO
if (bytes_written) *bytes_written = size;
{
char dummy[32];
DWORD read;
SIZE_T read;
ReadProcessMemory( process, addr, dummy, sizeof(dummy), &read );
}
return !res;

2
scheduler/thread.c
View File

@ -271,7 +271,7 @@ static void THREAD_Start(void)
/***********************************************************************
* CreateThread (KERNEL32.@)
*/
HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack,
LPTHREAD_START_ROUTINE start, LPVOID param,
DWORD flags, LPDWORD id )
{

2
win32/newfns.c
View File

@ -156,7 +156,7 @@ BOOL WINAPI QueryPerformanceFrequency(PLARGE_INTEGER frequency)
/****************************************************************************
* FlushInstructionCache (KERNEL32.@)
*/
BOOL WINAPI FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, DWORD dwSize)
BOOL WINAPI FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize)
{
if (GetVersion() & 0x80000000) return TRUE; /* not NT, always TRUE */
FIXME_(debug)("(0x%08lx,%p,0x%08lx): stub\n",(DWORD)hProcess, lpBaseAddress, dwSize);