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