Changeset 3567 for trunk/kStuff/kLdr/kLdrHlpHeap.c

Timestamp:

Aug 27, 2007, 9:54:05 PM (18 years ago)

Author:

bird

Message:

Use the new type system.

File:

• trunk/kStuff/kLdr/kLdrHlpHeap.c (modified) (21 diffs)

trunk/kStuff/kLdr/kLdrHlpHeap.c

@@ -58 +58 @@
     struct KLDRHEAPBLOCK   *pPrev;
     /** The size of this block including this header. */
-    size_t                  cb;
+    KSIZE                   cb;
     /** The flags. */
-    size_t                  fFlags;
+    KSIZE                   fFlags;
 } KLDRHEAPBLOCK, *PKLDRHEAPBLOCK;
 
 /** Indicates whether the block is free (set) or allocated (clear). */
-#define KLDRHEAPBLOCK_FLAG_FREE     ((size_t)1)
+#define KLDRHEAPBLOCK_FLAG_FREE     ((KSIZE)1)
 /** Valid flag mask. */
-#define KLDRHEAPBLOCK_FLAG_MASK     ((size_t)1)
+#define KLDRHEAPBLOCK_FLAG_MASK     ((KSIZE)1)
 
 /** Checks if the block is freed. */
@@ -75 +75 @@
  * Assumes pB1 < pB2. */
 #define KLDRHEAPBLOCK_IS_ADJACENT(pB1, pB2) \
-    ( ((uintptr_t)(pB1) + (pB1)->cb) == (uintptr_t)(pB2) )
+    ( ((KUPTR)(pB1) + (pB1)->cb) == (KUPTR)(pB2) )
 
 /** The block alignment. */
@@ -93 +93 @@
         KLDRHEAP_ASSERT(!((pBlock)->fFlags & ~KLDRHEAPBLOCK_FLAG_MASK)); \
         KLDRHEAP_ASSERT(!((pBlock)->cb & (KLDRHEAPBLOCK_ALIGNMENT - 1))); \
-        KLDRHEAP_ASSERT((uintptr_t)(pBlock)->pPrev < (uintptr_t)(pBlock)); \
-        KLDRHEAP_ASSERT((uintptr_t)(pBlock)->pNext > (uintptr_t)(pBlock) || !(pBlock)->pNext); \
+        KLDRHEAP_ASSERT((KUPTR)(pBlock)->pPrev < (KUPTR)(pBlock)); \
+        KLDRHEAP_ASSERT((KUPTR)(pBlock)->pNext > (KUPTR)(pBlock) || !(pBlock)->pNext); \
     } while (0)
 
@@ -100 +100 @@
     do { \
         KLDRHEAP_ASSERT_BLOCK(pHeap, &(pFree)->Core); \
-        KLDRHEAP_ASSERT((uintptr_t)(pFree)->pPrev < (uintptr_t)(pFree)); \
-        KLDRHEAP_ASSERT((uintptr_t)(pFree)->pNext > (uintptr_t)(pFree) || !(pFree)->pNext); \
+        KLDRHEAP_ASSERT((KUPTR)(pFree)->pPrev < (KUPTR)(pFree)); \
+        KLDRHEAP_ASSERT((KUPTR)(pFree)->pNext > (KUPTR)(pFree) || !(pFree)->pNext); \
     } while (0)
 
@@ -133 +133 @@
     void   *pvBase;
     /** The length of the segment (in bytes). */
-    size_t  cb;
+    KSIZE   cb;
 } KLDRHEAPSEG, *PKLDRHEAPSEG;
 
@@ -144 +144 @@
     struct KLDRHEAPSEGS    *pNext;
     /** The number of segments used. */
-    uint32_t                cSegs;
+    KU32                    cSegs;
     /** Array of chunks. */
     KLDRHEAPSEG             aSegs[64];
@@ -181 +181 @@
 static int      kLdrHeapInit(PKLDRHEAPANCHOR pHeap);
 static void     kLdrHeapDelete(PKLDRHEAPANCHOR pHeap);
-static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, size_t cb);
+static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, KSIZE cb);
 static void     kLdrHeapFree(PKLDRHEAPANCHOR pHeap, void *pv);
-static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, size_t cb);
-static int      kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, size_t cb);
+static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, KSIZE cb);
+static int      kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, KSIZE cb);
 static void     kLdrHeapSegFree(PKLDRHEAPSEG pSeg);
 
@@ -214 +214 @@
  * @param   cb      The requested heap block size.
  */
-void *kldrHlpAlloc(size_t cb)
+void *kldrHlpAlloc(KSIZE cb)
 {
     return kLdrHeapAlloc(&g_Heap, cb);
@@ -226 +226 @@
  * @param   cb      The requested heap block size.
  */
-void *kldrHlpAllocZ(size_t cb)
+void *kldrHlpAllocZ(KSIZE cb)
 {
     void *pv = kLdrHeapAlloc(&g_Heap, cb);
@@ -252 +252 @@
  * @param   cb      The amount of memory.
  */
-void kldrHlpHeapDonate(void *pv, size_t cb)
+void kldrHlpHeapDonate(void *pv, KSIZE cb)
 {
     kLdrHeapDonate(&g_Heap, pv, cb);
@@ -293 +293 @@
     {
         /* find the tail. */
-        uint32_t        iSeg;
+        KU32            iSeg;
         PKLDRHEAPSEGS   pSegs = pHeap->SegsHead.pNext;
         if (!pSegs)
@@ -322 +322 @@
  * Internal heap block allocator.
  */
-static void *   kldrHeapAllocSub(PKLDRHEAPANCHOR pHeap, size_t cb)
+static void *   kldrHeapAllocSub(PKLDRHEAPANCHOR pHeap, KSIZE cb)
 {
     /*
      * Find a fitting free block.
      */
-    const size_t    cbReq = KLDR_ALIGN_Z(cb + sizeof(KLDRHEAPBLOCK), KLDRHEAPBLOCK_ALIGNMENT);
+    const KSIZE     cbReq = KLDR_ALIGN_Z(cb + sizeof(KLDRHEAPBLOCK), KLDRHEAPBLOCK_ALIGNMENT);
     PKLDRHEAPFREE   pCur = pHeap->pFreeHead;
     while (pCur)
@@ -376 +376 @@
         pCur->Core.cb -= cbReq;
 
-        pNew = (PKLDRHEAPBLOCK)((uintptr_t)pCur + pCur->Core.cb);
+        pNew = (PKLDRHEAPBLOCK)((KUPTR)pCur + pCur->Core.cb);
         pNew->fFlags = 0;
         pNew->cb = cbReq;
@@ -415 +415 @@
  * @param   cb      The requested heap block size.
  */
-static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, size_t cb)
+static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, KSIZE cb)
 {
     void *pv;
@@ -563 +563 @@
  * @param cb    Size of the donated memory.
  */
-static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, size_t cb)
+static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, KSIZE cb)
 {
     PKLDRHEAPBLOCK pBlock;
@@ -576 +576 @@
      * Align the donation on a heap block boundrary.
      */
-    if ((uintptr_t)pv & (KLDRHEAPBLOCK_ALIGNMENT - 1))
-    {
-        cb -= (uintptr_t)pv & 31;
+    if ((KUPTR)pv & (KLDRHEAPBLOCK_ALIGNMENT - 1))
+    {
+        cb -= (KUPTR)pv & 31;
         pv = KLDR_ALIGN_P(pv, KLDRHEAPBLOCK_ALIGNMENT);
     }
-    cb &= ~(size_t)(KLDRHEAPBLOCK_ALIGNMENT - 1);
+    cb &= ~(KSIZE)(KLDRHEAPBLOCK_ALIGNMENT - 1);
 
     /*
@@ -593 +593 @@
 
     /* insert */
-    if ((uintptr_t)pBlock < (uintptr_t)pHeap->pHead)
+    if ((KUPTR)pBlock < (KUPTR)pHeap->pHead)
     {
         /* head */
@@ -600 +600 @@
         pHeap->pHead = pBlock;
     }
-    else if ((uintptr_t)pBlock > (uintptr_t)pHeap->pTail)
+    else if ((KUPTR)pBlock > (KUPTR)pHeap->pTail)
     {
         if (pHeap->pTail)
@@ -624 +624 @@
         {
             KLDRHEAP_ASSERT_BLOCK(pHeap, pCur);
-            if ((uintptr_t)pCur > (uintptr_t)pBlock)
+            if ((KUPTR)pCur > (KUPTR)pBlock)
                 break;
             pPrev = pCur;
@@ -650 +650 @@
  * @param   cbMin   The minimum segment size.
  */
-static int kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, size_t cbMin)
+static int kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, KSIZE cbMin)
 {
 #ifdef __OS2__
     APIRET rc;
 
-    pSeg->cb = (cbMin + 0xffff) & ~(size_t)0xffff;
+    pSeg->cb = (cbMin + 0xffff) & ~(KSIZE)0xffff;
     pSeg->pvBase = NULL;
     rc = DosAllocMem(&pSeg->pvBase, pSeg->cb, PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_ANY);
@@ -668 +668 @@
 
 #elif defined(__WIN__)
-    pSeg->cb = (cbMin + 0xffff) & ~(size_t)0xffff;
+    pSeg->cb = (cbMin + 0xffff) & ~(KSIZE)0xffff;
     pSeg->pvBase = VirtualAlloc(NULL, pSeg->cb, MEM_COMMIT, PAGE_READWRITE);
     if (!pSeg->pvBase)