home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / disk / misc / dcmp / source / source.lha / memblock.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-25  |  2.8 KB  |  127 lines
  1. /*-----------------------------------------*
  2.    Komfortable Speicher allokierfunktionen
  3.    von Tobias Ferber, geschrieben 1990.
  4.  *-----------------------------------------*/
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8.  
  9. static char rcs_id[]= "$Id: memblock.c,v 1.2 90/08/15 09:13:31 tf Exp $";
  10.  
  11. #define mb_NIL (struct memblock *)NULL
  12.  
  13. struct memblock { struct memblock *succ, *pred;
  14.                   char *memory;
  15.                   long bytesize;
  16.                 };
  17.  
  18. /*
  19.  * Die folgenden Funktionen arbeiten alle mit *einer* statischen Liste.
  20.  * mb_list mu\3 nicht *unbedingt* Kopf dieser Liste sein, muß aber in jedem
  21.  * Fall entweder mb_NIL oder Teil von ihr (dieser Liste, nicht mb_NIL :) sein.
  22.  */
  23.  
  24. static struct memblock *mb_list= mb_NIL;
  25.  
  26. struct memblock *tail_mb(struct memblock *list)
  27. { if(list==mb_NIL) list= mb_list;
  28.   while(list && list->succ)
  29.     list= list->succ;
  30.   return list;
  31. }
  32.  
  33. struct memblock *head_mb(struct memblock *list)
  34. { if(list==mb_NIL) list= mb_list;
  35.   while(list && list->pred)
  36.     list= list->pred;
  37.   return list;
  38. }
  39.  
  40. void insert_mb(struct memblock *node,
  41.                struct memblock *pred )
  42. { if(node)
  43.   { if(pred==mb_NIL) pred= mb_list;
  44.     if(pred)
  45.     { tail_mb(node)->succ= pred->succ;
  46.       pred->succ= head_mb(node);
  47.       head_mb(node)->pred= pred;
  48.     }
  49.     else mb_list= node;
  50.   }
  51. }
  52.  
  53. void delete_mb(struct memblock *node)
  54. { if(node)
  55.   { if(node->pred)
  56.     { if(node->succ)
  57.       { node->pred->succ= node->succ;
  58.         node->succ->pred= node->pred;
  59.       }
  60.       else node->pred->succ= mb_NIL;
  61.     }
  62.     else if(node->succ)
  63.       node->succ->pred= mb_NIL;
  64.  
  65.     node->pred= node->succ= mb_NIL;
  66.   }
  67. }
  68.  
  69. struct memblock *new_mb(void)
  70. { struct memblock *new= (struct memblock *)
  71.                         AllocMem(sizeof(struct memblock), MEMF_PUBLIC|MEMF_CLEAR);
  72.  
  73.   new->succ= new->pred= mb_NIL;
  74.   new->memory= (char *)NULL;
  75.   new->bytesize= (long)0;
  76.  
  77.   return new;
  78. }
  79.  
  80. void dispose_mb(struct memblock *which)
  81. { delete_mb(which); /* sicher ist sicher... */
  82.   FreeMem(which, sizeof(struct memblock));
  83. }
  84.  
  85. char *alloc_mem(long numbytes)
  86. { struct memblock *new= new_mb();
  87.   char *mem= (char *)NULL;
  88.   if(new)
  89.   { if(mem= (char *)AllocMem(numbytes, MEMF_PUBLIC))
  90.     { new->memory= mem;
  91.       new->bytesize= numbytes;
  92.       insert_mb(new, mb_list);
  93.     }
  94.     else
  95.     { dispose_mb(new);
  96.       new= mb_NIL;
  97.     }
  98.   }
  99.   return mem;
  100. }
  101.  
  102. void flame_mb(struct memblock *which)
  103. { if(which)
  104.   { if(which->memory && which->bytesize)
  105.     { FreeMem(which->memory, which->bytesize);
  106.       delete_mb(which);
  107.     }
  108.     dispose_mb(which);
  109.   }
  110. }
  111.  
  112. void free_mem(char *memory)
  113. { struct memblock *node= head_mb(mb_list);
  114.   while(node && node->memory != memory)
  115.     node= node->succ;
  116.   if(node) flame_mb(node);
  117. }
  118.  
  119. void free_all(void)
  120. { struct memblock *node= head_mb(mb_list);
  121.   while(node)
  122.   { struct memblock *temp= node->succ;
  123.     flame_mb(node);
  124.     node= temp;
  125.   }
  126. }
  127.