PROGRAM MERGE (INPUT,OUTPUT);                               
(* NATUERLICHES MISCHSORTIEREN. (KAPITEL 2.16)            *)
(* IM PROGRAMM SIND DIE OPERATIONEN RESET UND REWRITE     *)
(* DURCH OPEN- UND CLOSE-SEQUENZEN ERSETZT WORDEN.        *)
(* 1.5.1986 FLORIAN MATTHES                               *)
(* QUELLE: WIRTH; ALGORITHMEN & DATENSTRUKTUREN KAP.2.3.2 *)
                                                            
 CONST NAMEA ='0:FILE.A';(* FILENAMEN FUER DIE FLOPPY     *)
       NAMEB ='0:FILE.B';                                   
       NAMEC ='0:FILE.C';                                   
       RD    =',SEQ,READ';                                  
       WR    =',SEQ,WRITE';                                 
                                                            
 TYPE ITEM = RECORD                                         
               KEY: INTEGER                                 
               (* HIER KOENNEN WEITERE FELDER STEHEN *)     
              END;                                          
                                                            
      TAPE = FILE OF ITEM;                                  
                                                            
  VAR  C       : TAPE;                                      
                                                            
   PROCEDURE ERASE(N: STRING);                              
   (* LOESCHE FILE N AUF DER DISKETTE. (NUR PASCAL 2.0)   *)
     VAR KOMMANDO: TEXT;                                    
   BEGIN                                                    
     OPEN(KOMMANDO,8,15,'S' + N); CLOSE(KOMMANDO)           
   END; (* ERASE *)                                         
                                                            
  PROCEDURE LIST(VAR F: TAPE; N: STRING);                   
  (* ZEIGE DEN INHALT VON FILE F AN                       *)
  BEGIN                                                     
    WRITELN('INHALT DES FILES ', N, ':');                   
    OPEN(F,8,3, N + RD); GET(F);        (* NUR PASCAL 2.0 *)
    WHILE NOT EOF(F) DO                                     
      BEGIN  WRITE(F^.KEY:4); GET(F) END;                   
    WRITELN;                                                
    CLOSE(F);                           (* NUR PASCAL 2.0 *)
  END; (* LIST *)                                           
                                                            
  PROCEDURE NATURALMERGE;                                   
  (* SORTIERE FILE C. BENUTZT ZWEI HILFSFILES A UND B     *)
    VAR L  : INTEGER;  (* ANZAHL DER LAEUFE AUF C         *)
        EOR: BOOLEAN;  (* END OF RUN, ENDE DES LAUFS      *)
        A,B: TAPE;     (* HILFSFILES                      *)
                                                            
    PROCEDURE COPY (VAR X,Y: TAPE);                         
    (* KOPIERE KOMPONENTE VON X NACH Y, AKTUALISIERE EOR  *)
      VAR BUF: ITEM;                                        
    BEGIN                                                   
      BUF.KEY:=X^.KEY; GET(X);                              
      Y^.KEY:=BUF.KEY; PUT(Y);                              
      IF EOF(X) THEN EOR:= TRUE                             
                ELSE EOR:= BUF.KEY>X^.KEY                   
    END;(* COPY *)                                          
                                                            
    PROCEDURE COPYRUN(VAR X,Y: TAPE);                       
    (* KOPIERE LAUF VON X NACH Y                          *)
    BEGIN                                                   
      REPEAT COPY(X,Y) UNTIL EOR                            
    END;(* COPYRUN *)                                       
                                                            
    PROCEDURE DISTRIBUTE;                                   
    (* KOPIERE LAUEFE VON C ABWECHSELND AUF A UND B       *)
    BEGIN                                                   
      REPEAT                                                
        COPYRUN(C,A);                                       
        IF NOT EOF(C) THEN COPYRUN(C,B)                     
      UNTIL EOF(C)                                          
    END; (* DISTRIBUTE *)                                   
                                                            
    PROCEDURE MERGE;                                        
    (* MISCHE FILE A UND B ZU FILE C                      *)
                                                            
      PROCEDURE MERGERUN;                                   
      (* MISCHE LAEUFE VON A UND B ZU LAEUFEN AUF C       *)
      BEGIN                                                 
        REPEAT                                              
          IF A^.KEY<B^.KEY THEN                             
           BEGIN COPY(A,C);                                 
             IF EOR THEN COPYRUN(B,C)                       
           END                                              
          ELSE                                              
           BEGIN COPY(B,C);                                 
             IF EOR THEN COPYRUN(A,C)                       
           END                                              
        UNTIL EOR                                           
      END; (* MERGERUN *)                                   
                                                            
    BEGIN (* MERGE *)                                       
      REPEAT                                                
        MERGERUN; L:=L+1                                    
      UNTIL EOF(A) OR EOF(B);                               
      WHILE NOT EOF(A) DO                                   
        BEGIN                                               
          COPYRUN(A,C); L:=L+1                              
        END;                                                
      WHILE NOT EOF(B) DO                                   
        BEGIN                                               
          COPYRUN(B,C); L:=L+1                              
        END                                                 
    END;(* MERGE *)                                         
                                                            
  BEGIN (* NATURALMERGE *)                                  
    REPEAT                                                  
      ERASE(NAMEA); ERASE(NAMEB);       (* NUR PASCAL 2.0 *)
      OPEN(A,8,3,NAMEA + WR);                               
      OPEN(B,8,4,NAMEB + WR);                               
      OPEN(C,8,5,NAMEC + RD); GET(C);                       
      DISTRIBUTE;                                           
      CLOSE(A); CLOSE(B); CLOSE(C);                         
                                                            
      ERASE(NAMEC);                     (* NUR PASCAL 2.0 *)
      OPEN(A,8,3,NAMEA + RD); GET(A);                       
      OPEN(B,8,4,NAMEB + RD); GET(B);                       
      OPEN(C,8,5,NAMEC + WR);                               
      L:=0; MERGE;                                          
      CLOSE(A); CLOSE(B); CLOSE(C);     (* NUR PASCAL 2.0 *)
      LIST(C, NAMEC);                                       
    UNTIL L=1;                                              
  END; (* NATURALMERGE *)                                   
                                                            
BEGIN (* HAUPTPROGRAMM *)                                   
 WRITELN('SORTIEREN EINES SEQUENTIELLEN FILES:');           
 WRITELN('EINGABEZAHLEN: (0 AM ENDE)');                     
 ERASE(NAMEC);                          (* NUR PASCAL 2.0 *)
 OPEN(C,8,5,NAMEC + WR);                                    
                                                            
 READ(C^.KEY);                                              
 REPEAT                                                     
   PUT(C);                                                  
   READ(C^.KEY)                                             
 UNTIL C^.KEY=0;                                            
 CLOSE(C);                              (* NUR PASCAL 2.0 *)
 LIST(C, NAMEC);                                            
 NATURALMERGE;                                              
END.