home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 23 / AACD 23.iso / AACD / Programming / tek / mem / staticalloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-12  |  1.8 KB  |  106 lines
  1.  
  2. #include "tek/mem.h"
  3.  
  4. /* 
  5. **    TEKlib
  6. **    (C) 2001 TEK neoscientists
  7. **    all rights reserved.
  8. **
  9. **    TAPTR TStaticAlloc(TMEMHEAD *head, TUINT size)
  10. **
  11. **    allocate from static allocator.
  12. **
  13. */
  14.  
  15. TAPTR TStaticAlloc(TMEMHEAD *head, TUINT size)
  16. {
  17.     if (head && size)
  18.     {
  19.         TMEMNODE *p = (TMEMNODE *) head->mem;
  20.         TMEMNODE *n;
  21.     
  22.         size = (size + head->align) & ~head->align;
  23.  
  24.         while (p->next)
  25.         {
  26.             if (p->free == p->size)
  27.             {
  28.                 /* unused node */
  29.             
  30.                 if (p->free > size + head->memnodesize)    
  31.                 {
  32.                     /* create new node */
  33.  
  34.                     n = (TMEMNODE *) ((TUINT8 *) p + size + head->memnodesize);
  35.                     
  36.                     n->next = p->next;
  37.                     n->prev = p;
  38.  
  39.                     n->size = p->free - size - head->memnodesize;
  40.                     n->free = n->size;
  41.                     
  42.                     p->size = size;
  43.                     p->free = 0;
  44.                     
  45.                     p->next->prev = n;
  46.                     p->next = n;
  47.  
  48.                     head->freesize -= size + head->memnodesize;
  49.                 
  50.                     return (((TUINT8 *) p) + head->memnodesize);
  51.                 }
  52.                 else if (p->free >= size)
  53.                 {
  54.                     /* use node, do not create a new one */
  55.  
  56.                     p->free -= size;
  57.  
  58.                     head->freesize -= size;
  59.  
  60.                     return (((TUINT8 *) p) + head->memnodesize);
  61.                 }
  62.             }
  63.             
  64.             p = p->next;
  65.         }
  66.  
  67.         /* endnode */
  68.         
  69.         if (p->free == p->size)
  70.         {
  71.             /* unused end node */
  72.             
  73.             if (p->size >= size)
  74.             {
  75.                 p->free -= size;
  76.  
  77.                 head->freesize -= size;
  78.  
  79.                 return (((TUINT8 *) p) + head->memnodesize);
  80.             }
  81.         }
  82.         else
  83.         {
  84.             /* already used end node */
  85.             
  86.             if (p->free >= size + head->memnodesize)
  87.             {
  88.                 n = (TMEMNODE *) ((TUINT8 *) p + head->memnodesize + p->size - p->free);
  89.  
  90.                 p->next = n;
  91.                 p->size -= p->free;
  92.                 n->next = TNULL;
  93.                 n->prev = p;
  94.                 n->size = p->free - head->memnodesize;
  95.                 n->free = n->size - size;
  96.                 p->free = 0;
  97.  
  98.                 head->freesize -= size + head->memnodesize;
  99.  
  100.                 return (((TUINT8 *) n) + head->memnodesize);
  101.             }
  102.         }
  103.     }
  104.     return TNULL;
  105. }
  106.