home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / TEKST / CMTEX330 / SOURCE / ALLOC.C < prev    next >
C/C++ Source or Header  |  1992-02-19  |  3KB  |  180 lines
  1.  
  2. /*
  3.  * %Y%:%M%:%I%:%Q%
  4.  *
  5.  * Copyright 1987,1988,1991 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  *
  11.  */
  12.  
  13. #ifndef lint
  14. static char *sccsid = "%A%";
  15. #endif
  16.  
  17. #include "tex.h"
  18.  
  19. ptr     avail;
  20. ptr    avail_ptr;
  21. ptr    avail_end;
  22.  
  23. struct blk_t {
  24.     int    size_field;
  25.     ptr    free_field;
  26.     ptr    rblk_field;
  27.     ptr    lblk_field;
  28. };
  29. typedef struct blk_t blk_t;
  30.  
  31. #define size(B)        ((blk_t *) B)->size_field
  32. #define free(B)     ((blk_t *) B)->free_field
  33. #define rblk(B)        ((blk_t *) B)->rblk_field
  34. #define lblk(B)        ((blk_t *) B)->lblk_field
  35.  
  36. #define is_free(B)    (free(B) == nil)
  37.  
  38. ptr    rover;
  39. ptr    nil;
  40.  
  41. #ifdef STAT
  42. int     dyn_used;
  43. int    var_used;
  44. #endif
  45.  
  46. #define BLOCK_SIZE    (32*4096)
  47.  
  48. ptr
  49. new_avail ()
  50. {
  51.     ptr    p;
  52.  
  53.     p = avail;
  54.     if (p != null) {
  55.         avail = link(avail);
  56.     } else if (avail_ptr < avail_end) {
  57.         p = avail_ptr;
  58.         avail_ptr += sizeof(mcell);
  59.     } else {
  60.         p = avail_ptr = (ptr) malloc(BLOCK_SIZE);
  61.         if (avail_ptr == null) {
  62.             overflow("new avail", BLOCK_SIZE);
  63.         }
  64.         avail_end = avail_ptr + BLOCK_SIZE;
  65.         avail_ptr += sizeof(mcell);
  66.     }
  67.     link(p) = null;
  68.     type(p) = -1;
  69. #ifdef STAT
  70.     incr(dyn_used);
  71. #endif
  72.     return p;
  73. }
  74.  
  75. ptr
  76. new_node (s)
  77.     int     s;
  78. {
  79.     ptr    p;
  80.     ptr    q;
  81.     ptr    r;
  82.     ptr    t;
  83.  
  84. restart:
  85.     p = rover;
  86.     do {
  87.         q = p + size(p);
  88.         while (is_free(q)) {
  89.             t = rblk(q);
  90.             if (q == rover) {
  91.                 rover = t;
  92.             }
  93.             lblk(t) = lblk(q);
  94.             rblk(lblk(q)) = t;
  95.             q += size(q);
  96.         }
  97.         r = q - s;
  98.         if (r - p > sizeof(blk_t))  {
  99.             size(p) = r - p;
  100.             rover = p;
  101.             goto found;
  102.         }
  103.         if (r == p && rblk(p) != p) {
  104.             rover = rblk(p);
  105.             t = lblk(p);
  106.             lblk(rover) = t;
  107.             rblk(t) = rover;
  108.             goto found;
  109.         }
  110.         size(p) = q - p;
  111.         p = rblk(p);
  112.     } while (p != rover);
  113.  
  114.     q = (ptr)malloc(BLOCK_SIZE);
  115.     if (q == null) {
  116.         overflow("get node", BLOCK_SIZE);
  117.     }
  118.     p = lblk(rover);
  119.     rblk(p) = q;
  120.     lblk(rover) = q;
  121.     rblk(q) = rover;
  122.     lblk(q) = p;
  123.     free(q) = nil;
  124.     size(q) = BLOCK_SIZE - sizeof(blk_t);
  125.     memset(q + size(q), 0, sizeof(blk_t));
  126.     rover = q;
  127.     goto restart;
  128.  
  129.     found:
  130. #ifdef STAT
  131.     var_used += s;
  132. #endif
  133.     link(r) = null;
  134.     return r;
  135. }
  136.  
  137. void
  138. free_node (p, s)
  139.     ptr    p;
  140.     int    s;
  141. {
  142.     ptr     q;
  143.  
  144.     size(p) = s;
  145.     free(p) = nil;
  146.     q = lblk(rover);
  147.     lblk(p) = q;
  148.     rblk(p) = rover;
  149.     lblk(rover) = p;
  150.     rblk(q) = p;
  151. #ifdef STAT
  152.     var_used -= s;
  153. #endif
  154. }
  155.  
  156. void
  157. _alloc_init ()
  158. {
  159. }
  160.  
  161. void
  162. _alloc_init_once ()
  163. {
  164.     nil = (ptr)&nil;
  165.     avail = null;
  166.     rover = (ptr)malloc(BLOCK_SIZE);
  167.     if (rover == null) {
  168.         overflow("init alloc", BLOCK_SIZE);
  169.     }
  170.     size(rover) = BLOCK_SIZE - sizeof(blk_t);
  171.     free(rover) = nil;
  172.     lblk(rover) = rover;
  173.     rblk(rover) = rover;
  174.     memset(rover + size(rover), 0, sizeof(blk_t));
  175. #ifdef STAT
  176.     dyn_used = 0;
  177.     var_used = 0;
  178. #endif
  179. }
  180.