compiler/alib/liballocpooled.c

   1 /*
   2     Copyright © 1995-2001, 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     AROS_GET_SYSBASE_OK
  44     ULONG *puddle = NULL;
  45
  46     if (SysBase->LibNode.lib_Version >= 39)
  47         return (AllocPooled (pool, memSize));
  48
  49     if (poolHeader != NULL && memSize != 0)
  50     {
  51         ULONG size;
  52
  53         if (poolHeader->ThreshSize > memSize)
  54         {
  55             struct MemHeader * a = (struct MemHeader *)poolHeader->PuddleList.mlh_Head;
  56
  57             for(;;)
  58             {
  59                 if (a->mh_Node.ln_Succ!=NULL)
  60                 {
  61                     if (a->mh_Node.ln_Type
  62                         && (puddle = (ULONG *)Allocate (a, memSize)) != NULL
  63                     )
  64                         break;
  65
  66                     a = (struct MemHeader *)a->mh_Node.ln_Succ;
  67                 }
  68                 else
  69                 {
  70                     size = poolHeader->PuddleSize
  71                         + sizeof (struct MemHeader)
  72                         + 2 * sizeof (ULONG);
  73
  74                     if (!(puddle = (ULONG *)AllocMem (size, poolHeader->MemoryFlags)) )
  75                         return NULL;
  76
  77                     *puddle ++ = size;
  78
  79                     a = (struct MemHeader *)puddle;
  80
  81                     a->mh_Node.ln_Type   = NT_MEMORY;
  82                     a->mh_Lower          =
  83                         a->mh_First = (struct MemChunk *)(
  84                             (UBYTE *)a
  85                             + sizeof (struct MemHeader)
  86                             + sizeof (UBYTE *)
  87                         );
  88                     a->mh_First->mc_Next = NULL;
  89                     a->mh_Free           =
  90                         a->mh_First->mc_Bytes = poolHeader->PuddleSize;
  91                     a->mh_Upper          = (char *)a->mh_First + a->mh_Free;
  92
  93                     AddHead ((struct List *)&poolHeader->PuddleList, &a->mh_Node);
  94
  95                     puddle = (ULONG *)Allocate (a, memSize);
  96
  97                     break;
  98                 }
  99             }
 100
 101             /*
 102                 We do have to clear memory here. It may have been dirtied
 103                 by somebody using it beforehand.
 104             */
 105             if (poolHeader->MemoryFlags & MEMF_CLEAR)
 106             {
 107                 ULONG *p = puddle;
 108
 109                 memSize  += 7;
 110                 memSize >>= 3;
 111
 112                 do
 113                 {
 114                     *p++=0;
 115                     *p++=0;
 116                 } while (--memSize);
 117             }
 118         }
 119         else
 120         {
 121             size = memSize + sizeof (struct MinNode) + 2 * sizeof (ULONG);
 122
 123             if ((puddle = (ULONG *)AllocMem (size, poolHeader->MemoryFlags)))
 124             {
 125                 *puddle ++ = size;
 126
 127                 AddTail ((struct List *)&poolHeader->PuddleList
 128                     , (struct Node *)puddle
 129                 );
 130
 131                 puddle = (ULONG *)((struct MinNode *)puddle + 1);
 132
 133                 *puddle ++ = 0;
 134             }
 135         }
 136     }
 137
 138     return puddle;
 139 } /* LibAllocPooled */
 140