Debugger für XProfan

Willkommen bei der Hilfe des Debuggers für XProfan

Einführung

• Grundlagen JEUQFG

• Hinweise vor der Benutzung CVZBO

Das Programm

• Die Benutzeroberfläche JEUQGL

• Der Reiter SourceCode Scribble40

• Der Reiter Output Scribble30

• Der Reiter Process/Threads Scribble50

• Der Reiter DLLs Scribble60

• Der Reiter Exceptions/DebugErrors Scribble70

• Menüpunkte Scribble90

• Tastenkürzel CVXCO

• Aufruf über die Kommandozeile CVZ0O

Beispiele

• Der Debug-Vorgang JEUQML

• Befehlsfolgen im Einzelschritt MM7XX4

• Debuggen von Include-Dateien und Units MM7YS4

• Debuggen mit Ereignissen MM7YW4

• Debuggen von Programm mit Callback-Funktionen MM7YX4

• Debuggen von großen Programmen MM7ZS4

• Debuggen von objektorientierten Programmen MM7ZT4

• Mehrere Befehle in einer Zeile MM7ZV4

• Verwenden der Direktive $B/$D MM7ZX4

Erweiterungen

• PrfDebug-Unit zur optimaleren Unterstützung CVYAO

• Die Verwendung der PrfDebug-Unit CVZCO

Sonstiges

• Weiterentwicklung MM7ZW4

• Einschränkungen und Systemvoraussetzungen MM7YV4

• Tips und Tricks MM7ZR4

• Copyright und Gewährleistungsausschluss MM7XV4

Created with the Personal Edition of HelpNDoc: Generate EPub eBooks with ease

Dipl.-Ing. Stefan Schnell


Grundlagen

Was ist ein Bug?

Es ist ein Programmierfehler, aufgrund eines Entwurfs- oder Implementierungsfehlers, der sich erst zur Laufzeit eines Programms offenbart.

Was ist eigentlich ein Debugger?

Der Debugger ist ein Programm, das die Ausführung von Programmen überwacht. Ein Programmierer wird damit in die Lage versetzt den Ablauf Schritt für Schritt auszuführen und sich diesen genau zu betrachten, um so Bugs einfacher aufzuspüren, d.h. die Lokalisierung und Beseitigung von Fehlern vorzunehmen.

Der Begriff 'Debugger' hat einen erwähnenswerten Ursprung, der uns die Sinnhaftigkeit eines solchen Programms noch viel besser verdeutlicht:

Zu Zeiten als die Computer noch aus Elektronenröhren bestanden und die Größe einer Turnhalle hatten verirrte sich ein Käfer (engl. Bug) in einen solchen. Als der Käfer zwischen den Röhren herumkrabbelte verursachte er einen Kurzschluß und verschmorte. Dies führte dazu dass der Computer nicht die erwarteten Ergebnisse produzierte und die Bediener sich auf die Suche der Fehlerursache machten. Als sie den verschmorten Käfer entdeckten, entfernten sie diesen, 'De-Bug'-ten den Computer, und behoben so die Fehlerursache. Aus diesem Grund wird ein solches Programm heute Debugger genannt. Ob sich diese Geschichte so, oder so ähnlich, zugetragen hat, weiß allerdings keiner so genau.

Der Debugger für XProfan ist ein dynamischer Debugger, da er die Fehlerursachenermittlung während der Laufzeit des Programms vornimmt. Die Anwendung kann ganz normal gestartet und mir ihr so gearbeitet werden, wie es für den Benutzer möglich ist. Zusätzlich kann jedoch der Code eingesehen, jedoch nicht geändert werden. Der Debugger erlaubt die Überwachung und kontrollierte Ausführung auf Quellsprachenebene. Mit ihm kann Einzelschrittausführung durchgeführt werden, sowie Haltepunkte (Quelltexthaltepunkte und bedingte Haltepunkte, mit der beigefügten Unit) definiert, als auch Umgebungsinformationen des ausgeführten Programmes angezeigt werden. Nach Anhalten oder Absturz eines Programmes kann genau die aktuelle Stelle ermittelt sowie eine Auswertung der bisher ausgeführten Code-Zeilen durchgeführt werden.

• Zum technischen Hintergrund des Debuggers CVY_O

Fehlerkategorien

In einem Programm können wir es mit unterschiedlichen Fehlerarten zu tun haben:

• syntaktische Fehler,

• Laufzeitfehler oder

• logische Fehler

Syntaktische Fehler

Stößt der Interpreter auf einen Befehl den er nicht kennt, oder auf Argumente die nicht den richtigen Typ haben, sowie fehlen oder zuviel sind, so erzeugt er einen ERROR. Diese Fehler lassen sich sehr leicht lokalisieren, denn aus der Meldung des Interpreters geht die Ursache meistens eindeutig hervor. Diese Fehler nennt man Syntax-Fehler. Ein Indiz für ein syntaktisch einwandfreies Programm ist eine fehlerfreie Kompilierung.

Laufzeitfehler

Laufzeitfehler sind keine direkten Fehler im Source-Code des Programms. Sie sind auf äußere Umstände zurück zu führen, z.B. zu wenig freier Speicher auf der Festplatte oder eine falsche Eingabe des Benutzers. Im Regelfall führt ein Laufzeitfehler zu einem undefinierten Verhalten des Programmes, welches nicht selten in einem Absturz mündet bzw. das Programm vom Betriebssystem terminiert wird.

Logische Fehler

Führt ein einwandfrei laufendes Programm zu einem nicht erwarteten Ergebnis, so ist hier ein logischer Fehler im Spiel, d.h. das z.B. eine falsche Aktion ausgeführt wird. Diese Fehlerart lässt sich teilweise nur sehr schwer aufspüren, hierfür ist es notwendig das Programm Schritt für Schritt auszuführen und die Bedingungen und Variablen genau zu überprüfen.

Created with the Personal Edition of HelpNDoc: Generate EPub eBooks with ease


Die Benutzeroberfläche

Die Benutzeroberfläche des XProfan-Debuggers besteht, wie bei Windows-Programmen üblich, aus einem Fenster mit einer Titelzeile, Menüzeile und Toolbar im Kopfbereich, sowie einer Statuszeile, mit drei Feldern, im Fußbereich. Im mittleren Bereich sind die Ausgabebereiche des Debuggers, nach Themen mit Reitern geordnet, sowie ein Direktfenster:

• SourceCode Scribble40 - Hier wird der augenblicklich geladene Quellcode angezeigt.

• Output Scribble30 - In diesem Bereich werden die von XProfan, mit dem Windows-API-Befehl OutputDebugString, ausgegebenen Zeichenketten angezeigt.

• Process/Threads Scribble50 - Hier werden die vom Debugger bzw. dem geladenen Programm gestarteten Prozesse und Threads angezeigt.

• DLLs Scribble60 - Hier werden die vom Debugger bzw. dem ausgeführten Programm geladenen Libraries angezeigt.

• Exceptions/DebugErrors Scribble70 - Sobald eine Ausnahme oder ein Fehler auftritt, wird sie in diesem Bereich angezeigt.

Im mittleren Teil gibt es ein Direktfenster, hier werden alle Zeichenketten ausgegeben die mit dem XProfan-Befehl DebugOut oder dem Windows-API-Befehl OutputDebugString im XProfan-Programm ausgegeben werden. Auch die mit $B (Break) und $D (Debug) auszugebenden Texte werden in diesem Fenster angezeigt.

Hinweis: Das Direktfenster, das auch editierbar ist, wird von den Anzeigebereichen durch einen Splitter getrennt, d.h. dass die Größe der Ausgabebereiche sowie des Direktfensters beliebig variiert werden kann.

{bmc bm0.SHG}

Hinweis: Durch Anklicken der entsprechenden Bereiche in der obigen Grafik werden Erklärungen angezeigt oder zur weiteren Hilfe verzweigt.

Created with the Personal Edition of HelpNDoc: Free iPhone documentation generator


Output

In diesem Bereich werden die von XProfan, mit dem Windows-API-Befehl OutputDebugString, ausgegebenen Zeichenketten angezeigt. Dieser Befehl wird vom XProfan-Interpreter bzw. -Runtime intern verwendet, sobald das Programm den Befehl @Set("DebugMode", 2) aufruft.

Created with the Personal Edition of HelpNDoc: Free HTML Help documentation generator


SourceCode

Im SourceCode-Bereich wird der augenblicklich geladene Quellcode angezeigt und in der Output-Zeile wird die aktuelle Ausgabe des Output-Bereiches angezeigt.

Der zu ladende Quellcode wird über die Ausgabe des Befehles FILE: bestimmt. Die hier benannte Datei wird in das Fenster geladen.

Hinweis: Wird bei geladenem Quellcode und aktivem Debug-Prozeß die rechte Maustaste im Fenster betätigt, so öffnet sich ein Popup-Menü. In diesem Menü gibt es den Menüpunkt 'Ausführen einschließlich Cursor-Position'. Wird dieser Menüpunkt gewählt so wird das Programm bis zur Cursor-Position ausgeführt und nach der Zeile, in der augenblicklich der Cursor steht, wieder gestoppt.

Wichtiger Hinweis: Es ist wichtig, den Cursor, vor Ausführung des Menüpunktes, auf die Zeile zu positionieren die erreicht werden soll. Dies geschieht mit einem Mausklick der linken Maustaste. Die aktuell markierte Zeile verliert dabei ihre Markierung.

Created with the Personal Edition of HelpNDoc: Easily create HTML Help documents


Process/Threads

Hier werden die vom geladenen Programm gestarteten Prozesse und Threads mit detaillierten Informationen angezeigt.

Process

Wird ein Prozess gestartet, so wird seine Basis-Adresse sowie der benötigte Speicher angezeigt.

Wird ein Prozess beendet, so wird der Exitcode angezeigt.

Threads

Wird ein Thread gestartet, so wird seine Basis-Adresse angezeigt.

Wird ein Thread beendet, so wird der Exitcode angezeigt.

Created with the Personal Edition of HelpNDoc: Free Qt Help documentation generator


DLLs

Im Bereich DLLs werden die vom Debugger bzw. dem ausgeführten Programm geladenen Libraries (DLL = Dynamic Link Library) angezeigt.

Wird eine DLL geladen, so wird ihr Name, ihre Adresse sowie der benötigte Speicher angezeigt.

Wird eine DLL entladen, so wird angezeigt dass eine DLL mit der Adresse entladen wurde.

Created with the Personal Edition of HelpNDoc: Free PDF documentation generator


Exceptions/DebugErrors

Im diesem Bereich werden Ausnahmen oder Fehler angezeigt.

Tritt ein Ausnahmeereignis (Exception) ein oder ein Debugging-Fehler auf, so wird dieser hier detailliert angezeigt. Auch Programmfehler, die XProfan mit ERROR: kennzeichnet, werden hier ausgegeben.

Hinweis: Zum Start eines jeden Programmes wird immer das Debug-Ausnahmeereignis mit dem Code EXCEPTION_BREAKPOINT angezeigt. Dieses Event signalisiert dass der Debugger seine Arbeit aufgenommen hat.

Created with the Personal Edition of HelpNDoc: Easily create HTML Help documents


Der Debug-Vorgang

Mit dem Beispielprogramm MM7XW4 soll nun ein Debug-Vorgang etwas verdeutlicht werden:

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich wird die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen und Schritt für Schritt das Programm ausführen.

Nach viermaligen Betätigen der F8-Taste sieht der Debugger im SourceCode-Bereich wie folgt aus:

Der Output-Bereich sieht wie folgt aus:

• Nun die Taste F9 oder in der ToolBar das Icon 'Bis über das nächste Return/EndProc' [image] betätigen. Die Procedure Hugo ist vollständig ausgeführt worden und das Programm wurde nach dem EndProc gestoppt.

Hinweis: Im Direktfenster werden die Zahlen, die in der Prozedur mit DebugOut definiert wurden, angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen. Es wird das Kommando @Set("DebugMode", 0) ausgeführt. Die folgenden Programmteile werden nun ohne Debug-Ausgabe ausgeführt.

Hinweis: Im Direktfenster des Output-Bereiches werden die Zahlen, die mit DebugOut definiert wurden, angezeigt

• In Zeile 21 ist das Kommando @Set("DebugMode", 2) , welches dazu führt, dass die Programmausführung gestoppt wird.

• Jetzt die Taste F10 oder in der ToolBar das Icon 'Bis über das nächste Wend/EndWhile/Until' [image] betätigen. Jetzt wird die folgende Schleife schrittweise ausgeführt.

Nach zehnmaligen Betätigen sieht das Resultat wie folgt aus:

• Nach zweimaligen Betätigen der F8-Taste oder des Icons 'Nächster Schritt' [image] in der Toolbar wird das Programm beendet und wir haben den gleichen Status wie in Punkt 3 dieser Beschreibung.

Created with the Personal Edition of HelpNDoc: Full-featured Kindle eBooks generator


Menüpunkte

#Datei

• Programm laden

Es kann ein XProfan-SourceCode (PRF), -Kompilat (PRC) oder -Program (EXE) zum Debuggen ausgewählt werden.

• Debug-Ergebnisse exportieren

Es wird eine gleichnamige, wie die geladene, Datei mit der Extension TXT erzeugt, in der die Ergebnisse des Debug-Vorganges gespeichert werden.

• Beenden

Beendet den Debug-Vorgang und den Debugger.

#Debuggen

• Starten/Ausführen

Startet den Debug-Vorgang, oder, wenn er bereits aktiv ist, führt das Programm ohne Pause weiter aus.

• Nächster Schritt

Führt den nächsten Befehl des Programms aus.

• Bis über das nächste Return/EndProc

Führt das Programm ohne Pause weiter aus, bis der Befehl Return oder EndProc ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

• Bis über das nächste Wend/EndWhile/Until

Führt das Programm ohne Pause weiter aus, bis der Befehl Wend oder EndWhile ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

• Bis zum nächsten Ereignis

Führt das Programm ohne Pause weiter aus, bis ein Ereignis auftritt (Process/Thread wird geladen oder terminiert, DLL wird geladen oder entladen, DebugException tritt auf). Nach Auftreten des Ereignisses wird die Programmausführung gestoppt.

• Bis über das Kommando...

Öffnet ein weiteres Fenster, in dem ein beliebiges Kommando eingetragen werden kann. Nach Betätigung des Ok-Buttons wird das Programm ohne Pause weiter ausgeführt, bis das Kommando erreicht ist. Nach der Ausführung dieses Kommandos wird das Programm gestoppt.

• Unterbrechen

Unterbricht die automatische Ausführung des Debug-Vorganges.

• Beenden

Beendet den Debug-Vorgang.

#Optionen

• XProfan-Verzeichnis

Hier werden die Pfade zum Interpreter und zum Runtime-Modul von XProfan eingestellt. Diese Einstellung sollte vor der ersten Verwendung durchgeführt werden.

• Debugger immer im Vordergrund

Der Debugger wird immer im Vordergrund gehalten, auch wenn er nicht den Fokus besitzt.

• Befehlsfolgen im Einzelschritt ausführen

Die Ausführung von Befehlsfolgen, z.B. 'Bis über das nächste EndWhile', werden im Einzelschritt ausgeführt. Damit kann der Ablauf, ohne dauerndes Betätigen einer Taste, bequem überwacht werden. Alle 500 Millisekunden wird ein Befehl ausgeführt, sprich 2 Befehle pro Sekunde.

• Akustisches Fehlersignal

Es ertönt ein akustisches Signal wenn XProfan auf einen Fehler stößt und ERROR: ausgibt.

• Ausnahmeüberwachung

Es wird eine Ausnahmeüberwachung aktiviert bzw. deaktiviert. Treten mehr als 32 Ausnahmen (Exceptions) innerhalb von 16 Sekunden auf, d.h. im Durchschnitt 1 Ausnahme in einer halben Sekunde, so wird die Programmausführung angehalten und der Anwender kann wählen ob die Ausführung fortgesetzt werden soll oder abgebrochen.

• Bei Direktive $B/$D immer stoppen

Wird in einem Programm die Direktive $B (Break) oder $D (Debug) verwendet, so kann mit diesem Menüpunkt entschieden werden, ob die Programmausführung, nach Erreichen des Befehls, gestoppt wird.

#Hilfe

• Hilfe

Zeigt diese Hilfe an.

• Info über

Zeigt Informationen über den Debugger an.

Created with the Personal Edition of HelpNDoc: Free EPub producer


Tastenkürzel

Alt-C = Alle Fenster des Debuggers leeren.

Alt-D = Das Stoppen der Programmausführung, bei Erreichen der Direktive $B (Break) oder $D (Debug), wird an- oder abgeschaltet.

Alt-E = Die Ausführung von Befehlsfolgen im Einzelschritt wird an- oder abgeschaltet.

Alt-F = Akustisches Fehlersignal wird an- oder abgeschaltet.

Alt-V = Dass das Debugger-Fenster immer im Vordergrund steht (AllwaysOnTop) wird an- oder abgeschaltet.

Alt-W = Die Ausnahmeüberwachung wird an- oder abgeschaltet.

Alt-X = Beendet den Debug-Vorgang und den Debugger.

Strg-G = Öffnet oder schließt das Direktfenster.

F5 = Startet den Debug-Vorgang, oder, wenn er bereits aktiv ist, führt das Programm ohne Pause weiter aus.

F8 = Führt den nächsten Befehl des Programms aus.

F9 = Führt das Programm ohne Pause weiter aus, bis der Befehl Return oder EndProc ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

F10 = Führt das Programm ohne Pause weiter aus, bis der Befehl Wend, EndWhile oder Until ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

F11 = Öffnet ein weiteres Fenster, in dem ein beliebiges Kommando eingetragen werden kann. Nach Betätigung des Ok-Buttons wird das Programm ohne Pause weiter ausgeführt, bis das Kommando erreicht ist. Nach der Ausführung dieses Kommandos wird das Programm gestoppt.

F12 = Beendet den Debug-Vorgang.

Pause = Unterbricht die automatische Ausführung des Debug-Vorganges.

Created with the Personal Edition of HelpNDoc: Free help authoring tool


Datei auswählen

Es öffnet sich ein Dialog mit dem eine XProfan-Datei zum Debuggen ausgewählt werden kann.

Created with the Personal Edition of HelpNDoc: Write eBooks for the Kindle


Debuggen starten/Ausführen

Startet den Debug-Vorgang oder, wenn dieser bereits aktiv ist, führt das Programm ohne Pause weiter aus.

Hinweis: Der Startvorgang kann etwas Zeit in Anspruch nehmen, vorallendingen wenn (große) Header-Dateien geladen werden. Es ist unbedingt, vor jeder weiteren Aktion, abzuwarten, dass in der Zeile Output, im SourceCode-Reiter, die Ausgabe FILE: Dateiname angezeigt wird.

Created with the Personal Edition of HelpNDoc: Free EBook and documentation generator


Nächster Schritt

Führt den nächsten Befehl des Programms aus.

Created with the Personal Edition of HelpNDoc: Produce electronic books easily


Bis über das nächste Return/EndProc

Führt das Programm ohne Pause weiter aus, bis der Befehl Return oder EndProc ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

Created with the Personal Edition of HelpNDoc: Easily create iPhone documentation


Bis über das nächste Wend/EndWhile/Until

Führt das Programm ohne Pause weiter aus, bis der Befehl Wend, EndWhile oder Until ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt.

Created with the Personal Edition of HelpNDoc: Free Kindle producer


Bis über das Kommando...

Öffnet ein weiteres Fenster, in dem ein beliebiges Kommando eingetragen werden kann. Nach Betätigung des Ok-Buttons wird das Programm ohne Pause weiter ausgeführt, bis das Kommando erreicht ist. Nach der Ausführung dieses Kommandos wird das Programm gestoppt.

Created with the Personal Edition of HelpNDoc: Free EBook and documentation generator


Debuggen unterbrechen

Wird ein Programmabschnitt ausgeführt, so kann die Ausführung hiermit unterbrochen werden.

Created with the Personal Edition of HelpNDoc: Easy EBook and documentation generator


Debuggen beenden

Beendet den Debug-Vorgang.

Created with the Personal Edition of HelpNDoc: Qt Help documentation made easy


Ausgabefenster löschen

Löscht die Inhalte der Fenster aller Reiter.

Created with the Personal Edition of HelpNDoc: Free Web Help generator


Debugger beenden

Beendet den Debug-Vorgang und den Debugger.

Created with the Personal Edition of HelpNDoc: Write EPub books for the iPad


DebugThread aktiv

Das Feld DebugThread, in der Statuszeile des Programms, zeigt mit einem Ampelsymbol an, ob der DebugThread gerade aktiv ist, dann ist die Ampel grün, ober ob er nicht aktiv ist, dann ist die Ampel außer Betrieb.

Created with the Personal Edition of HelpNDoc: Easily create Qt Help files


Geladene Datei

Das Feld geladene Datei, in der Statuszeile des Programms, zeigt den Namen der geladenen Datei an. Ist noch keine Datei geladen so ist das Feld und das Symbol leer.

Created with the Personal Edition of HelpNDoc: Free EPub and documentation generator


Direktbereich

Hier werden die mit dem XProfan-Befehl DebutOut bzw. dem Windows-API-Befehl OutputDebugString ausgegebenen Zeichenketten angezeigt.

Die Trennung zwischen der normalen Ausgabe und der im Direktbereich geschieht über das Tabulator-Zeichen (@Chr$(9)). Ist dieses in der auszugebenden Zeichenkette enthalten so wird sie in der normalen Ausgabe angezeigt, andernfalls im Direktbereich.

Created with the Personal Edition of HelpNDoc: Free Qt Help documentation generator


Zum technischen Hintergrund des Debuggers

Der Debugger verwendet die Funktionen des Win32-Debug-API. Er öffnet einem eigenen Thread, in dem ein neuer Prozess mit dem zu überwachenden Programm gestartet wird. Der Prozess wird im Debug-Modus ausgeführt und liefert Debug-Informationen über den Zustand des Programmes zurück. Sobald ein Debug-Ereignis (Debug-Event) ausgelöst wird, reagiert der Debugger entsprechend und verarbeitet das Ereignis mit einer entsprechenden Aktion seinerseits.

Der Prozess wird mit der Option DEBUG_ONLY_THIS_PROCESS gestartet und verarbeitet folgende Ereignisse:

• OUTPUT_DEBUG_STRING_EVENT = OutputDebugString wurde aufgerufen

• CREATE_PROCESS_DEBUG_EVENT = Neuer Prozess wurde erzeugt

• EXIT_PROCESS_DEBUG_EVENT = Prozess wurde beendet

• CREATE_THREAD_DEBUG_EVENT = Neuer Thread wurde erzeugt

• EXIT_THREAD_DEBUG_EVENT = Thread wurde beendet

• LOAD_DLL_DEBUG_EVENT = DLL wurde geladen

• UNLOAD_DLL_DEBUG_EVENT = DLL wurde entladen

• EXCEPTION_DEBUG_EVENT = Ausnahmeereignis wurde erkannt

• RIP_EVENT = Debugging-Fehler

Eine genaue Beschreibung dieser Vorgehensweise ist dem Buch Delphi 3-Lösungen von Andreas Kosch zu entnehmen. Es ist im Franzis-Verlag, Feldkirchen 1997 erschienen und hat die ISBN 3-7723-4163-2.

Created with the Personal Edition of HelpNDoc: Free Web Help generator


Copyright und Gewährleistungsausschluss

Copyright

Die Urheberrechte des Programms PrfDebug.exe (Debugger für XProfan) sowie der zugehörigen Hilfe-Datei PrfDebug.hlp (Hilfe für XProfan-Debugger) liegen bei Dipl.-Ing. Stefan Schnell. Eine Veränderung, Dekompilierung oder Disassemblierung ist untersagt.

XProfan ist eine Programmiersprache, deren Urheberrechte bei Roland G. Hülsmann liegen.

Gewährleistungsausschluss

Diese Software wurde mit hoher Sorgfalt erstellt. Das alleine sorgt jedoch nicht für eine fehlerfreie Funktion, da diese auch im hohen Maße von der vorhandenen Soft- und Hardwareinstallation sowie deren Konfiguration abhängig ist. Da gerade diese Kategorie von Software sehr nahe am Betriebssystem arbeitet und potentiell fehlerbehaftete Software ausführt ist mit Reaktionen aller Art zu rechnen. Für eventuell entstehende Schäden wird keine Haftung und keine Verantwortung übernommen. Ein Betrieb dieser Software geschieht vollständig auf eigene Gefahr und ausschließlich auf eigenes Risiko. Durch die Installation und den Betrieb dieser Software stimmt der Betreiber diesen Bedingungen zu.

Created with the Personal Edition of HelpNDoc: Free CHM Help documentation generator


Beispielprogramm

'-Begin-----------------------------------------------------------------

@Set("DebugMode", 2)

Proc Hugo

WhileLoop 1,10,1

Print "Hugo" + @Str$(&Loop)

DebugOut 0, &Loop

EndWhile

EndProc

Cls

Print "Hugo"

Hugo

@Set("DebugMode", 0)

WhileLoop 1,10,1

Print "Bambi" + @Str$(&Loop)

DebugOut 0, &Loop

EndWhile

@Set("DebugMode", 2)

WhileLoop 1,10,1

Print "Fritz" + @Str$(&Loop)

EndWhile

'-End-------------------------------------------------------------------

End

Created with the Personal Edition of HelpNDoc: Free PDF documentation generator


Befehlsfolgen im Einzelschritt

Mit dem Beispielprogramm MM7XW4 sollen nun ein Befehlsfolgen im Einzelschritt etwas verdeutlicht werden:

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Dann den Menüpunkt Optionen - Befehlsfolgen im Einzelschritt ausführen aktivieren oder Alt-E betätigen.

• Dann die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: Jetzt wird das Programm automatisch Schritt für Schritt, mit 2 Befehlen pro Sekunde, ausgeführt.

• Zu einem beliebigen Zeitpunkt die Taste 'Pause' oder den Button 'Debuggen unterbrechen' [image] in der ToolBar betätigen. Die automatische Programmausführung stoppt sofort.

• Zum Beenden des Debug-Vorganges die Taste F12 oder das Icon 'Debuggen beenden' [image] in der ToolBar betätigen.

Created with the Personal Edition of HelpNDoc: Create help files for the Qt Help Framework


PrfDebug-Unit zur optimaleren Unterstützung des Debuggers

'-Begin-----------------------------------------------------------------

'-

'- Unit zur Unterstuetzung des XProfan-Debuggers

'-

'- Autor: Dipl.-Ing. Stefan Schnell

'-

'-----------------------------------------------------------------------

$L

'-External functions--------------------------------------------------

Def @OutputDebugString(1) !"KERNEL32.DLL", "OutputDebugStringA"

'-Procedure Debug.Assert----------------------------------------------

'-

'- Unterbricht die Ausfuehrung entsprechend der Bedingung

'-

'- Aufruf: Debug.Assert BoolscherAusdruck

'-

'---------------------------------------------------------------------

Proc Debug.Assert

If %PCount = 1

Parameters Condition&

If Condition&

@Set("DebugMode", 2)

EndIf

EndIf

EndProc

'-Procedure Debug.Go--------------------------------------------------

'-

'- Setzt die Programmausfuehung fort

'-

'- Aufruf: Debug.Go [Mode]

'-

'---------------------------------------------------------------------

Proc Debug.Go

If %PCount = 0

@Set("DebugMode", 0)

ElseIf %PCount = 1

Parameters Mode&

@Set("DebugMode", Mode&)

EndIf

EndProc

'-Procedure Debug.Print-----------------------------------------------

'-

'- Gibt Text im Direktbereich des Debuggers aus

'-

'- Aufruf: Debug.Print Text[, Mode]

'-

'---------------------------------------------------------------------

Proc Debug.Print

If %PCount = 1

Parameters PrintString$

@OutputDebugString(@Addr(PrintString$))

ElseIf %PCount = 2

Parameters PrintString$, Mode&

DebugOut Mode&, PrintString$

EndIf

EndProc

'-Procedure Debug.Stop------------------------------------------------

'-

'- Unterbricht die Programmausfuehrung

'-

'- Aufruf: Debug.Stop

'-

'---------------------------------------------------------------------

Proc Debug.Stop

@Set("DebugMode", 2)

EndProc

'-End-------------------------------------------------------------------

Created with the Personal Edition of HelpNDoc: Write EPub books for the iPad


Unit-Beispielprogramm

'-Begin-----------------------------------------------------------------

$U PrfDebug.pcu

Debug.Stop

Proc Hugo

WhileLoop 1,10,1

Print "Hugo" + @Str$(&Loop)

Debug.Print @Str$(&Loop)

EndWhile

EndProc

Cls

Print "Hugo"

Hugo

Debug.Go

WhileLoop 1,10,1

Print "Bambi" + @Str$(&Loop)

Debug.Assert @Equ(&Loop, 5)

Debug.Print @Str$(&Loop)

EndWhile

BreakMark:

WhileLoop 1,10,1

Print "Fritz" + @Str$(&Loop)

EndWhile

'-End-------------------------------------------------------------------

End

Created with the Personal Edition of HelpNDoc: Full-featured Help generator


Die Verwendung der XProfan-Unit

Mit dem Unit-Beispielprogramm CVYBO soll nun deren Verwendung etwas verdeutlicht werden:

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Nun die Taste F9 oder in der ToolBar das Icon 'Bis über das nächste Return/EndProc' [image] betätigen. Die Procedure Hugo ist vollständig ausgeführt worden und das Programm wurde nach dem EndProc gestoppt.

Hinweis: Die Funktion Debug.Print hat nun im Direktfenster die gewünschten Text ausgegeben.

• Als nächster Befehl wird nun Debug.Go ausgeführt, nun die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Das Programm stoppt jetzt, mittels Debug.Assert, sobald der Schleifenzähler (&Loop) die Zahl fünf angenommen hat.

• Jetzt die F11-Taste oder in der ToolBar das Icon 'Bis über das Kommando...' [image] betätigen. In sich das nun öffnende Fenster die Sprungmarke BreakMark: eintragen und den Ok-Button drücken.

• Das Programm stoppt nun in der folgenden Zeile von BreakMark:.

• Zum Beenden des Debug-Vorganges die Taste F12 oder das Icon 'Debuggen beenden' [image] in der ToolBar betätigen.

Created with the Personal Edition of HelpNDoc: Easy EBook and documentation generator


Aufruf über die Kommandozeile

Das zu untersuchende Programm kann auch direkt über die Kommandozeile an den Debugger übergeben werden, z.B.:

PrfDebug.exe Test.prf

Dies führt zum Start des Debuggers und das Programm Test.prf wird geladen.

Es ist egal ob als Argument ein Programm Name.PRF, Name.PRC oder Name.exe übergeben wird, der Debugger erkennt eigenständig welcher Typ übergeben wird.

Created with the Personal Edition of HelpNDoc: Full-featured EBook editor


Debuggen von Include-Dateien und Units

Include-Dateien

Wird eine Funktion oder Prozedur aus einer Include-Datei aufgerufen, so lädt der Debugger die entsprechende Include-Datei, deren Dateiname ja mit FILE: angegeben wird, und es kann Schritt für Schritt die Verarbeitung nachvollzogen werden.

Units

Units können nicht mit dem Debugger betrachtet werden. Wird eine Funktion oder Prozedur aus einer Unit aufgerufen, so wird diese als ein Schritt ausgeführt ohne dass die Verarbeitung im Detail nachvollzogen werden kann.

Created with the Personal Edition of HelpNDoc: Produce Kindle eBooks easily


Dateityp

In diesem Feld wird der erkannte Dateityp angezeigt:

PRF = XProfan-Quellcode

PRC = XProfan-Kompilat

EXE = XProfan-Programm

Created with the Personal Edition of HelpNDoc: News and information about help authoring tools and software


Bis zum nächsten Ereignis

Der Debug-Vorgang wird bis zum nächsten auftretenden Ereignis (Process/Thread wird geladen oder terminiert, DLL wird geladen oder entladen, DebugException tritt auf) ausgeführt und mit dem Ereignis gestoppt.

Created with the Personal Edition of HelpNDoc: Free help authoring environment


Einschränkungen und Systemvoraussetzungen

Systemvoraussetzungen

• Der Debugger funktioniert ausschließlich mit dem Betriebssystem Microsoft Windows. Als Version wird hier mindestens Windows 95 B vorausgesetzt. Der Debugger wurde getestet mit Windows 95 B, 98 SE und XP Home sowie XP Professional. Niedrigere Betriebssystemversionen werden nicht unterstützt. In diesem Rahmen sei hier auf den Gewährleistungsausschluß MM7XV4 verwiesen. Weiterhin bedarf es für den Betrieb des Debuggers XProfan 9. Niedrigere Versionen von XProfan können zwar den Debugger verwenden, unterstützen dessen Funktionsumfang aber nicht korrekt und nicht vollständig, so dass von einer derartigen Konstellation abgeraten wird. Die verwendete Bildschirmauflösung muss mindestens 800 mal 600 Pixel betragen, um den Debugger vollständig nach dem Start auf dem Bildschirm zu sehen. Sollte die Bildschirmauflösung geringer sein, besteht die Möglichkeit, nach dem Start des Debuggers, mit der Tastenkombination Alt-Leertaste das Systemmenü des Debuggers zu öffnen und dann mit der Taste X diesen auf die verfügbare Bildschirmgröße zu maximieren. Die eingestellte Bildschirmauflösung sollte bei 96 dpi liegen, wird eine andere verwendet so kann es dazu kommen dass das visuelle Erscheinungsbild des Programmes von dem hier gezeigten abweicht. Auch können anwenderspezifsche Einstellungen der Schriftarten zu diesem Effekt führen.

Einschränkungen

• Wird ein Source-Code mit mehr als 32766 Zeilen in den Debugger geladen und diese Grenze beim Ausführen des Programmes überschritten, so wird die aktuelle Zeile nicht mehr markiert. Zwar wird die momentan aktive Zeile immer noch in der Mitte des Source-Code-Fensters angezeigt, jedoch die Markierung fehlt. Trotz dieses Verhaltens arbeitet der Debugger korrekt weiter, hierbei handelt es sich nicht um einen Fehler.

• Die Befehle TraceOn und TraceOff sind bei Programmen, die mit dem Debugger überwacht werden, auf jeden Fall zu vermeiden. Sie führen zu Störungen des Bildschirmaufbaus des Debuggers. Eine Verwendung dieser Befehle, in Kombination mit dem Debugger, ist auch sinnlos, da die gewünschte Funktionalität der Einzelschrittüberwachung im vollen Umfang vom Debugger abgedeckt ist.

Created with the Personal Edition of HelpNDoc: Write eBooks for the Kindle


Debuggen mit Ereignissen

Mit folgendem Quellcode können wir sehr leicht das Debuggen mit Ereignissen ausprobieren:

'-Begin-----------------------------------------------------------------

Declare hDLL&, DLL$

@Set("DebugMode", 2)

Cls

DLL$ = $SysPath + "\\mshtml.dll"

DebugOut 0, "DLL$ = " + DLL$

hDLL& = @UseDLL(DLL$)

DebugOut 0, "hDLL = " + @Str$(hDLL&)

DrawExtIcon hDLL&, "32528", 20, 20

FreeDLL hDLL&

'-End-------------------------------------------------------------------

End

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Jetzt in der ToolBar das Icon 'Bis zum nächsten Ereignis' [image] betätigen.

Hinweis: Der Reiter wechselt automatisch zu dem, in dem das Ereignis stattgefunden hat, in diesem Fall der Reiter 'DLLs'. Das Ereignis das eingetreten ist, war das Laden der DLL MSHTML.

Hinweis: Im Direktfenster wird die Zeile DLL$ = C:\WIN95\SYSTEM\mshtml.dll angezeigt.

• Nach zweimaligen Betätigen der F8-Taste wird das gewünschte Icon im Fenster angezeigt.

Hinweis: Im Direktfenster wird jetzt auch das Handle der DLL angezeigt.

• Jetzt kann die Programmausführung mit der F12-Taste beendet werden.

Created with the Personal Edition of HelpNDoc: Free EPub producer


Debuggen von Programmen mit Callback-Funktion

Mit diesem Beispielprogramm CVZAO soll die Vorgehensweise vom Debuggen von Programm mit Callback-Funktion verdeutlicht werden. Dieses Beispiel wurde der XProfan-Hilfe entnommen und lediglich um zwei Zeilen ergänzt:

1. In Zeile 39 wurde Set("DebugMode", 2) hinzugefügt.

2. In Zeile 75 wurde die Sprungmarke BreakPoint: hinzugefügt.

Nun zum Ablauf:

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Das Programm stoppt in Zeile 43 mit dem Befehl Window 0, 0 - 640, 480.

• Jetzt mit der Tastenkombination Alt-V den Debugger in den Vordergrund-Modus schalten.

• Jetzt die F11-Taste betätigen oder in der ToolBar das Icon 'Bis über das Kommando...' [image] betätigen. In sich das dann öffnende Fenster 'BreakPoint:' eingeben und den Ok-Button betätigen.

Hinweis: Jetzt wird das Programm, auch über die CallBack-Funktion Proc ChangeControl bis zum nächsten Ereignis, das durch WaitInput abgefangen wird, ausgeführt.

• Nun einfach die Größe des Programmfensters verändern, dies führt zu einem Ereignis das durch WaitInput abgefangen wird und der Debugger stoppt die Programmausführung in Zeile 77. Die Ausführung des Programms kann jetzt mit der F8-Taste, bzw. in der IconBar mit dem Button 'Nächster Schritt' [image] , oder der F11-Taste, bzw. in der IconBar mit dem Button 'Bis über das Kommando...' [image] , und dem Kommando 'BreakPoint:' fortgesetzt werden, ganz nach Wunsch.

• Zum Beenden im Programmfenster den Button 'Ende' betätigen und mit der F8-Taste, oder in der IconBar mit dem Button 'Nächster Schritt' [image] , die Programmausführung zur Beendigung bringen.

Anmerkung: Wird die Programmausführung ausschließlich im Einzelschritt-Modus durchgeführt, so kommt es für uns Betrachter so vor, als ob die Ausführung der CallBack-Funktion scheinbar völlig willkürlich durchgeführt wird. Dies ist aber keinesfalls so, das Betriebssystem durchläuft diese Routine immer dann, wenn eine Windows-Message (WM) für das Programm vorliegt. Diese Nachricht kann viele Ursachen haben, z.B. wenn das Fenster verschoben wird, wird die Nachricht WM_MOVE übergeben und die CallBack-Funktion ausgeführt. In diesem Beispiel interessiert uns aber nur die Nachricht WM_SIZE, also eine Größenveränderung des Programmfensters.

Hinweis: Soll die CallBack-Funktion selber überprüft werden, so kann auch in ihr eine Sprungmarke eingefügt werden. Dies kann z.B. nach der Zeile 19 (If Message& = ~WM_SIZE) geschehen, d.h. wenn jetzt über den oben beschriebenen Ablauf diese Marke angesprungen wird, stoppt das Programm. Wird nun die Größe des Fensters verändert, stoppt die Programmausführung an diesem Punkt. Aber Achtung, dies kann zu einem 'quälenden' Vorgang werden, da die Nachricht WM_SIZE bei der Größenänderung eines Fensters sehr oft vorkommt; ein paar Hundert sind keine Seltenheit.

Created with the Personal Edition of HelpNDoc: Easily create Qt Help files


CallBack-Beispielprogramm

'-Begin-----------------------------------------------------------------

'-HeaderFiles---------------------------------------------------------

$H Windows.ph

$H Messages.ph

'-Variables Declaration-----------------------------------------------

Declare Ende%, OldWndProc&, hButton%

'-CallBack Routine----------------------------------------------------

Proc ChangeControl

Parameters hWnd&, Message&, wParam&, lParam&

Declare btnHeight&

If Message& = ~WM_SIZE

'-Abfrage, damit Button nicht kleiner 16 Pixel Hoehe------------

If @Height(%hWnd) / 5 < 16

btnHeight& = 16

Else

btnHeight& = @Height(%hWnd) / 5

EndIf

'-Groesse des Buttons aendern-----------------------------------

SetWindowPos hButton%, 10, 34 - @Width(%hWnd) - 20, btnHeight&

EndIf

Return ~CallWindowProc(OldWndProc&, hWnd&, Message&, \

wParam&, lParam&)

EndProc

'-Main----------------------------------------------------------------

'-Erweitertes MessageHandling abschalten----------------------------

Set("FastMode", 1)

Set("DebugMode", 2)

'-Fenster oeffnen und GUI aufbauen----------------------------------

Window 0, 0 - 640, 480

WindowTitle "Größenänderung von Steuerelementen in Echtzeit"

'-Hintergrundfarbe des Fensters setzten---------------------------

Declare Color&, Red%, Green%, Blue%

Color& = ~GetSysColor(~COLOR_3DFACE)

Red% = @GetRValue(Color&)

Green% = @GetGValue(Color&)

Blue% = @GetBValue(Color&)

Cls @RGB(Red%, Green%, Blue%)

'-----------------------------------------------------------------

@Create("Text", %hWnd, "Ändere die Größe dieses Fensters", 10, \

10, 250, 20)

hButton% = @Create("Button", %hWnd, "Ende", 10, 34, \

@Width(%hWnd) - 20, @Height(%hWnd) / 5)

'-ProgramMainRoutine mit CallBack umleiten auf eigene---------------

OldWndProc& = ~GetWindowLong(%hWnd, ~GWL_WNDPROC)

~SetWindowLong(%hWnd, ~GWL_WNDPROC, @ProcAddr("ChangeControl", 4))

'-Dialog-Schleife---------------------------------------------------

Clear Ende%

WhileNot Ende%

WaitInput

BreakPoint:

If %Key = 2

Ende% = 1

ElseIf @GetFocus(hButton%)

Ende% = 1

EndIf

EndWhile

'-Urspruengliche ProgramMainRoutine wieder herstellen---------------

~SetWindowLong(%hWnd, ~GWL_WNDPROC, OldWndProc&)

'-End-------------------------------------------------------------------

End

Created with the Personal Edition of HelpNDoc: Single source CHM, PDF, DOC and HTML Help creation


Hinweise vor der Benutzung

• Wenn ein Programm mit dem Debugger verfolgt werden soll, so ist es von Vorteil, das Programm mit dem Befehl @Set("DebugMode", 2) zu beginnen. So stehen alle Möglichkeiten der Überwachung von Anfang an zur Verfügung. Wird kein entsprechender DebugMode definiert, so erzeugt der Interpreter keinen OutputDebugString den der Debugger verarbeiten kann, und damit kann auch keine Steuerung des Programmablaufes durchgeführt werden.

• Der Debugger für XProfan ist ein vom XProfan-Interpreter bzw. -Runtime-Modul unabhängiges Programm. Bedingt durch diesen Umstand kann es dazu kommen, dass der Debugger bei der Programmausführung den Eingabe-Fokus verliert, z.B. wenn ein Fenster geöffnet wird. Wird dann z.B. die Taste F8 betätigt, um in der Programmausführung einen Schrit voran zu gehen, so wird dieser an das gerade geöffnete Fenster geleitet und nicht an den Debugger. Es ist daher immer darauf zu achten, dass der Debugger den Eingabe-Fokus besitzt oder erhält, wenn eine Aktion mit ihm ausgeführt werden soll. Auch gerade dann wenn viel mit den (Funktions-)Tasten oder Tastenkombinationen gearbeitet wird.

• Wird der Debugger mit der Option 'Debugger immer im Vordergrund' ausgeführt, so kann es dazu kommen dass Nachrichten, z.B. vom Interpreter in Form einer MessageBox, überdeckt werden und nicht sichtbar sind. Dann wartet der Interpreter auf die Reaktion durch betätigen des Buttons der MessageBox und der Anwender wartet auf die weitere Ausführung des Programms durch den Debugger. Jeder wartet auf jeden und nichts passiert. Aus diesem Grund sollte die Option 'Debugger immer im Vordergrund' mit Umsicht verwendet werden sowie stets dieser Umstand bedacht werden.

• Jeder Schritt der mit dem Debugger ausgeführt wird braucht Zeit, manchmal mehr, manchmal weniger. Auch wenn der 'Status der direkten Eingabeverarbeitung' signalisiert wird, ist es bei einem Debugging-Vorgang ratsam mit bedacht vorzugehen. Mit Ungeduld ist nicht viel zu erreichen, da jede Betätigung einer Taste nicht verloren geht. So führt z.B. beim Start, der je nach Größe des Programmes einige Zeit dauern kann, die mehrmalige Betätigung der Taste F5 nicht nur zum Starten des Debug-Vorganges, sondern auch zum Ausführen des Programms, ohne Pause.

Created with the Personal Edition of HelpNDoc: Easily create iPhone documentation


Status der direkten Eingabeverarbeitung

Hier wird Angezeigt ob Eingaben, beim Debugging-Vorgang, direkt vom Debugger verarbeitet werden können.

Grau = Es ist im Augenblick kein Debug-Vorgang aktiv.

Grün = Die Eingabe wird direkt verarbeitet.

Rot = Die Eingabe wird zum nächstmöglichen Zeitpunkt verarbeitet.

Created with the Personal Edition of HelpNDoc: Full-featured Help generator


Tips und Tricks

• Wird ein SourceCode geladen, der 72 Zeichen Breite nicht überschreitet, so baut das SourceCode-Fenster keinen horizontalen Scroll-Balken auf. Der Debugger ist mit seinen Startparametern so ausgelegt, dass er einen Quellcode mit 72 Zeichen Breite ohne Scroll-Balken darstellen kann.

• Die Verwendung von Programmen mit zu hoher Zeilenzahl sollte unterbleiben. XProfan bietet sowohl Include-Dateien als auch Units zur Modularisierung von Programmen an. Von diesen Möglichkeiten sollte reger Gebrauch gemacht werden.

Created with the Personal Edition of HelpNDoc: Easily create EPub books


Debuggen von großen Programmen

Hinweis: Mit XProfan können Programme mit maximal 262143 Zeilen verarbeitet werden.

Mit dem folgenden Programm erzeugen wir einen XProfan-Quelltext mit 65535 Zeilen, um das Debuggen von großen Programmen nachvollziehen zu können:

'-Begin-----------------------------------------------------------------

Assign #1, "DEMO.PRF"

Rewrite #1

Print #1, "Declare i&"

WhileLoop 2, 32764

If &Loop Mod 1000 = 0

Print #1, "DebugOut 0, \q" + @Str$(&Loop) + "\q"

Else

Print #1, "i& = " + @Str$(&Loop)

EndIf

EndWhile

Print #1, "@Set(\qDebugMode\q, 2)"

WhileLoop 32766, 65534

If &Loop Mod 1000 = 0

Print #1, "DebugOut 0, \q" + @Str$(&Loop) + "\q"

Else

Print #1, "i& = " + @Str$(&Loop)

EndIf

EndWhile

Print #1, "End"

Close #1

@MessageBox("Datei erzeugt", "Hinweis", 64)

'-End-------------------------------------------------------------------

End

Hinweis: Das Programm vollbringt nichts besonderes, es weist der Variablen i& mit jeder neuen Zeile einen neuen Wert zu, der die Zeilenzahl entspricht. Nach dem Ausführen des Programms wurde ein XProfan-Programm mit dem Namen DEMO.PRF und einer Größe von 775.906 Byte erzeugt.

Nachdem das Programm DEMO.PRF erzeugt wurde, kann dieses in den Debugger geladen werden:

• In der ToolBar das Icon 'Datei auswählen' [image] anklicken und das Programm ausgewählen, welches dann geladen wird.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Wichtiger Hinweis: Da das Programm bis zur Zeile 32765 nicht das Kommando @Set("DebugMode", 2) enthält, wird es sofort ausgeführt.

• Im Direktfenster werden jetzt, entsprechend der DebugOut-Kommandos, die Zahlen 1000, 2000, 3000 bis 32000 ausgegeben.

• Wird die Zeile 32765 erreicht, so stoppt die Programmausführung, mit erreichen von @Set("DebugMode", 2), und in der Output-Zeile, oberhalb des SourceCodes, wird 32766 i& = 32766 angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] mehrfach betätigen.

Hinweis: Die Markierung bleibt in der Zeile 32766 stehen, obwohl in der Output-Zeile mit jedem weiteren Schritt die korrekte Zeile angezeigt wird. Siehe auch dazu die Einschränkungen MM7YV4.

• Wird nun die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigt, so wird das Programm bis zu seinem Ende ausgeführt und im Direktfenster werden die Zahlen 33000, 34000, 35000 bis 65000 ausgegeben.

Created with the Personal Edition of HelpNDoc: Single source CHM, PDF, DOC and HTML Help creation


Debuggen von objektorientieren Programmen

Mit diesem Beispielprogramm MM7ZU4 soll nun der Debug-Vorgang eine objektorientierten Programmes erläutert werden:

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich wird die Zeile: 'FILE: C:\LANGUAGE\PROFAN\OOP.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen und Schritt für Schritt das Programm ausführen bis zur Zeile 34. Mit Ausführung dieser Zeile liefert das Programm die Zahl 16664 an das Direktfenster des Debuggers.

• Schreiten wir jetzt mit der F8-Taste, oder in der ToolBar das Icon 'Nächster Schritt' [image] , bis zur Zeile 42 vor, so liefert das Programm die Zahl 231263 an das Direktfenster des Debuggers.

Anmerkung: An diesem Beispiel können wir sehr schön die Funktionsweise der objektorientierten Programmierung erkennen. Durch Instanzierung der Klasse werden unterschiedliche Bereiche geschaffen, die für uns aber sichtbar, jedoch in Wahrheit nur scheinbar, die gleichen Funktionen verwenden.

Created with the Personal Edition of HelpNDoc: Free help authoring environment


Objektorientiertes Beispielprogramm

'-Begin-----------------------------------------------------------------

@Set("DebugMode", 2)

'-Klasse Test---------------------------------------------------------

Class Test = #X&, +SetX@, +GetX@

Proc Test.SetX

Parameters NewX&

.X& = NewX&

EndProc

Proc Test.GetX

Return .X&

EndProc

'-Variablen deklarieren-----------------------------------------------

Declare Klasse#, Klasse2#

'-Klassen instanzieren------------------------------------------------

Dim Klasse#, Test

Dim Klasse2#, Test

'-X der Klasse setzen-------------------------------------------------

Klasse#.SetX(16664)

'-X der Klasse lesen--------------------------------------------------

DebugOut 0, "X der Klasse Test = " + @Str$(Klasse#.GetX())

'-X der 2. Klasse setzen----------------------------------------------

Klasse2#.SetX(231263)

'-X der 2. Klasse lesen-----------------------------------------------

DebugOut 0, "X der 2. Klasse von Test = " + @Str$(Klasse2#.GetX())

'-Speicher leeren-----------------------------------------------------

Dispose Klasse#

Dispose Klasse2#

'-End-------------------------------------------------------------------

End

Created with the Personal Edition of HelpNDoc: Free EPub producer


Mehrere Befehle in einer Zeile

Testen wir folgendes Programm um zu sehen, wie XProfan mit der Bearbeitung von mehreren Befehlen in einer Zeile umgeht:

'-Begin-----------------------------------------------------------------

@Set("DebugMode", 2)

Cls : Print "Hier stehen mehrere" : Print "Befehle in einer" : \

Print "Reihe"

'-End-------------------------------------------------------------------

End

XProfan arbeitet eine Zeile mit mehreren Befehlen so ab, als ob jeder Befehl für sich in der gleichen Zeile steht. D.h. im Debugger wird die Zeile 7 vier mal ausgeführt, da in ihr vier Befehle stehen (1x Cls und 3x Print).

Bei der Verwendung von mehreren Befehlen pro Zeile sollte dieser Umstand beim Debugging-Vorgang immer bedacht werden.

Created with the Personal Edition of HelpNDoc: Easy EBook and documentation generator


Weiterentwicklung

Wie fast alle Anwendungen so lebt und entwickelt sich auch diese von den Erfahrungen ihrer Anwender. Sollten daher Vorschläge zur Weiterentwicklung oder konstruktive Kritik an bestehenden Funktionen vorliegen, so bitte ich um Sendung einer eMail an: mail@stschnell.de.

Created with the Personal Edition of HelpNDoc: Full-featured Help generator


Verwenden der Direktive $B/$D

Mit dem Direktiven-Beispielprogramm MM7ZY4 soll die Vorgehensweise der Verwendung der Direktiven $B (Break) und $D (Debug) verdeutlicht werden.

• Die Direktive $B setzt einen BreakPoint und stoppt die Programmausführung. Daneben kann ein beliebiger Text ausgegeben werden.

• Die Direktive $D verhält sich wie die Direktive $B, nur mit dem Unterschied, dass neben einem beliebigen Text auch Variableninhalte ausgegeben werden können.

• Zuerst muss der Debugger gestartet werden.

• Sofern noch nicht geschehen sollten die XProfan-Verzeichnis eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Die Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen, die Pfade werden automatisch übernommen.

• Dann wird in der ToolBar das Icon 'Datei auswählen' [image] angeklickt und das Programm ausgewählt und geladen.

Hinweis: In der Statuszeile, im Feld 'Geladene Datei' wird jetzt der Name des ausgewählten Programmes angezeigt.

Hinweis: Im SourceCode-Bereich wird jetzt die Datei angezeigt.

• Jetzt die F5-Taste oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] betätigen.

Hinweis: In der Statuszeile, im Feld 'Debug-Thread', hat sich jetzt das Ampel-Symbol verändert und es wird der Status 'aktiv...' angezeigt.

Hinweis: Im Output-Bereich die Zeile: 'FILE: C:\LANGUAGE\PROFAN\TEST.PRF', bzw. der entsprechende Pfad und Dateiname angezeigt.

• Jetzt die F8-Taste oder in der ToolBar das Icon 'Nächster Schritt' [image] betätigen.

• Nun die Taste F9 oder in der ToolBar das Icon 'Bis über das nächste Return/EndProc' [image] betätigen. Obwohl die Aktion 'Bis über das nächste Return/EndProc' ausgewählt wurde, stoppt das Programm nach Ausführung der Direktive $B.

Hinweis: Im Direktfenster wird die BREAK-Ausgabe angezeigt.

• Wiederholen wir diesen Vorgang, so ändert sich nichts an der Ausführungsweise.

• Nun Betätigen wir die Tastenkombination Alt-D, oder wählen den Menüpunkt 'Optionen - Bei Direktive $B/$D immer stoppen' und deaktiveren diesen.

• Wird jetzt die F9-Taste betätigt, so wird die Prozedur bis zu ihrem Ende ausgeführt, obwohl die Direktive $B verwendet wird. Die Programmausführung stoppt in Zeile 19, der nächsten Zeile nach dem Prozeduraufruf.

• Nun Betätigen wir wieder die Tastenkombination Alt-D, oder wählen den Menüpunkt 'Optionen - Bei Direktive $B/$D immer stoppen' und aktiveren diesen.

• Jetzt die Taste F10 oder in der ToolBar das Icon 'Bis über das nächste Wend\EndWhile\Until' [image] betätigen. Die Programmausführung stoppt nach der Direktive $D.

Hinweis: Im Direktfenster wird die DEBUG-Ausgabe angezeigt.

• Wiederholen wir diesen Vorgang, so ändert sich nichts an der Ausführungsweise.

• Nun Betätigen wir wieder die Tastenkombination Alt-D, oder wählen den Menüpunkt 'Optionen - Bei Direktive $B/$D immer stoppen' und deaktiveren diesen.

• Jetzt die F5-Taste betätigen oder in der ToolBar das Icon 'Debuggen starten/Ausführen' [image] und das Programm wird vollständig ausgeführt und beendet.

Created with the Personal Edition of HelpNDoc: Easily create iPhone documentation


Direktiven-Beispielprogramm

Dieses Beispielprogramm beruht auf einer gekürzten Version des Programmes für den Debug-Vorgang, nur dass hier die DebugOut-Kommandos gegen $B (Break) und $D (Debug) ausgetauscht wurden.

'-Begin-----------------------------------------------------------------

Declare i&

@Set("DebugMode", 2)

Proc Hugo

WhileLoop 1,10,1

Print "Hugo" + @Str$(&Loop)

$B Hugo

EndWhile

EndProc

Cls

Print "Hugo"

Hugo

WhileLoop 1,10,1

Print "Bambi" + @Str$(&Loop)

i& = &Loop

$D "Bambi", i&

EndWhile

'-End-------------------------------------------------------------------

En

Created with the Personal Edition of HelpNDoc: Produce Kindle eBooks easily