Power-Programmierung/CD1.mdf/pascal/library/dos/tp_util/biosdump.pas

Pascal/Delphi Source File | 1990-06-16 | 20.9 KB | 717 lines

PROGRAM BIOSDUMP;
{ DUMP DER BIOS- VARIABLEN }


USES  DOS,SELECTD,TPCRT,{DISPLAY,}TPSTRING,TPWINDOW;


TYPE  BUFFERTYP = ARRAY[0..255] OF BYTE;


CONST BI     = $40;
      TANORM = $07;
      TATBUF = $0B;
      TAUNGL = $0F;

      OMODE  : BYTE = 1;
      DEFATT : BYTE = $07;


VAR   I,J,K          : INTEGER;
      TBM,DUMPEND    : WORD;
      CH,CH1         : CHAR;
      B,TA,XP,CURS,
      CE,AVP,ADF     : BYTE;
      FILEDA,DKOPF   : BOOLEAN;
      HELPWIN        : WINDOWPTR;
      BRAM           : BUFFERTYP ABSOLUTE BI:0;
      BRAM5          : BUFFERTYP ABSOLUTE $50:0;
      BRAM6          : BUFFERTYP ABSOLUTE $60:0;
      BRAM7          : BUFFERTYP ABSOLUTE $70:0;
      BUF,RBUF       : BUFFERTYP;
      F              : FILE OF BUFFERTYP;


PROCEDURE OCHAR(C:CHAR);
VAR   B   : BYTE ABSOLUTE C;
      I,J : BYTE;
      R   : REGISTERS;

PROCEDURE BIOUT(C:CHAR); { AUSGABE ZEICHEN AUS 256- ER ZEICHENSATZ }
BEGIN
  R.AH := $0F;
  INTR($10,R); { LESEN VIDEO- MODUS & SEITE }

  R.AH := $09;
  R.AL := ORD(C);
  CASE C OF
      #0 : R.BL := TEXTATTR XOR $EE;
    #255 : R.BL := TEXTATTR XOR $DD;
  ELSE R.BL := TEXTATTR;
  END; { CASE }
  R.CX := 1;
  INTR($10,R); { AUSGEBEN ZEICHEN }

  IF WHEREX > LO(WINDMAX) THEN BEGIN
    IF WHEREY > HI(WINDMAX) THEN WRITELN ELSE GOTOXY(1,SUCC(WHEREY));
  END ELSE GOTOXY(SUCC(WHEREX),WHEREY);
END; { BIOUT }

BEGIN { OCHAR }
{
  OMODE = OUTPUT- MODUS FUER BILDSCHIRM
  0 = ASCII 256, $00 = BRAUN, $FF = VIOLETT
  1 = ALLE CONTROLZEICHEN ANZEIGEN :
     $00..$1F  = BLAUER HINTERGRUND
     $20..$7F  = SCHWARZER HINTERGRUND
     HIGHBIT 0 = WEISSE SCHRIFT
     HIGHBIT 1 = GELBE SCHRIFT
  2 = CR,LF & TAB ALS STEUERZEICHEN, SONST WIE OMODE 1
  3 = ANSI - TERMINAL
  4 = TERMINALEMULATION
}
  CASE OMODE OF
    0 : IF B IN [0..31,255] THEN BIOUT(C)     { 256- BYTE ZEICHENSATZ }
                            ELSE WRITE(C);
    1 : BEGIN { CONTROL & HIGHBIT UEBER ATTRIBUT }
          IF B > 127 THEN BEGIN
            TEXTCOLOR(14);
            B := B AND $7F;
            IF B < 32 THEN BEGIN
              TEXTATTR := $1E; {GELB AUF BLAU} { TEXTATTR XOR $7F; }
              B := B + 64;
            END;
          END ELSE BEGIN
            IF B < 32 THEN BEGIN
              TEXTATTR := $1F; {HELLWEISS AUF BLAU} { TEXTATTR XOR $7F; }
              B := B + 64;
            END;
          END;
          WRITE(C);
          TEXTATTR := DEFATT;
        END;
    2 : BEGIN { CONTROL & HIGHBIT UEBER ATTRIBUT }
          IF B = 9 THEN BEGIN
            J := PRED(WHEREX AND $F8) + 10 - WHEREX; IF J = 9 THEN J := 1;
            FOR I := 1 TO J DO WRITE(' ');
          END ELSE BEGIN
            IF NOT (B IN [10,13]) THEN BEGIN
              IF B > 127 THEN BEGIN
                TEXTCOLOR(14);
                B := B AND $7F;
                IF B < 32 THEN BEGIN
                  TEXTATTR := $1E; {GELB AUF BLAU} { TEXTATTR XOR $7F; }
                  B := B + 64;
                END;
              END ELSE BEGIN
                IF B < 32 THEN BEGIN
                  TEXTATTR := $1F; {HELLWEISS AUF BLAU} { TEXTATTR XOR $7F; }
                  B := B + 64;
                END;
              END;
            END;
            WRITE(C);
            TEXTATTR := DEFATT;
          END;
        END;
    3 : BEGIN { ANSI TERMINAL (WENN ANSI.SYS GELADEN IST) }
          R.AH := 2;
          R.DL := B;
          MSDOS(R);
        END;
    4 : BEGIN         { EMULIEREN }
        END;
  ELSE WRITE(C); { DIREKT AUSGEBEN }
  END; { CASE }
END; { OCHAR }


PROCEDURE ENDE;
BEGIN
  SETVISIBLEPAGE(AVP);
  NORMALCURSOR;
  TEXTATTR := TA;
  HALT;
END;


PROCEDURE DUMP(I:WORD);
VAR   J  : WORD;
      B  : BYTE;
BEGIN
  FOR J := 0 TO 15 DO BEGIN
    B := RBUF[16*I+J];
    IF ADF = 0 THEN BEGIN
      IF (16*I+J) IN [$1A..$3D] THEN BEGIN
{ TASTATURBUFFER }
        TEXTATTR := TATBUF;
      END ELSE BEGIN
{ UNGLEICH- MARKE }
        IF FILEDA THEN IF BUF[16*I+J] <> B THEN TEXTATTR := TAUNGL;
      END;
{ CURSOR }
      IF ((16*I+J) >= CURS) AND ((16*I+J) <= CE) THEN TEXTBACKGROUND(4);
      WRITE(HEXB(B));
{ ZEIGER IM TASTATURBUFFER (HEXDUMP) }
      K := RBUF[$1C] - 2;
      IF K < MEM[BI:$80] THEN K := MEM[BI:$82] - 2;
      TEXTATTR := TAUNGL;
      IF (I*16+J) = K THEN WRITE(#29) ELSE WRITE(' ');
      TEXTATTR := TANORM;
    END ELSE WRITE(HEXB(B),' ');
    IF (J AND 3) = 3 THEN WRITE(' ');
  END; { NEXT J }
  WRITE(' ');
  FOR J := 0 TO 15 DO BEGIN
    B := RBUF[16*I+J];
    IF ADF = 0 THEN BEGIN
      IF (16*I+J) IN [$1A..$3D] THEN BEGIN
{ TASTATURBUFFER }
        TEXTATTR := TATBUF;
      END ELSE BEGIN
{ UNGLEICH- MARKE }
        IF FILEDA THEN IF BUF[16*I+J] <> B THEN TEXTATTR := TAUNGL;
      END;
    END;
    IF (B IN [7,8,10,13]) THEN WRITE('.')
                          ELSE WRITE(CHR(B));
    TEXTATTR := TANORM;
  END; { NEXT J }
  TEXTATTR := TA;
END;


PROCEDURE WERTEANZEIGEN;
VAR   I  : WORD;
BEGIN
  CASE ADF OF
    0 : RBUF := BRAM;
    1 : RBUF := BRAM5;
    2 : RBUF := BRAM6;
    3 : RBUF := BRAM7;
  END; { CASE ADF }
  GOTOXY(24,3);
  WRITE(MEML[BI:$6C]);

{ TASTATURFLAGS }
  GOTOXY(12,4);
  WRITE(HEXB(BRAM[$17]),' ',HEXB(BRAM[$18]),' ');
  WRITE(HEXB(BRAM[$96]),' ',HEXB(BRAM[$97]),' ');
  WRITE(HEXB(BRAM[$19]));
{ TASTATURBUFFER }
  IF TBM <> RBUF[$1C] THEN BEGIN
    GOTOXY(35,4);
    FOR I := MEMW[BI:$80] TO MEMW[BI:$82] - 2 DO BEGIN
      XP := WHEREX;
      IF NOT ODD(I) THEN OCHAR(CHR(MEM[BI:I]));
      IF I = RBUF[$1C] THEN BEGIN
        GOTOXY(35,3); CLREOL;
        GOTOXY(XP,3);
        WRITE(#25);
        GOTOXY(SUCC(XP),4);
      END;
    END;
    TBM := RBUF[$1C];
  END;

{ HEX / ASCII - DUMP }
  FOR I := 0 TO DUMPEND DO BEGIN
    IF DKOPF THEN BEGIN
      GOTOXY(1,10+I);
      CASE ADF OF
        0 : WRITE('40:');
        1 : WRITE('50:');
        2 : WRITE('60:');
        3 : WRITE('70:');
      END; { CASE ADF }
      WRITE(HEXB(I*16),'  ');
    END ELSE GOTOXY(8,10+I);
    DUMP(I);
  END; { NEXT I }
  IF ADF = 0 THEN DUMPEND := 10 ELSE DUMPEND := 15;
  DKOPF := FALSE;
END;


PROCEDURE SETCURS;
BEGIN
  DUMPEND := 15;
  CASE CURS OF
    $00..$0F : BEGIN
                 CURS := 0;
                 CE   := $0F;
               END;
    $10..$16 : BEGIN
                 CURS := $10;
                 CE   := $16;
               END;
    $17..$19 : BEGIN
                 CURS := $17;
                 CE   := $19;
               END;
    $1A..$3D : BEGIN
                 CURS := $1A;
                 CE   := $3D;
               END;
    $3E..$48 : BEGIN
                 CURS := $3E;
                 CE   := $48;
               END;
    $49..$66 : BEGIN
                 CURS := $49;
                 CE   := $66;
               END;
    $67..$6B : BEGIN
                 CURS := $67;
                 CE   := $6B;
               END;
    $6C..$70 : BEGIN
                 CURS := $6C;
                 CE   := $70;
               END;
    $71..$73 : BEGIN
                 CURS := $71;
                 CE   := $73;
               END;
    $74..$77 : BEGIN
                 CURS := $74;
                 CE   := $77;
               END;
    $78..$7F : BEGIN
                 CURS := $78;
                 CE   := $7F;
               END;
    $80..$83 : BEGIN
                 CURS := $80;
                 CE   := $83;
               END;
    $84..$8A : BEGIN
                 CURS := $84;
                 CE   := $8A;
               END;
    $8B..$95 : BEGIN
                 CURS := $8B;
                 CE   := $95;
               END;
    $96..$97 : BEGIN
                 CURS := $96;
                 CE   := $97;
               END;
    $98..$A0 : BEGIN
                 CURS := $98;
                 CE   := $A0;
               END;
    $A1..$A7 : BEGIN
                 CURS := $A1;
                 CE   := $A7;
               END;
    $A8..$C3 : BEGIN
                 CURS := $A8;
                 CE   := $C3;
               END;
    $C4..$CD : BEGIN
                 CURS := $C4;
                 CE   := $CD;
               END;
    $CE..$CF : BEGIN
                 CURS := $CE;
                 CE   := $CF;
               END;
    $D0..$FF : BEGIN
                 CURS := $D0;
                 CE   := $FF;
               END;
  END; { CASE CURS }
END;


PROCEDURE CURSZURUECK;
BEGIN
  CURS := PRED(CURS);
  SETCURS;
END;


PROCEDURE CURSVOR;
BEGIN
  CURS := SUCC(CE);
  SETCURS;
END;


PROCEDURE HILFETEXT;
BEGIN
  CLRSCR;
  CASE CURS OF
    $00..$0F : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$00..$40:$0F befinden sich');
WRITELN(' (soweit vom BIOS beim Booten festgestellt) die I/O- ');
WRITELN(' Adressen der Schnittstellen COM1..COM4 und LPT1..LPT4.');
WRITELN(' Siehe auch Bildschirmzeilen 1 und 2.');
WRITELN(' Dort steht nach dem / die Timeoutzeit der Schnittstelle.');
WRITELN(' Die Timeout- Werte stehen in den Adressen $78..$7F.');
WRITE  (' Bei PS/2 enthält $40:$0E Extended BIOS RAM !');
               END;
    $10..$16 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$10 (WORD) = Equipment Status');
WRITELN(' $40:$12 (BYTE) = benutzt vom Selbsttest');
WRITELN(' $40:$13 (WORD) = RAM- Größe in kByte (Bildschirmzeile 3)');
WRITELN(' $40:$15 (BYTE) = benutzt vom Selbsttest');
WRITELN(' $40:$16 (BYTE) = benutzt vom Selbsttest');
WRITELN(' ');
               END;
    $17..$19 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$17..$40:$19 befinden sich die Tastaturflags,');
WRITELN(' weitere Tastaturflags sind in $96 und $97 zu finden.');
WRITELN(' ');
WRITELN(' Informationen über Tastaturflags sind mit dem Programm');
WRITELN(' SCANCODE besser ersichtlich.');
WRITELN(' $19 = Puffer für ALT-Keypad-Eingabe.');
WRITE  (' Siehe auch Bildschirmzeile 4.');
               END;
    $1A..$3D : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$1A..$40:$3D befindet sich der Tastaturbuffer :');
WRITELN(' ');
WRITELN(' $1A (WORD) = Input- Pointer (Offset)');
WRITELN(' $1C (WORD) = Output- Pointer (Offset)');
WRITELN(' $1E..$3D enthält jeweils ASCII- und Scancode pro Taste');
WRITELN(' ');
               END;
    $3E..$48 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$3E..$40:$48 befinden sich');
WRITELN(' den Disketten- Controller betreffende Informationen.');
WRITELN(' $40:$40 (BYTE) = Motor- Timer');
WRITELN(' $40:$41 (BYTE) = Disk- Fehler');
WRITELN(' $40:$42..$40:$48 = Status des NEC 765 Controller');
               END;
    $49..$66 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$49..$40:$66 befinden sich');
WRITELN(' den Video- Controller betreffende Informationen.');
WRITELN(' ');
WRITELN(' Siehe Bildschirmzeilen 5 bis 8.');
               END;
    $67..$6B : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$67..$40:$6B befinden sich');
WRITELN(' bei alten PCs Daten für den Kassettenrecorder;');
WRITELN(' ');
WRITELN(' $40:$67 (FAR POINTER) = Shutdown- Pointer');
WRITELN(' $40:$6B (BYTE) = falscher Interrupt vom BIOS erkannt');
               END;
    $6C..$70 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$6C..$40:$70 befindet sich der Systemtimer.');
WRITELN(' Der Timer ist ein DWORD (LONGINT), der vom Hardwaretimer');
WRITELN(' 18 mal pro Sekunde incrementiert wird.');
WRITELN(' Bei NEAT- Boards kann dies schneller geschehen.');
WRITELN(' $70 wird beim Sprung über die 24- Stunden- Grenze auf 1');
WRITE  (' gesetzt.');
               END;
    $71..$73 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$71 -> $80 = Ctrl-Break (Strg-Untbr) betätigt.');
WRITELN(' $40:$72 (WORD) :');
WRITELN('    enthält diese Adresse $1234, wird bei RESET ein Warm-');
WRITELN('    Boot durchgeführt, ansonsten ein Kaltboot mit RAMTEST.');
WRITELN(' ');
               END;
    $74..$77 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$74..$40:$77 befinden sich');
WRITELN(' die Festplatte betreffende Informationen.');
WRITELN(' $40:$74 (BYTE) = HD Fehlerbyte');
WRITELN(' $40:$75 (BYTE) = Anzahl angeschlossene HDs');
               END;
    $78..$7F : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$78..$40:$7F befinden sich');
WRITELN(' die Timeoutzeiten (in Sekunden) für die Schnittstellen');
WRITELN(' COM1..COM4 und LPT1..LPT4.');
WRITELN(' ');
WRITELN(' Siehe auch Bildschirmzeilen 1 und 2.');
WRITELN(' Dort steht nach dem / die Timeoutzeit.');
               END;
    $80..$83 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$80..$40:$83 befinden sich');
WRITELN(' die Offsets (WORD) für Anfang und Ende des Tastaturbuf-');
WRITELN(' fers - hier sollte $1E,$00,$3E,$00 stehen.');
WRITELN(' ');
               END;
    $84..$8A : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$84 (BYTE) -> Zeilen pro Bildschirmseite -1');
WRITELN(' $40:$85 (WORD) -> Anzahl Bytes pro Zeichen im Zeichensatz');
WRITELN(' $40:$87 (BYTE) -> Video- Info');
WRITELN(' $40:$88 (BYTE) -> Video- Info1 D0..D3 = DIP- Schalter');
WRITELN(' $40:$89 (BYTE) -> Video- Info2 (nur VGA)');
WRITELN(' $40:$8A (BYTE) -> Video- Info3 Display Combination Code');
               END;
    $8B..$95 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$8B..$40:$95 befinden sich');
WRITELN(' Informationen für Disketten / Festplattenzugriffe.');
WRITELN(' ');
               END;
    $96..$97 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$96..$40:$97 befinden sich Tastaturflags,');
WRITELN(' weitere Tastaturflags sind in $17 bis $19 zu finden.');
WRITELN(' ');
WRITELN(' Informationen über Tastaturflags sind mit dem Programm');
WRITELN(' SCANCODE besser ersichtlich.');
WRITELN(' ');
WRITE  (' Siehe auch Bildschirmzeile 4.');
               END;
    $98..$A0 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$98..$40:$A0 befinden sich');
WRITELN(' Daten, die in Zusammenhang mit INT 15H stehen.');
WRITELN(' $40:$98 (DWORD) = Adresse User Wait Flag');
WRITELN(' $40:$9C (DWORD) = INT 15H Timer');
WRITELN(' $40:$98 (BYTE)  = Wait active Flag');
               END;
    $A1..$A7 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$A1..$40:$A7 ');
WRITELN(' Reserviert für lokales Netzwerk');
               END;
    $A8..$C3 : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$A8..$40:$C3 -> EGA SAVE_TBL');
WRITELN(' Danach ist Platz für 6 weitere alternative SAVE_TBL -');
WRITELN(' Pointer');
               END;
    $C4..$CD : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$C4..$40:$CD UNBEKANNT');
               END;
    $CE..$CF : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' $40:$CE (WORD) Tagezähler seit 1.1.80 (nur PS/2)');
               END;
    $D0..$FF : BEGIN
{       '-----------------------------------------------------------' }
WRITELN(' In $40:$D0..$40:$FF befindet sich freier Speicher.');
WRITELN(' Sind hier andere Werte als $00 zu finden, wirkt da ein ');
WRITELN(' besonders schlaues oder hinterhältiges Programm.');
WRITELN(' ');
               END;
  END; { CASE CURS }
END;


PROCEDURE HELP;
VAR   P            : POINTER;
      CH1,CH2,CH3  : CHAR;

PROCEDURE HINTERGRUND;
BEGIN
  P := ERASETOPWINDOW;
  WERTEANZEIGEN;
  IF NOT DISPLAYWINDOW(HELPWIN) THEN ENDE;
END;

BEGIN
  IF NOT DISPLAYWINDOW(HELPWIN) THEN ENDE;
  REPEAT
    HILFETEXT;
    CH1 := READKEY; IF CH1 = #0 THEN CH2 := READKEY ELSE CH2 := #0;
    CASE CH2 OF
{ F1 }  #59 : BEGIN
                CLRSCR;
                WRITELN('   PROGRAMM   BIOSDUMP');
                WRITELN('');
                WRITELN(' F2 = save aktuelle Daten Segment $40:0');
                WRITELN(' F5 = Dump Segment $40 (Default)');
                WRITELN(' F6 = Dump Segment $50');
                WRITE  (' F7 = Dump Segment $60');
                CH3 := READKEY; IF CH3 = #0 THEN CH3 := READKEY;
              END;
{ PUP } #73 : BEGIN
                CURSZURUECK;
                HINTERGRUND;
              END;
{ PDN } #81 : BEGIN
                CURSVOR;
                HINTERGRUND;
              END;
{ UP }  #72 : BEGIN
                IF NOT MOVEWINDOW(0,-1) THEN {};
              END;
{ DN }  #80 : BEGIN
                IF NOT MOVEWINDOW(0,1) THEN {};
              END;
{ LE }  #75 : BEGIN
                IF NOT MOVEWINDOW(-1,0) THEN {};
              END;
{ RI }  #77 : BEGIN
                IF NOT MOVEWINDOW(1,0) THEN {};
              END;
    END; { CASE CH2 }
  UNTIL CH1 = ^[;
  P := ERASETOPWINDOW;
END;


PROCEDURE BEREINIGEN;
BEGIN
  FOR I := 0 TO 255 DO MEM[$60:I] := $FF;
  FOR I := $01 TO $03 DO MEM[$50:I] := $FF; { ? }
  FOR I := $05 TO $0E DO MEM[$50:I] := $FF; { ? }
  FOR I := $1E TO $21 DO MEM[$50:I] := $FF;
  FOR I := $2E TO $2F DO MEM[$50:I] := $FF;
  FOR I := $36 TO $FF DO MEM[$50:I] := $FF;
END;


BEGIN { MAIN }
  OMODE := 0;
  TBM   := 0;
  ADF   := 0;
  DKOPF := TRUE;

  IF PARAMSTR(1) = 'BEREINIGEN' THEN BEGIN
    BEREINIGEN;
    HALT;
  END;

  IF LASTMODE IN [0,1,4,5,6,$0D..$7F] THEN BEGIN
    TEXTMODE(CO80);
    TEXTATTR := $07;
    DELAY(100);
  END;

  { CREATE HELP WINDOW }
  if not MakeWindow(HELPWIN,10,1,70,9,True,True,TRUE,$70,$16,$1E,' Help ') THEN ENDE;

{$I-}
  FILEDA := FALSE;
  ASSIGN(F,'BIOSDUMP.SAV');
  RESET(F);
  IF IORESULT = 0 THEN BEGIN
    READ(F,BUF);
    CLOSE(F);
    FILEDA := TRUE;
  END;
{$I+}

  AVP := BRAM[$62];
  SETVISIBLEPAGE(1);
  TA := TEXTATTR;
  TEXTATTR := TANORM;
  CLRSCR;

  RBUF := BRAM;
  GOTOXY(1,1);
  WRITE(    'COM1 : ',HEXW(MEMW[BI:$00]),'/',BRAM[$7C]:3);
  WRITE(',   COM2 : ',HEXW(MEMW[BI:$02]),'/',BRAM[$7D]:3);
  WRITE(',   COM3 : ',HEXW(MEMW[BI:$04]),'/',BRAM[$7E]:3);
  WRITE(',   COM4 : ',HEXW(MEMW[BI:$06]),'/',BRAM[$7F]:3);
  WRITELN;
  WRITE(    'LPT1 : ',HEXW(MEMW[BI:$08]),'/',BRAM[$78]:3);
  WRITE(',   LPT2 : ',HEXW(MEMW[BI:$0A]),'/',BRAM[$79]:3);
  WRITE(',   LPT3 : ',HEXW(MEMW[BI:$0C]),'/',BRAM[$7A]:3);
  WRITE(',   LPT4 : ',HEXW(MEMW[BI:$0E]),'/',BRAM[$7B]:3);
  WRITELN;
  WRITE('Memory : ',MEMW[BI:$13]:4,'k');
  WRITE(',  Timer ',MEML[BI:$6C]);
  WRITELN;
  WRITE('Tastatur : ');
  GOTOXY(34,4); WRITE(#16);
  GOTOXY(35+((MEMW[BI:$82] - MEMW[BI:$80]) SHR 1),4);
  WRITELN(#17);

  WRITE('Video- Mode ',HEXB(BRAM[$49]));
  WRITE(', ',MEMW[BI:$4A],'*',BRAM[$84]+1,' Zeichen,');
  WRITE('  Page ',BRAM[$62],', ');
  WRITE(MEMW[BI:$85],' Bytes/Zeichen');

  WRITELN;
  WRITE('Memsize : ',MEMW[BI:$4C]:6);
  WRITE(', MEM-ADR : ',HEXW(MEMW[BI:$4E]));
  WRITE(', CONTROLLER-ADR : ',HEXW(MEMW[BI:$63]));
  WRITE(', Flag ',HEXB(BRAM[$65]));

  WRITELN;
  WRITE('Palette ',HEXB(BRAM[$66]));
  WRITE(', EGA STATUS : ',HEXB(BRAM[$89]));
  WRITE(', SAVE_TBL : ',HEXW(MEMW[BI:$AA]),':',HEXW(MEMW[BI:$A8]));

  WRITELN;
  WRITE('Cursor : ',HEXW(MEMW[BI:$60]),', ');
  FOR I := 0 TO 15 DO BEGIN
    WRITE(RBUF[I+$50]:2);
    IF (I AND 1) = 0 THEN WRITE(',') ELSE WRITE('  ');
  END; { NEXT I }

    GOTOXY(1,10+I);
    WRITE('40:',HEXB(I*16),'  ');

  HIDDENCURSOR;
  CURS  := 0;
  SETCURS;
  CH := ' ';
  REPEAT
    WERTEANZEIGEN;

    IF KEYPRESSED THEN BEGIN
      CH := READKEY;
      IF CH = #0 THEN CH1 := READKEY ELSE CH1 := #0;
      CASE CH1 OF
{ F1 }  #59 : HELP;
{ F2 }  #60 : BEGIN
{$I-}
                FILEDA := FALSE;
                ASSIGN(F,'BIOSDUMP.SAV');
                REWRITE(F);
                IF IORESULT = 0 THEN BEGIN
                  BUF := BRAM;
                  WRITE(F,BUF);
                  CLOSE(F);
                  FILEDA := (IORESULT = 0);
                END;
{$I+}
              END;
{ F5 }  #63 : BEGIN
                ADF := 0;
                DUMPEND := 15;
                DKOPF := TRUE;
              END;
{ F6 }  #64 : BEGIN
                ADF := 1;
                DUMPEND := 15;
                DKOPF := TRUE;
              END;
{ F7 }  #65 : BEGIN
                ADF := 2;
                DUMPEND := 15;
                DKOPF := TRUE;
              END;
{ F8 }  #66 : BEGIN
                ADF := 3;
                DUMPEND := 15;
                DKOPF := TRUE;
              END;
{ PU }  #73,
{ UP }  #72,
{ LE }  #75 : CURSZURUECK;
{ PD }  #81,
{ DN }  #80,
{ RI }  #77 : CURSVOR;
      END; { CASE CH1 }
    END; { IF KEYPRESSED }
  UNTIL CH = ^[;

  ENDE;

END.