home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / Tex29 / StTeXsrc.zoo / src / heap.c < prev    next >
C/C++ Source or Header  |  1988-03-13  |  5KB  |  236 lines
  1.  
  2. /*
  3.  * @(#)heap.c 2.6 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "box.h"
  15. #include "evalstack.h"
  16. #include "par.h"
  17. #include "page.h"
  18.  
  19. mword   mem[MEM_MAX-MEM_MIN+1];
  20. ptr     mem_end;
  21. ptr     lo_mem_max;
  22. ptr     hi_mem_min;
  23. ptr     avail;
  24. int     dyn_used;
  25. ptr     rover;
  26. int     var_used;
  27. int     max_var_used;
  28. ptr     temp_ptr;
  29.  
  30. ptr
  31. get_avail ()
  32. {
  33.     ptr     p;
  34.  
  35.     p = avail;
  36.     if (p != NULL) {
  37.         avail = link(avail);
  38.     } else if (mem_end < MEM_MAX) {
  39.         incr(mem_end);
  40.         p = mem_end;
  41.     } else {
  42.         decr(hi_mem_min);
  43.         p = hi_mem_min;
  44.         if (hi_mem_min <= lo_mem_max) {
  45.             runaway();
  46.             overflow("main memory size", MEM_MAX - MEM_MIN);
  47.         }
  48.     }
  49.     link(p) = NULL;
  50. #ifdef STAT
  51.     incr(dyn_used);
  52. #endif
  53.     return p;
  54. }
  55.  
  56. ptr
  57. get_node (s)
  58.     int     s;
  59. {
  60.     ptr     p;
  61.     ptr     q;
  62.     int     r;
  63.     int     t;
  64.  
  65. restart:
  66.     p = rover;
  67.     do {
  68.         q = p + node_size(p);
  69.         while (is_empty(q)) {
  70.             t = rlink(q);
  71.             if (q == rover)
  72.                 rover = t;
  73.             llink(t) = llink(q);
  74.             rlink(llink(q)) = t;
  75.             q += node_size(q);
  76.         }
  77.         r = q - s;
  78.         if (r > (int) p + 1)  {
  79.             node_size(p) = r - p;
  80.             rover = p;
  81.             goto found;
  82.         }
  83.         if (r == p && rlink(p) != p) {
  84.             rover = rlink(p);
  85.             t = llink(p);
  86.             llink(rover) = t;
  87.             rlink(t) = rover;
  88.             goto found;
  89.         }
  90.         node_size(p) = q - p;
  91.         p = rlink(p);
  92.     } while (p != rover);
  93.     if (s == 010000000000)
  94.         return MAX_HALFWORD;
  95.     if (lo_mem_max + 2 < hi_mem_min && 
  96.         lo_mem_max + 2 <= MEM_BOT + MAX_HALFWORD) {
  97.         if (lo_mem_max + 1000 < hi_mem_min)
  98.             t = lo_mem_max + 1000;
  99.         else t = (lo_mem_max + hi_mem_min + 2) / 2;
  100.         p = llink(rover);
  101.         q = lo_mem_max;
  102.         rlink(p) = q;
  103.         llink(rover) = q;
  104.         if (t > MEM_BOT + MAX_HALFWORD)
  105.             t = MEM_BOT + MAX_HALFWORD;
  106.         rlink(q) = rover;
  107.         llink(q) = p;
  108.         link(q) = EMPTY_FLAG;
  109.         node_size(q) = t - lo_mem_max;
  110.         lo_mem_max = t;
  111.         link(lo_mem_max) = NULL;
  112.         info(lo_mem_max) = NULL; 
  113.         rover = q;
  114.         goto restart;
  115.     }
  116.  
  117.     overflow("main memory size", MEM_MAX + 1 - MEM_MIN);
  118.  
  119. found:
  120.     link(r) = NULL;
  121. #ifdef STAT
  122.     var_used += s;
  123. #endif
  124.     return r;
  125. }
  126.  
  127. free_node (p, s)
  128.     ptr     p;
  129.     hword   s;
  130. {
  131.     ptr     q;
  132.  
  133.     node_size(p) = s;
  134.     link(p) = EMPTY_FLAG;
  135.     q = llink(rover);
  136.     llink(p) = q;
  137.     rlink(p) = rover;
  138.     llink(rover) = p;
  139.     rlink(q) = p;
  140. #ifdef STAT
  141.     var_used -= s;
  142. #endif
  143. }
  144.  
  145. init_mem ()
  146. {
  147.     int     k;
  148.     
  149. #ifdef INIT
  150.     for (k = MEM_BOT + 1; k <= LO_MEM_STAT_MAX; k++)
  151.         mem[k].sc = 0;
  152.     for (k = MEM_BOT; k <= LO_MEM_STAT_MAX; k += GLUE_SPEC_SIZE) {
  153.         glue_ref_count(k) = NULL + 1;
  154.         stretch_order(k) = NORMAL;
  155.         shrink_order(k) = NORMAL;
  156.     }
  157.     stretch(fil_glue) = UNITY;
  158.     stretch_order(fil_glue) = FIL;
  159.     stretch(fill_glue) = UNITY;
  160.     stretch_order(fill_glue) = FILL;
  161.     stretch(ss_glue) = UNITY;
  162.     stretch_order(ss_glue) = FIL;
  163.     shrink(ss_glue) = UNITY;
  164.     shrink_order(ss_glue) = FIL;
  165.     stretch(fil_neg_glue) = -UNITY;
  166.     stretch_order(fil_neg_glue) = FIL;
  167.     
  168.     rover = LO_MEM_STAT_MAX + 1;
  169.     link(rover) = EMPTY_FLAG;
  170.     node_size(rover) = 1000;
  171.     llink(rover) = rover;
  172.     rlink(rover) = rover;
  173.  
  174.     lo_mem_max = rover + 1000;
  175.     link(lo_mem_max) = NULL;
  176.     info(lo_mem_max) = NULL;
  177.     for (k = HI_MEM_STAT_MIN; k <= MEM_TOP; incr(k))
  178.         mem[k] = mem[lo_mem_max];
  179.  
  180.     link(end_span) = MAX_QUARTERWORD + 1;
  181.     info(end_span) = NULL;
  182.     type(last_active) = HYPHENATED;
  183.     subtype(last_active) = 0;
  184.     line_number(last_active) = MAX_HALFWORD;
  185.     type(page_ins_head) = SPLIT_UP;
  186.     subtype(page_ins_head) = qi(255);
  187.     link(page_ins_head) = page_ins_head;
  188.     type(page_head) = GLUE_NODE;
  189.     subtype(page_head) = NORMAL;
  190.  
  191.     avail = NULL;
  192.     mem_end = MEM_TOP;
  193.     hi_mem_min = HI_MEM_STAT_MIN;
  194.     var_used = LO_MEM_STAT_MAX + 1 - MEM_BOT;
  195.     dyn_used = HI_MEM_STAT_USAGE;
  196. #endif
  197. }
  198.  
  199. sort_avail()
  200. {
  201.     ptr     p;
  202.     ptr     q;
  203.     ptr     r;
  204.     ptr     old_rover;
  205.  
  206. #ifdef INIT
  207.     get_node(010000000000);
  208.     p = rlink(rover);
  209.     rlink(rover) = MAX_HALFWORD;
  210.     old_rover = rover;
  211.     while (p != old_rover) {
  212.         if (p < rover) {
  213.             q = p;
  214.             p = rlink(q);
  215.             rlink(q) = rover;
  216.             rover = q;
  217.         } else {
  218.             q = rover;
  219.             while (rlink(q) < p)
  220.                 q = rlink(q);
  221.             r = rlink(p);
  222.             rlink(p) = rlink(q);
  223.             rlink(q) = p;
  224.             p = r;
  225.         }
  226.     }
  227.     p = rover;
  228.     while (rlink(p) != MAX_HALFWORD) {
  229.         llink(rlink(p)) = p;
  230.         p = rlink(p);
  231.     }
  232.     rlink(p) = rover;
  233.     llink(rover) = p;
  234. #endif
  235. }
  236.