home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / getmem.c < prev    next >
C/C++ Source or Header  |  1993-11-04  |  13KB  |  807 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #ifdef AMIGA
  5. # ifdef BIG
  6. #  define AMIGA_ASM
  7. # endif
  8. #endif
  9.  
  10.  
  11. /*
  12.  *  Hier sind alle Routinen der Speicherverwaltung (Part 9), von der die
  13.  *  wichtigsten in Assembler geschrieben sind.
  14.  *
  15.  * Achtung: Wird `max_halfword', sizeof(memoryword), Node-Layout oder die
  16.  *          Groesse einiger globaler Variablen geaendert, so muss auch hier
  17.  *          geaendert werden!
  18.  *
  19.  */
  20.  
  21.  
  22. #if defined(__GNUC__) && defined(atarist)
  23.  
  24. #  ifdef BIG
  25.  
  26. __asm__("
  27. .text
  28.     .even
  29. .globl _getavail
  30. _getavail:
  31. "
  32. #ifdef REG_A5
  33. "    movel a5,a0 "
  34. #else
  35. "    movel _zzzaa,a0 "
  36. #endif
  37. "
  38.     movel _avail,d0        | p = avail
  39.     jeq   L_growavail
  40.  
  41.     movel d0,d1
  42.     asll  #3,d1
  43.     movel a0@(d1:l),_avail
  44.     jra   L_getavailend
  45.  
  46. L_growavail:
  47.     movel _memend,d0    | p = memend
  48.     cmpl  _memmax:l,d0
  49.     jge   L_growdown
  50.  
  51.     addql #1,d0        | kann nicht groesser als 65534 werden
  52.     movel d0,_memend
  53.     jra   L_beforeend
  54.  
  55. L_growdown:
  56.     subql #1,_himemmin
  57.     movel _himemmin,d0
  58.     cmpl  _lomemmax:l,d0
  59.     jgt   L_beforeend
  60.  
  61.     jbsr  _runaway
  62.     movel _memmax,a1
  63.     addqw #1,a1
  64.     movel a1,sp@-
  65.     pea   3:w
  66.     jbsr  _overflow
  67.     | Not reached
  68.  
  69. L_beforeend:
  70.     movel d0,d1
  71.     asll  #3,d1
  72.  
  73. L_getavailend:
  74.     clrl  a0@(d1:l)
  75.     addql #1,_dynused
  76.     rts
  77. ");
  78.  
  79. #  else
  80.  
  81. __asm__("
  82. .text
  83.     .even
  84. .globl _getavail
  85. _getavail:
  86. "
  87. #ifdef REG_A5
  88. "    movel a5,a0 "
  89. #else
  90. "    movel _zzzaa,a0 "
  91. #endif
  92. "
  93.     moveq #0,d0
  94.     movew _avail,d0        | p = avail
  95.     jeq   L_growavail
  96.  
  97.     movel d0,d1
  98.     asll  #2,d1
  99.     movew a0@(d1:l),_avail
  100.     jra   L_getavailend
  101.  
  102. L_growavail:
  103.     movew _memend,d0    | p = memend
  104.     cmpl  _memmax:l,d0
  105.     jge   L_growdown
  106.  
  107.     addqw #1,d0        | kann nicht groesser als 65534 werden
  108.     movew d0,_memend
  109.     jra   L_beforeend
  110.  
  111. L_growdown:
  112.     subqw #1,_himemmin
  113.     movew _himemmin,d0
  114.     movew _lomemmax,d1
  115.     cmpw  d0,d1
  116.     jcs   L_beforeend
  117.  
  118.     jbsr  _runaway
  119.     movel _memmax,d1
  120.     addql #1,d1
  121.     movel d1,sp@-
  122.     pea   3:w
  123.     jbsr  _overflow
  124.     | Not reached
  125.  
  126. L_beforeend:
  127.     movel d0,d1
  128.     asll  #2,d1
  129.  
  130. L_getavailend:
  131.     clrw  a0@(d1:l)
  132.     addql #1,_dynused
  133.     rts
  134. ");
  135.  
  136. #  endif
  137.  
  138. #else  /* defined(__GNUC__) && defined(atarist) */
  139.  
  140. #  if !defined(AMIGA_ASM)
  141.  
  142. long_halfword STDARGS getavail ( void )
  143. { getavail_regmem
  144.   register halfword p;
  145.  
  146.   p = avail;
  147.   if ( p != 0 ) {
  148.     avail = link( p /* avail */ );
  149.     link ( p ) = 0;
  150.   } else {
  151.     if ( memend < memmax ) {
  152.       incr ( memend );
  153.       p = memend;
  154.     } else {
  155.       decr ( himemmin );
  156.       p = himemmin;
  157.       if ( himemmin <= lomemmax ) {
  158.     runaway();
  159.     overflow(3, memmax + 1 - memmin);
  160.       }
  161.     }
  162.     link ( p ) = 0;
  163.   }
  164.  
  165. #ifdef STAT
  166.   incr ( dynused );
  167. #endif /* STAT */
  168.   return( (long_halfword)p );
  169. }
  170.  
  171. #  endif
  172.  
  173. #endif
  174.  
  175.  
  176. #if defined(__GNUC__) && defined(atarist)
  177.  
  178. #  ifdef BIG
  179.  
  180. __asm__("
  181. .text
  182.     .even
  183. .globl _flushlist
  184. _flushlist:
  185.     movel sp@(4),d0        | Argument (long) p
  186.     jeq   L_endflush
  187.  
  188.     subl  a1,a1        | count = 0
  189. "
  190. #ifdef REG_A5
  191. "    movel a5,a0 "
  192. #else
  193. "    movel _zzzaa,a0 "
  194. #endif
  195. "
  196. L_loop:
  197.     addqw #1,a1        | count++
  198.  
  199.     movel d0,d1        | q = r (= p)
  200.     asll  #3,d1
  201.     movel a0@(d1:l),d0    | r = link(q)
  202.     jne   L_loop
  203.  
  204.     movel _avail,a0@(d1:l)
  205.     movel sp@(4),_avail
  206.  
  207.     movel a1,d0
  208.     subl  d0,_dynused
  209.  
  210. L_endflush:
  211.     rts
  212. ");
  213.  
  214. #  else
  215.  
  216. __asm__("
  217. .text
  218.     .even
  219. .globl _flushlist
  220. _flushlist:
  221.     moveq #0,d0        | [hi-word(d0) = 0  for this function]
  222.     movel d0,a1        | count = 0
  223.  
  224.     movew sp@(6),d0        | Argument (halfword) p
  225.     jeq   L_endflush
  226. "
  227. #ifdef REG_A5
  228. "    movel a5,a0 "
  229. #else
  230. "    movel _zzzaa,a0 "
  231. #endif
  232. "
  233. L_loop:
  234.     addqw #1,a1
  235.  
  236.     movel d0,d1           | q = r  ( = p )
  237.     asll  #2,d1
  238.     movew a0@(d1:l),d0     | r = link(q)
  239.     jne   L_loop
  240.  
  241.     movew _avail,a0@(d1:l)
  242.     movew sp@(6),_avail
  243.  
  244.     movel a1,d0
  245.     subl  d0,_dynused
  246.  
  247. L_endflush:
  248.     rts
  249. ");
  250.  
  251. #  endif
  252.  
  253. #else /* defined(__GNUC__) && defined(atarist) */
  254.  
  255. #  if !defined(AMIGA_ASM)
  256.  
  257. void STDARGS flushlist ( long_halfword p )
  258. { flushlist_regmem
  259.  
  260.   if ( p != 0 ) {
  261.     register long_halfword q, r;
  262.     register long count = 0L;
  263.  
  264.     r = p;
  265.     do {
  266. #ifdef STAT
  267.       /* decr ( dynused ); */
  268.       count++;
  269. #endif /* STAT */
  270.       q = r;
  271.       r = link ( q /* r */ );
  272.     } while ( r != 0 );
  273.  
  274.     link ( q ) = avail;
  275.     avail = p;
  276. #ifdef STAT
  277.     dynused -= count;
  278. #endif /* STAT */
  279.   }
  280. }
  281.  
  282. #  endif
  283.  
  284. #endif
  285.  
  286.  
  287.  
  288.     /* take this out of getnode, because it's called only, if the
  289.      * lower part of mem grows by 1000 words at a time.
  290.      */
  291. /*static*/ void STDARGS getnode_grow( void )
  292. { getnode_regmem
  293.  
  294.   if ( lomemmax + 2 < himemmin )
  295.   if ( lomemmax + 2 <= membot + maxhalfword ) {
  296.     register halfword p, q;
  297.     register integer t;
  298.  
  299.     if ( himemmin - lomemmax >= 1998 )
  300.       t = lomemmax + 1000;
  301.     else
  302.       t = lomemmax + 1 + ( himemmin - lomemmax ) / 2;
  303.     p = llink ( rover );
  304.     q = lomemmax;
  305.     rlink ( p ) = q;
  306.     llink ( rover ) = q;
  307.     if ( t > membot + maxhalfword )
  308.       t = membot + maxhalfword;
  309.     rlink ( q ) = rover;
  310.     llink ( q ) = p;
  311.     link ( q ) = emptyflag;
  312.     nodesize ( q ) = t - lomemmax;
  313.     lomemmax = t;
  314.     link ( lomemmax ) = 0;
  315.     info ( lomemmax ) = 0;
  316.     rover = q;
  317.     return;
  318.   }
  319.   overflow(3, memmax + 1 - memmin);
  320. }
  321.  
  322.  
  323.  
  324. #if defined(__GNUC__) && defined(atarist)
  325.  
  326. #  ifdef BIG
  327.  
  328. __asm__("
  329. .text
  330.     .even
  331. .globl _getnode
  332. _getnode:
  333.     moveml d2/d3/d4,sp@-    | #0x3800
  334.  
  335. L_restart:
  336. "
  337. #ifdef REG_A5
  338. "    movel a5,a0 "
  339. #else
  340. "    movel _zzzaa,a0 "
  341. #endif
  342. "
  343.     lea   _rover,a1        | a1 = &rover
  344.     movel a1@,d2        | p = rover    /* hi_word = 0 */
  345.  
  346. L_repeatloop:
  347.     movel d2,d1        | q = p        /* hi_word = 0 */
  348.  
  349. L_whileloop:
  350.     movel d1,d0
  351.     asll  #3,d0        | Adr(q)
  352.  
  353.     addl  a0@(4,d0:l),d1    | q += nodesize(q)
  354.  
  355.     movel d1,d0        | /* hi_word(q) ist noch 0 */
  356.     asll  #3,d0        | Adr(q)
  357.  
  358.     cmpl  #524287,a0@(d0:l)
  359.     jne   L_exitwhile
  360.  
  361.     movel a0@(8,d0:l),d3    | t = rlink(q)
  362.  
  363.     cmpl  a1@,d1
  364.     jne   L_notrover    | if( q = rover )
  365.     movel d3,a1@        |   rover = t;
  366. L_notrover:
  367.  
  368.     movel d3,d4
  369.     asll  #3,d4        | Adr(t)
  370.  
  371.     movel a0@(12,d0:l),a0@(12,d4:l)    | llink(t) = llink(q)
  372.  
  373.     movel a0@(12,d0:l),d4    | d4 = llink(q)
  374.     asll  #3,d4
  375.     movel d3,a0@(8,d4:l)    | rlink(d4) = t
  376.  
  377.     jra   L_whileloop
  378.  
  379. L_exitwhile:
  380.     movel sp@(16),d4    | !!! --->>>> hole Argument (long) s
  381.     movel d1,d0
  382.     subl  d4,d0        | r = q - s ,  /* q in d1 */
  383.  
  384.     movel d2,d3    | d3 = p + 1
  385.     addql #1,d3
  386.     cmpl  d0,d3    | if ( r > p + 1 )
  387.     jge   L_too_short
  388.  
  389.     |
  390.     | es passt rein:
  391.     |
  392.     movel d2,d3
  393.     asll  #3,d3        | Adr(p)
  394.  
  395.     movel d0,d1
  396.     subl  d2,d1        | d4 = r - p
  397.     movel d1,a0@(4,d3:l)    | nodesize(p) = r - p
  398.  
  399.     movel d2,a1@        | rover = p
  400.     |
  401.     | r ist jetzt in d0, s in d4
  402.     jra L_found
  403.  
  404. L_too_short:
  405.     cmpl  d0,d2        | if ( r == p )
  406.     jne   L_nextwhile
  407.  
  408.     movel d2,d3
  409.     asll  #3,d3
  410.     cmpl  a0@(8,d3:l),d2    | if ( rlink(p) != p )
  411.     jeq   L_nextwhile
  412.  
  413.     movel a0@(8,d3:l),d1
  414.     movel d1,a1@        | rover = rlink(p)
  415.  
  416.     movel a0@(12,d3:l),d2    | t = llink(p)
  417.  
  418.     asll  #3,d1
  419.     movel d2,a0@(12,d1:l)    | llink(rover) = t
  420.  
  421.     asll  #3,d2
  422.     movel a1@,a0@(8,d2:l)    | rlink(t) = rover
  423.     |
  424.     | r ist jetzt in d0, s in d4
  425.     jra   L_found
  426.  
  427. L_nextwhile:
  428.     movel d2,d3
  429.     asll  #3,d3        | Adr(p)
  430.  
  431.     subl  d2,d1
  432.     movel d1,a0@(4,d3:l)    | nodesize(p) = q - p
  433.  
  434.     movel a0@(8,d3:l),d2    | p = rlink(p)
  435.     cmpl  a1@,d2
  436.     jne   L_repeatloop
  437.  
  438.     cmpl  #1073741824,d4
  439.     jne   L_growmem
  440.  
  441.     movel #524287,d0
  442.     jra   L_exitgetnode
  443.  
  444. L_growmem:    | wird nur sehr selten durchlaufen, ...
  445.     jbsr  _getnode_grow
  446.     jra   L_restart
  447.  
  448.  
  449. L_found:            | r ist in d0:l, s in d4:l
  450.     movel d0,d1
  451.     asll  #3,d1
  452.     clrl  a0@(d1:l)        | link(r) = 0
  453.  
  454.     addl  d4,_varused
  455.  
  456. L_exitgetnode:
  457.     moveml sp@+,d2/d3/d4    | #0x3c
  458.     rts
  459. ");
  460.  
  461. #  else
  462.  
  463. __asm__("
  464. .text
  465.     .even
  466. .globl _getnode
  467. _getnode:
  468.     moveml d2/d3/d4,sp@-    | #0x3800
  469.  
  470. L_restart:
  471. "
  472. #ifdef REG_A5
  473. "    movel a5,a0 "
  474. #else
  475. "    movel _zzzaa,a0 "
  476. #endif
  477. "
  478.     lea   _rover,a1        | a1 = &rover
  479. /*
  480. | Damit nicht laufend mit 'moveq #0,di ; movew X,di' X auf long gebracht
  481. | werden muss, wurde mit Vorsicht(!) die Hi-Words von d1 und d2 auf 0
  482. | gelassen. (Bei Aenderungen beachten, da sonst nur ??? herauskommt)
  483. */
  484.     moveq #0,d2
  485.     movew a1@,d2        | p = rover    /* hi_word = 0 */
  486.  
  487. L_repeatloop:
  488.     movel d2,d1        | q = p        /* hi_word = 0 */
  489.  
  490. L_whileloop:
  491.     movel d1,d0
  492.     asll  #2,d0        | Adr(q)
  493.  
  494.     addw  a0@(2,d0:l),d1    | q += nodesize(q)
  495.  
  496.     movel d1,d0        | /* hi_word(q) ist noch 0 */
  497.     asll  #2,d0        | Adr(q)
  498.  
  499.     cmpw  #65535,a0@(d0:l)
  500.     jne   L_exitwhile
  501.  
  502.     moveq #0,d3
  503.     movew a0@(4,d0:l),d3    | t = rlink(q)
  504.  
  505.     cmpw  a1@,d1
  506.     jne   L_notrover    | if( q = rover )
  507.     movew d3,a1@        |   rover = t;
  508. L_notrover:
  509.  
  510.     movel d3,d4
  511.     asll  #2,d4        | Adr(t)
  512.  
  513.     movew a0@(6,d0:l),a0@(6,d4:l)    | llink(t) = llink(q)
  514.  
  515.     moveq #0,d4
  516.     movew a0@(6,d0:l),d4    | d4 = llink(q)
  517.     asll  #2,d4
  518.     movew d3,a0@(4,d4:l)    | rlink(d4) = t
  519.  
  520.     jra   L_whileloop
  521.  
  522. L_exitwhile:
  523.     movel sp@(16),d4    | !!! --->>>> hole Argument (long) s
  524.     movel d1,d0
  525.     subl  d4,d0        | r = q - s ,  /* q in d1 */
  526.  
  527.     movel d2,d3    | d3 = p + 1
  528.     addql #1,d3
  529.     cmpl  d0,d3    | if ( r > p + 1 )
  530.     jge   L_too_short
  531.  
  532.     |
  533.     | es passt rein:
  534.     |
  535.     movel d2,d3
  536.     asll  #2,d3        | Adr(p)
  537.  
  538.     movel d0,d1
  539.     subl  d2,d1        | d4 = r - p
  540.     movew d1,a0@(2,d3:l)    | nodesize(p) = r - p
  541.  
  542.     movew d2,a1@        | rover = p
  543.     |
  544.     | r ist jetzt in d0, s in d4
  545.     jra   L_found
  546.  
  547. L_too_short:
  548.     cmpl  d0,d2        | if ( r == p )
  549.     jne   L_nextwhile
  550.  
  551.     movel d2,d3
  552.     asll  #2,d3
  553.     cmpw  a0@(4,d3:l),d2    | if ( rlink(p) != p )
  554.     jeq   L_nextwhile
  555.  
  556.     moveq #0,d1
  557.     movew a0@(4,d3:l),d1
  558.     movew d1,a1@        | rover = rlink(p)
  559.  
  560.     movew a0@(6,d3:l),d2    | t = llink(p)
  561.  
  562.     asll  #2,d1
  563.     movew d2,a0@(6,d1:l)    | llink(rover) = t
  564.  
  565.     asll  #2,d2
  566.     movew a1@,a0@(4,d2:l)    | rlink(t) = rover
  567.     |
  568.     | r ist jetzt in d0, s in d4
  569.     jra   L_found
  570.  
  571. L_nextwhile:
  572.     movel d2,d3
  573.     asll  #2,d3        | Adr(p)
  574.  
  575.     subl  d2,d1
  576.     movew d1,a0@(2,d3:l)    | nodesize(p) = q - p
  577.  
  578.     movew a0@(4,d3:l),d2    | p = rlink(p)
  579.     cmpw  a1@,d2
  580.     jne   L_repeatloop
  581.  
  582.     cmpl  #1073741824,d4
  583.     jne   L_growmem
  584.  
  585.     movel #65535,d0
  586.     jra   L_exitgetnode
  587.  
  588. L_growmem:    | wird nur sehr selten durchlaufen, ...
  589.     jbsr  _getnode_grow
  590.     jra   L_restart
  591.  
  592.  
  593. L_found:            | r ist in d0:l, s in d4:l
  594.     movel d0,d1
  595.     asll  #2,d1
  596.     clrw  a0@(d1:l)        | link(r) = 0
  597.  
  598.     addl  d4,_varused
  599.  
  600. L_exitgetnode:
  601.     moveml sp@+,d2/d3/d4    | #0x3c
  602.     rts
  603. ");
  604.  
  605. #  endif
  606.  
  607. #else
  608.  
  609. #  if !defined(AMIGA_ASM)
  610.  
  611.   long_halfword    STDARGS    /* produces better code in the caller function */
  612. getnode ( integer s )
  613. { getnode_regmem
  614.   register integer r;
  615.  
  616. lab20:
  617.   { register halfword p;
  618.     register halfword q;
  619.     register halfword *roverPTR = &rover;
  620. #define rover  (*roverPTR)
  621.  
  622.   p = rover;
  623.   do {
  624.     q = p;
  625.     while(1) {
  626.       register halfword r;
  627.  
  628.       q += nodesize( q );
  629.  
  630.       if( ! isempty( q ) )
  631.     break;
  632.  
  633.       r = rlink ( q );
  634.       if ( q == rover )
  635.         rover = r;
  636.       llink ( r ) = llink ( q );
  637.       rlink ( llink ( q ) ) = r;
  638.     }
  639.     r = q - s;
  640.     if ( r > toint ( p + 1 ) ) {
  641.       nodesize ( p ) = r - p;
  642.       rover = p;
  643.       goto lab40;
  644.     }
  645.     if ( r == p ) {
  646.       if ( p != rlink ( p ) ) {
  647.     q = llink ( p );
  648.     p /* rover */ = rlink ( p );
  649.     rlink ( q ) = p /* rover */;
  650.     llink ( p /* rover */ ) = q;
  651.     rover = p;
  652.     goto lab40;
  653.       }
  654.     }
  655.     nodesize ( p ) = q - p;
  656.     p = rlink ( p );
  657.   } while ( p != rover );
  658.  
  659.   if ( s == 1073741824L )
  660.     return(maxhalfword);
  661.  
  662. #undef rover
  663.   }
  664.  
  665.   getnode_grow();
  666.   goto lab20;
  667.  
  668. lab40:
  669. #ifdef STAT
  670.   varused += s;
  671. #endif /* STAT */
  672.   link ( r ) = 0;
  673.   return( (long_halfword)r );
  674. }
  675.  
  676. #  endif
  677.  
  678. #endif
  679.  
  680.  
  681.  
  682. #if defined(__GNUC__) && defined(atarist)
  683.  
  684. #  ifdef BIG
  685.  
  686. __asm__("
  687. .text
  688.     .even
  689. .globl _freenode
  690. _freenode:
  691. "
  692. #ifdef REG_A5
  693. "    movel a5,a0 "
  694. #else
  695. "    movel _zzzaa,a0 "
  696. #endif
  697. "
  698.     movel sp@(4),d0        | Argument (long) p
  699.  
  700.     movel d0,d1
  701.     asll  #3,d1
  702.     lea   a0@(d1:l),a1    | Adr. von p
  703.  
  704.     movel sp@(8),d1        | Argument (long) s
  705.  
  706.     subl  d1,_varused    | varused -= s
  707.  
  708.     movel #524287,a1@+    | link(p) = emptyflag
  709.     movel d1,a1@+        | nodesize(p) = s
  710.  
  711.     movel _rover,d1
  712.     movel d1,a1@+        | rlink(p) = rover
  713.  
  714.     movel d2,sp@-
  715.  
  716.     movel d1,d2
  717.     asll  #3,d2
  718.     movel a0@(12,d2:l),d1    | q = llink(rover)
  719.     movel d0,a0@(12,d2:l)    | llink(rover) = p
  720.  
  721.     movel sp@+,d2
  722.  
  723.     movel d1,a1@        | llink(p) = q
  724.     asll  #3,d1
  725.     movel d0,a0@(8,d1:l)    | rlink(q) = p
  726.     rts
  727. ");
  728.  
  729. #  else
  730.  
  731. __asm__("
  732. .text
  733.     .even
  734. .globl _freenode
  735. _freenode:
  736. "
  737. #ifdef REG_A5
  738. "    movel a5,a0 "
  739. #else
  740. "    movel _zzzaa,a0 "
  741. #endif
  742. "
  743.     moveq #0,d0
  744.     movew sp@(6),d0        | Argument (halfword) p
  745.  
  746.     movel d0,d1
  747.     asll  #2,d1
  748.     lea   a0@(d1:l),a1    | Adr. von p
  749.  
  750.     moveq #0,d1
  751.     movew sp@(10),d1    | Argument (halfword) s
  752.  
  753.     subl  d1,_varused    | varused -= s
  754.  
  755.     movew #65535,a1@+    | link(p) = emptyflag
  756.     movew d1,a1@+        | nodesize(p) = s
  757.  
  758.     movew _rover,d1
  759.     movew d1,a1@+        | rlink(p) = rover
  760.  
  761.     movel d2,sp@-
  762.  
  763.     movel d1,d2
  764.     asll  #2,d2
  765.     movew a0@(6,d2:l),d1    | q = llink(rover)
  766.     movew d0,a0@(6,d2:l)    | llink(rover) = p
  767.  
  768.     movel sp@+,d2
  769.  
  770.     movew d1,a1@        | llink(p) = q
  771.     asll  #2,d1
  772.     movew d0,a0@(4,d1:l)    | rlink(q) = p
  773.     rts
  774. ");
  775.  
  776. #  endif
  777.  
  778. #else /* defined(__GNUC__) && defined(atarist) */
  779.  
  780. #  if !defined(AMIGA_ASM)
  781.  
  782. void STDARGS freenode ( long_halfword p, long_halfword s )
  783. { freenode_regmem
  784.  
  785. #ifdef STAT
  786.   varused -= s;
  787. #endif /* STAT */
  788.   nodesize ( p ) = s;
  789.   link ( p ) = emptyflag;
  790.  
  791.   { register halfword q;
  792.     register halfword r_rover = rover;    /* (br) constant */
  793.  
  794.   q = llink ( r_rover );
  795.   rlink ( p ) = r_rover;
  796.   llink ( p ) = q;
  797.   rlink ( q ) = p;
  798.   llink ( r_rover ) = p;
  799.   }
  800. }
  801.  
  802. #  endif
  803.  
  804. #endif
  805.  
  806. /* -- end -- */
  807.