Relative Dateien leicht verständlich

Die Datenverwaltung zählt – neben dem Spielen – wohl zu den häufigsten Anwendungsgebieten für Heimcomputer. Um Daten aber effektiv verwalten zu können, bedarf es des sinnvollen Einsatzes bestimmter Verfahren und Techniken.

Die relative Dateiorganisation, die sich vor allem bei der Verwaltung größerer Datenbestände als sehr nützlich erweist, ist eine davon und wird im folgenden Artikel näher erläutert.

Zunächst ein paar Worte zum Begriff der »Datei«. Eine Datei läßt sich am besten vergleichen mit einem Karteikasten mit vielen gleichartigen Karteikarten. Einer Karteikarte entspricht dabei ein sogenannter »Datensatz« der Datei. Jeder Datensatz unterteilt sich wiederum in verschiedene »Datenfelder«, in die die einzelnen Eintragungen auf der Karteikarte erfolgen.

Ein kleines Beispiel: In Bild 1 links sehen Sie, wie ein Eintragungs- bzw. Eingabeschema zur Verwaltung von Adressen aussehen könnte. Die Punkte zwischen den Ausrufezeichen markieren die Stellen, an die die einzelnen Daten jeweils geschrieben werden, wie Sie in Bild 1 rechts sehen können. Die Bereiche zwischen den Ausrufezeichen stellen also die einzelnen Datenfelder dar! Alle Inhalte der Datenfelder zusammen (das heißt eine komplette Adresse bestehend aus Nachname, Vorname, Straße, Wohnort und Telefon) ergeben dann einen Datensatz; mehrere gleichartige Datensätze eine Datei. (Eine schematische Darstellung dieses Sachverhalts finden Sie in Bild 2.)

Um nun Daten mit dem Computer zu verwalten, gibt es beim Commodore 64 in Verbindung mit der Floppy VC 1541 grundsätzlich zwei Dateiarten: Die sequentielle und eben die relative.

Bei der sequentiellen Dateiorganisation werden alle Datensätze hintereinander, das heißt sequentiell gespeichert. Wenn nun Datensätze (in unserem Beispiel Adressen) gelesen, hinzugefügt, gelöscht oder geändert werden sollen – diese Vorgänge bezeichnet man übrigens als Dateiarbeit oder »Datenpflege« -, dann muß dazu die komplette Datei in den Rechner geladen und nach Beendigung der Datenpflege wieder auf die Diskette zurückgespeichert werden. Ein direkter Zugriff auf jeden einzelnen Datensatz der Datei ist nicht möglich.

Dieser Umstand ist einerseits sehr zeitraubend (die Floppy 1541 ist ja nicht gerade die Schnellste), andererseits macht er die maximale Dateigröße vom verfügbaren Speicherplatz im Rechner abhängig. Die sequentielle Datenspeicherung ist daher mehr etwas für kleinere Dateien (mit wenigen Datensätzen) oder für Dateien mit sehr kurzen Datensätzen (was wir uns später noch zunutze machen werden).

Wesentlich flexibler in bezug auf die Datenpflege ist die relative Dateiorganisation, die ja der eigentliche Gegenstand dieses Artikels ist. Bei ihr ist es nämlich möglich, direkt auf jeden einzelnen Datensatz – auch »Record« genannt – der Datei zuzugreifen! (Zusätzlich kann sogar auf eine beliebige Stelle innerhalb eines Records positioniert werden.)

Zum Prinzip der relativen Datei

Bei der relativen Dateiorganisation werden alle Datensätze (Records) in laufender Reihenfolge durchnumeriert. Der erste Datensatz bekommt dabei die Nummer 1, der zweite die Nummer 2, etc. Wenn Sie jetzt auf einen Datensatz zugreifen wollen, müssen Sie nur noch dessen Nummer angeben.

Dieser Vorteil ist allerdings mit einer wichtigen Bedingung verbunden:

Alle Records einer Datei müssen eine konstante, beim Einrichten der Datei festzulegende Länge zwischen 1 und 254 Byte (Zeichen) aufweisen!

Diese Bedingung wird verständlich, wenn man sich überlegt, wie das Floppy-Betriebssystem (kurz: Floppy-DOS) aus der Recordnummer die Position des Datensatzes auf der Diskette bestimmt.

Angenommen, Sie wollen auf den 27. Record einer Datei mit einer Recordlänge von 50 Byte zugreifen. Um nun die Position dieses Datensatzes zu ermitteln, multipliziert das Floppy-DOS die Recordlänge (in unserem Fall also 50) mit der Recordnummer -1 (also 26), was die Anzahl der Byte ergibt, die von den ersten 26 Records der Datei belegt werden (=1300 Byte). Dieser Wert wird jetzt noch zur Anfangsposition der Datei hinzuaddiert, was schließlich die Position des gewünschten Datensatzes ergibt. (Die ersten 26 Records werden durch das Aufaddieren ihrer Gesamtlänge auf den Anfang der Datei praktisch »übersprungen«.)

Jetzt wird auch der Name dieser Dateiart, nämlich »relativ«, verständlich, denn die Record-Position wird ja relativ zum Anfang der Datei ermittelt! (Im Beispiel beginnt der gewünschte Datensatz 1300 Byte vom Anfang der Datei entfernt.)

Wie gesagt kann also jeder Datensatz einer relativen Datei durch Angabe seiner Nummer direkt angesprochen werden. Wenn Sie aber zum Beispiel eine bestimmte Adresse suchen, werden Sie in der Regel kaum die Nummer des betreffenden Datensatzes kennen. Das gleiche gilt auch für die meisten anderen Anwendungsgebiete. (Höchstens bei einer Kontenverwaltung – zum Beispiel für ein Haushaltsbuch – wäre eine direkte Verwendung der Recordnummer sinnvoll.) Daher verwendet man in der Praxis häufig eine Mischform aus sequentieller und relativer Dateiorganisation, die »indexsequentielle Datei«.

Das Prinzip ist ganz einfach:

Alle Daten werden – wie bisher – in einer relativen Hauptdatei abgelegt. Zusätzlich wird dann eine sequentielle Index- oder Schlüsseldatei angelegt. Diese Schlüsseldatei enthält von jedem Datensatz der relativen Datei nur einen Teil – bei einer Adreßdatei zum Beispiel den Nachnamen – sowie die Recordnummer des zugehörigen Datensatzes der relativen Hauptdatei, in dem – im Beispiel – die komplette Adresse untergebracht ist.

Wenn Sie jetzt beispielsweise nach der Adresse eines Herrn Müller suchen, wird einfach die Schlüsseldatei komplett in den Computer geladen (da sie sehr kurz ist, geht dies ja relativ schnell, und auch die Maximalanzahl der Adressen ist verhältnismäßig hoch), dort durchsucht und – sofern der Datensatz »Müller« vorhanden ist – auf den bei »Müller« (in Form der Recordnummer) vermerkten Datensatz positioniert. Dieser wird dann schließlich in den Speicher geladen und ausgegeben.

Natürlich ist es auch möglich, zu einer relativen Hauptdatei mehrere Indexdateien anzulegen (zum Beispiel eine mit den Nachnamen als Index, eine mit den Vornamen, etc.). Allerdings muß man dann das eventuell wieder auftretende Speicherplatzproblem – die Indexdateien müssen ja komplett in den Speicher geladen werden – im Auge behalten beziehungsweise muß sich vor der Dateiarbeit entscheiden, mit welcher Indexdatei man jeweils arbeiten will.

Nach all der Theorie kommen wir nun zur Praxis:

Wie werden relative Dateien mit dem Commodore 64 und der Floppy VC 1541 – die Anlage relativer Dateien auf Kassette ist nicht möglich! – angelegt und verwaltet? Mit dieser Frage wollen wir uns im Folgenden ausführlich befassen. Zum Abschluß wird dann noch eine kleine, ausführlich kommentierte indexsequentielle Adreßverwaltung (Listing 2) vorgestellt, die Sie selbst nach Belieben abändern können, um so Ihre neuen Kenntnisse in der Praxis zu erproben.

Die Verwaltung einer relativen Datei gliedert sich grob in vier Abschnitte:

• »Öffnen« der Datei
• Positionieren auf den gewünschten Record
• Lesen/Schreiben des Records
• »Schließen« der Datei.

Da das Basic 2.0 des Commodore 64 leider keine speziellen Befehle zur Unterstützung von relativen Dateien zur Verfügung stellt, bleibt nur der Weg über »OPEN«- und »CHR$(...)«-Sequenzen. Daher sieht das Ganze auf den ersten (und wohl auch zweiten) Blick etwas kompliziert aus. Wenn man sich die erforderlichen Programmteile aber – wie in Listing 1 geschehen – als Unterprogramme schreibt, ist es halb so schlimm.

Kommen wir zum ersten Schritt, dem »Öffnen« der Datei.

Öffnen einer relativen Datei

Bei einer relativen Datei ist es – im Gegensatz zum Beispiel zur sequentiellen Datei – praktisch egal, ob die Datei auf der Diskette schon eingerichtet ist oder nicht oder ob Sie Daten lesen oder schreiben wollen. Der Öffnungsbefehl ist immer derselbe:

OPEN LF,GA,SA,DN$+",L," +CHR$(RL)

Die einzelnen Variablen – auch »Parameter« genannt – haben folgende Bedeutung:

LF: Das ist die logische Filenummer der Datei. Sie ist erforderlich, damit der Computer bei späteren Lese- oder Schreibbefehlen (bei denen diese Nummer angegeben werden muß) weiß, aus welcher Datei gelesen oder in welche Datei geschrieben werden soll. LF kann Werte zwischen 1 und 127 annehmen.

GA: Das ist die Geräteadresse der Floppy. Im Normalfall also 8.

SA: Die »Sekundäradresse« oder »Kanalnummer« SA hat auf Floppy-Ebene eine ähnliche Bedeutung wie die logische Filenummer LF auf Computer-Ebene.

Für uns ist aber nur wichtig, daß SA Werte zwischen 2 und 14 annehmen kann.

Wenn Sie mehrere Dateien gleichzeitig geöffnet haben, müssen Sie außerdem darauf achten, daß Sie jeder Datei eine andere Sekundäradresse zuweisen. Wird nämlich eine zweite Datei mit derselben Sekundäradresse wie die erste geöffnet, so wird die zuerst geöffnete Datei auf Floppy-Ebene geschlossen!

In diesem Zusammenhang noch ein wichtiger Hinweis:

Auf Floppy-Ebene können maximal drei Dateien gleichzeitig geöffnet sein. (Auf Computer-Ebene sind es übrigens maximal 10). Da zur Verwaltung einer relativen Datei neben der eigentlichen Datei – wie wir gleich noch sehen werden – auch der Floppy-Kommandokanal geöffnet werden muß, bedeutet das, daß maximal eine relative und eine sequentielle Datei gleichzeitig geöffnet sein können (was gerade für eine indexsequentielle Dateiorganisation reicht).

DN$: DN$ enthält den Namen der Datei. Dieser darf maximal 16 Zeichen lang sein. Außerdem ist darauf zu achten, daß kein File (=Datei oder Programm) desselben Namens bereits auf der Diskette existiert – außer natürlich eine früher definierte relative Datei dieses Namens, mit der Sie jetzt arbeiten wollen, denn sonst gibt es einen »FILE EXISTS ERROR«.

",L,": Dieser Parameter teilt dem Floppy-DOS mit, daß eine relative Datei geöffnet werden soll. (Die Kommas dienen zur Abtennung von den übrigen Parametern.)

RL: RL enthält die gewünschte Recordlänge der Datei und kann Werte zwischen 1 und 254 annehmen.

Wichtig: Die beim ersten Öffnen der Datei angegebene Recordlänge kann später nicht mehr geändert werden! (Wenn Sie versuchen, eine bereits existierende relative Datei mit einer anderen Recordlänge als bei der ersten Öffnung angegeben zu öffnen, so wird ein »RECORD NOT PRESENT ERROR« angezeigt.)

Zur Ermittlung der Recordlänge zählen Sie einfach alle Datenfeldlängen eines Datensatzes zusammen. Im Eingangsbeispiel ergibt das eine Länge von 15 (Nachname) + 10 (Vorname) + 15 (Straße) + 15 (Wohnort) + 11 (Telefon) = 66 Byte.

Sofern Sie zum Einlesen der Records in den Computer den INPUT #-Befehl benutzen, müssen Sie dazu noch ein Byte addieren, denn, um das Ende eines Records erkennen zu können, benötigt der INPUT #-Befehl ein »RETURN« (entspricht CHR$(13)) oder ein Komma (entspricht CHR$(44)) am Ende des Records. Das »RETURN« wird normalerweise am Ende eines jeden PRINT- beziehungsweise PRINT #-Befehls gesendet – sofern Sie es nicht durch ein Semikolon am Ende des PRINT-Kommandos (zum Beispiel bei »PRINT #1, " text";«) unterdrücken.

Im Beispiel ergibt sich also eine Gesamtlänge von 67 Byte. Nachdem die Datei geöffnet wurde, kann mit der eigentlichen Dateiarbeit begonnen werden. Um jetzt einen bestimmten Record zu schreiben beziehungsweise zu lesen, muß zunächst auf ihn positioniert werden.

Positionieren auf einen Record

Da die Positionieranweisung über den Floppy-Kommandokanal gesendet werden muß, muß dieser zuerst mit »OPEN 15,8,15,« geöffnet werden. Die erste 15 ist wieder die logische Filenummer (Um Kollisionen mit Dateien zu vermeiden, ist es zweckmäßig, hier immer dieselbe logische Filenummer zu verwenden); bei der 8 handelt es sich um die Geräteadresse der Floppy. Die zweite 15 ist die Kanalnummer des Floppy-Kommandokanals.

Der Positionierbefehl ist ähnlich kompliziert aufgebaut wie der OPEN-Befehl:

PRINT#15,"P"+CHR$(SA)+CHR$(LB)+CHR$(HB)+CHR$(RP)

Die Parameter im einzelnen:

SA: Das ist die beim Öffnen der Datei festgelegte Sekundäradresse.

LB/HB: Das ist die Recordnummer in einer für Sie vielleicht etwas ungewohnten Form, der sogenannten Lowbyte-/Highbyte-Form.

Da mit CHR$(...) nur Werte bis zu 255 übermittelt werden können, muß die Recordnummer in zwei solcher Werte aufgeteilt werden, die sich aus folgenden Formeln ergeben:
HB=INT(RN/256):LB=RN-256*HB

RP: Mit RP können Sie auf eine bestimmte Stelle innerhalb des Records positionieren. Wollen Sie zum Beispiel einen Record ab dem 10. Zeichen einlesen, so muß RP den Wert 10 erhalten.

Wichtig: Eine Positionierung auf eine Stelle innerhalb eines Records ist nur beim Lesen dieses Records sinnvoll. Zum Schreiben eines Records muß RP auf 1 gesetzt werden!

Und natürlich ist auch nur eine solche Positionsangabe sinnvoll, die kleiner gleich der Recordlänge ist. Daher ergibt sich für RP – eine entsprechende Recordlänge vorausgesetzt – ein Maximalwert von 254.

Nach der Positionierung ist der betreffende Record nun für einen Lese- oder Schreibzugriff bereit.

Schreiben eines Records

Vor dem Schreiben eines Records sind drei Dinge zu beachten:

• Es muß unbedingt auf das erste Byte des Records positioniert werden (RP=1).
• Es sollte sichergestellt werden, daß alle Datenfelder – und damit auch der Record – ihre vorgeschriebene Länge aufweisen. Wie eine solche Kontrolle und Korrektur aussehen könnte, sehen Sie in Listing 2 in den Zeilen 860-920.
• Da der Record in einem Stück geschrieben werden muß, müssen die einzelnen Datenfelder vor dem Schreiben zusammengefaßt werden (siehe auch Listing 2 Zeile 940 bis 960).

Sind diese Voraussetzungen erfüllt, so kann der Record mit folgendem Befehl geschrieben werden:

PRINT#LF,RC$

LF ist dabei die beim OPEN-Befehl festgelegte logische Filenummer; RC$ enthält den zu schreibenden Record.

In diesem Zusammenhang erwähnenswert ist die Fehlermeldung »RECORD NOT PRESENT ERROR«, was soviel bedeutet wie »Datensatz nicht vorhanden«. Falls nämlich auf einen Record zugegriffen (geschrieben/gelesen) wird, der zuvor noch nicht beschrieben wurde, so wird diese Meldung erzeugt. Beim (erstmaligen) Schreiben eines Records kann diese Meldung natürlich ignoriert werden. (Der Schreibbefehl wird trotz der Meldung ausgeführt.)

Weiterhin ist zu beachten: Ein Schreibbefehl auf einen zuvor noch nicht beschriebenen Record hat zur Folge, daß alle davor liegenden (zuvor noch nicht beschriebenen) Records ebenfalls beschrieben werden!

Ein Beispiel: Sie haben eine relative Datei bereits bis zum 20. Record beschrieben. Nun schreiben Sie den 100. Record. Dadurch werden gleichzeitig die Records 21 bis 99 (mit demselben Inhalt wie der 100. Record) beschrieben!

Wenn Sie also eine relative Datei nicht der Reihe nach beschreiben wollen, dann sollten Sie beim Einrichten der Datei als erstes den Record mit der höchsten Nummer (mit einem beliebigen Inhalt) beschreiben. Dadurch bleiben Ihnen unnötige Wartezeiten bei der Dateiarbeit – das Beschreiben von zum Beispiel 50 Records nimmt einige Zeit in Anspruch – erspart.

Lesen eines Records

Zum Lesen eines Records gibt es zwei Möglichkeiten:

Die erste Möglichkeit stellt der INPUT #-Befehl dar. Mit ihm kann ein Record komplett in den Computer geladen werden – unter zwei Bedingungen: Der Record darf nicht länger als 88 Zeichen sein, und er muß ein »RETURN« oder ein Komma als letztes Zeichen aufweisen.

Das Befehlsformat: INPUT#LF,RC$

LF ist dabei die beim OPEN-Befehl festgelegte logische Filenummer; RC$ wird der Record zugewiesen.

Eine zweite Möglichkeit – bei einer Recordlänge von mehr als 88 Byte zudem die einzige – bietet der GET #-Befehl. Um zum Beispiel einen 100 Byte langen Record einzulesen, wäre folgende Befehlssequenz denkbar:

FOR I=1 TO 100:GET#LF,EG$:RC$=RC$+EG$: NEXT I

LF ist dabei wieder die beim OPEN-Befehl festgelegte logische Filenummer.

Schließen einer relativen Datei

Nach Beendigung der Dateiarbeit muß die Datei geschlossen werden. Der dazu erforderliche Befehl ist – ausnahmsweise – sehr einfach.

CLOSE LF

LF ist dabei wiederum die beim OPEN-Befehl festgelegte logische Filenummer.

Zum Abschluß eine kleine Adreßverwaltung zum Experimentieren. Bitte geben Sie dazu Listing 2 ein.

Wichtig: Das Programm ist nur mit den in Listing 1 enthaltenen Unter-Programmen lauffähig. Tippen Sie also am besten zuerst Listing 1 ein und speichern es (für spätere eigene Entwicklungen, für die Sie die Unterprogramme gut gebrauchen können). Danach geben Sie zusätzlich Listing 2 ein und speichern das Gesamtprogramm dann ebenfalls auf Diskette.

Da das Programm selbst ausführlich dokumentiert ist, möchte ich an dieser Stelle nur noch kurz ein paar Bedienungshinweise geben:

Nachdem das Hauptmenü ausgegeben wurde, geben Sie als erstes »1« (+ "RETURN") ein. Dadurch werden alle notwendigen Vorbereitungen für die Dateiarbeit getroffen. Sobald das Hauptmenü wieder erschienen ist, können Sie wahlweise (und auch abwechselnd) Adressen ein- oder ausgeben. Bei der Ausgabe wird dabei der Nachname als Index verwendet. Nach Beendigung der Dateiarbeit geben Sie »4« ein, wodurch die Datei ordnungsgemäß geschlossen und das Programm beendet wird.

Das Programm ist zwar recht spartanisch, dafür aber sehr flexibel. Beides soll Sie dazu animieren, selbst tätig zu werden und das Programm nach Ihren speziellen Wünschen abzuändern und zu ergänzen. Denn auch bei der Datenverwaltung gilt, wie überall: Übung macht den Meister!

1680 rem--- unterprogramme zur verwaltung von relativen dateien ----------------
1690 rem--- (w) 1985 by martin hecht,stgt --------------------------------------
1700 :
1710 :
1720 :
1730 rem--- oeffnen einer relativen datei --------------------------------------
1740 :
1750 rem  lf = logische filenummer
1760 rem  sa = sekundaeradresse
1770 rem  dn$= dateiname
1780 rem  rl = recordlaenge
1790 :
1800 open 15,8,15:rem floppy-kommandokanal oeffnen
1810 open lf,8,sa,dn$+",l,"+chr$(rl):rem datei oeffnen
1820 :
1830 return
1840 :
1850 :
1860 :
1870 rem--- positionieren auf einen record -------------------------------------
1880 :
1890 rem  sa = sekundaeradresse
1900 rem  rn = recordnummer
1910 rem  rp = position innerhalb des records
1920 :
1930 hb=int(rn/256):lb=rn-256*hb:rem recordnummer in low/high aufteilen
1940 print#15,"p"+chr$(sa)+chr$(lb)+chr$(hb)+chr$(rp)
1950 :
1960 return
1970 :
1980 :
1990 :
2000 rem--- schliessen einer (relativen) datei ---------------------------------
2010 :
2020 rem  lf = logische filenummer
2030 :
2040 close lf:rem relative datei schliessen
2050 close 15:rem floppy-fehlerkanal schliessen
2060 :
2070 return

100 rem--- adressverwaltung mit indexsequentieller dateiorganisation -----------
110 rem--- (w) 1985 by martin hecht,stgt ---------------------------------------
120 :
130 :
140 :
150 rem--- dimensionierungen ---------------------------------------------------
160 :
170 dm=100:rem maximale datensatzanzahl
180 :
190 dim id$(dm):rem indexfeld (enthaelt nachnamen)
200 dim in(dm):rem enthaelt zugehoerige recordnummern
210 dim ds$(5):rem datenfelder
220 :
230 :
240 :
250 rem--- hauptmenue ----------------------------------------------------------
260 :
270 wl=0:print:print
280 print tab(11) "adressenverwaltung"
290 print
300 print tab(8)"-1-: dateiarbeit beginnen"
310 print tab(8)"-2-: adressen eingeben"
320 print tab(8)"-3-: adressen ausgeben"
330 print tab(8)"-4-: dateiarbeit beenden"
340 print
350 :
360 print tab(11) "ihre wahl (1-4)";:input wl
370 :
380 if wl=1 then gosub 490:rem dateiarbeit beginnen
390 if wl=2 then gosub 710:rem adressen eingeben
400 if wl=3 then gosub 1110:rem adressen ausgeben
410 if wl=4 then goto 1480:rem dateiarbeit beenden
420 :
430 goto 270:rem zurueck zum hauptmenue
440 :
450 :
460 :
470 rem--- dateiarbeit beginnen ------------------------------------------------
480 :
490 lf=1:sa=2:dn$="reladr":rl=67:gosub 1800:rem relative datei 'reladr' oeffnen
500 :
510 open 2,8,3,"seqadr,s,r":rem sequentielle datei 'seqadr' zum lesen oeffnen
520 :
530 gosub 1620:rem floppy-fehlerkanal auslesen
540 if er<>0 then ad=0:goto 590:rem datei ist noch nicht angelegt
550 :
560 input#2,ad:rem anzahl der datensaetze
570 for i=1 to ad:input#2,id$(i),in(i):next i:rem indexdatei einlesen
580 :
590 fl=1:rem kennzeichnung fuer 'datei im rechner'
600 :
610 close 2:rem sequentielle datei schliessen
620 :
630 print:print:print tab(7) "dateiarbeit kann beginnen !"
640 :
650 return
660 :
670 :
680 :
690 rem--- adressen eingeben ---------------------------------------------------
700 :
710 if fl=0 then print:print tab(8) "keine datei im rechner !":return
720 :
730 rem adresse eingeben
740 print:print
750 input "nachname (15) :";ds$(1)
760 input "vorname (10) :";ds$(2)
770 input "strasse (15) :";ds$(3)
780 input "wohnort (15) :";ds$(4)
790 input "telefon (11) :";ds$(5)
800 :
810 rem adresse in indexdatei vermerken
820 ad=ad+1:rem anzahl der adressen um 1 erhoehen
830 id$(ad)=ds$(1):rem nachname
840 in(ad)=rn:rem recordnummer
850 :
860 rem adressfelder auf richtige laenge bringen
870 le$="               ":rem leerstring zum auffuellen der felder
880 ds$(1)=left$(ds$(1)+left$(le$,abs(15-len(ds$(1)))),15)
890 ds$(2)=left$(ds$(2)+left$(le$,abs(10-len(ds$(2)))),10)
900 ds$(3)=left$(ds$(3)+left$(le$,abs(15-len(ds$(3)))),15)
910 ds$(4)=left$(ds$(4)+left$(le$,abs(15-len(ds$(4)))),15)
920 ds$(5)=left$(ds$(5)+left$(le$,abs(11-len(ds$(5)))),11)
930 :
940 rem adresse fuer speicherung zusammenfassen
950 rc$=""
960 for i=1 to 5:rc$=rc$+ds$(i):next i
970 :
980 rem adresse speichern
990 rn=ad:rp=1:gosub 1930:rem auf record (nr.=ad) positionieren
1000 print#lf,rc$:rem adresse in record schreiben
1010 gosub 1600:rem floppy-fehlerkanal auslesen
1020 :
1030 print:print:printtab(5)"adresse ist gespeichert !"
1040 :
1050 return
1060 :
1070 :
1080 :
1090 rem--- adressen ausgeben ---------------------------------------------------
1100 :
1110 if fl=0 then print:print tab(8) "keine datei im rechner !":return
1120 :
1130 print:print:input "nachname";nn$:rem index erfragen
1140 :
1150 for i=1 to ad:rem indexdatei durchsuchen
1160 if nn$=id$(i) then gn=i:i=ad:next i:goto 1220:rem index gefunden
1170 next i
1180 :
1190 print:print:print tab(5) "adresse ist nicht vorhanden !"
1200 return
1210 :
1220 rn=gn:rp=1:gosub 1930:rem auf record (nr. = in(i)) positionieren
1230 input#lf,rc$:rem record einlesen
1240 :
1250 rem record aufteilen
1260 ds$(1)=mid$(rc$,1,15):rem nachname
1270 ds$(2)=mid$(rc$,16,10):rem vorname
1280 ds$(3)=mid$(rc$,26,15):rem strasse
1290 ds$(4)=mid$(rc$,41,15):rem wohnort
1300 ds$(5)=mid$(rc$,56,11):rem wohnort
1310 :
1320 rem record ausgeben
1330 print:print
1340 print "nachname: ";ds$(1)
1350 print "vorname: ";ds$(2)
1360 print "strasse: ";ds$(3)
1370 print "wohnort: ";ds$(4)
1380 print "telefon: ";ds$(5)
1390 :
1400 print:print:print "weiter mit 'space' !"
1410 get t$:if t$<>chr$(32) then 1410:rem warten auf 'return'
1420 :
1430 return
1440 :
1450 :
1460 :
1470 rem--- dateiarbeit beenden -------------------------------------------------
1480 print#15,"s:seqadr":rem indexdatei auf diskette loeschen
1490 :
1500 open 2,8,3,"seqadr,s,w":rem seq. datei 'seqadr' zum schreiben oeffnen
1510 print#2,ad:rem anzahl der datensaetze
1520 for i=1 to ad:print#2,id$(i)","in(i):next i:rem indexdatei speichern
1530 :
1540 gosub 2040:rem relative datei schliessen
1550 :
1560 end:rem programm beenden
1570 :
1580 :
1590 :
1600 rem--- floppy-fehlerkanal auslesen -----------------------------------------
1610 :
1620 input#15,er,er$,tr,sk
1630 :
1640 return
1650 :
1660 :
1670 :