Use SIZE_T type for size variables in NTDLL when appropriate, avoid not necessary casts
Dmitry Timoshkov
dmitry at baikal.ru
Mon Jul 11 10:58:50 CDT 2005
Hello,
Win32 heap and virtual memory APIs use SIZE_T type for the memory size
variables, presumably NTDLL APIs should do the same.
Changelog:
Dmitry Timoshkov <dmitry at codeweavers.com>
Use SIZE_T type for size variables in NTDLL when appropriate,
avoid not necessary casts.
diff -up cvs/hq/wine/dlls/ntdll/heap.c wine/dlls/ntdll/heap.c
--- cvs/hq/wine/dlls/ntdll/heap.c Mon Jul 11 23:11:04 2005
+++ wine/dlls/ntdll/heap.c Tue Jul 12 00:45:08 2005
@@ -50,14 +50,14 @@ WINE_DEFAULT_DEBUG_CHANNEL(heap);
typedef struct tagARENA_INUSE
{
- DWORD size; /* Block size; must be the first field */
+ SIZE_T size; /* Block size; must be the first field */
DWORD magic : 27; /* Magic number */
DWORD unused_bytes : 5; /* Number of bytes in the block not used by user data (max value is HEAP_MIN_BLOCK_SIZE+ALIGNMENT) */
} ARENA_INUSE;
typedef struct tagARENA_FREE
{
- DWORD size; /* Block size; must be the first field */
+ SIZE_T size; /* Block size; must be the first field */
DWORD magic; /* Magic number */
struct tagARENA_FREE *next; /* Next free arena */
struct tagARENA_FREE *prev; /* Prev free arena */
@@ -88,7 +88,7 @@ static const DWORD HEAP_freeListSizes[HE
typedef struct
{
- DWORD size;
+ SIZE_T size;
ARENA_FREE arena;
} FREE_LIST_ENTRY;
@@ -96,9 +96,9 @@ struct tagHEAP;
typedef struct tagSUBHEAP
{
- DWORD size; /* Size of the whole sub-heap */
- DWORD commitSize; /* Committed size of the sub-heap */
- DWORD headerSize; /* Size of the heap header */
+ SIZE_T size; /* Size of the whole sub-heap */
+ SIZE_T commitSize; /* Committed size of the sub-heap */
+ SIZE_T headerSize; /* Size of the heap header */
struct tagSUBHEAP *next; /* Next sub-heap */
struct tagHEAP *heap; /* Main heap structure */
DWORD magic; /* Magic number */
@@ -129,7 +129,7 @@ static HEAP *firstHeap; /* head of s
static BOOL HEAP_IsRealArena( HEAP *heapPtr, DWORD flags, LPCVOID block, BOOL quiet );
/* mark a block of memory as free for debugging purposes */
-static inline void mark_block_free( void *ptr, size_t size )
+static inline void mark_block_free( void *ptr, SIZE_T size )
{
if (TRACE_ON(heap)) memset( ptr, ARENA_FREE_FILLER, size );
#ifdef VALGRIND_MAKE_NOACCESS
@@ -138,7 +138,7 @@ static inline void mark_block_free( void
}
/* mark a block of memory as initialized for debugging purposes */
-static inline void mark_block_initialized( void *ptr, size_t size )
+static inline void mark_block_initialized( void *ptr, SIZE_T size )
{
#ifdef VALGRIND_MAKE_READABLE
VALGRIND_DISCARD( VALGRIND_MAKE_READABLE( ptr, size ));
@@ -146,7 +146,7 @@ static inline void mark_block_initialize
}
/* mark a block of memory as uninitialized for debugging purposes */
-static inline void mark_block_uninitialized( void *ptr, size_t size )
+static inline void mark_block_uninitialized( void *ptr, SIZE_T size )
{
#ifdef VALGRIND_MAKE_WRITABLE
VALGRIND_DISCARD( VALGRIND_MAKE_WRITABLE( ptr, size ));
@@ -162,7 +162,7 @@ static inline void mark_block_uninitiali
}
/* clear contents of a block of memory */
-static inline void clear_block( void *ptr, size_t size )
+static inline void clear_block( void *ptr, SIZE_T size )
{
mark_block_initialized( ptr, size );
memset( ptr, 0, size );
@@ -177,29 +177,28 @@ static void HEAP_Dump( HEAP *heap )
SUBHEAP *subheap;
char *ptr;
- DPRINTF( "Heap: %08lx\n", (DWORD)heap );
- DPRINTF( "Next: %08lx Sub-heaps: %08lx",
- (DWORD)heap->next, (DWORD)&heap->subheap );
+ DPRINTF( "Heap: %p\n", heap );
+ DPRINTF( "Next: %p Sub-heaps: %p", heap->next, &heap->subheap );
subheap = &heap->subheap;
while (subheap->next)
{
- DPRINTF( " -> %08lx", (DWORD)subheap->next );
+ DPRINTF( " -> %p", subheap->next );
subheap = subheap->next;
}
DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
- DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
- (DWORD)&heap->freeList[i].arena, heap->freeList[i].size,
- (DWORD)heap->freeList[i].arena.prev,
- (DWORD)heap->freeList[i].arena.next );
+ DPRINTF( "%p free %08lx prev=%p next=%p\n",
+ &heap->freeList[i].arena, heap->freeList[i].size,
+ heap->freeList[i].arena.prev,
+ heap->freeList[i].arena.next );
subheap = &heap->subheap;
while (subheap)
{
- DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
- DPRINTF( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
- (DWORD)subheap, subheap->size, subheap->commitSize );
+ SIZE_T freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
+ DPRINTF( "\n\nSub-heap %p: size=%08lx committed=%08lx\n",
+ subheap, subheap->size, subheap->commitSize );
DPRINTF( "\n Block Stat Size Id\n" );
ptr = (char*)subheap + subheap->headerSize;
@@ -208,9 +207,9 @@ static void HEAP_Dump( HEAP *heap )
if (*(DWORD *)ptr & ARENA_FLAG_FREE)
{
ARENA_FREE *pArena = (ARENA_FREE *)ptr;
- DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
- (DWORD)pArena->prev, (DWORD)pArena->next);
+ DPRINTF( "%p free %08lx prev=%p next=%p\n",
+ pArena, pArena->size & ARENA_SIZE_MASK,
+ pArena->prev, pArena->next);
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_FREE);
freeSize += pArena->size & ARENA_SIZE_MASK;
@@ -218,8 +217,8 @@ static void HEAP_Dump( HEAP *heap )
else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
- DPRINTF( "%08lx Used %08lx back=%08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK, *((DWORD *)pArena - 1) );
+ DPRINTF( "%p Used %08lx back=%08lx\n",
+ pArena, pArena->size & ARENA_SIZE_MASK, *((ULONG_PTR *)pArena - 1) );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
usedSize += pArena->size & ARENA_SIZE_MASK;
@@ -227,8 +226,8 @@ static void HEAP_Dump( HEAP *heap )
else
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
- DPRINTF( "%08lx used %08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK );
+ DPRINTF( "%p used %08lx\n",
+ pArena, pArena->size & ARENA_SIZE_MASK );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
usedSize += pArena->size & ARENA_SIZE_MASK;
@@ -369,7 +368,7 @@ static SUBHEAP *HEAP_FindSubHeap(
*/
static inline BOOL HEAP_Commit( SUBHEAP *subheap, void *ptr )
{
- DWORD size = (DWORD)((char *)ptr - (char *)subheap);
+ SIZE_T size = (SIZE_T)((char *)ptr - (char *)subheap);
size = (size + COMMIT_MASK) & ~COMMIT_MASK;
if (size > subheap->size) size = subheap->size;
if (size <= subheap->commitSize) return TRUE;
@@ -395,9 +394,9 @@ static inline BOOL HEAP_Commit( SUBHEAP
static inline BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr )
{
void *addr;
- ULONG decommit_size;
+ SIZE_T decommit_size;
+ SIZE_T size = (SIZE_T)((char *)ptr - (char *)subheap);
- DWORD size = (DWORD)((char *)ptr - (char *)subheap);
/* round to next block and add one full block */
size = ((size + COMMIT_MASK) & ~COMMIT_MASK) + COMMIT_MASK + 1;
if (size >= subheap->commitSize) return TRUE;
@@ -421,7 +420,7 @@ static inline BOOL HEAP_Decommit( SUBHEA
* Create a free block at a specified address. 'size' is the size of the
* whole block, including the new arena.
*/
-static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, DWORD size )
+static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, SIZE_T size )
{
ARENA_FREE *pFree;
char *pEnd;
@@ -478,7 +477,7 @@ static void HEAP_CreateFreeBlock( SUBHEA
static void HEAP_MakeInUseBlockFree( SUBHEAP *subheap, ARENA_INUSE *pArena )
{
ARENA_FREE *pFree;
- DWORD size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
+ SIZE_T size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
/* Check if we can merge with previous block */
@@ -504,7 +503,7 @@ static void HEAP_MakeInUseBlockFree( SUB
if (((char *)pFree == (char *)subheap + subheap->headerSize) &&
(subheap != &subheap->heap->subheap))
{
- ULONG size = 0;
+ SIZE_T size = 0;
SUBHEAP *pPrev = &subheap->heap->subheap;
/* Remove the free block from the list */
pFree->next->prev = pFree->prev;
@@ -529,7 +528,7 @@ static void HEAP_MakeInUseBlockFree( SUB
*
* Shrink an in-use block.
*/
-static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, DWORD size)
+static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, SIZE_T size)
{
if ((pArena->size & ARENA_SIZE_MASK) >= size + HEAP_MIN_BLOCK_SIZE)
{
@@ -551,7 +550,7 @@ static void HEAP_ShrinkBlock(SUBHEAP *su
* HEAP_InitSubHeap
*/
static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
- DWORD commitSize, DWORD totalSize )
+ SIZE_T commitSize, SIZE_T totalSize )
{
SUBHEAP *subheap;
FREE_LIST_ENTRY *pEntry;
@@ -637,7 +636,7 @@ static BOOL HEAP_InitSubHeap( HEAP *heap
* If heap == NULL, creates a main heap.
*/
static SUBHEAP *HEAP_CreateSubHeap( HEAP *heap, void *base, DWORD flags,
- DWORD commitSize, DWORD totalSize )
+ SIZE_T commitSize, SIZE_T totalSize )
{
LPVOID address = base;
@@ -663,7 +662,7 @@ static SUBHEAP *HEAP_CreateSubHeap( HEAP
if (!HEAP_InitSubHeap( heap ? heap : (HEAP *)address,
address, flags, commitSize, totalSize ))
{
- ULONG size = 0;
+ SIZE_T size = 0;
if (!base) NtFreeVirtualMemory( NtCurrentProcess(), &address, &size, MEM_RELEASE );
return NULL;
}
@@ -678,7 +677,7 @@ static SUBHEAP *HEAP_CreateSubHeap( HEAP
* Find a free block at least as large as the requested size, and make sure
* the requested size is committed.
*/
-static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
+static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, SIZE_T size,
SUBHEAP **ppSubHeap )
{
SUBHEAP *subheap;
@@ -691,7 +690,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
pArena = pEntry->arena.next;
while (pArena != &heap->freeList[0].arena)
{
- DWORD arena_size = (pArena->size & ARENA_SIZE_MASK) +
+ SIZE_T arena_size = (pArena->size & ARENA_SIZE_MASK) +
sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
if (arena_size >= size)
{
@@ -709,8 +708,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
if (!(heap->flags & HEAP_GROWABLE))
{
- WARN("Not enough space in heap %08lx for %08lx bytes\n",
- (DWORD)heap, size );
+ WARN("Not enough space in heap %p for %08lx bytes\n", heap, size );
return NULL;
}
/* make sure that we have a big enough size *committed* to fit another
@@ -723,8 +721,8 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
max( HEAP_DEF_SIZE, size ) )))
return NULL;
- TRACE("created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
- (DWORD)subheap, size, (DWORD)heap );
+ TRACE("created new sub-heap %p of %08lx bytes for heap %p\n",
+ subheap, size, heap );
*ppSubHeap = subheap;
return (ARENA_FREE *)(subheap + 1);
@@ -757,54 +755,52 @@ static BOOL HEAP_ValidateFreeArena( SUBH
char *heapEnd = (char *)subheap + subheap->size;
/* Check for unaligned pointers */
- if ( (long)pArena % ALIGNMENT != 0 )
+ if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
{
- ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
return FALSE;
}
/* Check magic number */
if (pArena->magic != ARENA_FREE_MAGIC)
{
- ERR("Heap %08lx: invalid free arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: invalid free arena magic for %p\n", subheap->heap, pArena );
return FALSE;
}
/* Check size flags */
if (!(pArena->size & ARENA_FLAG_FREE) ||
(pArena->size & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: bad flags %lx for free arena %08lx\n",
- (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad flags %08lx for free arena %p\n",
+ subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
}
/* Check arena size */
if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
- ERR("Heap %08lx: bad size %08lx for free arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad size %08lx for free arena %p\n",
+ subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check that next pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
{
- ERR("Heap %08lx: bad next ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
+ ERR("Heap %p: bad next ptr %p for arena %p\n",
+ subheap->heap, pArena->next, pArena );
return FALSE;
}
/* Check that next arena is free */
if (!(pArena->next->size & ARENA_FLAG_FREE) ||
(pArena->next->magic != ARENA_FREE_MAGIC))
{
- ERR("Heap %08lx: next arena %08lx invalid for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
+ ERR("Heap %p: next arena %p invalid for %p\n",
+ subheap->heap, pArena->next, pArena );
return FALSE;
}
/* Check that prev pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
{
- ERR("Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
+ ERR("Heap %p: bad prev ptr %p for arena %p\n",
+ subheap->heap, pArena->prev, pArena );
return FALSE;
}
/* Check that prev arena is free */
@@ -813,8 +809,8 @@ static BOOL HEAP_ValidateFreeArena( SUBH
{
/* this often means that the prev arena got overwritten
* by a memory write before that prev arena */
- ERR("Heap %08lx: prev arena %08lx invalid for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p invalid for %p\n",
+ subheap->heap, pArena->prev, pArena );
return FALSE;
}
/* Check that next block has PREV_FREE flag */
@@ -823,17 +819,17 @@ static BOOL HEAP_ValidateFreeArena( SUBH
if (!(*(DWORD *)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: free arena %p next block has no PREV_FREE flag\n",
+ subheap->heap, pArena );
return FALSE;
}
/* Check next block back pointer */
if (*((ARENA_FREE **)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
{
- ERR("Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena,
- *((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
+ ERR("Heap %p: arena %p has wrong back ptr %08lx\n",
+ subheap->heap, pArena,
+ *((ULONG_PTR *)((char *)(pArena+1) + (pArena->size & ARENA_SIZE_MASK)) - 1));
return FALSE;
}
}
@@ -849,19 +845,17 @@ static BOOL HEAP_ValidateInUseArena( con
const char *heapEnd = (const char *)subheap + subheap->size;
/* Check for unaligned pointers */
- if ( (long)pArena % ALIGNMENT != 0 )
+ if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
{
if ( quiet == NOISY )
{
- ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR( "Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
if ( TRACE_ON(heap) )
HEAP_Dump( subheap->heap );
}
else if ( WARN_ON(heap) )
{
- WARN( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ WARN( "Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
if ( TRACE_ON(heap) )
HEAP_Dump( subheap->heap );
}
@@ -872,13 +866,11 @@ static BOOL HEAP_ValidateInUseArena( con
if (pArena->magic != ARENA_INUSE_MAGIC)
{
if (quiet == NOISY) {
- ERR("Heap %08lx: invalid in-use arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: invalid in-use arena magic for %p\n", subheap->heap, pArena );
if (TRACE_ON(heap))
HEAP_Dump( subheap->heap );
} else if (WARN_ON(heap)) {
- WARN("Heap %08lx: invalid in-use arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ WARN("Heap %p: invalid in-use arena magic for %p\n", subheap->heap, pArena );
if (TRACE_ON(heap))
HEAP_Dump( subheap->heap );
}
@@ -887,23 +879,23 @@ static BOOL HEAP_ValidateInUseArena( con
/* Check size flags */
if (pArena->size & ARENA_FLAG_FREE)
{
- ERR("Heap %08lx: bad flags %lx for in-use arena %08lx\n",
- (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad flags %08lx for in-use arena %p\n",
+ subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check arena size */
if ((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
- ERR("Heap %08lx: bad size %08lx for in-use arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad size %08lx for in-use arena %p\n",
+ subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check next arena PREV_FREE flag */
if (((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
(*(const DWORD *)((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: in-use arena %p next block has PREV_FREE flag\n",
+ subheap->heap, pArena );
return FALSE;
}
/* Check prev free arena */
@@ -913,23 +905,23 @@ static BOOL HEAP_ValidateInUseArena( con
/* Check prev pointer */
if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
{
- ERR("Heap %08lx: bad back ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: bad back ptr %p for arena %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
/* Check that prev arena is free */
if (!(pPrev->size & ARENA_FLAG_FREE) ||
(pPrev->magic != ARENA_FREE_MAGIC))
{
- ERR("Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p invalid for in-use %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
/* Check that prev arena is really the previous block */
if ((const char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (const char *)pArena)
{
- ERR("Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p is not prev for in-use %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
}
@@ -999,7 +991,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
ret = FALSE;
break;
}
- ptr += sizeof(ARENA_FREE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
+ ptr += sizeof(ARENA_FREE) + (*(SIZE_T *)ptr & ARENA_SIZE_MASK);
}
else
{
@@ -1007,7 +999,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
ret = FALSE;
break;
}
- ptr += sizeof(ARENA_INUSE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
+ ptr += sizeof(ARENA_INUSE) + (*(SIZE_T *)ptr & ARENA_SIZE_MASK);
}
}
subheap = subheap->next;
@@ -1035,7 +1027,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
* Success: A HANDLE to the newly created heap.
* Failure: a NULL HANDLE.
*/
-HANDLE WINAPI RtlCreateHeap( ULONG flags, PVOID addr, ULONG totalSize, ULONG commitSize,
+HANDLE WINAPI RtlCreateHeap( ULONG flags, PVOID addr, SIZE_T totalSize, SIZE_T commitSize,
PVOID unknown, PRTL_HEAP_DEFINITION definition )
{
SUBHEAP *subheap;
@@ -1101,7 +1093,7 @@ HANDLE WINAPI RtlDestroyHeap( HANDLE hea
while (subheap)
{
SUBHEAP *next = subheap->next;
- ULONG size = 0;
+ SIZE_T size = 0;
void *addr = subheap;
NtFreeVirtualMemory( NtCurrentProcess(), &addr, &size, MEM_RELEASE );
subheap = next;
@@ -1127,13 +1119,13 @@ HANDLE WINAPI RtlDestroyHeap( HANDLE hea
* NOTES
* This call does not SetLastError().
*/
-PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, ULONG size )
+PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size )
{
ARENA_FREE *pArena;
ARENA_INUSE *pInUse;
SUBHEAP *subheap;
HEAP *heapPtr = HEAP_GetPtr( heap );
- ULONG rounded_size;
+ SIZE_T rounded_size;
/* Validate the parameters */
@@ -1181,8 +1173,7 @@ PVOID WINAPI RtlAllocateHeap( HANDLE hea
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning %08lx\n",
- heap, flags, size, (DWORD)(pInUse + 1) );
+ TRACE("(%p,%08lx,%08lx): returning %p\n", heap, flags, size, pInUse + 1 );
return (LPVOID)(pInUse + 1);
}
@@ -1225,8 +1216,7 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
{
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- TRACE("(%p,%08lx,%08lx): returning FALSE\n",
- heap, flags, (DWORD)ptr );
+ TRACE("(%p,%08lx,%p): returning FALSE\n", heap, flags, ptr );
return FALSE;
}
@@ -1238,8 +1228,7 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning TRUE\n",
- heap, flags, (DWORD)ptr );
+ TRACE("(%p,%08lx,%p): returning TRUE\n", heap, flags, ptr );
return TRUE;
}
@@ -1259,13 +1248,12 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
* Success: A pointer to the resized block (which may be different).
* Failure: NULL.
*/
-PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, ULONG size )
+PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, SIZE_T size )
{
ARENA_INUSE *pArena;
- DWORD oldSize;
HEAP *heapPtr;
SUBHEAP *subheap;
- ULONG rounded_size;
+ SIZE_T oldSize, rounded_size;
if (!ptr) return NULL;
if (!(heapPtr = HEAP_GetPtr( heap )))
@@ -1287,8 +1275,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
{
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- TRACE("(%p,%08lx,%08lx,%08lx): returning NULL\n",
- heap, flags, (DWORD)ptr, size );
+ TRACE("(%p,%08lx,%p,%08lx): returning NULL\n", heap, flags, ptr, size );
return NULL;
}
@@ -1302,7 +1289,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
char *pNext = (char *)(pArena + 1) + oldSize;
if ((pNext < (char *)subheap + subheap->size) &&
(*(DWORD *)pNext & ARENA_FLAG_FREE) &&
- (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= rounded_size))
+ (oldSize + (*(SIZE_T *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= rounded_size))
{
/* The next block is free and large enough */
ARENA_FREE *pFree = (ARENA_FREE *)pNext;
@@ -1373,8 +1360,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx,%08lx): returning %08lx\n",
- heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
+ TRACE("(%p,%08lx,%p,%08lx): returning %p\n", heap, flags, ptr, size, pArena + 1 );
return (LPVOID)(pArena + 1);
}
@@ -1460,15 +1446,15 @@ BOOLEAN WINAPI RtlUnlockHeap( HANDLE hea
* NOTES
* The size may be bigger than what was passed to RtlAllocateHeap().
*/
-ULONG WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
+SIZE_T WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
{
- DWORD ret;
+ SIZE_T ret;
HEAP *heapPtr = HEAP_GetPtr( heap );
if (!heapPtr)
{
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_HANDLE );
- return (ULONG)-1;
+ return (SIZE_T)-1;
}
flags &= HEAP_NO_SERIALIZE;
flags |= heapPtr->flags;
@@ -1476,7 +1462,7 @@ ULONG WINAPI RtlSizeHeap( HANDLE heap, U
if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
{
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- ret = (ULONG)-1;
+ ret = (SIZE_T)-1;
}
else
{
@@ -1485,8 +1471,7 @@ ULONG WINAPI RtlSizeHeap( HANDLE heap, U
}
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning %08lx\n",
- heap, flags, (DWORD)ptr, ret );
+ TRACE("(%p,%08lx,%p): returning %08lx\n", heap, flags, ptr, ret );
return ret;
}
@@ -1640,7 +1625,7 @@ HW_end:
*/
ULONG WINAPI RtlGetProcessHeaps( ULONG count, HANDLE *heaps )
{
- DWORD total;
+ ULONG total;
HEAP *ptr;
if (!processHeap) return 0; /* should never happen */
diff -up cvs/hq/wine/dlls/ntdll/ntdll_misc.h wine/dlls/ntdll/ntdll_misc.h
--- cvs/hq/wine/dlls/ntdll/ntdll_misc.h Mon Jun 27 12:29:37 2005
+++ wine/dlls/ntdll/ntdll_misc.h Tue Jul 12 00:25:24 2005
@@ -87,7 +87,7 @@ extern NTSTATUS FILE_GetNtStatus(void);
extern BOOL DIR_is_hidden_file( const UNICODE_STRING *name );
/* virtual memory */
-extern DWORD VIRTUAL_HandleFault(LPCVOID addr);
+extern NTSTATUS VIRTUAL_HandleFault(LPCVOID addr);
extern BOOL VIRTUAL_HasMapping( LPCVOID addr );
extern void VIRTUAL_UseLargeAddressSpace(void);
diff -up cvs/hq/wine/dlls/ntdll/virtual.c wine/dlls/ntdll/virtual.c
--- cvs/hq/wine/dlls/ntdll/virtual.c Wed Jul 6 13:14:39 2005
+++ wine/dlls/ntdll/virtual.c Tue Jul 12 00:41:40 2005
@@ -67,7 +67,7 @@ typedef struct file_view
{
struct list entry; /* Entry in global view list */
void *base; /* Base address */
- UINT size; /* Size in bytes */
+ size_t size; /* Size in bytes */
HANDLE mapping; /* Handle to the file mapping */
BYTE flags; /* Allocation flags (VFLAG_*) */
BYTE protect; /* Protection for all pages at allocation time */
@@ -532,7 +532,7 @@ static BYTE VIRTUAL_GetProt( DWORD prote
*/
static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */
void *base, /* [in] Starting address */
- UINT size, /* [in] Size in bytes */
+ size_t size, /* [in] Size in bytes */
BYTE vprot ) /* [in] Protections to use */
{
TRACE("%p-%p %s\n",
@@ -611,9 +611,9 @@ static NTSTATUS map_view( struct file_vi
/* Release the extra memory while keeping the range
* starting on the granularity boundary. */
- if ((unsigned int)ptr & granularity_mask)
+ if ((ULONG_PTR)ptr & granularity_mask)
{
- unsigned int extra = granularity_mask + 1 - ((unsigned int)ptr & granularity_mask);
+ size_t extra = granularity_mask + 1 - ((ULONG_PTR)ptr & granularity_mask);
munmap( ptr, extra );
ptr = (char *)ptr + extra;
view_size -= extra;
@@ -753,7 +753,7 @@ static NTSTATUS decommit_pages( struct f
* Apply the relocations to a mapped PE image
*/
static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
- int delta, DWORD total_size )
+ int delta, SIZE_T total_size )
{
IMAGE_BASE_RELOCATION *rel;
@@ -816,8 +816,8 @@ static int do_relocations( char *base, c
*
* Map an executable (PE format) image into memory.
*/
-static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size,
- DWORD header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
+static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_size,
+ SIZE_T header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
{
IMAGE_DOS_HEADER *dos;
IMAGE_NT_HEADERS *nt;
@@ -920,7 +920,7 @@ static NTSTATUS map_image( HANDLE hmappi
for (i = pos = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{
- DWORD size;
+ SIZE_T size;
/* a few sanity checks */
size = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
@@ -1031,7 +1031,7 @@ static NTSTATUS map_image( HANDLE hmappi
sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{
- DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
+ SIZE_T size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
BYTE vprot = VPROT_COMMITTED;
if (sec->Characteristics & IMAGE_SCN_MEM_READ) vprot |= VPROT_READ;
if (sec->Characteristics & IMAGE_SCN_MEM_WRITE) vprot |= VPROT_READ|VPROT_WRITECOPY;
@@ -1097,10 +1097,10 @@ void virtual_init(void)
/***********************************************************************
* VIRTUAL_HandleFault
*/
-DWORD VIRTUAL_HandleFault( LPCVOID addr )
+NTSTATUS VIRTUAL_HandleFault( LPCVOID addr )
{
FILE_VIEW *view;
- DWORD ret = EXCEPTION_ACCESS_VIOLATION;
+ NTSTATUS ret = EXCEPTION_ACCESS_VIOLATION;
RtlEnterCriticalSection( &csVirtual );
if ((view = VIRTUAL_FindView( addr )))
@@ -1158,11 +1158,11 @@ void VIRTUAL_UseLargeAddressSpace(void)
* ZwAllocateVirtualMemory (NTDLL.@)
*/
NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_bits,
- ULONG *size_ptr, ULONG type, ULONG protect )
+ SIZE_T *size_ptr, ULONG type, ULONG protect )
{
void *base;
BYTE vprot;
- DWORD size = *size_ptr;
+ SIZE_T size = *size_ptr;
NTSTATUS status = STATUS_SUCCESS;
struct file_view *view;
@@ -1267,13 +1267,13 @@ NTSTATUS WINAPI NtAllocateVirtualMemory(
* NtFreeVirtualMemory (NTDLL.@)
* ZwFreeVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr, ULONG type )
+NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr, ULONG type )
{
FILE_VIEW *view;
char *base;
NTSTATUS status = STATUS_SUCCESS;
LPVOID addr = *addr_ptr;
- DWORD size = *size_ptr;
+ SIZE_T size = *size_ptr;
TRACE("%p %p %08lx %lx\n", process, addr, size, type );
@@ -1340,7 +1340,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HAN
* NtProtectVirtualMemory (NTDLL.@)
* ZwProtectVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr,
+NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr,
ULONG new_prot, ULONG *old_prot )
{
FILE_VIEW *view;
@@ -1348,7 +1348,8 @@ NTSTATUS WINAPI NtProtectVirtualMemory(
char *base;
UINT i;
BYTE vprot, *p;
- DWORD prot, size = *size_ptr;
+ ULONG prot;
+ SIZE_T size = *size_ptr;
LPVOID addr = *addr_ptr;
TRACE("%p %p %08lx %08lx\n", process, addr, size, new_prot );
@@ -1417,7 +1418,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HA
FILE_VIEW *view;
char *base, *alloc_base = 0;
struct list *ptr;
- UINT size = 0;
+ SIZE_T size = 0;
MEMORY_BASIC_INFORMATION *info = buffer;
if (info_class != MemoryBasicInformation)
@@ -1519,7 +1520,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HA
* NtLockVirtualMemory (NTDLL.@)
* ZwLockVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
+NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
{
if (!is_current_process( process ))
{
@@ -1534,7 +1535,7 @@ NTSTATUS WINAPI NtLockVirtualMemory( HAN
* NtUnlockVirtualMemory (NTDLL.@)
* ZwUnlockVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
+NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
{
if (!is_current_process( process ))
{
@@ -1617,25 +1618,25 @@ NTSTATUS WINAPI NtOpenSection( HANDLE *h
* ZwMapViewOfSection (NTDLL.@)
*/
NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_ptr, ULONG zero_bits,
- ULONG commit_size, const LARGE_INTEGER *offset_ptr, ULONG *size_ptr,
+ SIZE_T commit_size, const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr,
SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect )
{
IO_STATUS_BLOCK io;
FILE_FS_DEVICE_INFORMATION device_info;
NTSTATUS res;
- UINT size = 0;
+ SIZE_T size = 0;
int unix_handle = -1;
int prot;
void *base;
struct file_view *view;
- DWORD size_low, size_high, header_size, shared_size;
+ SIZE_T size_low, size_high, header_size, shared_size;
HANDLE shared_file;
BOOL removable = FALSE;
LARGE_INTEGER offset;
offset.QuadPart = offset_ptr ? offset_ptr->QuadPart : 0;
- TRACE("handle=%p process=%p addr=%p off=%lx%08lx size=%x access=%lx\n",
+ TRACE("handle=%p process=%p addr=%p off=%lx%08lx size=%lx access=%lx\n",
handle, process, *addr_ptr, offset.u.HighPart, offset.u.LowPart, size, protect );
if (!is_current_process( process ))
@@ -1752,7 +1753,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HAND
/* Map the file */
- TRACE("handle=%p size=%x offset=%lx%08lx\n",
+ TRACE("handle=%p size=%lx offset=%lx%08lx\n",
handle, size, offset.u.HighPart, offset.u.LowPart );
res = map_file_into_view( view, unix_handle, 0, size, offset.QuadPart, prot, removable );
@@ -1768,7 +1769,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HAND
}
else
{
- ERR( "map_file_into_view %p %x %lx%08lx failed\n",
+ ERR( "map_file_into_view %p %lx %lx%08lx failed\n",
view->base, size, offset.u.HighPart, offset.u.LowPart );
delete_view( view );
}
@@ -1812,7 +1813,7 @@ NTSTATUS WINAPI NtUnmapViewOfSection( HA
* ZwFlushVirtualMemory (NTDLL.@)
*/
NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
- ULONG *size_ptr, ULONG unknown )
+ SIZE_T *size_ptr, ULONG unknown )
{
FILE_VIEW *view;
NTSTATUS status = STATUS_SUCCESS;
@@ -1866,14 +1867,14 @@ NTSTATUS WINAPI NtWriteVirtualMemory( HA
SIZE_T size, SIZE_T *bytes_written )
{
static const unsigned int zero;
- unsigned int first_offset, last_offset, first_mask, last_mask;
+ SIZE_T first_offset, last_offset, first_mask, last_mask;
NTSTATUS status;
if (!size) return STATUS_INVALID_PARAMETER;
/* compute the mask for the first int */
first_mask = ~0;
- first_offset = (unsigned int)addr % sizeof(int);
+ first_offset = (ULONG_PTR)addr % sizeof(int);
memset( &first_mask, 0, first_offset );
/* compute the mask for the last int */
diff -up cvs/hq/wine/include/winternl.h wine/include/winternl.h
--- cvs/hq/wine/include/winternl.h Mon Jul 11 23:11:13 2005
+++ wine/include/winternl.h Tue Jul 12 00:33:42 2005
@@ -1689,7 +1689,7 @@ NTSTATUS WINAPI NtAlertResumeThread(HAN
NTSTATUS WINAPI NtAlertThread(HANDLE ThreadHandle);
NTSTATUS WINAPI NtAllocateLocallyUniqueId(PLUID lpLuid);
NTSTATUS WINAPI NtAllocateUuids(PULARGE_INTEGER,PULONG,PULONG);
-NTSTATUS WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,ULONG,ULONG*,ULONG,ULONG);
+NTSTATUS WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
NTSTATUS WINAPI NtCallbackReturn(PVOID,ULONG,NTSTATUS);
NTSTATUS WINAPI NtCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
NTSTATUS WINAPI NtCancelTimer(HANDLE, BOOLEAN*);
@@ -1734,9 +1734,9 @@ NTSTATUS WINAPI NtFindAtom(const WCHAR*
NTSTATUS WINAPI NtFlushBuffersFile(HANDLE,IO_STATUS_BLOCK*);
NTSTATUS WINAPI NtFlushInstructionCache(HANDLE,LPCVOID,ULONG);
NTSTATUS WINAPI NtFlushKey(HANDLE);
-NTSTATUS WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtFlushWriteBuffer(VOID);
-NTSTATUS WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
NTSTATUS WINAPI NtGetContextThread(HANDLE,CONTEXT*);
NTSTATUS WINAPI NtGetPlugPlayEvent(ULONG,ULONG,PVOID,ULONG);
@@ -1750,9 +1750,9 @@ NTSTATUS WINAPI NtListenPort(HANDLE,PLP
NTSTATUS WINAPI NtLoadDriver(const UNICODE_STRING *);
NTSTATUS WINAPI NtLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
NTSTATUS WINAPI NtLockFile(HANDLE,HANDLE,PIO_APC_ROUTINE,void*,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,ULONG*,BOOLEAN,BOOLEAN);
-NTSTATUS WINAPI NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtMakeTemporaryObject(HANDLE);
-NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
+NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
NTSTATUS WINAPI NtNotifyChangeDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,ULONG,BOOLEAN);
NTSTATUS WINAPI NtNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
@@ -1775,7 +1775,7 @@ NTSTATUS WINAPI NtPowerInformation(POWE
NTSTATUS WINAPI NtPrivilegeCheck(HANDLE,PPRIVILEGE_SET,PBOOLEAN);
NTSTATUS WINAPI NtPrivilegeObjectAuditAlarm(PUNICODE_STRING,HANDLE,HANDLE,ULONG,PPRIVILEGE_SET,BOOLEAN);
NTSTATUS WINAPI NtPrivilegedServiceAuditAlarm(PUNICODE_STRING,PUNICODE_STRING,HANDLE,PPRIVILEGE_SET,BOOLEAN);
-NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
+NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG,ULONG*);
NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
NTSTATUS WINAPI NtQueueApcThread(HANDLE,PNTAPCFUNC,ULONG_PTR,ULONG_PTR,ULONG_PTR);
NTSTATUS WINAPI NtQueryAttributesFile(const OBJECT_ATTRIBUTES*,FILE_BASIC_INFORMATION*);
@@ -1878,7 +1878,7 @@ NTSTATUS WINAPI NtUnloadDriver(const UN
NTSTATUS WINAPI NtUnloadKey(HANDLE);
NTSTATUS WINAPI NtUnloadKeyEx(POBJECT_ATTRIBUTES,HANDLE);
NTSTATUS WINAPI NtUnlockFile(HANDLE,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,PULONG);
-NTSTATUS WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
NTSTATUS WINAPI NtVdmControl(ULONG,PVOID);
NTSTATUS WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
@@ -1905,7 +1905,7 @@ PVOID WINAPI RtlAddVectoredException
NTSTATUS WINAPI RtlAdjustPrivilege(ULONG,BOOLEAN,BOOLEAN,PBOOLEAN);
NTSTATUS WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
RTL_HANDLE * WINAPI RtlAllocateHandle(RTL_HANDLE_TABLE *,ULONG *);
-PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
+PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,SIZE_T);
WCHAR WINAPI RtlAnsiCharToUnicodeChar(LPSTR *);
DWORD WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
NTSTATUS WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
@@ -1939,7 +1939,7 @@ void WINAPI RtlCopyUnicodeString(UN
NTSTATUS WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
NTSTATUS WINAPI RtlCreateAtomTable(ULONG,RTL_ATOM_TABLE*);
NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
-HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
+HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,SIZE_T,SIZE_T,PVOID,PRTL_HEAP_DEFINITION);
NTSTATUS WINAPI RtlCreateProcessParameters(RTL_USER_PROCESS_PARAMETERS**,const UNICODE_STRING*,
const UNICODE_STRING*,const UNICODE_STRING*,
const UNICODE_STRING*,PWSTR,const UNICODE_STRING*,
@@ -2104,7 +2104,7 @@ NTSTATUS WINAPI RtlQueryTimeZoneInforma
void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
void WINAPI RtlRaiseStatus(NTSTATUS);
ULONG WINAPI RtlRandom(PULONG);
-PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
+PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,SIZE_T);
void WINAPI RtlReleasePebLock(void);
void WINAPI RtlReleaseResource(LPRTL_RWLOCK);
ULONG WINAPI RtlRemoveVectoredExceptionHandler(PVOID);
@@ -2127,7 +2127,7 @@ void WINAPI RtlSetLastWin32Error(DW
void WINAPI RtlSetLastWin32ErrorAndNtStatusFromNtStatus(NTSTATUS);
NTSTATUS WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
NTSTATUS WINAPI RtlSetTimeZoneInformation(const RTL_TIME_ZONE_INFORMATION*);
-ULONG WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
+SIZE_T WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
NTSTATUS WINAPI RtlStringFromGUID(REFGUID,PUNICODE_STRING);
LPDWORD WINAPI RtlSubAuthoritySid(PSID,DWORD);
LPBYTE WINAPI RtlSubAuthorityCountSid(PSID);
More information about the wine-patches
mailing list