PRINZIP DER DYNAMISCHEN SPEICHERVERWALTUNG:       
£££££££££££££££££££££££££££££££££££££££££££       
ALLGEMEINES:                                      
-(LAENGE DER OBJEKTE IN BYTES) MOD 4 = 0          
-AUFBAU DER FREILISTE:                            
 TYPE ELEM = RECORD LEN  :INTEGER;                
                    LINK :^ ELEM                  
             END;                                 
 LEN GIBT DIE ANZAHL DER FREIEN BYTES (INCL. 4    
 BYTES FUER ELEM) AN, DIE AUF ELEM FOLGEN.        
-BEI PROGRAMMSTART WIRD DIE FREILISTE MIT EINER   
 WURZEL WIE FOLGT INITIALISIERT.                  
     W:=TOP OF MEMORY - 4                         
     W.LINK := 0                                  
     W.LEN  := 0                                  
     TOP    := W-4 (*RESERVIERE 2 BYTES UNTER-    
                     HALB VON W^*)                
GLOBAL:                                           
     W    (*ZEIGER AUF DIE WURZEL*)               
     TOP  (*ZEIGER AUF DIE 1. FREIE SPEICHERZELLE 
            UNTERHALB DES HEAP*)                  
     T    (*TOP OF STACK*)                        
                                                  
PROCEDURE NEW(L:INTEGER;ADR:^...);                
(*SETZE ZEIGER AUF EIN NEUES OBJEKT DER LAENGE L*)
(*EVTL. FEHLERMELDUNG: HEAP OVERFLOW            *)
 LABEL 1;                                         
 VAR HEAP,LAST:^ELEM;                             
BEGIN                                             
 HEAP:=W;                                         
 WHILE HEAP^.LINK<>NIL DO                         
  BEGIN LAST:=HEAP;HEAP:=HEAP^.LINK;              
   IF HEAP^.LEN>=L THEN                           
    BEGIN (*PLATZ IN DER FREILISTE GEFUNDEN*)     
     IF ADR=HEAP THEN                             
      (*ELEM LOESCHEN*)                           
      LAST^.LINK:=HEAP^.LINK                      
     ELSE                                         
      (*ELEM ANPASSEN*)                           
       HEAP^.LEN:=HEAP^.LEN-L;                    
     ADR:=HEAP+HEAP^.LEN-L                        
     GOTO 1;                                      
    END;                                          
  END;(*WHILE*)                                   
 (*HEAP ERWEITERN*)                               
 TOP:=TOP-L;                                      
 ADR:=TOP;                                        
 IF TOP<=TOS THEN (*ERROR...*);                   
 1:                                               
END;(*NEW*)                                       
                                                  
PROCEDURE DISPOSE(ADR:^...,L:INTEGER);            
(*L BYTES AB ADR FREIGEBEN. FALLS ADR NICHT IM  *)
(*BEREICH TOP..W FEHLERMELDUNG: OBJECT NOT FOUND*)
 VAR HEAP,LAST:^ELEM;                             
BEGIN                                             
 IF(ADR<TOS)OR(ADR>=W) THEN ERROR...;             
 HEAP:=W;                                         
 WHILE(HEAP^.LINK<>NIL)AND(HEAP^.LINK>ADR) DO     
  BEGIN LAST:=HEAP;HEAP:=HEAP^.LINK END;          
 (*HEAP ZEIGT OBERHALB VON ADR, LAST EVTL. AUF  *)
 (*VORGAENGER VON HEAP. ERZEUGE ELEM            *)
 ADR^.LINK:=HEAP^.LINK;                           
 HEAP^.LINK:=ADR;ADR^.LEN:=L;                     
 (*VERSCHMELZEN NACH OBEN MOEGLICH?*)             
 IF ADR+L=HEAP (*IMMER FALSE FUER W^ !*)          
  BEGIN (*HEAP^ LOESCHEN*)                        
   LAST^.LINK:=ADR;ADR^.LEN:=L+HEAP^.LEN;         
   HEAP:=LAST                                     
  END;                                            
 LAST:=ADR^.LINK;                                 
 (*JETZT GILT IMMER: HEAP->ADR->LAST*)            
 IF LAST=NIL THEN                                 
  BEGIN                                           
   IF TOP=ADR THEN (*HEAPENDE HOCHSETZEN*)        
     TOP:=TOP+ADR^.LEN                            
  END                                             
 ELSE                                             
  BEGIN                                           
  IF LAST+LAST^.LEN=ADR THEN                      
   BEGIN (*AUFNEHMEN NACH UNTEN*)                 
    LAST^.LEN:=LAST^.LEN+ADR^.LEN;                
    HEAP^.LINK:=LAST;                             
   END                                            
  END                                             
END;(*DISPOSE*)