PROGRAM BOOKS (INPUT, OUTPUT);                              
(* DEMONSTRATIONSPROGRAMM ZUR VERWALTUNG EINER RELATIV-   *)
(* DATEI IN PASCAL 2.0.                         21.3.1987 *)
                                                            
  CONST DEVICE = 8; (* GERAETEADRESSE DER FLOPPY          *)
        SECOND = 3; (* SEKUNDAERADRESSE DER RELATIVDATEI  *)
        NAME   = '0:BUCHTITEL';                             
        DEFAULTSIZE = 50;                                   
                                                            
  TYPE  BUCH = RECORD                                       
                 TITEL   : STRING[30];                      
                 AUTOR   : STRING[30];                      
                 SIGNATUR: INTEGER;                         
                 MARKE   : CHAR;           (* SIEHE TEXT! *)
               END;                                         
                                                            
  VAR REL      : FILE OF BUCH;  (* RELATIVE DATEI         *)
      DSK      : TEXT;          (* KOMMANDO-KANAL FLOPPY  *)
      WAHL     : CHAR;                                      
      POSITION : INTEGER;                                   
                                                            
 PROCEDURE DSTATUS;                                         
 (* FEHLERKANAL DER FLOPPY AUSLESEN, FEHLER IM KLARTEXT   *)
 (* MIT FEHLERNUMMER, SPUR UND SEKTOR ANZEIGEN:           *)
   VAR NUMMER: INTEGER;                                     
       TEXT  : STRING[40];                                  
 BEGIN                                                      
  READ(DSK, NUMMER);                                        
  IF NUMMER>=20 THEN                                        
    BEGIN                                                   
      READLN(DSK, TEXT); WRITELN(NUMMER:3, TEXT);           
    END;                                                    
 END; (* DSTATUS *)                                         
                                                            
 PROCEDURE SEEK (INDEX: INTEGER);                           
 (* SETZE DEN FILEZEIGER IM FILE 'REL' AUF DIE KOMPONENTE *)
 (* MIT DER RECORDNUMMER 'INDEX'  (>=1).                  *)
 BEGIN                                                      
   WRITE(DSK,'P',             (*  BEFEHL: POINTER SETZEN  *)
    CHR(SECOND),              (*  IN DIESER DATEI         *)
    CHR(INDEX AND 255),       (*  AUF DIESEN RECORD       *)
    CHR(HBYTE(INDEX)),        (*  (LOW UND HIGH-BYTE)     *)
    CHR(1));                  (*  AUF DAS ERSTE BYTE IN   *)
                              (*  DER KOMPONENTE TRECORD  *)
    DSTATUS;                                                
 END;(* SEEK *)                                             
                                                            
 PROCEDURE INITREL;                                         
 (* ANLEGEN EINER NEUEN RELATIVDATEI. EINE EVENTUELL      *)
 (* BEREITS EXISTIERENDE DATEI WIRD GELOESCHT.            *)
   VAR DNAME : STRING[20];                                  
       I     : INTEGER;                                     
 BEGIN                                                      
   WRITELN(DSK,'S' + NAME);       (* LOESCHE ALTE DATEI   *)
   (* NEUE DATEI MIT SATZLAENGE ANLEGEN:                  *)
   DNAME:= NAME + ',L,' + CHR(SIZEOF(BUCH));                
   OPEN(REL, DEVICE, SECOND, DNAME);                        
   DSTATUS;                                                 
   WRITELN('DATEI WIRD INITIALISIERT');                     
   WITH REL^ DO                                             
     BEGIN                                                  
       TITEL   :='';                                        
       AUTOR   :='';                                        
       SIGNATUR:=0;                                         
       MARKE   := CHR(13);                     (* S. TEXT *)
     END;                                                   
   SEEK(1);                            (* ZUM DATEIANFANG *)
   FOR I:= 1 TO DEFAULTSIZE DO                              
     PUT(REL);                                              
   CLOSE(REL); DSTATUS;                                     
 END; (* INITREL *)                                         
                                                            
 PROCEDURE READRECORD(P: INTEGER);                          
 (* !! WEGEN EINES FEHLERS IM BETRIEBSSYSTEM DER FLOPPY !!*)
 (* !! MUSS JEDER SATZ ZWEIMAL GELESEN WERDEN!          !!*)
 BEGIN                                                      
   SEEK(P); GET(REL);                (* JETZT NOCHEINMAL: *)
   SEEK(P); GET(REL); DSTATUS;                              
   WITH REL^ DO                                             
     BEGIN                                                  
       WRITELN('TITEL:'   :10, TITEL);                      
       WRITELN('AUTOR:'   :10, AUTOR);                      
       WRITELN('SIGNATUR:':10, SIGNATUR);                   
     END                                                    
 END; (* READRECORD *)                                      
                                                            
 PROCEDURE WRITERECORD(P: INTEGER);                         
 BEGIN                                                      
   WITH REL^ DO                                             
     BEGIN                                                  
       WRITE('TITEL:'   :10); READLN(TITEL);                
       WRITE('AUTOR:'   :10); READLN(AUTOR);                
       WRITE('SIGNATUR:':10); READLN(SIGNATUR);             
       MARKE:= CHR(13);                                     
     END;                                                   
   SEEK(P); PUT(REL); DSTATUS                               
 END; (* WRITERECORD *)                                     
                                                            
BEGIN                                                       
  OPEN(DSK, DEVICE, 15, 'I0');   (* KOMMANDOKANAL FLOPPY *) 
                                                            
  WRITELN(#147, 'BUCHDATEI:':25);                           
  WRITELN(      '==========':25);                           
  WRITELN;                                                  
  WRITELN('MOECHTEN SIE EINE NEUE DATEI ANLEGEN?');         
  WRITELN;                                                  
  WRITE('==>N'  #157); READLN(WAHL);                        
  IF WAHL<>'N' THEN INITREL;                                
                                                            
  OPEN(REL, DEVICE, SECOND, NAME + ',REL'); DSTATUS;        
  SEEK(1);                             (* ZUM DATEIANFANG *)
  WRITELN;                                                  
  WRITELN;                                                  
  WRITELN('JETZT KOENNEN DIE  SAETZE DURCH');               
  WRITELN('EINGABE DER SATZNUMMER (#)');                    
  WRITELN('BEARBEITET WERDEN:');                            
  REPEAT                                                    
    WRITELN;                                                
    WRITELN('WAEHLEN SIE:');                                
    WRITELN('X    BEENDEN');                                
    WRITELN('L # LESEN   ');                                
    WRITELN('S # SCHREIBEN');                               
    WRITE('==>'); READ(WAHL);                               
    CASE WAHL OF                                            
      'X':;                                                 
      'L': BEGIN READLN(POSITION);                          
             READRECORD(POSITION);                          
           END;                                             
      'S': BEGIN READLN(POSITION);                          
             WRITERECORD(POSITION);                         
           END;                                             
      ELSE WRITELN('  UNGUELTIGE WAHL!')                    
    END;(* CASE *)                                          
  UNTIL WAHL='X';                                           
  CLOSE(REL); DSTATUS;                                      
  CLOSE(DSK)                                                
END.