Im Magazin „CHIP SPECIAL", Ausgabe 4, wurde der folgende Artikel abgedruckt.

Das Programm stellt einen Datei-Editor dar, bei dem die Routine zum Arbeiten mit Byte-Dateien eingesetzt wird.

Dateien auf's Byte geschaut

Normale Diskettendoktoren1 greifen physikalisch auf die gespeicherten Informationen zu. Die Adressierung erfolgt dabei über Seite, Spur und Sektor. Will man jedoch eine existierende Datei untersuchen, so erweist sich diese Art des Zugriffs als eher hinderlich. Die Datei kann physikalisch unzusammenhängend Über die ganze Diskette verstreut sein. Man muß selbst die Aufgabe des Betriebssystems übernehmen, um das jeweils nächste Dateistuck zu finden. Hier schafft ein File-Editor Abhilfe, bei dem die Suche dem Betriebssystem überlassen bleibt und der Zugriff damit Datei-orientiert erfolgt. EDITFILE2 ist ein solcher File-Editor mit einigen zusätzlichen Features, die ihn bezüglich Leistungsfähigkeit und Bedienungskomfort über seine Konkurrenten heben.

[Großes Bild]

Der Aufruf erfolgt mit EDITFILE Dateiname. Auf dem Bildschirm erscheint die erste Seite (= 256 Bytes) der gewählten Datei sowie alle Angaben zur Bedienung des Programms.

Links oben steht der Dateiname. Im Feld daneben wird der momentane Betriebsmodus angezeigt - Alpha oder Hex, je nachdem ob sie über Bytes oder ASCII-Zeichen auf die Datei zugreifen. Ein dem Modus nachgestelltes '/L' zeigt an, daß Sie im Augenblick nicht in die Datei schreiben können, eine Fehlbedienung also keine eventuellen Katastrophen nach sich zieht (locked=verschlossen).

Die nächsten beiden Informationen geben die Position des Cursors in der Datei an (128-Byte-) Block und Byte (-Nummer innerhalb des Blocks). Am Ende der Kopfzeile ist noch die Dateigröße in Blöcken angegeben.

Den Hauptteil des Bildschirms nehmen die eigentlichen Datei-Informationen in Anspruch, links als Bytes (in Hex-DarStellung), rechts als ASCII-Zeichen (wobei nicht darstellbare Zeichen als '.'angegeben werden. Je nach Betriebsmodus befindet sich der Cursor im linken oder rechten Feld.

Unten am Bildschirm sind sämtliche verfügbaren Kommandos ersichtlich. Die Bedienung ist an die des Turbo-Editors angelehnt, mit folgenden Ausnahmen:

`^A` und `^F`	springen an Zeilenanfang und -ende. Es wird nicht gescrollt, sondern nur seitenweise geblättert.
`^Z`	beendet das Programm (und nicht `^KD`).
`^Q^U`	schaltet den Schreibschutz (locked/unlocked) um. Im /L-Modus werden die Dateiinformationen mit lowvideo dargestellt.
`^Q^A`	Beim Suchen kann, je nach Betriebsmodus, eine Bytefolge (als Sequenz von Hexziffern `3A FF 01` ..) oder eine Zeichenkette eingegeben werden. Die Möglichkeit, Groß- und Kleinschreibung zu ignorieren, wirkt nur im Alpha-Modus. Besonderheit: Im Hex-Modus kann bei der Eingabe der zu suchenden Bytefolge mit '`=Blocknummer`' ein beliebiger Block der Datei auf den Bildschirm gebracht werden.

Hinweis: Ist die Schreibsperre aufgehoben, so werden alle Eingaben als gewollte Veränderungen der Datei aufgefaßt und sofort ausgeführt. Sie sollten also die Schreibsperre nur bei Notwendigkeit aufheben.

U.K.

Listing von EDITFILE.PAS 3

  1: 0 (****************************************************************************)
  2: 0 (*        File-Editor zum Problemlosen Editieren von Diskettendateien       *)
  3: 0 (*                       Version 1.0 (c) U.K. 1986                          *)
  4: 0 (****************************************************************************)
  5: 0
  6: 0 PROGRAM File_Editor;
  7: 0
  8: 0 (*$I BYTEFILE.BIB *)                 (* Nur bei CP/M *)
  9: 0
 10: 0 TYPE str20 = STRING[20];
 11: 0
 12: 0 CONST HexZiffern : SET OF char = ['0'..'9','A'..'F'];
 13: 0       AlphaZeichen : SET OF char = [#32..#126,#128..#255];
 14: 0
 15: 0 VAR f : ByteFile;                    (* Nur bei CP/M, sonst FILE OF BYTE *)
 16: 0                                      (* Fuer MS-DOS:                     *)
 17: 0                                      (* Alle Vorkommen von 'ByteFile'    *)
 18: 0                                      (* ersatzlos streichen!             *)
 19: 0     Block, ByteNr, last, MaxByte : integer;
 20: 0     Eingabe : char;
 21: 0     Modus : (Alpha,Hex);
 22: 0     SuchZeile : STRING[40];
 23: 0     locked : boolean;
 24: 0     FileGroesse : real;
 25: 0     UpperCase : boolean;
 26: 0
 27: 0 (****************************************************************************)
 28: 0 (*                           Hilfsprozeduren                                *)
 29: 0 (****************************************************************************)
 30: 0
 31: 0 PROCEDURE LiesZeichen(VAR c : char);   (* Ihre spezielle Anpassung fuer die *)
 32: 0   BEGIN                                (* Cursor-Tasten. Siehe Turboheft 3  *)
 33: 1     read(kbd.c);
 34: 1   END; (* LiesZeichen *)
 35: 0
 36: 0 PROCEDURE WarteAufESC(Meldung : str20);
 37: 0   VAR c : char;
 38: 0   BEGIN
 39: 1     write(Meldung,' <ESC>');
 40: 1     REPEAT read(kbd,c) UNTIL c=#27
 41: 1   END; (* WarteAufESC *)
 42: 0
 43: 0 FUNCTION MAX(x,y:integer):integer;
 44: 0   BEGIN
 45: 1     IF x>y THEN MAX:=x ELSE MAX:=y
 46: 1   END; (* MAX *)
 47: 0
 48: 0 FUNCTION MIN(x,y:integer):integer;
 49: 0   BEGIN
 50: 1     IF x<y THEN MIN:=x ELSE MIN:=y
 51: 1   END; (* MIN Ť)
 52: 0
 53: 0 PROCEDURE writeHex(b : byte);
 54: 0   CONST HexZiffer:ARRAY[0..15] OF char = '0123456789ABCDEF';
 55: 0   BEGIN
 56: 1     write(HexZiffer[b SHR 4],HexZiffer[b AND 15])
 57: 1   END; (* writeHex *)
 58: 0
 59: 0 (****************************************************************************)
 60: 0 (*                 Bildschirm-Handling und Cursor-Steuerung                 *)
 61: 0 (****************************************************************************)
 62: 0
 63: 0 PROCEDURE ShowPage;
 64: 0  VAR i,j : integer; AlfaZeile : STRING[16]; b : byte; r : real;
 65: 0  BEGIN
 66: 1    gotoxy(44,1); write(succ(Block),'':5-trunc(ln(1+Block)/ln(10)));
 67: 1    LongSeekByteFile(f,128.0*Block);
 68: 1    r:=FileGroesse-128.0*Block;
 69: 1    IF r>=256 THEN MaxByte:=255 ELSE MaxByte:=pred(trunc(r));
 70: 1    IF locked THEN LowVideo;
 71: 1    FOR i:=1 TO 16 DO
 72: 1      BEGIN
 73: 2        gotoxy(l,i+2 ); AlfaZeile:='';
 74: 2        FOR j:=1 TO 16 DO IF (pred(i) SHL 4) OR pred(j)<=MaxByte THEN
 75: 2          BEGIN
 76: 3            readByteFile(f,b);
 77: 3            writeHex(b); write(' ');
 78: 3            IF chr(b) IN AlphaZeichen
 79: 3              THEN AlfaZeile:=AlfaZeile+chr(b)
 80: 3              ELSE AlfaZeile:=AlfaZeile+'.';
 81: 3          END ELSE write('   ');
 82: 2        gotoxy(53,i+2); write(AlfaZeile); ClrEol;
 83: 2      END; (* FOR *)
 84: 1    NormVideo;
 85: 1  END; (* ShowPage *)
 86: 0
 87: 0 PROCEDURE SeiteHoch;
 88: 0   BEGIN
 89: 1     IF Block>0
 90: 1       THEN BEGIN Block:=MAX(Block-2,0); ShowPage END
 91: 1       ELSE write(^G)
 92: 1   END; (* SeiteHoch *)
 93: 0
 94: 0 PROCEDURE SeiteTief;
 95: 0   BEGIN
 96: 1     IF Block<pred(last)
 97: 1       THEN BEGIN Block:=MIN(Block+2,last); ShowPage END
 98: 1       ELSE write(^G)
 99: 1  END; (* SeiteTief *)
100: 0
101: 0 PROCEDURE ChangeModus;
102: 0   BEGIN
103: 1     IF Modus=Hex THEN Modus:=Alpha ELSE Modus:=Hex;
104: 1     gotoxy(29,1); IF Modus=Alpha THEN write('Alpha') ELSE write('Hex  ')
105: 1   END; (* ChangeModus *)
106: 0
107: 0 PROCEDURE HauptBildschirm;
108: 0   BEGIN
109: 1     ClrScr; LowVideo; write('FILE:');
110: 1     gotoxy(22,1); write('MODUS:'); gotoxy(37,1); write('BLOCK:');
111: 1     gotoxy(50,1); write('BYTE:'); gotoxy(63,1); write('GESAMT:');
112: 1     NormVideo;
113: 1     gotoxy(7,1); wrlte(ParamStr(1));
114: 1     gotoxy(71,1); write(succ(last));
115: 1     Modus:=Alpha; ChangeModus; LowVideo;
116: 1     gotoxy(1,20); writeln('Kommandos:');
117: 1     write('  ^E : Zeile hoch,   ^X : Zeile tief,  ');
118: 1     write('  ^S : Byte links,   ^D : Byte rechts  '); writeln;
119: 1     write('  ^A : Zeilenanfang, ^F : Zeilenende,  ');
120: 1     write('  ^C : Seite tief,   ^R : Seite hoch,  '); writeln;
121: 1     write('^Q^R : Fileanfang, ^Q^C : Fileende     ');
122: 1     write('^Q^F : suchen,     ^Q^U : Schreibschutz'); writeln;
123: 1     write('  ^V : Alpha/Hex,    ^L : weitersuchen ');
124: 1     write('                     ^Z : Ende-Edit    ');
125: 1     NormVideo
126: 1   END; (* HauptBildschirm *)
127: 0
128: 0 (****************************************************************************)
129: 0 (*                        Editieren und Suchen                              *)
130: 0 (****************************************************************************)
131: 0
132: 0 PROCEDURE LiesByte;
133: 0   LABEL EXIT;
134: 0   VAR z : char; b : byte; t,fc : integer;
135: 0   BEGIN
136: 1     CASE Modus OF
137: 2       Alpha : b:=ord(Eingabe);
138: 2       Hex  : BEGIN
139: 3                Eingabe:=upcase(Eingabe);
140: 3                IF NOT (Eingabe IN HexZiffern)
141: 3                THEN BEGIN write(^G); GOTO EXIT END
142: 3                ELSE BEGIN
143: 4                       write(Eingabe);
144: 4                       REPEAT
145: 5                         read(kbd,z); z:=upcase(z)
146: 5                       UNTIL z IN HexZiffern+[#27];
147: 4                       IF z=#27
148: 4                         THEN BEGIN
149: 5                                LongSeekByteFile(f,128.0*Block+ByteNr);
150: 5                                readByteFile(f,b)
151: 5                              END
152: 4                         ELSE BEGIN val('$'+Eingabe+z,t,fc); b:=LO(t) END
153: 4                     END (* ELSE *)
154: 3              END (* BEGIN *)
155: 2     END; (* CASE *)
156: 1     LongSeekByteFile(f,128.0*Block+ByteNr); writeByteFile(f,b);
157: 1     gotoxy(1+(ByteNr AND 15 )*3,3+(ByteNr SHR 4)); writeHex(b);
158: 1     gotoxy(53+(ByteNr AND 15),3+(ByteNr SHR 4));
159: 1     IF chr(b) IN AlphaZeichen THEN write(chr(b)) ELSE write('.');
160: 1     ByteNr:=succ(ByteNr);
161: 1     EXIT:
162: 1   END; (* LiesByte *)
163: 0
164: 0 PROCEDURE Suche(neu:boolean); (* Sucht nach STRING oder BYTE-Folge *)
165: 0   LABEL EXIT;
166: 0   VAR Position, Laenge, Fehlercode, Seite : integer;
167: 0       gefunden, ShowFlag, Fehler : boolean;
168: 0       BytePosition : real;
169: 0       temp : STRING[40];
170: 0       c : char; i : integer;
171: 0       AnfangsByte, SuchByte, VergleichsByte : byte;
172: 0
173: 0   PROCEDURE KonvertHexLine(VAR Fehler : boolean);
174: 0     VAR HexLine : STRING[20];
175: 0         HexZahl : integer;
176: 0     BEGIN
177: 1       temp:=SuchZeile;
178: 1       WHILE pos( ' ',temp)>0 DO delete(temp,pos(' ',temp),1);
179: 1       HexLine:=''; Fehler:=false;
180: 1       WHILE (length(temp)>1) AND (NOT Fehler) DO
181: 1         BEGIN
182: 2           val('$'+copy(temp,1,2),HexZahl,Fehlercode);
183: 2           Fehler:=FehlerCode<>0; HexLine:=HexLine+chr(LO(HexZahl));
184: 2           delete(temp,1,2)
185: 2         END; (* WHILE *)
186: 1       IF temp<>'' THEN Fehler:=true;
187: 1       temp:=HexLine; Laenge:=length(temp)
188: 1     END; (* KonvertHexLine *)
189: 0
190: 0   BEGIN (* suche *)
191: 1     gotoxy(1,2); LowVideo;
192: 1     IF Modus=Alpha THEN write('Suchbegriff: ') ELSE write('Bytefolge: ');
193: 1     NormVideo;
194: 1     IF neu
195: 1       THEN BEGIN
196: 2              read(SuchZeile);
197: 2              IF Modus=Alpha THEN
198: 2                BEGIN
199: 3                  write(' Gross/Klein-unterscheiden? ');
200: 3                  REPEAT read(kbd.c); c:=upcase(c) UNTIL (c='J') OR (c='N');
201: 3                  UpperCase:=c='N';
202: 3                  IF UpperCase THEN FOR i:=1 TO length(SuchZeile) DO
203: 3                    SuchZeile[i]:=upcase(SuchZeile[i]);
204: 3                  gotoxy(14,2); write(SuchZeile); ClrEol
205: 3                END
206: 2            END
207: 1       ELSE write(SuchZeile);
208: 1     IF SuchZeile='' THEN GOTO EXIT ELSE Laenge:=length(SuchZeile);
209: 1     ShowFlag:=false; Fehler:=false; gefunden:=false;
210: 1     IF Modus=Alpha
211: 1       THEN temp:=SuchZeile
212: 1       ELSE IF SuchZeile[1]='='
213: 1              THEN BEGIN
214: 2                     val(copy(suchZeile,2,pred(Laenge)),Seite,Fehlercode);
215: 2                     IF (FehlerCode=0) AND (Seite<=succ(last)) AND (Seite>0)
216: 2                       THEN BEGIN
217: 3                              ShowFlag:=true; Block:=pred(Seite); GOTO EXIT
218: 3                            END
219: 2                       ELSE BEGIN WarteAufESC(' ???'); GOTO EXIT END
220: 2                   END
221: 1       ELSE KonvertHexLine(Fehler);
222: 1     IF Fehler THEN BEGIN WarteAufESC(' ???'); GOTO EXIT END;
223: 1     BytePosition:=128.0*Block+ByteNr; LongSeekByteFile(f,BytePosition);
224: 1     Position:=1; AnfangsByte:=ord(temp[Position]);
225: 1     VergleichsByte:=AnfangsByte;
226: 1     WHILE (NOT EOFByteFile(f)) AND (NOT gefunden) DO
227: 1       BEGIN
228: 2         IF keypressed THEN
229: 2           BEGIN
230: 3             read(kbd,c);
231: 3             IF c=^U THEN
232: 3               BEGIN WarteAufESC(' ABBRUCH!'); GOTO EXIT END
233: 3           END; (* IF * )
234: 2         readByteFile(f,SuchByte);
235: 2         IF UpperCase THEN SuchByte:=ord(upcase(chr(SuchByte)));
236: 2         IF SuchByte=VergleichsByte
237: 2           THEN IF Position=Laenge
238: 2                  THEN gefunden:=true
239: 2                  ELSE BEGIN
240: 3                         Position:=succ(Position);
241: 3                         VergleichsByte:=ord(temp[Position])
242: 3                       END
243: 2           ELSE IF Position>1
244: 2                  THEN BEGIN
245: 3                         LongSeekByteFile(f,LongFilePosByteFile(f)+1-Position);
246: 3                         Position:=1;
247: 3                         VergleichsByte:=AnfangsByte
248: 3                       END
249: 2       END; (* WHILE *)
250: 1     IF gefunden
251: 1       THEN BEGIN
252: 2              BytePosition:=LongFilePosByteFile(f);
253: 2              Seite:=trunc(BytePosition/128);
254: 2              ByteNr:=trunc(BytePosition-128.0*Seite);
255: 2              IF Block=pred(Seite)
256: 2                THEN ByteNr:=ByteNr+128
257: 2                ELSE IF Block<>Seite
258: 2                       THEN BEGIN ShowFlag:=true; Block:=Seite END;
259: 2              IF Block>last THEN BEGIN Block:=last; ByteNr:=127 END;
260: 2              IF Block=last THEN IF last>0
261: 2                THEN BEGIN Block:=pred(Block); ByteNr:=128+ByteNr END
262: 2            END (* IF...THEN *)
263: 1       ELSE WarteAufESC(' ... nicht gefunden');
264: 1     EXIT: gotoxy(1,2); ClrEol; IF ShowFlag THEN ShowPage
265: 1   END; (* suche *)
266: 0
267: 0 PROCEDURE HoleZeichen(erstes : char; VAR c : char);
268: 0   BEGIN
269: 1     gotoxy(1,1); LowVideo; write('^',erstes, '   '); gotoxy(3,1);
270: 1     read(kbd.c);
271: 1     gotoxy(1,1); write('FILE:'); NormVideo
272: 1   END; (* HoleZeichen *)
273: 0
274: 0 PROCEDURE Lock_Unlock; (* Macht ein Veraendern der Datei unmoeglich *)
275: 0   BEGIN
276: 1     locked:=NOT locked; gotoxy(34,1);
277: 1     IF locked THEN write('/L') ELSE write('  '); ShowPage;
278: 1   END; (* Lock_Unlock *)
279: 0
280: 0 PROCEDURE Ctrl_Q_Menue;
281: 0   VAR Auswahl : char;
282: 0
283: 0   PROCEDURE ZumAnfang;
284: 0     BEGIN
285: 1       Block:=0; ByteNr:=0; ShowPage
286: 1     END; (* ZumAnfang *)
287: 0
288: 0   PROCEDURE ZumEnde;
289: 0     BEGIN
290: 1       Block:=MAX(last-1,0); ShowPage; ByteNr:=MaxByte
291: 1     END; (* ZumEnde *)
292: 0
293: 0   BEGIN (* Ctrl_Q_Menue *)
294: 1     HoleZeichen('Q',Auswahl);
295: 1     CASE upcase(Auswahl) OF
296: 2       ^R, 'R' : ZumAnfang;
297: 2       ^C, 'C' : ZumEnde;	-
298: 2       ^F, 'F' : Suche(true);
299: 2       ^U, 'U' : Lock_Unlock
300: 2     END
301: 1   END;
302: 0
303: 0 (****************************************************************************)
304: 0 (*                        Das Hauptprogramm                                 *)
305: 0 (****************************************************************************)
306: 0
307: 0 BEGIN
308: 1   IF ParamCount=0 THEN BEGIN writeln('Parameter fehlen'); halt END;
309: 1   assignByteFile(f,ParamStr(1)); (*$I-*) resetByteFile(f) (*$I+*);
310: 1   IF IOResultByteFile<>0 THEN BEGIN writeln('Kein File!'); halt END;
311: 1   FileGroesse:=LongFileSizeByteFile(f);
312: 1   last:=pred(trunc(FileGroesse/128)); Block:=0; ByteNr:=0;
313: 1   SuchZeile:=''; locked:=false; cbreak:=false;
314: 1   HauptBildschirm; Lock_Unlock;
315: 1   REPEAT
316: 2     IF ByteNr<0
317: 2       THEN IF Block>0 THEN BEGIN SeiteHoch; ByteNr:=256+ByteNr END
318: 2                       ELSE BEGIN ByteNr:=0; write(^G) END;
319: 2     IF ByteNr>MaxByte
320: 2       THEN IF MaxByte<255 THEN BEGIN ByteNr:=MaxByte; write(^G) END
321: 2                           ELSE BEGIN SeiteTief; ByteNr:=ByteNr AND 255 END;
322: 2     gotoxy(56,1); write(succ(ByteNr):3);
323: 2     IF Modus=Hex THEN gotoxy(1+(ByteNr AND 15)*3,3+(ByteNr SHR 4))
324: 2                  ELSE gotoxy(53+(ByteNr AND 15),3+(ByteNr SHR 4));
325: 2     LiesZeichen(Eingabe);
326: 2     CASE Eingabe OF
327: 3       ^D : ByteNr:=succ(ByteNr);
328: 3       ^S : ByteNr:=pred(ByteNr);
329: 3       ^X : ByteNr:=ByteNr+16;
330: 3       ^E : ByteNr:=ByteNr-16;
331: 3       ^R : SeiteHoch;
332: 3       ^C : SeiteTief;
333: 3       ^A : ByteNr:=ByteNr AND $F0;
334: 3       ^F : ByteNr:=ByteNr OR 15;
335: 3       ^V : ChangeModus;
336: 3       ^Q : Ctrl_Q_Menue;
337: 3       ^L : Suche(false);
338: 3       ^Z : ;
339: 3       ELSE IF Eingabe>=#32 THEN IF NOT locked THEN LiesByte ELSE write(^G)
340: 3     END
341: 2   UNTIL Eingabe=^Z;
342: 1   closeByteFile(f); ClrScr
343: 1 END. (* File_Editor *)

1.	Ein sehr guter Datei-Editor ist `SUPERZAP.COM`. Ein Disk-Editor, mit dem auf Betriebssytem-Ebene auch Daten restauriert werden können, ist `DISKUTIL.COM`. Beide können hier heruntergeladen werden.
2.	Zum Compilieren wird die Include Datei BYTEFILE.BIB benötigt. Diese wird im Artikel FILE OF BYTE unter CP/M beschrieben.
2.	Im Magazin „CHIP SPECIAL", Ausgabe 5, wurde folgende Korrektur abgedruckt: EDITFILE.PAS (Fehler beim letzten Sektor mit FILE OF BYTE) Zeile 313 einfügen: IF FileGroesse>128.0*succ(last) then last:=succ(last); Hier das korrigierte Programm.