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