compiler/alib/liballocpooled.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     Original version from libnix
   4     $Id$
   5 */
   6
   7 #define AROS_LIBREQ(base,ver)   /* We test for versions manually */
   8
   9 #include "pool.h"
  10 #include <proto/exec.h>
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/alib.h>
  16
  17         APTR LibAllocPooled (
  18
  19 /*  SYNOPSIS */
  20         APTR  pool,
  21         ULONG memSize)
  22
  23 /*  FUNCTION
  24
  25     INPUTS
  26
  27     RESULT
  28
  29     NOTES
  30
  31     EXAMPLE
  32
  33     BUGS
  34
  35     SEE ALSO
  36
  37     INTERNALS
  38
  39     HISTORY
  40         06.12.96 digulla Created after original from libnix
  41
  42 ******************************************************************************/
  43 {
  44 #   define poolHeader   ((POOL *)pool)
  45     ULONG *puddle = NULL;
  46
  47     if (SysBase->LibNode.lib_Version >= 39)
  48         return (AllocPooled (pool, memSize));
  49
  50     if (poolHeader != NULL && memSize != 0)
  51     {
  52         ULONG size;
  53
  54         if (poolHeader->ThreshSize > memSize)
  55         {
  56             struct MemHeader * a = (struct MemHeader *)poolHeader->PuddleList.mlh_Head;
  57
  58             for(;;)
  59             {
  60                 if (a->mh_Node.ln_Succ!=NULL)
  61                 {
  62                     if (a->mh_Node.ln_Type
  63                         && (puddle = (ULONG *)Allocate (a, memSize)) != NULL
  64                     )
  65                         break;
  66
  67                     a = (struct MemHeader *)a->mh_Node.ln_Succ;
  68                 }
  69                 else
  70                 {
  71                     size = poolHeader->PuddleSize
  72                         + sizeof (struct MemHeader)
  73                         + 2 * sizeof (ULONG);
  74
  75                     if (!(puddle = (ULONG *)AllocMem (size, poolHeader->MemoryFlags)) )
  76                         return NULL;
  77
  78                     *puddle ++ = size;
  79
  80                     a = (struct MemHeader *)puddle;
  81
  82                     a->mh_Node.ln_Type   = NT_MEMORY;
  83                     a->mh_Lower          =
  84                         a->mh_First = (struct MemChunk *)(
  85                             (UBYTE *)a
  86                             + sizeof (struct MemHeader)
  87                             + sizeof (UBYTE *)
  88                         );
  89                     a->mh_First->mc_Next = NULL;
  90                     a->mh_Free           =
  91                         a->mh_First->mc_Bytes = poolHeader->PuddleSize;
  92                     a->mh_Upper          = (char *)a->mh_First + a->mh_Free;
  93
  94                     AddHead ((struct List *)&poolHeader->PuddleList, &a->mh_Node);
  95
  96                     puddle = (ULONG *)Allocate (a, memSize);
  97
  98                     break;
  99                 }
 100             }
 101
 102             /*
 103                 We do have to clear memory here. It may have been dirtied
 104                 by somebody using it beforehand.
 105             */
 106             if (poolHeader->MemoryFlags & MEMF_CLEAR)
 107             {
 108                 ULONG *p = puddle;
 109
 110                 memSize  += 7;
 111                 memSize >>= 3;
 112
 113                 do
 114                 {
 115                     *p++=0;
 116                     *p++=0;
 117                 } while (--memSize);
 118             }
 119         }
 120         else
 121         {
 122             size = memSize + sizeof (struct MinNode) + 2 * sizeof (ULONG);
 123
 124             if ((puddle = (ULONG *)AllocMem (size, poolHeader->MemoryFlags)))
 125             {
 126                 *puddle ++ = size;
 127
 128                 AddTail ((struct List *)&poolHeader->PuddleList
 129                     , (struct Node *)puddle
 130                 );
 131
 132                 puddle = (ULONG *)((struct MinNode *)puddle + 1);
 133
 134                 *puddle ++ = 0;
 135             }
 136         }
 137     }
 138
 139     return puddle;
 140 } /* LibAllocPooled */
 141