home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / tools / debugger / mdebug / mdebug1 / testmd.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1992-05-29  |  22.5 KB  |  644 lines
  1. {---------------------------------------------------------------}
  2. { TESTMD.PAS                                                    ]
  3. {                                                               }
  4. { Demoprogramm zur Nutzung von MDEBUG in eigenen Turbo Pascal-  }
  5. { Programmen (Turbo Pascal Version 4.0 oder höher)              }
  6. {                                                               }
  7. { Achtung:                                                      }
  8. { Zur Ermittlung des Userints sollte nur CHECKMD verwendet      }
  9. { werden (keine Konstante einsetzen!), da Turbo Pascal einen    }
  10. { Interrupt zwischen 60h und 66h (normalerweise den Interrupt   }
  11. { 60h) in der Entwicklungsumgebung für eigene Zwecke gebraucht! }
  12. { (Getestet in Version 5.0)                                     }
  13. {                                                               }
  14. { (c) by Bernd Schemmer 1989, 1990, 1991, 1992                  }
  15. {                                                               }
  16. { Benötigt die Object-Dateien CALLMD.OBJ, CHECKMD.OBJ,          }
  17. { MDCMD.OBJ und KONVERT.OBJ zur Compilierung                    }
  18. {                                                               }
  19. { letzter Update: 09.05.1992, Bernd Schemmer                    }
  20.  
  21. USES dos,crt;
  22.  
  23. {---------------------------------------------------------------}
  24. { Aufbau des Status-Records von MDEBUG                          }
  25.  
  26. TYPE
  27.  StatusTable = RECORD
  28.                 PSP     : WORD;     { Code-Segment von MDEBUG   }
  29.                 Int08   : POINTER;  { Adresse der alten Routine }
  30.                                     { für den Int 8h            }
  31.                 Int09   : POINTER;  { -"- Int 9h                }
  32.                 Int16   : POINTER;  { Adresse der von MDEBUG    }
  33.                                     { benutzten Int 16h-Routine }
  34.                 Version : STRING;   { Versionskennung von MDEBUG}
  35.                                     { als Pascal-String         }
  36.                END;
  37.  
  38. VAR
  39.  StatusPtr : ^StatusTable;
  40.  
  41. {---------------------------------------------------------------}
  42. { Aufbau des Hilfsregister-Arrays von MDEBUG                    }
  43. { (9 Register von R0 bis R8 mit Wort-Größe)                     }
  44.  
  45. TYPE
  46.  HilfsRegisterSet = ARRAY[0..8] of WORD;
  47.  
  48. VAR
  49.  HilfsRegisterPtr : ^HilfsRegisterSet;
  50.  
  51. {---------------------------------------------------------------}
  52. { Hilfsvariablen                                                }
  53.  
  54. VAR
  55.  regs    : REGISTERS;         { Register-Record zum Aufruf von  }
  56.                               { MDEBUG                          }
  57.  userint : BYTE;              { Nummer des Userints             }
  58.  
  59. VAR
  60.  TestString : STRING[$3F];
  61.  Erklaerung : STRING[$3F];
  62.  passwort   : STRING[4];      { Variable zum Speichern des      }
  63.                               { Passwortes                      }
  64.  
  65. CONST
  66.  _Erklaerung = '**** Der Inhalt der Variablen TESTSTRING kann geändert werden ***';
  67.  
  68. CONST
  69.  CR_LF = #13#10;
  70.  BELL  = #7;
  71.  
  72. CONST
  73.   mdmessages : ARRAY[0..3] of STRING =
  74.     ('im Monitor',
  75.      'im Interpreter',
  76.      'in der Onlinehilfe des Monitors',
  77.      'in der Onlinehilfe des Interpreters');
  78.  
  79. {---------------------------------------------------------------}
  80. { Einbinden der Routine zum Testen, ob MDEBUG geladen ist       }
  81. {$L CheckMd}
  82.  
  83. {---------------------------------------------------------------}
  84. { CheckMD                                                       }
  85. {                                                               }
  86. { Funktion:  Ermittelt ob MDEBUG geladen ist und ob ein         }
  87. {            Userint installiert ist                            }
  88. {                                                               }
  89. { Eingabe: -                                                    }
  90. {                                                               }
  91. { Ausgabe:                                                      }
  92. {  Funktionswert: -1 : MDEBUG nicht installiert                 }
  93. {                  0 : MDEBUG ohne Userint installiert          }
  94. {          60h - 67h : MDEBUG installiert und der Funktions-    }
  95. {                      wert ist die Nummer des Userints         }
  96. {                      Andere Werte sollten nicht vorkommen     }
  97. {                                                               }
  98. { Besonderheiten:    Benutzt die MCBs                           }
  99. {---------------------------------------------------------------}
  100.  
  101. { Deklaration der Funktion (FAR!): }
  102.  
  103. {$F+} FUNCTION CheckMD:BYTE; EXTERNAL; {$F-}
  104.  
  105. {---------------------------------------------------------------}
  106. { Einbinden der Routine zum Aufruf von MDEBUG                   }
  107. { (Der Aufruf kann auch über die Funktion INTR() erfolgen)      }
  108. {$L callmd}
  109.  
  110. {---------------------------------------------------------------}
  111. { CallMD                                                        }
  112. {                                                               }
  113. { Funktion:  Aufruf des Userints von MDEBUG                     }
  114. {                                                               }
  115. { Eingabe:   intnumber : Nummer des Userints von MDEBUG         }
  116. {                        (Ermittelt über CheckMD !)             }
  117. {            regs      : Registerwerte für den Aufruf           }
  118. {                                                               }
  119. { Ausgabe:   regs      : evtl. geänderte Registerwerte          }
  120. {---------------------------------------------------------------}
  121.  
  122. { Deklaration der Prozedur (FAR!): }
  123.  
  124. {$F+}
  125. PROCEDURE CallMd(    intnumber : BYTE;
  126.                  VAR regs      : REGISTERS); EXTERNAL;
  127. {$F-}
  128.  
  129. {---------------------------------------------------------------}
  130. { Einbinden der Routine zur Ausführung von Befehlen über MDEBUG }
  131. {$L MDCMD}
  132.  
  133. {---------------------------------------------------------------}
  134. { MDCMD                                                         }
  135. {                                                               }
  136. { Funktion:  Ausführen von Befehlen über MDEBUG                 }
  137. {                                                               }
  138. { Eingabe:   CheckInts : TRUE : Unterdrückt die Interrupts 20h, }
  139. {                               27h und die Funktionen 0h und   }
  140. {                               31h des Interrupts 21h          }
  141. {                               während der Ausführung der      }
  142. {                               Befehl(e)                       }
  143. {                        FALSE: keine Überprüfung der Interrupts}
  144. {            commands  : Befehl(e) für MDEBUG als Pascal-String }
  145. {            regs      : Registerwerte für den Aufruf           }
  146. {                                                               }
  147. { Ausgabe:   regs      : evtl. geänderte Registerwerte          }
  148. {                                                               }
  149. { Bes.:      Benötigt die Routine CHECKMD, setzt temporär die   }
  150. {            Interrupts 20h, 21h und 27h um.                    }
  151. {            Besondere Zeichen im String für die Befehle:       }
  152. {            ^  ->> falls das folgende Zeichen im Intervall     }
  153. {                   zwischen 'A' und 'Z' liegt, wird der Wert   }
  154. {                   der entsprechenden Taste mit CTRL übergeben.}
  155. {                   (Ansonsten wird es so übergeben)            }
  156. {                   z.B. '^M' entspricht der Taste <RETURN>     }
  157. {                        '^m' wird nicht konvertiert!           }
  158. {            #  ->> falls dem Zeichen '#' mindestens eine Ziffer}
  159. {                   folgt, wird/werden diese als SCAN-Code einer}
  160. {                   Taste interpretiert und übergeben (Ansonsten}
  161. {                   wird das Zeichen so übergeben)              }
  162. {                   z.B.                                        }
  163. {                   '#4400' ist der SCAN-Code der Taste <F10>   }
  164. {                   '#0DM' wird übergeben als <RETURN> gefolgt  }
  165. {                   von der Taste 'M'                           }
  166. {                   '#W' wird so übergeben!                     }
  167. {---------------------------------------------------------------}
  168.  
  169. { Deklaration der Prozedur (FAR!): }
  170.  
  171. {$F+}
  172. FUNCTION MDCMD(    CheckInts: BOOLEAN;
  173.                VAR regs     : REGISTERS;
  174.                VAR commands : STRING):BYTE; EXTERNAL;
  175.  
  176. {$F-}
  177.  
  178. {---------------------------------------------------------------}
  179. { Hilfs-Routinen                                                }
  180.  
  181. {---------------------------------------------------------------}
  182. { Einbinden der externen Assembler-Routinen zum Erstellen von   }
  183. { Hexstrings                                                    }
  184.  
  185. {$L konvert.obj}
  186.  
  187. {$F+ ebenfalls als FAR! }
  188. {---------------------------------------------------------------}
  189. { HexByte                                                       }
  190. {                                                               }
  191. { Funktion:  Umwandeln eines Bytes in einen 2-stelligen         }
  192. {            Hexstring                                          }
  193. {                                                               }
  194. { Eingabe:   zahl - Umzuwandelndes Byte                         }
  195. {                                                               }
  196. { Ausgabe:   Als Funktions-Wert wird der Hexstring zurückgegeben}
  197. {---------------------------------------------------------------}
  198.  
  199. FUNCTION HexByte(zahl : BYTE):STRING; EXTERNAL;
  200.  
  201. {---------------------------------------------------------------}
  202. { HexWord                                                       }
  203. {                                                               }
  204. { Funktion:  Umwandeln eines Wortes in einen 4-stelligen        }
  205. {            Hexstring                                          }
  206. {                                                               }
  207. { Eingabe:   zahl - Umzuwandelndes Wort                         }
  208. {                                                               }
  209. { Ausgabe:   Als Funktions-Wert wird der Hexstring zurückgegeben}
  210. {---------------------------------------------------------------}
  211.  
  212. FUNCTION Hexword(zahl : WORD):STRING; EXTERNAL;
  213.  
  214. {$F-}
  215.  
  216. {---------------------------------------------------------------}
  217. { LeseTaste                                                     }
  218. {                                                               }
  219. { Funktion:  Ausgabe einer Wartemeldung und lesen einer Taste   }
  220. {---------------------------------------------------------------}
  221.  
  222. PROCEDURE LeseTaste;
  223.  
  224. VAR
  225.  c : CHAR;
  226.  
  227. BEGIN
  228.  WHILE keypressed DO c:=ReadKey;
  229.  write(CR_LF,'Bitte eine Taste drücken [ESC für Programm-Ende] ...');
  230.  c:=ReadKey;
  231.  writeln(CR_LF);
  232.  IF c=CHAR($1B) THEN
  233.  BEGIN
  234.   writeln;
  235.   writeln('Programm durch Benutzer abgebrochen!');
  236.   writeln;
  237.   halt(255);
  238.  END;
  239. END;
  240.  
  241. {---------------------------------------------------------------}
  242. { Prozeduren zur Demonstration der Nutzung von MDEBUG           }
  243.  
  244. {---------------------------------------------------------------}
  245. { CheckMDEBUGError                                              }
  246. {                                                               }
  247. { Funktion:  Testen, ob der Aufruf von MDEBUG erfolgreich war   }
  248. {                                                               }
  249. { Eingabe:   RetCode = von MDEBUG gelieferter RETURN-Code       }
  250. {                                                               }
  251. { Bes.:      Falls ein Fehler auftrat, wird das Programm nach   }
  252. {            der Ausgabe einer Fehler-Meldung beendet           }
  253. {---------------------------------------------------------------}
  254.  
  255. PROCEDURE CheckMDEBUGError(RetCode:WORD);
  256.  
  257. BEGIN
  258.  IF (RetCode AND $FF00) = $FF00 THEN
  259.  BEGIN
  260.   writeln;
  261.   writeln(BELL,'*** Fehler beim Aufruf von MDEBUG aufgetreten! ***');
  262.   writeln;
  263.  END;
  264.  IF RetCode=$FFFF THEN
  265.  BEGIN
  266.   writeln('Fehler: Aufruf von MDEBUG ist nicht erlaubt!');
  267.   writeln('        Zur Behebung des Fehlers sollten Sie MDEBUG mit ');
  268.   writeln('        dem Parameter ''SET'' einmal aufrufen!');
  269.   writeln(CR_LF);
  270.   halt(255);
  271.  END
  272.  ELSE
  273.  IF RetCode=$FFFE THEN
  274.  BEGIN
  275.   writeln('Fehler: Falsches Passwort eingegeben!');
  276.   writeln(CR_LF);
  277.   halt(255);
  278.  END
  279.  ELSE
  280.  IF RetCode=$FFFD THEN
  281.  BEGIN
  282.   writeln('Fehler: Falscher Bildschirm-Modus!');
  283.   writeln('        MDEBUG kann, falls kein Bildschirmtreiber geladen ist,');
  284.   writeln('        nur in einem Textmodus mit mindestens 80 Zeichen pro');
  285.   writeln('        Zeile und mindestens 25 Zeilen pro Seite aufgerufen');
  286.   writeln('        werden!');
  287.   writeln(CR_LF);
  288.   halt(255);
  289.  END
  290.  ELSE
  291.  IF RetCode=$FFFC THEN
  292.  BEGIN
  293.   writeln('Fehler: Falsche Funktionsnummer für den User-Int verwendet!');
  294.   writeln(CR_LF);
  295.   halt(255);
  296.  END
  297. END;
  298.  
  299. {---------------------------------------------------------------}
  300. { GetMDEBUGPasswort                                             }
  301. {                                                               }
  302. { Funktion:  Aufruf von MDEBUG zur Ermittlung, ob ein Passwort  }
  303. {            aktiv ist                                          }
  304. {---------------------------------------------------------------}
  305.  
  306. PROCEDURE GetMDEBUGPasswort;
  307.  
  308. VAR
  309.  k : BYTE;
  310.  
  311. BEGIN
  312.   writeln('--> Aufruf von MDEBUG zur Ermittlung, ob ein Passwort aktiv ist');
  313.   writeln('    (Funktion 06h des Userints)');
  314.   writeln;
  315.   regs.ax:=$0600;             { keine Abfrage des Passwortes    }
  316.   CallMD(Userint,regs);
  317.  
  318.   IF regs.al <> $0 THEN
  319.   BEGIN
  320.    writeln('    Passwort von MDEBUG ist aktiv, für die folgenden Aufrufe kann');
  321.    writeln('    das Passwort eingegeben werden. Falls kein Passwort eingegeben');
  322.    writeln('    wird, muß bei jedem Aufruf das Passwort neu eingegeben werden.');
  323.    writeln;
  324.    write  ('    Passwort (<RETURN> -> kein Passwort): ');
  325.  
  326.    k:=textattr;
  327.    textattr:=0;               { Passwort unsichtbar eingeben!   }
  328.    readln(Passwort);
  329.    textattr:=k;
  330.    IF passwort='' THEN
  331.     passwort:=#0;
  332.   END
  333.   ELSE
  334.    writeln('--> Passwort von MDEBUG nicht aktiv oder nicht installiert.');
  335.   writeln;
  336.   Lesetaste;
  337.   writeln;
  338. END;
  339.  
  340. {---------------------------------------------------------------}
  341. { ShowRegs                                                      }
  342. {                                                               }
  343. { Funktion:  Ausgabe der Inhalte der Register                   }
  344. {                                                               }
  345. { Eingabe:   which : Auszugebender Record                       }
  346. {---------------------------------------------------------------}
  347.  
  348. PROCEDURE ShowRegs(which:REGISTERS);
  349.  
  350. BEGIN
  351.  WITH which DO
  352.  BEGIN
  353.   writeln('     AX = $',hexword(ax),
  354.           '     BX = $',hexword(bx),
  355.           '     CX = $',hexword(cx),
  356.           '     DX = $',hexword(dx));
  357.   writeln('     SI = $',hexword(si),
  358.           '     DI = $',hexword(di),
  359.           '     BP = $',hexword(bp),
  360.           '     DS = $',hexword(ds),
  361.           '     ES = $',hexword(es));
  362.  END;
  363. END;
  364.  
  365. {---------------------------------------------------------------}
  366. { Normaler Aufruf von MDEBUG                                    }
  367.  
  368. PROCEDURE CallMDEBUG;
  369.  
  370. BEGIN
  371.   writeln('--> Aufruf von MDEBUG ohne Änderung der Registerwerte: ');
  372.   writeln('    (Funktion 04h des Userints)');
  373.   writeln;
  374.   regs.ax:=$0400;
  375.  
  376.  
  377.   regs.ds:=seg(passwort);
  378.   regs.si:=ofs(passwort)+1;   { DS:SI zeigt auf das Passwort    }
  379.  
  380.   writeln('    Register vor dem Aufruf: ');
  381.   ShowRegs(regs);
  382.  
  383.   LeseTaste;
  384.  
  385.   CallMD(Userint,regs);
  386.   CheckMDEBUGError(regs.AX);
  387.  
  388.   writeln('    Register nach dem Aufruf: ');
  389.   ShowRegs(regs);
  390.  
  391. END;
  392.  
  393. {---------------------------------------------------------------}
  394. { Normaler Aufruf von MDEBUG                                    }
  395.  
  396. PROCEDURE CallMDEBUG1;
  397.  
  398. BEGIN
  399.   writeln('--> Aufruf von MDEBUG zur Anzeige einer Variablen (hier eines Strings): ');
  400.   writeln('    (Funktion 03h des Userints)');
  401.   writeln('    Bitte einen String eingeben: ');
  402.   write  ('    ');
  403.   readln(teststring);
  404.   writeln;
  405.   regs.ax:=$0300;
  406.  
  407.   regs.es:=Seg(TestString);
  408.   regs.di:=ofs(TestSTring);   { ES:DI zeigt auf die Variable    }
  409.  
  410.   regs.ds:=seg(passwort);
  411.   regs.si:=ofs(passwort)+1;   { DS:SI zeigt auf das Passwort    }
  412.  
  413.   writeln;
  414.   writeln('    Register vor dem Aufruf: ');
  415.   ShowRegs(regs);
  416.  
  417.   LeseTaste;
  418.  
  419.   CallMD(Userint,regs);
  420.   CheckMDEBUGError(regs.AX);
  421.  
  422.   writeln('    Register nach dem Aufruf: ');
  423.   ShowRegs(regs);
  424.  
  425.   writeln;
  426.   writeln('    Inhalt des TestStrings nach dem Aufruf: ');
  427.   writeln('    ',Teststring);
  428. END;
  429.  
  430. {---------------------------------------------------------------}
  431. { Normaler Aufruf von MDEBUG                                    }
  432.  
  433. PROCEDURE CallMDEBUG2;
  434.  
  435. VAR
  436.  temp : BYTE;
  437.  okay : BOOLEAN;
  438.  
  439. BEGIN
  440.  
  441.  REPEAT
  442.   writeln('--> Aufruf von MDEBUG zur Ausführung von Befehlen: ');
  443.   writeln('    (Die Interrupts 20h und 27h und die Funktionen 0h und 31h des');
  444.   writeln('     Interrupts 21h können NICHT ausgeführt werden!)');
  445.  
  446.   regs.ds:=seg(passwort);
  447.   regs.si:=ofs(passwort)+1;  { DS:SI zeigt auf das Passwort    }
  448.  
  449.   regs.ax:=$0700;
  450.   CallMD(Userint,regs);
  451.   CheckMDEBUGError(regs.ax);
  452.  
  453.   IF regs.al <= 3 THEN
  454.   BEGIN
  455.     highvideo;
  456.     writeln('    ***** MDEBUG startet ', mdmessages[regs.al]);
  457.     normvideo;
  458.   END;
  459.   writeln('    Bitte die Tasten bzw. die Befehlszeile eingeben (* <RETURN> für Ende): ');
  460.   write  ('    ');
  461.   readln(teststring);
  462.   okay:= (teststring = '*');
  463.   writeln;
  464.  
  465.   IF NOT OKAY THEN
  466.   BEGIN
  467.    regs.ds:=seg(passwort);
  468.    regs.si:=ofs(passwort)+1;  { DS:SI zeigt auf das Passwort    }
  469.  
  470.    writeln;
  471.    writeln('    Register vor dem Aufruf: ');
  472.    ShowRegs(regs);
  473.  
  474.    LeseTaste;
  475.  
  476.    temp := MDCmd(TRUE,regs,teststring);
  477.                               { Falls die Interrupts 20h, 27h   }
  478.                               { und die Funktionen 0 und 31h    }
  479.                               { des Interrupts 21h ausgeführt   }
  480.                               { werden sollen, muß als erster   }
  481.                               { Parameter FALSE eingegeben      }
  482.                               { werden!                         }
  483.    CheckMDEBUGError(Regs.AX);
  484.  
  485.    writeln('    Register nach dem Aufruf: ');
  486.    ShowRegs(regs);
  487.  
  488.    writeln;
  489.   END
  490.  
  491.  UNTIL okay
  492. END;
  493.  
  494. {---------------------------------------------------------------}
  495. { Ermitteln des Status von MDEBUG                               }
  496.  
  497. PROCEDURE GetMDEBUGStatus;
  498.  
  499. BEGIN
  500.  
  501.  regs.ds:=seg(passwort);
  502.  regs.si:=ofs(passwort)+1;    { DS:SI zeigt auf das Passwort    }
  503.  
  504.  regs.ah:=$0;
  505.  CallMD(Userint,regs);
  506.  CheckMDEBUGError(regs.AX);
  507.  StatusPtr:=ptr(regs.ds,regs.si);
  508.  writeln('--> Status von MDEBUG     : ');
  509.  writeln('    (Funktion 0h des Userints)');
  510.  writeln('    Adresse der Statustabelle: $',hexword(regs.ds),':$',hexword(regs.si));
  511.  writeln;
  512.  WITH StatusPtr^ DO
  513.  BEGIN
  514.   writeln('    PSP von MDEBUG         : $',hexword(psp));
  515.   writeln('    alter Int08            : $',hexword(seg(int08^)),':$',HexWord(ofs(int08^)));
  516.   writeln('    alter Int09            : $',hexword(seg(int09^)),':$',hexword(ofs(int09^)));
  517.   writeln('    Int16 von MDEBUG       : $',hexword(seg(int16^)),':$',Hexword(ofs(int16^)));
  518.   writeln('    Version:               : ',version);
  519.  END;
  520.  WITH regs DO
  521.  BEGIN
  522.   writeln('    Monitor-Adresse        : $',hexword(es),':$',hexword(di));
  523.   writeln('    Monitor-Farbe          : $',hexbyte(ch));
  524.   writeln('    Monitor-Startzeile     : $',hexbyte(bh));
  525.   writeln('    Interpreter-Farbe      : $',hexbyte(cl));
  526.   writeln('    Interpreter-Startzeile : $',hexbyte(bl));
  527.   writeln('    Basis-Prozess-Nummer   : $',hexbyte(dh));
  528.   writeln('    Scan-Code des Hotkeys  : $',hexbyte(ah));
  529.   writeln('    ASCII-Code des Hotkeys : ','''',CHAR(al),'''');
  530.   writeln;
  531.  
  532.   write('    Aufruf über den Hotkey: ');
  533.   IF (dl AND $04) <> 0 THEN   write('<CTRL>-');
  534.   IF (dl AND $08) <> 0 THEN   write('<ALT>-');
  535.   IF (dl AND $02) <> 0 THEN   write('<LeftSHFIT>-');
  536.   IF (dl AND $01) <> 0 THEN   write('<RightShift>-');
  537.   writeln('<',char(al),'>');
  538.   writeln;
  539.  END;
  540.  
  541.  writeln;
  542.  LeseTaste;
  543. END;
  544.  
  545. {---------------------------------------------------------------}
  546. { Ermitteln der Adresse der HilfsRegister von MDEBUG            }
  547.  
  548. PROCEDURE GetMDEBUGRegAdress;
  549.  
  550. VAR
  551.  k                : BYTE;
  552.  
  553. BEGIN
  554.  writeln('--> Adressen und Inhalt der HilfsRegister: ');
  555.  writeln('    (Funktion 01h des Userints)');
  556.  writeln;
  557.  regs.ah:=$01;
  558.  
  559.  regs.ds:=seg(passwort);
  560.  regs.si:=ofs(passwort)+1;    { DS:SI zeigt auf das Passwort    }
  561.  
  562.  CallMD(Userint,regs);
  563.  CheckMDEBUGError(Regs.AX);
  564.                               { ES:DI zeigt auf R1              }
  565.                               { ->> Array beginnt bei ES:DI-2   }
  566.  HilfsRegisterPtr:=ptr(regs.es,regs.di-2);
  567.  FOR k:=0 TO 8 DO
  568.  BEGIN
  569.   writeln('    Register R',k,' bei $',hexword(regs.es),':$',hexword(regs.di),' -> $',
  570.            hexword(HilfsRegisterPtr^[k]));
  571.   regs.di:=regs.di+2;
  572.  END;
  573.  writeln;
  574.  lesetaste;
  575. END;
  576.  
  577. {---------------------------------------------------------------}
  578. { Macro zur Ermittlung der Flags                                }
  579. {                                                               }
  580. { Funktionswert: Inhalt des Flag-Registers                      }
  581. {---------------------------------------------------------------}
  582.  
  583. FUNCTION GetFlags:WORD;
  584. INLINE($9C/     { PUSHF  }
  585.        $58);    { POP AX }
  586.  
  587. {---------------------------------------------------------------}
  588. { Hauptprogramm                                                 }
  589. {---------------------------------------------------------------}
  590.  
  591. BEGIN
  592.  clrscr;
  593.  Erklaerung:=_Erklaerung;
  594.  passwort:='????';
  595.  passwort:='';
  596.  
  597.  regs.ax:=0;                  { Registerwerte vorbesetzen       }
  598.  regs.bx:=0;
  599.  regs.cx:=0;
  600.  regs.dx:=0;
  601.  regs.ds:=DSeg;
  602.  regs.es:=Dseg;
  603.  regs.si:=0;
  604.  regs.di:=0;
  605.  regs.flags:=GetFlags;        { Wichtig!                        }
  606.  
  607.  writeln;
  608.  writeln('                 ********************************');
  609.  writeln('                 *** Demo-Programm für MDEBUG ***');
  610.  writeln('                 ********************************');
  611.  writeln;
  612.  Userint:=CheckMD;
  613.  IF (Userint = 0) OR (Userint = $FF) THEN
  614.  BEGIN
  615.   writeln('Fehler: MDEBUG nicht geladen, oder kein Userint installiert');
  616.   halt(255);
  617.  END
  618.  ELSE
  619.  BEGIN
  620.   writeln('-> MDEBUG geladen, der Userint ist der Interrupt Nr. ',
  621.               Userint,' (Hexadezimal: $',hexbyte(userint),')');
  622.   writeln;
  623.   writeln('-> Aufrufe von MDEBUG über den Userint');
  624.   writeln;
  625.  
  626.   GetMDEBUGPasswort;
  627.   writeln;
  628.   GetMDEBUGStatus;
  629.   writeln;
  630.   GetMDEBUGRegAdress;
  631.   writeln;
  632.   callMDEBUG;
  633.   writeln;
  634.   callMDEBUG1;
  635.   writeln;
  636.   callMDEBUG2;
  637.   writeln;
  638.   writeln('***** Demo beendet. *****');
  639.  END;
  640. END.
  641.  
  642. {---------------------------------------------------------------}
  643.  
  644.