UNIT KB;

INTERFACE

CONST { Definition der einzelnen Tastencodes }

      KB_None       =   0;   { 0 = kein Tastencode }
      KB_ANY        = $FFFF; { irgend eine Taste }

      KB_ESC        =  27;   { Esc  Taste                }
      KB_Space      =  32;   { Leer Taste                }
      KB_Return     =  13;   { Return Taste              }
      KB_Enter      =  13;   { Entertaste = Return Taste }
      KB_BackSlash  =  92;   { Schraegstrich \           }
      KB_BackSpace  =   8;   { R�ckschritt               }
      KB_TabRight   =   9;   { Tabulator rechts          }
      KB_TabLeft    = 271;   { Tabulator links, in Verbindung mit Shift }

      KB_Left  = 331;        { Cursor Links    }
      KB_Right = 333;        { Cursor Rechts   }
      KB_Home  = 327;        { Cursor Home     }
      KB_End   = 335;        { Cursor End      }
      KB_PgUp  = 329;        { Seite aufw„rts  }
      KB_PgDn  = 337;        { Seite abw„rts   }
      KB_Up    = 328;        { Cursor aufw„rts }
      KB_Down  = 336;        { Cursor abw„rts  }
      KB_Ins   = 338;        { Insert Taste    }
      KB_Del   = 339;        { Delete Taste    }

      KB_Shift_Left  = 52;
      KB_Shift_Right = 54;
      KB_Shift_Home  = 55;
      KB_Shift_End   = 49;
      KB_Shift_PgUp  = 51;
      KB_Shift_PgDn  = 57;
      KB_Shift_Down  = 50;
      KB_Shift_Up    = 56;
      KB_Shift_Ins   = 261;
      KB_Shift_Del   = 263;

      KB_F1  = 315;          { Funktionstaste F1  }
      KB_F2  = 316;          { Funktionstaste F2  }
      KB_F3  = 317;          { Funktionstaste F3  }
      KB_F4  = 318;          { Funktionstaste F4  }
      KB_F5  = 319;          { Funktionstaste F5  }
      KB_F6  = 320;          { Funktionstaste F6  }
      KB_F7  = 321;          { Funktionstaste F7  }
      KB_F8  = 322;          { Funktionstaste F8  }
      KB_F9  = 323;          { Funktionstaste F9  }
      KB_F10 = 324;          { Funktionstaste F10 }
      KB_F11 = 389;          { Funktionstaste F11 }
      KB_F12 = 390;          { Funktionstaste F12 }

      KB_Shift_F1  = 340;    { Funktionstaste F1  mit Shifttaste }
      KB_Shift_F2  = 341;    { Funktionstaste F2  mit Shifttaste }
      KB_Shift_F3  = 342;    { Funktionstaste F3  mit Shifttaste }
      KB_Shift_F4  = 343;    { Funktionstaste F4  mit Shifttaste }
      KB_Shift_F5  = 344;    { Funktionstaste F5  mit Shifttaste }
      KB_Shift_F6  = 345;    { Funktionstaste F6  mit Shifttaste }
      KB_Shift_F7  = 346;    { Funktionstaste F7  mit Shifttaste }
      KB_Shift_F8  = 347;    { Funktionstaste F8  mit Shifttaste }
      KB_Shift_F9  = 348;    { Funktionstaste F9  mit Shifttaste }
      KB_Shift_F10 = 349;    { Funktionstaste F10 mit Shifttaste }
      KB_Shift_F11 = 391;    { Funktionstaste F11 mit Shifttaste }
      KB_Shift_F12 = 392;    { Funktionstaste F12 mit Shifttaste }

      KB_CTRL_A =  1;        { "A" Taste mit CTRL-Taste }
      KB_CTRL_B =  2;        { "B" Taste mit CTRL-Taste }
      KB_CTRL_C =  3;        { "C" Taste mit CTRL-Taste }
      KB_CTRL_D =  4;        { "D" Taste mit CTRL-Taste }
      KB_CTRL_E =  5;        { "E" Taste mit CTRL-Taste }
      KB_CTRL_F =  6;        { "F" Taste mit CTRL-Taste }
      KB_CTRL_G =  7;        { "G" Taste mit CTRL-Taste }
      KB_CTRL_H =  8;        { "H" Taste mit CTRL-Taste }
      KB_CTRL_I =  9;        { "I" Taste mit CTRL-Taste }
      KB_CTRL_J = 10;        { "J" Taste mit CTRL-Taste }
      KB_CTRL_K = 11;        { "K" Taste mit CTRL-Taste }
      KB_CTRL_L = 12;        { "L" Taste mit CTRL-Taste }
      KB_CTRL_M = 13;        { "M" Taste mit CTRL-Taste }
      KB_CTRL_N = 14;        { "N" Taste mit CTRL-Taste }
      KB_CTRL_O = 15;        { "O" Taste mit CTRL-Taste }
      KB_CTRL_P = 16;        { "P" Taste mit CTRL-Taste }
      KB_CTRL_Q = 17;        { "Q" Taste mit CTRL-Taste }
      KB_CTRL_R = 18;        { "R" Taste mit CTRL-Taste }
      KB_CTRL_S = 19;        { "S" Taste mit CTRL-Taste }
      KB_CTRL_T = 20;        { "T" Taste mit CTRL-Taste }
      KB_CTRL_U = 21;        { "U" Taste mit CTRL-Taste }
      KB_CTRL_V = 22;        { "V" Taste mit CTRL-Taste }
      KB_CTRL_W = 23;        { "W" Taste mit CTRL-Taste }
      KB_CTRL_X = 24;        { "X" Taste mit CTRL-Taste }
      KB_CTRL_Y = 25;        { "Y" Taste mit CTRL-Taste }
      KB_CTRL_Z = 26;        { "Z" Taste mit CTRL-Taste }

      KB_CTRL_F1  = 350;     { Funktionstaste F1  mit CTRL-Taste }
      KB_CTRL_F2  = 351;     { Funktionstaste F2  mit CTRL-Taste }
      KB_CTRL_F3  = 352;     { Funktionstaste F3  mit CTRL-Taste }
      KB_CTRL_F4  = 353;     { Funktionstaste F4  mit CTRL-Taste }
      KB_CTRL_F5  = 354;     { Funktionstaste F5  mit CTRL-Taste }
      KB_CTRL_F6  = 355;     { Funktionstaste F6  mit CTRL-Taste }
      KB_CTRL_F7  = 356;     { Funktionstaste F7  mit CTRL-Taste }
      KB_CTRL_F8  = 357;     { Funktionstaste F8  mit CTRL-Taste }
      KB_CTRL_F9  = 358;     { Funktionstaste F9  mit CTRL-Taste }
      KB_CTRL_F10 = 359;     { Funktionstaste F10 mit CTRL-Taste }
      KB_CTRL_F11 = 393;     { Funktionstaste F11 mit CTRL-Taste }
      KB_CTRL_F12 = 394;     { Funktionstaste F12 mit CTRL-Taste }

      KB_CTRL_Left  = 371;   { Cursor Links  mit CTRL-Taste }
      KB_CTRL_Right = 322;   { Cursor Rechts mit CTRL-Taste }
      KB_CTRL_Home  = 375;   { Cursor Home   mit CTRL-Taste }
      KB_CTRL_End   = 373;   { Cursor End    mit CTRL-Taste }
      KB_CTRL_PgUp  = 388;   { PgUp-Taste    mit CTRL-Taste }
      KB_CTRL_PgDn  = 374;   { PgDn-Taste    mit CTRL-Taste }

      KB_ALT_1 = 376;        { "1" Taste mit ALT-Taste }
      KB_ALT_2 = 377;        { "2" Taste mit ALT-Taste }
      KB_ALT_3 = 378;        { "3" Taste mit ALT-Taste }
      KB_ALT_4 = 379;        { "4" Taste mit ALT-Taste }
      KB_ALT_5 = 380;        { "5" Taste mit ALT-Taste }
      KB_ALT_6 = 381;        { "6" Taste mit ALT-Taste }
      KB_ALT_7 = 382;        { "7" Taste mit ALT-Taste }
      KB_ALT_8 = 383;        { "8" Taste mit ALT-Taste }
      KB_ALT_9 = 384;        { "9" Taste mit ALT-Taste }
      KB_ALT_0 = 385;        { "0" Taste mit ALT-Taste }

      KB_ALT_A = 286;        { "A" Taste mit ALT-Taste }
      KB_ALT_B = 304;        { "B" Taste mit ALT-Taste }
      KB_ALT_C = 302;        { "C" Taste mit ALT-Taste }
      KB_ALT_D = 288;        { "D" Taste mit ALT-Taste }
      KB_ALT_E = 274;        { "E" Taste mit ALT-Taste }
      KB_ALT_F = 289;        { "F" Taste mit ALT-Taste }
      KB_ALT_G = 290;        { "G" Taste mit ALT-Taste }
      KB_ALT_H = 291;        { "H" Taste mit ALT-Taste }
      KB_ALT_I = 279;        { "I" Taste mit ALT-Taste }
      KB_ALT_J = 292;        { "J" Taste mit ALT-Taste }
      KB_ALT_K = 293;        { "K" Taste mit ALT-Taste }
      KB_ALT_L = 294;        { "L" Taste mit ALT-Taste }
      KB_ALT_M = 306;        { "M" Taste mit ALT-Taste }
      KB_ALT_N = 305;        { "N" Taste mit ALT-Taste }
      KB_ALT_O = 280;        { "O" Taste mit ALT-Taste }
      KB_ALT_P = 281;        { "P" Taste mit ALT-Taste }
      KB_ALT_Q = 272;        { "Q" Taste mit ALT-Taste }
      KB_ALT_R = 275;        { "R" Taste mit ALT-Taste }
      KB_ALT_S = 287;        { "S" Taste mit ALT-Taste }
      KB_ALT_T = 276;        { "T" Taste mit ALT-Taste }
      KB_ALT_U = 278;        { "U" Taste mit ALT-Taste }
      KB_ALT_V = 303;        { "V" Taste mit ALT-Taste }
      KB_ALT_W = 273;        { "W" Taste mit ALT-Taste }
      KB_ALT_X = 301;        { "X" Taste mit ALT-Taste }
      KB_ALT_Y = 277;        { "Y" Taste mit ALT-Taste }
      KB_ALT_Z = 44;         { "Z" Taste mit ALT-Taste }

      KB_ALT_F1  = 360;      { Funktionstaste F1  mit ALT-Taste }
      KB_ALT_F2  = 361;      { Funktionstaste F2  mit ALT-Taste }
      KB_ALT_F3  = 362;      { Funktionstaste F3  mit ALT-Taste }
      KB_ALT_F4  = 363;      { Funktionstaste F4  mit ALT-Taste }
      KB_ALT_F5  = 364;      { Funktionstaste F5  mit ALT-Taste }
      KB_ALT_F6  = 365;      { Funktionstaste F6  mit ALT-Taste }
      KB_ALT_F7  = 366;      { Funktionstaste F7  mit ALT-Taste }
      KB_ALT_F8  = 367;      { Funktionstaste F8  mit ALT-Taste }
      KB_ALT_F9  = 368;      { Funktionstaste F9  mit ALT-Taste }
      KB_ALT_F10 = 369;      { Funktionstaste F10 mit ALT-Taste }
      KB_ALT_F11 = 395;      { Funktionstaste F11 mit ALT-Taste }
      KB_ALT_F12 = 396;      { Funktionstaste F12 mit ALT-Taste }

      KB_ALT_SPACE = 258;    { SPACE Taste mit ALT-TASTE }
      KB_Cursor_5 = 332;     { mittlere Cursor 5 }

Type YesNoRangeType   = #13..#127;   { gueltige Character fuer YES NO }

Procedure KB_Clear;
Procedure KB_Read (Var KeyCode : Word);
Function  KB_Pressed           : Boolean;
Function  KB_CtrlPressed       : Boolean;
Function  KB_AltPressed        : Boolean;
Function  KB_ScrollPressed     : Boolean;
Function  KB_NumPressed        : Boolean;
Function  KB_CapsPressed       : Boolean;
Function  KB_InsPressed        : Boolean;
Function  KB_ShiftPressed      : Boolean;
Function  KB_ShiftRightPressed : Boolean;
Function  KB_ShiftLeftPressed  : Boolean;

Function  KB_ScrollActive      : Boolean;
Function  KB_NumActive         : Boolean;
Function  KB_CapsActive        : Boolean;
Function  KB_InsActive         : Boolean;

Procedure KB_Wait      (KeyCode        : Word);
Function  KB_YesNo     (YesChar,NoChar : YesNoRangeType):Boolean;
Procedure KB_Put       (KeyCode        : Word);
Procedure KB_PutString (S:String);
{****************************************************************************}

IMPLEMENTATION 


CONST

BIOS_READ_PTR  = $041A;  { BIOS-Variable Tastatur-Lesezeiger      0040:001A }
BIOS_LAST_PTR  = $041C;  { BIOS-Variable Zeiger auf letzte Taste  0040:001C }
BIOS_START_PTR = $0480;  { Zeiger auf Start des Tastaturpuffers   0040:0080 }
BIOS_END_PTR   = $0482;  { Zeiger auf Ende  des Tastaturpuffers   0040:0082 }

BIOS_STATUS_1  = $0417;  { BIOS-Variable Tastatur-Status-Byte 1   0040:0017 }
BIOS_STATUS_2  = $0418;  { BIOS-Variable Tastatur-Status-Byte 2   0040:0018 }


Bit_ShiftRight = $01;    { Bits im BIOS Statusbyte }
Bit_ShiftLeft  = $02;
Bit_Shift      = $03;
Bit_Ctrl       = $04;
Bit_Alt        = $08;
Bit_Scroll     = $10;
Bit_Num        = $20;
Bit_Caps       = $40;
Bit_Ins        = $80;

VAR

OldExitProc     : Pointer;       { Orginal Exit Procedure }

org_start_ptr : Word;  { Orginal Start des Tastatur-Puffers }
org_end_ptr   : Word;  { Orginal Ende  des Tastatur-Puffers }

{============================================================================}
Procedure KB_Clear;
var key:Word;
Begin
  While KB_Pressed do KB_read(key);
end;
{============================================================================}
Function KB_ShiftRightPressed:Boolean; Assembler;

 { liefert True, wenn rechte Shifttaste momentan gedrueckt, sonst False. }

ASM  XOR  AX,AX
     MOV  ES,AX
     TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_ShiftRight
     JZ   @@1
     INC  AX
@@1: RET
end;
{============================================================================}
Function KB_ShiftLeftPressed:Boolean; Assembler;

 { liefert True, wenn linke Shifttaste momentan gedrueckt, sonst False. }

ASM  XOR  AX,AX
     MOV  ES,AX
     TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_ShiftLeft
     JZ   @@1
     INC  AX
@@1: RET
end;
{============================================================================}
Function KB_ShiftPressed:Boolean; Assembler;

 { liefert True, wenn eine Shifttaste momentan gedrueckt, sonst False. }

ASM  XOR  AX,AX
     MOV  ES,AX
     TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Shift
     JZ   @@1
     INC  AX
@@1: RET
end;
{============================================================================}
Function KB_CtrlPressed:Boolean; Assembler;

  { liefert True, wenn eine CTRL-Taste momentan gedrueckt, sonst False. }

ASM  XOR  AX,AX
     MOV  ES,AX
     TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Ctrl
     JZ   @@1
     INC  AX
@@1: RET
end;
{============================================================================}
Function KB_AltPressed:Boolean; Assembler;
   { liefert True, wenn eine ALT-Taste momentan gedrueckt, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Alt
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_ScrollActive:Boolean; Assembler;

   { liefert True, wenn eine SCROLL-Taste aktiviert ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Scroll
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_NumActive:Boolean; Assembler;

  { liefert True, wenn eine NUMLOCK-Taste aktiviert ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Num
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_CapsActive:Boolean; Assembler;

   { liefert True, wenn die CAPSLOCK-Taste aktiviert ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Caps
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_InsActive:Boolean; Assembler;

  { liefert True, wenn die INSERT-Taste aktiviert ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_1],Bit_Ins
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_ScrollPressed:Boolean; Assembler;

 { liefert True, wenn die SCROLL-Taste momentan gedrueckt ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_2],Bit_Scroll
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_NumPressed:Boolean; Assembler;

 { liefert True, wenn die NUMLOCK-Taste momentan gedrueckt ist, sonst False.}

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_2],Bit_Num
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_CapsPressed:Boolean; Assembler;

 { liefert True, wenn die CAPSLOCK-Taste momentan gedrueckt ist, sonst False. }

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_2],Bit_Caps
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_InsPressed:Boolean; Assembler;

{ liefert True, wenn die INSERT-Taste momentan gedrueckt ist, sonst False.}

ASM   XOR  AX,AX
      MOV  ES,AX
      TEST Byte Ptr ES:[BIOS_STATUS_2],Bit_Ins
      JZ   @@1
      INC  AX
@@1:  RET
end;
{============================================================================}
Function KB_pressed:Boolean; Assembler;

      { liefert TRUE, wenn sich mindestens ein Zeichen im }
      { Tastaturpuffer befindet, ansonsten FALSE.         }

ASM    PUSHF                       { IRQ-FLAG merken }
       CLI                         { Interrupts sperren }
       XOR  AX,AX
       MOV  ES,AX
       MOV  BX,ES:[BIOS_READ_PTR]  { BIOS-Lesezeiger }
       CMP  BX,ES:[BIOS_LAST_PTR]  { = BIOS Letztezeiger ? }
       JE   @@1                    { dann kein Zeichen im Puffer }
       INC  AX                     { sonst TRUE, Zeichen im Puffer }
@@1:   POPF                        { IRQ-Flag restaurieren }
       RET
end;
{============================================================================}
Procedure KB_read(Var KeyCode:Word);

   { Liest wenn vorhanden ein Zeichen aus dem Tastaturpuffer }
   { in die uebergebene Variable KeyCode ein.                }
   { Befindet sich kein Zeichen im Tastaturpuffer, so wird   }
   { solange gewartet bis ein Zeichen vorhanden ist.         }

Begin
ASM         XOR  AX,AX
            MOV  ES,AX
            MOV  BX,ES:[BIOS_READ_PTR]  { BIOS-Lesezeiger }
@@wait:     CMP  BX,ES:[BIOS_LAST_PTR]  { = BIOS Letztezeiger ? }
            JE   @@wait                 { dann kein Zeichen im Puffer }
            MOV  AX,ES:[BX+400h]        { sonst Code aus Puffer holen }
            CMP  AL,224                 { extended Code ? }
            JE   @@extended             { ja }
            CMP  AL,240                 { extended Code ? }
            JE   @@extended             { ja }
            CMP  AL,0                   { extended Code ? }
            JZ   @@extended             { ja }
            XOR  AH,AH                  { sonst normale Ascii Taste }
            JMP  @@normal
@@extended: MOV  AL,1                   { AL Code + 256 }
            XCHG AL,AH
@@normal:   ADD  BX,2                   { BIOS Lesezeiger + 2 }
            CMP  BX,ES:[BIOS_END_PTR]   { am Ende des BIOS Puffer ? }
            JNE  @@1                    { nein }
            MOV  BX,ES:[BIOS_START_PTR] { sonst an Start des BIOS Puffers }
@@1:        MOV  ES:[BIOS_READ_PTR],BX  { BIOS Lesezeiger speichern }
            LES  BX,KeyCode             { Adresse der Variablen KeyCode }
            MOV  ES:[BX],AX             { KeyCode uebergeben }
  end;
end;
{============================================================================}
Procedure KB_put(KeyCode:Word);

  { alle Register retten wird speater von Mouse Unit aufgerufen }

Begin
   ASM PUSH AX
       PUSH BX
       PUSH CX
       PUSH ES
       MOV  AX,KeyCode                 { Tastencode nach AX }
       OR   AH,AH                      { erweiterter CODE ? }
       JZ   @@1                        { nein, dann ok }
       SUB  AX,256                     { sonst Tastencode - 256 }
       XCHG AL,AH                      { AL=0 AH=Code }
@@1:   XOR  BX,BX
       MOV  ES,BX
       PUSHF                           { IRQ-Flag merken }
       CLI                             { Interrupts sperren }
       MOV  BX,ES:[BIOS_Last_Ptr]      { Einlesezeiger }
       MOV  CX,BX                      { nach CX }
       ADD  CX,2                       { +2 }
       CMP  CX,ES:[BIOS_End_Ptr]       { am Ende des Puffers  ? }
       JNE  @@2                        { nein, dann ok }
       MOV  CX,ES:[BIOS_Start_Ptr]     { sonst Puffer von vorn }
@@2:   CMP  CX,ES:[BIOS_Read_Ptr]      { Einlesezeiger = Auslesezeiger }
       JE   @@3                        { ja, Puffer voll Exit }
       MOV  ES:[BX+400h],AX            { nein dann Zeichen eintragen }
       MOV  ES:[BIOS_Last_Ptr],CX      { Einlesezeiger speichern }
@@3:   POPF                            { IRQ-FLAG restaurieren }
       POP  ES
       POP  CX
       POP  BX
       POP  AX
  end;
end;
{============================================================================}
Procedure KB_PutString(S:String);
Var i:Integer;
Begin
  For i:=1 to Length(S) do KB_Put( Ord(S[i]) );
end;
{============================================================================}
Procedure KB_Wait(KeyCode:Word);
Var Key:Word;
Begin
  repeat
    while NOT KB_Pressed do ;
    if KeyCode = KB_ANY then Exit;
    KB_Read(Key);
  Until Key=KeyCode;
end;
{============================================================================}
{$F+}
Procedure KB_ExitProc;
Begin
  ASM XOR AX,AX
      MOV ES,AX
      MOV AX,org_start_ptr
      PUSHF
      CLI
      MOV ES:[BIOS_START_PTR],AX
      MOV ES:[BIOS_READ_PTR],AX
      MOV ES:[BIOS_LAST_PTR],AX
      MOV AX,org_end_ptr
      MOV ES:[BIOS_END_PTR],AX
      POPF
  end;
  ExitProc:=OldExitProc;
end;
{$F-}
{============================================================================}
Function KB_YesNo(YesChar,NoChar:YesNoRangeType):Boolean;
Var Key:Word;  ch:Char;
Begin
  KB_YesNo:=False;
  YesChar:=UpCase(YesChar);
  NoChar :=UpCase(NoChar);
  Repeat
    KB_read(Key);
    ch := Upcase(Chr(Key));
    if ch = YesChar then KB_YesNo:=TRUE;
  Until (ch=YesChar) or (ch=NoChar);
end;
{============================================================================}
Begin                 { Initialisierung }
  ASM XOR AX,AX
      MOV ES,AX
      MOV AX,ES:[BIOS_START_PTR]   { Orginal Start }
      MOV org_start_ptr,AX         { merken }
      MOV AX,ES:[BIOS_END_PTR]     { orginal Ende }
      MOV org_end_ptr,AX           { merken }

      MOV AX,200h                  { Offset 400h+200h=600h neuer Puffer }
      PUSHF                        { IRQ-Flag merken }
      CLI                          { Interrupts sperren }
      MOV ES:[BIOS_START_PTR],AX   { Startadresse setzen }
      MOV ES:[BIOS_READ_PTR],AX    { Lesezeiger auf Start }
      MOV ES:[BIOS_LAST_PTR],AX    { Schreibzeiger auf Start }
      ADD AX,200                   { 200 Bytes = Platz fuer 100 Tastencodes }
      MOV ES:[BIOS_END_PTR],AX
      POPF                         { IRQ-Flag restaurieren }
  end;
  OldExitProc := ExitProc;
  ExitProc    := @KB_ExitProc;
end.