Einführung

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

Stefan Schnell


Willkommen

Einführung ››

Created with the Personal Edition of HelpNDoc: Benefits of a Help Authoring Tool


Neuigkeiten

Einführung ››

Created with the Personal Edition of HelpNDoc: Create cross-platform Qt Help files


Erste Schritte

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


Systemanforderungen

Erste Schritte ››

Created with the Personal Edition of HelpNDoc: Benefits of a Help Authoring Tool


Hilfe erhalten

Erste Schritte ››

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


Debugger für XProfan

Willkommen bei der Hilfe des Debuggers für XProfan

Einführung

• Grundlagen 2WGDZDX

• Benutzerhinweise und Ratschläge 2WGDZFX

Das Programm

• Die Benutzeroberfläche 2WGDZGX

• Der Reiter SourceCode Scribble10070

• Der Reiter Output Scribble10080

• Der Reiter Process/Threads Scribble10090

• Der Reiter DLLs Scribble10100

• Der Reiter Exceptions/DebugErrors Scribble10110

• Der Reiter Notizen Scribble10120

• Menüpunkte Scribble10130

• Tastenkürzel UVKRUS

• Aufruf über die Kommandozeile UVKRVS

Beispiele

• Bevor es los geht UVKRVN

• Der Debug-Vorgang UVKRWS

• Debuggen von Include-Dateien, Units, Header-Dateien und DLLs UVKRYS

• Debuggen mit Befehlsfolgen im Einzelschritt UVKRZS

• Debuggen mit Debug-Ereignissen 1H4WSH8

• Debuggen von Programm mit Callback-Funktionen UVKSRS

• Debuggen von großen Programmen UVKSTS

• Debuggen objektorientierter Programme UVKSUS

• Debuggen mit Argumentübergabe UVKSWS

• Debuggen mit Haltepunkten UVKSWN

Betrachtungen

• Mehrere Befehle in einer Zeile UVKSXS

• Mehrere Zeilen für ein Befehl UVKSXN

• Verwenden der Direktive $B/$D UVKSYS

Erweiterungen

• PrfDebug-Unit zur optimaleren Unterstützung UVKTSS

• Die Verwendung der PrfDebug-Unit UVKTTS

• PrfDebug-Include zur einfacheren Einbindung der Debug-Unterstützung UVKTVS

• Code-Injektion zur vereinfachten Übernahme von Modulen UVKTVN

Sonstiges

• Einschränkungen und Systemvoraussetzungen UVKTWS

• Tipps und Tricks UVKTXS

• Weiterentwicklung UVKTYS

• Copyright und Gewährleistungsausschluss UVKTZS

• Literaturverzeichns 2WJDZKX

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


Grundlagen

Was ist ein Bug?

Es ist ein Programmierfehler, aufgrund eines Entwurfs- oder Implementierungsfehlers, der sich erst zur Laufzeit eines Programms offenbart, also wenn das Program ausgeführt wird.

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 Kurzschluss 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, oder etwas anders zugetragen hat, weiß allerdings keiner so genau. Varianten gibt es einige, die jedoch immer zum selben Ergebnis führen.

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 mit ihr so gearbeitet werden, wie es für den Benutzer möglich ist. Zusätzlich kann jedoch der Code eingesehen und 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 2WGDZEX

Fehlerkategorien

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

· syntaktische Fehler

· Laufzeitfehler

· logische Fehler

Syntaktische Fehler

Stößt der Interpreter auf einen Befehl, den er nicht kennt, oder auf Argumente, die nicht den richtigen Typ haben, 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.

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 einen 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. dass 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: Free CHM Help documentation generator


Zum technischen Hintergrund des Debuggers

Der Debugger verwendet die Funktionen des Win32-Debug-API. Er öffnet einen 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 [1] 2WJDZKX zu entnehmen .

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


Benutzerhinweise und Ratschläge

Siehe auch Einschränkungen und Systemvoraussetzungen UVKTWS.

· Wenn ein Programm mit dem Debugger verfolgt werden soll, so ist es notwendig, das Programm mit dem Befehl @Set("DebugMode", 2) zu beginnen. So stehen alle Möglichkeiten der Überwachung 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.

Zur einfacheren Einbindung der Unterstützung der Debugger-Funktionalität kann die mitgelieferte Datei PrfDebug.inc UVKTVS verwendet werden. Sie bindet die PrfDebug-Unit UVKTSS ein, instanziert ihre Klassen und und setzt den entsprechenden DebugMode. Wird die Include-Datei verwendet, so darf nicht vergessen werden, spätestens zum Ende der Programmausführung, die Speicherbereich der instanzierten Klassen mit Dispose wieder freizugeben, bzw. die Prozedur FreePrfDebug aufzurufen.

· 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 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 überdeckt werden und nicht sichtbar sind, z.B. vom Interpreter in Form einer MessageBox. 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, 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.

· Wie bereits im vorherigen Punkt erwähnt, so sei hier nochmals besonders herausgestellt, dass die Taste F5 bzw. das Icon "Debuggen starten/Ausführen" [image] eine Doppelbelegung hat. Mit ihr wird der Debug-Vorgang gestartet und, wenn der Debug-Vorgang bereits aktiv ist, das Programm ausgeführt. Die Verwendung dieser Funktion sollte daher immer mit äußerster Sorgfalt und Umsicht erfolgen.

· Wird während des Debug-Vorganges und einem wartenden Programm im Debugger z.B. ein Fenster verschoben oder ein anderes maximiert, so wird der Inhalt des Fensters des wartenden Programms zerstört, und es ist nur eine weiße Fläche zu sehen. Dies ist völlig normal, da der Debugger die Programmausführung gestoppt hat und damit auch kein Wiederaufbau (Redraw) des Fensters erfolgen kann. Mit dem weiteren Ausführen des Programmes, mit der Taste F8 im Einzelschritt oder F5 für die weitere Ausführung, wird das Fenster jedoch wieder neu aufgebaut.

· Wird die Funktion "Ausführen einschließlich Cursor-Position" oder ein Haltepunkt [image] verwendet und die ausgewählte Position beinhaltet einen Prozeduraufruf, so wird die Programmausführung mit der ersten Zeile der Prozedur gestoppt, da dies die nächste Zeile nach der ausgewählten ist. Diesem Umstand kann jedoch einfach begegnet werden, indem dann die Shift-F9-Tastenkombination betätigt wird. Sie führt das Programm bis zum nächsten Return/EndProc aus, sofern keine weiteren Prozeduren als verschachtelte Aufrufe verwendet werden, siehe dazu auch den nächsten Hinweis. Ist dies der Fall, so ist es von Vorteil eine Sprungmarke einzufügen und mit der Funktion "Bis über das Kommando" zu arbeiten. (Ein Beispiel dafür ist hier UVKTTS zu finden.)

· Bei einem Aufruf von "Bis über das nächste Return/EndProc" [image] oder "Bis über das nächste Wend/EndWhile/Until/EndSelect" [image] , der zu einem verschachtelten Prozedur- oder Schleifenaufruf führt, wird immer beim Erreichen des nächsten entsprechenden Befehles gestoppt. Ruft z.B. eine Prozedur wieder eine Prozedur auf, so wird bei deren Return oder EndProc angehalten. Auch hier bietet es sich an mit einer Sprungmarke zu arbeiten.

· Die als Beispiele verwendeten Quelltexte sind mehr oder weniger sinnlos. Sie enthalten einfache Befehle und sind primär zum Vorführen der gewünschten Funktionen im Debugger erstellt. Mit diesem Schritt wird ganz bewusst die Aufmerksamkeit auf die Funktionen des Debuggers gelenkt und nicht zusätzliche Probleme durch das Verständnis für die Programmierung geschaffen.

· Bestimmte Schritte der beschriebenen Abläufe wiederholen sich häufig, und es lässt sich die Frage stellen, ob die Ausführung selbiger immer in diesem Detailgrad notwendig ist? Je häufiger mit dem Debugger gearbeitet wird, desto weniger ist die Erklärung, quasi selbstverständlicher Schritte, notwendig. Jedoch wird nicht jeder ständig mit diesem Werkzeug hantieren, so dass auch diesen Anwendern die Gelegenheit gegeben wird, selektiv ihre Beispiele zu bearbeiten, ohne groß hin- und herblättern zu müssen.

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


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 vier Feldern, im Fußbereich. Im mittleren Bereich sind die Ausgabebereiche des Debuggers, nach Themen mit Reitern geordnet, sowie ein Direktbereich:

· SourceCode Scribble10070

Hier wird der augenblicklich geladene Quellcode angezeigt.

· Output Scribble10080

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

· Process/Threads Scribble10090

Hier werden die vom Debugger bzw. dem geladenen Programm gestarteten Prozesse und Threads angezeigt.

· DLLs Scribble10100

Hier werden die vom Debugger bzw. dem ausgeführten Programm geladenen Libraries angezeigt.

· Exceptions/DebugErrors Scribble10110

Sobald eine Ausnahme oder ein Fehler auftritt, wird sie in diesem Bereich angezeigt.

· Notizen Scribble10120

Hier besteht die Möglichkeit, Notizen zu einem Debugging-Vorgang zu erfassen und diese abzuspeichern und bei Bedarf wieder zu laden.

Im mittleren Teil gibt es einen Direktbereich, hier werden alle Zeichenketten angezeigt, 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) spezifizierten Texte werden in diesem Fenster angezeigt.

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

{bmc bm4.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: Produce Kindle eBooks easily


SourceCode

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

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

#Haltepunkte

Wird bei geladenem Quellcode und aktivem Debug-Prozess die rechte Maustaste im Fenster betätigt, so öffnet sich ein Popup-Menü. In diesem Menü gibt es u.a. 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.

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

Wird bei geladenem Quellcode und aktivem Debug-Prozess die F9-Taste betätigt, so wird die aktuelle Zeile, also die in der sich gerade der Cursor befindet, als Haltepunkt markiert.

Nun wird der Programmablauf immer mit überschreiten dieser Zeile gestoppt. Betätigt man die F9-Taste erneut, wenn diese Zeile die aktuelle ist, so wird der Haltepunkt wieder gelöscht.

Hinweis: Es kann zwar jede Zeile als Haltepunkt markiert werden, jedoch wird im Programmablauf auch nur bei der Zeile gestoppt, die verarbeitet wird. Z.B. kann eine Kommentarzeile als Haltepunkt markiert werden, jedoch wird diese nicht verarbeitet und somit wird auch nicht gestoppt. Bei Befehlen über mehrere Zeilen ist immer die letzte Zeile zu markieren. Wird eine andere Zeile markiert so wird ebenfalls nicht gestoppt. Es liegt in der Verantwortung des Anwenders die Haltepunkte in den richtigen Zeilen zu setzen. Für die Verwendung von Haltepunkten mit der F9-Taste bzw. dem Toolbarbutton [image] sind die Einschränkungen UVKTWS zu beachten. Ein Beispiel sowie weitere Ausführungen zu Haltepunkten ist in Debuggen mit Haltepunkten UVKSWN zu finden.

Veränderungen im Quellcode

Der Quellcode des Programms kann im SourceCode-Bereich auch bearbeitet werden. Dies ist aber nur möglich, so lange der Debug-Thread inaktiv ist. Der Debugger legt nach einer Änderung mit dem erneuten Start des Debug-Vorganges eine neue Datei an. Diese Datei hat den gleichen Namen, jedoch wird vor der Extension DEBUG eingefügt. Zum Beispiel wird aus TEST.PRF dann TEST.DEBUG.PRF. D.h. der ursprüngliche Quellcode wird nicht verändert, jede Veränderung findet nur in der neu angelegten Datei statt. Diese Datei bleibt auch nach Beendigung des Debuggers bestehen und kann weiter verarbeitet werden.

Hinweis: Der Debugger ersetzt damit keine Entwicklungsumgebung. Die Möglichkeit der Veränderung von Quellcode sollte wirklich nur für Kleinigkeiten verwendet werden, z.B. das Verändern von Variablenzuweisungen, das Einfügen von Labels sowie Variablenausgaben im Direktbereich oder der Korrektur aufgetretener Fehler. Die Veränderungen sollten im Zusammenhang mit dem Debug-Vorgang stehen und keinen eigenständigen Entwicklungs- oder Ergänzungsprozess darstellen.

Hinweis: Die Tastenkombinationen

· Strg+C = Kopieren

· Strg+X = Ausschneiden

· Strg+V = Einfügen

· Strg+Z = Rückgängig

· Strg+A = Alles markieren

funktionieren im SourceCode-Bereich und können bei der Bearbeitung von Quelltexten verwendet werden.

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


Output

In diesem Bereich werden die von XProfan mit dem XProfan-Befehl DebugOut und 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 oder die Option 'Jede Ausgabe anzeigen' aktiviert ist.

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


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 und der benötigte Speicher angezeigt. Wird er beendet, so wird der Exitcode angezeigt.

Threads

Wird ein Thread gestartet, so wird seine Basis-Adresse angezeigt. Wird er beendet, wird der Exitcode angezeigt.

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


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 sie entladen, so wird angezeigt, dass eine DLL mit der Adresse entladen wurde.

Created with the Personal Edition of HelpNDoc: Create HTML Help, DOC, PDF and print manuals from 1 single source


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.

Anmerkung: Wird eine Funktion des WinAPI mit einer falschen Anzahl von Argumenten aufgerufen, so endet dies in dem ständigen Auftreten der Fehlermeldung "Debug-Ausnahmeereignis mit dem Code EXCEPTION_ACCESS_VIOLATION". Wenn Sie daher bei der Verwendung von Funktionen des WinAPI unsicher sind, so empfiehlt es sich, die Ausnahmeüberwachung mit der Tastenkombination Alt+W einzuschalten.

Hinweis: Der Aufruf einer WinAPI-Funktion mit einer falschen Anzahl Argumenten führt unter Windows 95 B zu einem Systemabsturz mit einer BlueScreen-Anzeige des Betriebssystems. Das in der Anmerkung beschriebene Verhalten tritt unter Windows XP auf.

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


Notizen

Im Fenster dieses Bereiches können spezifische Notizen zum Debug-Vorgang erfasst werden. Dies können z.B. noch vorzunehmende Änderungen, Ideen für Weiterentwicklungen o.ä. sein. Die Funktionalität dieses Bereiches orientiert sich an gängigen Editoren. Die Notizen können im RichtTextFormat (RTF) abgespeichert und mit jeder Textverarbeitung, die dieses Format lesen kann, weiter verarbeitet werden. Ebenso können die Notizen auch wieder eingelesen werden und stehen dann zu Wiederverarbeitung zur Verfügung.

{bmc bm12.SHG}

Hinweis: Durch Anklicken der entsprechenden Bereiche in der obigen Grafik werden Erklärungen angezeigt.

Wer schreibt, der bleibt

Wie oft geschieht es uns, dass wir spontan eine gute Idee haben? Doch, wann haben wir diese Ideen? Beim Einkaufen, auf der Fahrt zur Arbeit, oftmals zu den unmöglichsten Zeiten und in den unerwartetsten Situationen. Der nächste Gedanke: Ach, diese Idee ist so gut, die vergessen wir schon nicht. Dann, nachdem wir zur Besinnung gekommen sind, da war doch noch was, und schon kann eine gute Innovation wieder weg sein.

Da erfahrungsgemäß beim detaillierten Betrachten von Quell-Code, während der Ausführung eines Programmes, die meisten Ideen zur Fehlerbeseitigung und -behandlung sowie zur Optimierung entstehen, ist auch die Wahrscheinlichkeit des Verlustes einer solchen sehr hoch. Um diesen so gering wie möglich zu halten, können mit dem Notizen-Editor diese Ideen aufgeschrieben und gespeichert werden.

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


Menüpunkte

#Datei

· Programm laden

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

· Code injizieren

Es öffnet sich ein Dialog, mit dem eine beliebige XProfan-Quellcode-Datei ausgewählt werden kann. Sobald die Datei gewählt ist, wird deren Inhalt an der aktuellen Cursor-Position eingefügt.

· Debugger-Unterstützung

Wird im Sub-Menü der Menüpunkt "Aktivierung injizieren" ausgewählt, so wird der Inhalt der Datei PrfDebug.Start.inc an der aktuellen Cursor-Position im SourceCode-Bereich eingefügt. Wird der Menüpunkt "Deaktivierung injizieren" gewählt, so geschieht selbiges, jedoch mit der Datei PrfDebug.Stop.inc.

· Datei anzeigen

Es kann eine Textdatei zum Anzeigen ausgewählt werden. Der Inhalt der Textdatei wird dann in einem zusätzlichen Fenster angezeigt. Als Filter sind hierbei voreingestellt *.PRF, *.TXT, *.MAPFILE, *.* sowie PROFAN.LOG und DEBUG.INI.

· Beenden

Beendet den Debug-Vorgang und den Debugger.

#Ansicht

· Direktfenster anzeigen/verstecken

Versteckt bzw. schließt das Direktfenster wenn es geöffnet ist oder öffnet es, wenn es geschlossen ist.

· Programmfenster vergrößern/verkleinern

Erweitert das Programmfenster des Debuggers bis zum oberen Bildschirmrand oder stellt die Ausgangsposition wieder her.

· Refresh des Programmfensters

Führt ein Refresh des Programmfensters des Debuggers durch. Alle Bildschirmelemente des Debuggers werden neu gezeichnet.

#Debuggen

· Starten/Ausführen

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

· Haltepunkt setzen/löschen

Setzt einen Haltepunkt (BreakPoint) in der Zeile, in der der Cursor positioniert ist bzw. löscht selbige wenn bereits ein Haltepunkt vorhanden ist.

· Alle Haltepunkte löschen

Löscht alle vorhanden Haltepunkte im Programmablauf.

· Alle Haltepunkte anzeigen

Zeigt eine Liste mit allen definierten Haltepunkten im Programmablauf.

Mit dem Button 'Haltepunkt entfernen' können einzelne Haltepunkte gezielt entfernt werden. Dazu ist die gewünschte Zeile einfach zu markieren und der Button zu betätigen.

· 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/EndSelect

Führt das Programm ohne Pause weiter aus, bis der Befehl Wend, EndWhile, Until oder EndSelect 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 und Restart

Beendet den Debug-Vorgang und startet ihn erneut.

· Beenden

Beendet den Debug-Vorgang.

· Ausgabefenster löschen

Löscht die Inhalte der Fenster der Reiter, die beim Debugging-Vorgang Informationen erhalten.

Hinweis: Der SourceCode- und Notizen-Bereich wird hiermit nicht gelöscht, sondern nur die Fenster, die originär beim Debugging-Prozess befüllt werden.

· Debug-Ergebnisse exportieren

Es wird eine Datei, die den gleichen Namen wie das untersuchte Programm hat, mit der Extension TXT erzeugt. In ihr werden die Ergebnisse des Debug-Vorganges gespeichert.

#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.

· Include-Verzeichnis

Mit dieser Dialogbox können Pfade für Include-Dateien angegeben werden. Sollen mehrere Pfade verwendet werden, so sind diese mit einem Semikolon zu trennen (;). Die Pfade werden in der Datei PROFED32.INI im Windows-Verzeichnis gespeichert. Der XProfan-Interpreter und -Compiler fragen zu ihrer Laufzeit diese Datei ab.

· Programmargumente

Mit dieser Dialogbox können die Programmargumente übergeben werden.

· Schriftgröße der Ausgabebereiche

Es öffnet sich ein Untermenü mit dem die Größe der Schrift, in den Ausgabebereichen, eingestellt werden kann. Die Schriftgrößen 10, 11, 12 und 14 stehen zur Verfügung.

· 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: oder WARN: ausgibt.

· Ausnahmeüberwachung

Es wird eine Ausnahmeüberwachung aktiviert bzw. deaktiviert. Treten mehr als 16 Ausnahmen (Exceptions) innerhalb von 4 Sekunden auf, d.h. im Durchschnitt eine Ausnahme in einer drittel 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 der Direktive gestoppt wird.

· Jede Ausgabe anzeigen

Um jede Ausgabe im Output-Bereich zu sehen, die mit OutputDebugString erzeugt werden, ist dieser Menüpunkt auszuwählen. Ist diese Einstellung deaktiviert, werden Programmzeilen unterdrückt, z.B. beim Überspringen von Schleifen oder Prozeduren. Es wird davon ausgegangen, dass deren nähere Betrachtung, da sie ja übersprungen werden, nicht gewünscht ist.

Hinweis: Nach der Ausgabe von 1500 Zeilen werden, sowie neue Zeilen hinzugefügt werden, die obersten Zeilen gelöscht.

Neben der Programmzeilenausgabe wird zusätzlich noch die benötigte Zeit angezeigt. In der ersten Spalte wird die Zeit seit Programmstart angezeigt und in der zweiten Spalte die Differenz zur vorherigen Zeile. Damit können einfache Performance-Messungen durchgeführt und zeitkritische Routinen einfach ermittelt werden.

Hinweis: Die Zeitmessung gibt einen ungefähren Anhaltspunkt über die Ausführungsdauer, jedoch keinen genauen, da der Debugger auch Zeit für die Verarbeitung benötigt. Dieser Umstand sollte stets berücksichtigt und bedacht werden.

#Hilfe

· PrfDebug-Hilfe öffnen

Zeigt die Hilfe an.

· Übersicht Tastenbelegung

Zeigt in der Hilfe die Übersicht der Tastenbelegung (Tastenkürzel) an.

· XProfan-Hilfe öffnen

Ruft die XProfan-Hilfe auf.

· Andere Hilfe-Datei öffnen

Es wird ein Dialog zum Öffnen einer beliebigen Hilfe-Datei angezeigt.

· Debuggen im Internet

Zeigt eine Sammlung von Verknüpfungen auf Seiten in das Internet, die sich mit dem Thema Debuggen beschäftigen. Mit der Auswahl eines Unterpunktes wird der installierte Web-Browser geöffnet und die Seite angezeigt.

· Info über

Zeigt Informationen über den Debugger an.

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


Tastenkürzel

Alt+A = Aktivierung des Debuggers injizieren, d.h. der Inhalt der Datei PrfDebug.Start.inc wird an der aktuellen Cursor-Position im SourceCode-Bereich eingefügt.

Alt+C = Alle Fenster des Debuggers leeren, dies entspricht dem Toolbarbutton [image] .

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

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

Alt+G = Die umfassende Ausgabe von Zeichenketten im Output-Bereich wird an- oder abgeschaltet.

Alt+S = Debug-Ergebnisse in Datei sichern.

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

Alt+Q = Beendet den Debug-Vorgang und den Debugger, dies entspricht dem Toolbarbutton [image] .

Alt+V = Es wird an- oder abgeschaltet, dass das Debugger-Fenster immer im Vordergrund steht (AllwaysOnTop).

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

Alt+X = Beendet den Debug-Vorgang und den Debugger, dies entspricht dem Toolbarbutton [image] .

Alt+Y = Deaktivierung des Debuggers injizieren, d.h. der Inhalt der Datei PrfDebug.Stop.inc wird an der aktuellen Cursor-Position im SourceCode-Bereich eingefügt.

Strg+G = Öffnet oder schließt den Direktbereich.

Strg+H = Erweitert das Programmfenster des Debuggers bis zum oberen Bildschirmrand oder stellt die Ausgangsposition wieder her.

Strg+O = Öffnet den Dialog zum Laden eines Programmes, dies entspricht dem TooBar-Icon [image] .

Strg+R = Führt ein Refresh des Programmfensters des Debuggers durch. Alle Bildschirmelemente des Debuggers werden neu gezeichnet.

Strg+S = Sichert den geänderten Quellcode.

F1 = Öffnet die Hilfe des Debuggers.

Strg+F1 = Öffnet die XProfan-Hilfe.

Alt+F1 = Es wird ein Dialog geöffnet, mit dem eine beliebige Hilfe-Datei ausgewählt und geöffnet werden kann.

F3 = Es öffnet sich ein Dialog mit dem eine Textdatei zum Anzeigen ausgewählt werden kann.

F5 = Startet den Debug-Vorgang, oder, wenn er bereits aktiv ist, führt das Programm ohne Pause weiter aus. Dies entspricht dem Toolbarbutton [image] .

Shift+F5 = Restart entspricht dem Toolbarbutton [image] . Damit wird der laufende Debug-Vorgang beendet und erneut gestartet.

F8 = Führt den nächsten Befehl des Programms aus, dies entspricht dem Toolbarbutton [image] .

Shift+F8 = 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. Dies entspricht dem Toolbarbutton [image] .

Alt+F8 = Führt das Programm ohne Pause weiter aus, bis der Befehl Wend, EndWhile, Until oder EndSelect ausgeführt wird. Nach der Ausführung dieses Befehls wird das Programm gestoppt. Dies entspricht dem Toolbarbutton [image] .

Strg+F8 = Führt das Programm ohne Pause bis zur aktuellen Cursor-Position aus.

F9 = Setzt oder löscht einen Haltepunkt. Dies entspricht dem Toolbarbutton [image] .

Shift+F9 = Zeigt alle Haltepunkte in einer Liste an. Dies entspricht dem Toolbarbutton [image] .

Strg+Shift+F9 = Löscht alle Haltepunkte. Dies entspricht dem Toolbarbutton [image] .

F10 = Führt das Programms bis zum Eintreten des nächsten Ereignisses aus, dies entspricht dem Toolbarbutton [image] .

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. Dies entspricht dem Toolbarbutton [image] .

F12 = Beendet den Debug-Vorgang, dies entspricht dem Toolbarbutton [image] .

Pause = Unterbricht die automatische Ausführung des Debug-Vorganges, dies entspricht dem Toolbarbutton [image] .

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


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.

Hinweis: Weitere Argumente werden vom Debugger nicht verarbeitet und müssen, sofern gewünscht, über den Menüpunkt Option - Programmargumente... übergeben werden.

Created with the Personal Edition of HelpNDoc: What is a Help Authoring tool?


Bevor es los geht

Folgende Grundeinstellungen des Debuggers sollten bei dessen ersten Benutzung durchgeführt werden:

· Die XProfan-Verzeichnisse sollten eingestellt werden. Dazu Menü Optionen - XProfan-Verzeichnis... wählen. Den Button mit den drei Punkten betätigen und Interpreter sowie Runtime auswählen: Die Pfade werden automatisch übernommen.

· Die Pfade für die Include-, Header- und Unit-Dateien sollten eingestellt werden. Dazu Menü Optionen - Include-Verzeichnis... wählen. Nun können die Pfade eingetragen werden, mehrere Pfade werden durch ein Semikolon getrennt (;).

Die Pfade werden in die Datei PROFED32.INI im Windows-Verzeichnis eingetragen und vom XProfan-Interpreter bzw. -Compiler zur Laufzeit abgefragt. Sollten bereits, z.B. durch den XProfan-Editor, Einträge vorhanden sein, so werden diese im Dialog angezeigt.

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


Der Debug-Vorgang

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

· Zuerst wird in der Toolbar der Button "Programm laden" [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 und im SourceCode-Bereich die Datei angezeigt.

· Jetzt die F5-Taste oder in der Toolbar der Button "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. Im Output-Bereich wird die Zeile: "FILE: DATEINAME.PRF", bzw. der entsprechende Pfad und Dateiname angezeigt.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen und Schritt für Schritt das Programm ausführen.

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

Der Output-Bereich sieht wie folgt aus:

· Nun die Tasten Shift-F8 oder in der Toolbar den Button "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 Direktbereich werden die Zahlen, die in der Prozedur mit DebugOut definiert wurden, angezeigt.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen. Es wird das Kommando @Set("DebugMode", 0) ausgeführt. Die folgenden Programmteile werden nun ohne Debugger-Unterstützung ausgeführt.

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

· Das folgende Kommando @Set("DebugMode", 2) führt dazu, dass die Programmausführung gestoppt wird.

· Jetzt die Tasten Strg+F8 oder in der Toolbar den Button "Bis über das nächste Wend/EndWhile/Until/EndSelect" [image] betätigen. Jetzt wird die folgende Schleife schrittweise ausgeführt.

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

· Nach zweimaligem Betätigen der F8-Taste oder des Buttons "Nächster Schritt" [image] in der Toolbar wird das Programm beendet, und wir haben den gleichen Status wie in Punkt 3 dieser Beschreibung.

Mit diesem Beispiel haben wir die grundlegenden Vorgehensweisen des Debuggers kennen gelernt. Auf der einen Seite die Einzelschrittmethode, um die Programmausführung zeilenweise und damit im höchsten Detailgrad zu betrachten. Auf der anderen Seite die Vorgehensweisen bei Prozeduren, Funktionen und Schleifen, also in der nächst höheren Aggregationsebene, für die Ausführung von Code-Blöcken. Dies gibt uns die Basis für den Umgang mit dem Debugger.

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


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: Produce online help for Qt applications


Debuggen von Include-Dateien, Units, Header-Dateien und DLLs

Include-Dateien

Wird eine Funktion oder Prozedur aus einer Include-Datei aufgerufen, welche mit der Direktive $I in das XProfan-Programm eingebunden wird, 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.

Header-Dateien

Wird eine Funktion oder Prozedur aufgerufen, die in einer Header-Datei definiert ist, welche mit der Direktive $H in das XProfan-Programm eingebunden wird, erfolgt deren Bearbeitung genauso wie bei einer Unit. Die Funktion oder Prozedur wird einem Schritt ausgeführt, ohne die Verarbeitung detailliert zu zeigen.

DLLs

Funktionen und Prozeduren aus DLLs können in einem XProfan-Programm mit dem Kommando Def definiert und bereitgestellt werden. Wird nun eine solche Funktion oder Prozedur im Programm aufgerufen, so wird, genauso wie bei den Units, diese in einem Schritt ausgeführt, ohne dass ihre Verarbeitung im einzelnen nachvollzogen werden kann.

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


Debuggen mit Befehlsfolgen im Einzelschritt

Mit dem Beispielprogramm UVKRXS sollen nun die Befehlsfolgen im Einzelschritt etwas verdeutlicht werden:

· Zuerst wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "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 den Button "Debuggen starten/Ausführen" [image] betätigen.

Hinweis: Jetzt wird das Programm automatisch Schritt für Schritt 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 den Button "Debuggen beenden" [image] in der Toolbar betätigen.

Created with the Personal Edition of HelpNDoc: Easy CHM and documentation editor


Debuggen mit Debug-Ereignissen

Mit folgendem Quellcode können wir sehr leicht das Debuggen mit Debug-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 wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen.

· Jetzt die F10-Taste oder in der Toolbar den Button "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 Direktbereich wird die Zeile DLL$ = [PFAD]\mshtml.dll angezeigt bzw. der entsprechende Pfad und Dateiname angezeigt.

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

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

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

Wichtiger Hinweis: Wird ein Programm beendet, so werden auch diverse Ereignisse dokumentiert, z.B. das Entladen von DLLs oder das Terminieren des Prozesses. Diese Ereignisse werden nicht abgefangen, da diese in dem Moment auftreten, wenn das Programm beendet wird. D.h. es werden nur Ereignisse abgefangen, die während der Ausführung eines Programmes auftreten, aber nicht zum Start oder zum Ende.

Created with the Personal Edition of HelpNDoc: Create iPhone web-based documentation


Debuggen von Programmen mit Callback-Funktion

Mit diesem Beispielprogramm UVKSSS 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. Die Zeile Set("DebugMode", 2) wurde hinzugefügt.

2. Die Zeile mit der Sprungmarke BreakPoint: wurde hinzugefügt.

Nun zum Ablauf:

· Zuerst wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen.

· Das Programm stoppt in der Zeile mit dem Befehl Window 0, 0 - 640, 480.

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

· Nun die F11-Taste betätigen oder in der Toolbar den Button "Bis über das Kommando..." [image] betätigen. In sich das dann öffnende Fenster "BreakPoint:" eingeben und den Ok-Button betätigen.

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

· 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. Die Ausführung des Programms kann jetzt mit der F8-Taste, bzw. in der Toolbar mit dem Button "Nächster Schritt" [image] , oder der F11-Taste, bzw. in der Toolbar 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 Toolbar 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 uns Betrachtern 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 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: Create iPhone web-based documentation


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: Free help authoring tool


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, welcher der 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 den Button "Programm laden" [image] anklicken und das Programm auswählen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

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

· Im Direktbereich 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). In der Output-Zeile, oberhalb des SourceCodes, wird 32766 i& = 32766 angezeigt.

· Jetzt die F8-Taste oder in der Toolbar den Button "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 UVKTWS.

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

Es ist ohne weiteres möglich, die Programmausführung von Programmen mit großer Zeilenzahl im Debugger zu betrachten. Einschränkungen müssen bei einer Zeilenzahl von mehr als 32767 hingenommen werden, siehe hierzu auch Tips und Tricks UVKTXS.

Created with the Personal Edition of HelpNDoc: Easy CHM and documentation editor


Debuggen objektorientierter Programme

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

· Zuerst wird in der Toolbar den Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "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 den Direktbereich des Debuggers.

· Schreiten wir jetzt mit der F8-Taste, oder in der Toolbar den Button "Nächster Schritt" [image] , bis zur Zeile 42 vor, so liefert das Programm die Zahl 231263 an den Direktbereich 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: iPhone web sites made easy


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 PDF documentation generator


Debuggen mit Argumentübergabe

Mit dem folgenden Programm können wir die Argumentübergabe an ein XProfan-Programm überprüfen:

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

@Set("DebugMode", 2)

DebugOut 0, %ParCount + 1

WhileLoop 0, %ParCount, 1

DebugOut 0, @Par$(&Loop)

EndWhile

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

End

· Zuerst wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen und Schritt für Schritt das Programm ausführen. Da wir keine Argumente angegeben haben, erscheint im Direktbereich als Anzahl der Argumente 2 und die entsprechenden Argumente: Zum einen der Interpreter und zum anderen der Name unseres Programmes

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen, um das Programm bis zum Ende auszuführen.

· Nun die obigen Schritte bis zum ersten Betätigen der F5-Taste wiederholen, und bevor der Debug-Vorgang gestartet wird, die Programmargumente eingeben.

· Als nächstes öffnen wir den Dialog "Programmargumente" über die Auswahl des Menüs Optionen - Programmargumente... und geben folgende Argumente ein:

Nach der Eingabe ist der Ok-Button zu betätigen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Nun die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen und Schritt für Schritt das Programm ausführen.

Wie wir sehen sind jetzt 13 Argumente erkannt worden, zwei die im Interpreter-Modus immer vorhanden sind und die von uns 11 spezifizierten. Sie werden im Direktbereich sukzessive angezeigt.

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


Debuggen mit Haltepunkten

Mit dem Beispielprogramm UVKRXS zum Debug-Vorgang wird nun die Handhabung von Haltepunkten, die mit der F9-Taste bzw. mit dem Toolbarbutton [image] gesetzt oder gelöscht werden können, verdeutlicht.

· Zuerst wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Nun setzen wir nach und nach in allen Zeilen, die einen Print-Befehl beinhalten, den Cursor und betätigen die F9-Taste oder das Toolbarbutton "Haltepunkt setzen/löschen" [image] .

· Im Folgenden wird die F5-Taste oder das Toolbarbutton "Debuggen starten/Ausführen" [image] betätigt.

· Die Programmausführung stoppt nach der Ausgabe von Hugo1.

· Mit jeder weiteren Betätigung der F5-Taste oder des Toolbarbuttons "Debuggen starten/Ausführen" [image] wird die Programmausführung nach der Ausgabe von HugoX, wobei X die jeweilige Zahl darstellt, gestoppt. Dieser Vorgang geht bis Hugo10.

· Nun wird mit dem Befehl @Set("DebugMode", 0) die unterbrechungsfreie Ausführung aktiviert und BambiX wird ausgegeben, ohne dass der gesetzte Haltepunkt zum Stoppen führt.

· Erst mit dem Befehl @Set("DebugMode", 2) wird die Möglichkeit zum Stoppen wieder aktiviert und die Ausführung stoppt nach Fritz1.

· Überprüfen wir zwischenzeitlich doch einmal die Liste der gesetzten Haltepunkte mit dem Toolbarbutton "Alle Haltepunkte anzeigen" [image] :

· Mit dem Betätigen des Toolbarbuttons "Alle Haltepunkte löschen" [image] oder den Tasten Strg+Shift+F9 werden alle Haltepunkte entfernt.

· Wird die F5-Taste bzw. der Toolbarbutton "Debuggen starten/Ausführen" [image] betätigt, so wird das Programm weiter ausgeführt und beendet.

Hinweis: Haltepunkte werden nur dann berücksichtigt, wenn der Debug-Modus @Set("DebugMode", 2) aktiviert ist. Auch werden sie nur im aktuell geöffneten Quelltext berücksichtigt, d.h. wird z.B. ein Haltepunkt in einer Include-Datei gesetzt und diese wird von einem Programm mit "Debuggen starten/Ausführen" verwendet, wird der Haltepunkt nicht berücksichtigt, da die Include-Datei nicht geöffnet wird. Soll der gesetzte Haltepunkt verwendet werden, so ist der Aufruf der Include-Datei so auszuführen, dass diese mittels FILE geöffnet wird.

Es sind die Einschränkungen UVKTWS für die Verwendung von Haltepunkten sowie die Hinweise zu Haltepunkten im SourceCode1GI66BN zu beachten.

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


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 5 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.

Hinweis: Die Verwendung eines Haltepunktes, in einer Zeile mit mehreren Befehlen, führt zu mehrfachen Stopps in der Zeile.

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


Mehrere Zeilen für ein Befehl

Um zu sehen wie XProfan mit einem Befehl über mehreren Zeilen umgeht, verwenden wir folgendes Programm:

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

@Set("DebugMode", 2)

Print "Hier werden mehrere Zeilen" + \

" in einem Befehl verwendet" + \

" um zu demonstrieren, was passiert."

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

End

XProfan führt einen Befehl über mehrere Zeilen so aus, als ob er in der letzten Zeile als eine zusammenhängende Zeichenkette geschrieben wäre. In unserem Beispiel wird also in der 7. Zeile der gesamte Befehl zusammengefasst. Bei der Verwendung von mehreren Zeilen für einen Befehl sollte dieser Umstand beim Debugging-Vorgang immer bedacht werden.

Hinweis: Wird ein Haltepunkt, bei einem Befehl über mehrere Zeilen, verwendet, so ist immer die letzte Zeile als Haltepunkt zu wählen. Wird eine andere gewählt, so wird die Programmausführung nicht angehalten, da die anderen Zeilen "nicht" ausgeführt werden.

Created with the Personal Edition of HelpNDoc: Create HTML Help, DOC, PDF and print manuals from 1 single source


Verwenden der Direktive $B/$D

Mit dem Beispielprogramm soll die Vorgehensweise der Verwendung der Direktiven $B (Break) und $D (Debug) verdeutlicht werden. Dieses Programm 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-------------------------------------------------------------------

End

· 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 wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen.

· Nun die Tasten Shift-F8 oder in der Toolbar den Button "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 Direktbereich wird die BREAK-Ausgabe angezeigt.

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

· Nun Betätigen wir die Tastenkombination Alt+P oder wählen den Menüpunkt Optionen - Bei Direktive $B/$D immer stoppen und deaktivieren diesen.

· Werden jetzt die Shift-F8-Tasten betätigt, so wird die Prozedur bis zu ihrem Ende ausgeführt, obwohl die Direktive $B verwendet wird. Die Programmausführung stoppt in der nächsten Zeile nach dem Prozeduraufruf.

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

· Jetzt die Taste Strg+F8 oder in der Toolbar den Button "Bis über das nächste Wend\EndWhile\Until/EndSelect" [image] betätigen. Die Programmausführung stoppt nach der Direktive $D.

Hinweis: Im Direktbereich 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+P oder wählen den Menüpunkt Optionen - Bei Direktive $B/$D immer stoppen und deaktivieren diesen.

· Jetzt die F5-Taste betätigen oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] und das Programm wird vollständig ausgeführt und beendet.

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


PrfDebug-Unit zur optimaleren Unterstützung des Debuggers

Die Unit zur Unterstützung des XProfan-Debuggers beinhaltet die Klasse Debug. Sie enthält Methoden zur aktiven Unterstützung des Debugvorganges und zur Fehlersimulation.

Zusätzlich ist eine Dummy-Prozedur Stop definiert. Wird dieser Befehl verwendet, so wird die Programmausführung durch den Debugger angehalten, egal welche Aktion gerade durchgeführt wird.

Die Klasse Debug im Detail

Sie enthält sieben Methoden: Go, Stop, Print, Assert, Script, Fail und GetLastError. Mit der Methode Stop wird die Programmausführung im Debugger angehalten, die mit Go gestartet wurde, oder sie kann zur Initialsierung des Debug-Vorganges verwendet werden. Mit Print wird eine Ausgabe im Direktbereich des Debuggers erzeugt. GetLastError zeigt den letzten aufgetretenen Systemfehler als Klartext im Direktbereich an. Assert unterbricht die Programmausführung im Debugger, wenn die übergebene Bedinung wahr ist. Mit der Methode Fail kann ein Ausnahmefehler simuliert werden, z.B. zu Testzwecken der Überprüfung der Fehlerbehandlung. Die Script-Methode stellte einige Funktionen bereit, mit denen der Debugger gesteuert werden kann.

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

'-

'- Unit zur Unterstuetzung des XProfan-Debuggers

'-

'- Autor: Stefan Schnell

'-

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

$L

'-Header-Dateien------------------------------------------------------

$H Windows.ph

'-Class definitions---------------------------------------------------

Class Debug = +Assert@, \

+Fail@, \

+GetLastError@, \

+Go@, \

+Print@, \

+Script@, \

+Stop@

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

'-

'- Unterbricht die Ausfuehrung, nach einem Debug#.Go(), 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.Fail------------------------------------------------

'-

'- Erzeugt einen Ausnahmefehler

'-

'- Aufruf: Debug#.Fail(Fehlernummer[, Request])

'-

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

Proc Debug.Fail

Declare Skip&

If %PCount = 1

Parameters Number&

Declare Request&

Request& = 0

Skip& = 0

ElseIf %PCount = 2

Parameters Number&, Request&

Skip& = 0

Else

Skip& = 1

EndIf

IfNot Skip&

If Request&

If @MessageBox("Soll die Ausnahme " + @Str$(Number&) + \

" erzeugt werden?", "Ausnahmerückfrage", 36) = 6

~RaiseException(Number&, 0, 0, 0)

EndIf

Else

~RaiseException(Number&, 0, 0, 0)

EndIf

EndIf

EndProc

'-Procedure Debug.GetLastError----------------------------------------

'-

'- Gibt den letzten aufgetretenen Systemfehler als erklaerenden

'- Text im Direktbereich des Debuggers aus

'-

'- Aufruf: Debug#.GetLastError()

'-

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

Proc Debug.GetLastError

Declare Result&, ErrorText&, LastError&

Clear Result&, ErrorText&, LastError&

LastError& = ~GetLastError()

~SetLastError(0)

If LastError&

Result& = ~FormatMessage(~FORMAT_MESSAGE_ALLOCATE_BUFFER | \

~FORMAT_MESSAGE_FROM_SYSTEM, 0, LastError&, ~LANG_NEUTRAL, \

@Addr(ErrorText&), 0, 0)

If Result&

Debug.Print(@String$(ErrorText&, 0))

If ~LocalFree(ErrorText&)

LastError& = ~GetLastError()

Debug.Print("Es ist der Fehler " + @Str$(LastError&) + \

" ($" + @Hex$(LastError&) + ") aufgetreten")

EndIf

Else

Debug.Print("Es ist der Fehler " + @Str$(LastError&) + \

" ($" + @Hex$(LastError&) + ") aufgetreten")

EndIf

EndIf

EndProc

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

'-

'- Setzt die Programmausfuehung, nach einem Debug#.Stop(), 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$

If @Len(PrintString$) > 65534

PrintString$ = @Left$(PrintString$, 65534) + @Chr$(0)

EndIf

~OutputDebugString(@Addr(PrintString$))

ElseIf %PCount = 2

Parameters PrintString$, Mode&

If @Len(PrintString$) > 65534

PrintString$ = @Left$(PrintString$, 65534) + @Chr$(0)

EndIf

DebugOut Mode&, PrintString$

EndIf

EndProc

'-Procedure Debug.Script----------------------------------------------

'-

'- Fuehrt eine Funktion im Debugger aus

'-

'- Aufruf: Debug#.Script(Command)

'-

'- Kommandos: OutputClear = Loescht alle Ausgabebereiche

'- DirectHide = Direktfenster wird geschlossen

'- DirectShow = Direktfenster wird geoeffnet

'-

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

Proc Debug.Script

If %PCount = 1

Parameters Command$

Declare hDebug&

hDebug& = @FindWindow("Debugger für XProfan")

If hDebug&

If Command$ = "OutputClear"

@PostMessage(hDebug&, ~WM_USER, 0, $1000)

ElseIf Command$ = "DirectHide"

@PostMessage(hDebug&, ~WM_USER, 0, $1001)

ElseIf Command$ = "DirectShow"

@PostMessage(hDebug&, ~WM_USER, 0, $1002)

EndIf

EndIf

EndIf

EndProc

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

'-

'- Initialisiert den Debug-Vorgang oder unterbricht die

'- Programmausfuehrung, die durch ein Debug#.Go() eingeleitet wurde

'-

'- Aufruf: Debug#.Stop()

'-

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

Proc Debug.Stop

@Set("DebugMode", 2)

EndProc

'-Procedure Stop------------------------------------------------------

'-

'- Bereitstellung einer Dummy-Prozedur um die Programmausfuehrung

'- in jedem Fall, mit Aufruf dieses Befehls, zu stoppen

'-

'- Aufruf: Stop

'-

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

Proc Stop

EndProc

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

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


Die Verwendung der XProfan-Unit

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

· Zuerst wird in der Toolbar der Button "Programm laden" [image] angeklickt und das Programm ausgewählt und geladen.

· Jetzt die F5-Taste oder in der Toolbar den Button "Debuggen starten/Ausführen" [image] betätigen.

· Jetzt die F8-Taste oder in der Toolbar den Button "Nächster Schritt" [image] betätigen.

· Nun die Taste Shift-F8 oder in der Toolbar den Button "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 Direktbereich die gewünschten Texte ausgegeben.

· Als nächster Befehl wird nun Debug#.Go() ausgeführt, nun die F8-Taste oder in der Toolbar den Button "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 den Button "Bis über das Kommando..." [image] betätigen. In den sich nun öffnenden Dialog die Sprungmarke BreakMark: eintragen und den Ok-Button drücken.

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

· Wird nun die F5-Taste, oder in der Toolbar der Button "Debuggen starten/Ausführen" [image] betätigt, so kommt die folgende Schleife zur Ausführung und das Programm stoppt in der Zeile Debug#.Fail(17), nach dem Befehl Stop.

· Mit Abarbeitung dieser Zeile wird ein Ausnahmefehler erzeugt. Im Bereich Exceptions/DebugErrors wurde die Meldung "Debug-Ausnahmeereignis mit dem Code UNKNOWN" ausgegeben.

· Zum Beenden des Debug-Vorganges die Taste F12 oder den Button "Debuggen beenden" [image] in der Toolbar betätigen.

Created with the Personal Edition of HelpNDoc: Create iPhone web-based documentation


Unit-Beispielprogramm

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

$U PrfDebug.pcu

Declare Debug#

Dim Debug#, Debug

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

Stop

Debug#.Fail(17)

Dispose Debug#

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

End

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


PrfDebug-Include zur einfacheren Einbindung der Debug-Unterstützung

Um nicht jedesmal die wenigen Zeilen zur Unterstützung eines Debugging-Vorganges eintippen zu müssen, hier eine Include-Datei, die dies für uns erledigt:

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

'-Procedure FreePrfDebug----------------------------------------------

Proc FreePrfDebug

@Set("DebugMode", 0)

Dispose Debug#

EndProc

'-PrfDebugSupport-----------------------------------------------------

$U PrfDebug.pcu

Declare Debug#

Dim Debug#, Debug

@Set("DebugMode", 2)

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

Die Include-Datei muss mit $I PrfDebug.inc im Kopf, d.h. zu Beginn des zu untersuchenden Programms, eingebunden werden. Damit steht die volle Unterstützung des Debuggers zur Verfügung, z.B. können jetzt mit Stop beliebig Unterbrechungspunkte im Programmablauf hinzugefügt werden.

Wichtiger Hinweis: Wird die Include-Datei verwendet, so darf nicht vergessen werden, spätestens zum Ende der Programmausführung, den Speicherbereich der instanzierten Klasse mit Dispose wieder freizugeben, bzw. die Prozedur FreePrfDebug aufzurufen.

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


Code-Injektion zur vereinfachten Übernahme von Modulen

Um Code-Blöcke einfacher in das zu untersuchende Programm übernehmen zu können, bietet der Debugger die Funktion der Code-Injektion, die mit dem Toolbarbutton [image] ausgeführt werden kann. Es öffnet sich ein Dialog, mit dem eine beliebige XProfan-Quellcode-Datei ausgewählt werden kann. Sobald die Datei gewählt ist, wird deren Inhalt an der aktuellen Cursor-Position eingefügt.

Wird bei geladenem Quellcode und nicht aktivem Debug-Prozess die rechte Maustaste im SourceCode-Bereich betätigt, so öffnet sich ein Popup-Menü. In diesem Menü gibt es u.a. zwei Menüpunkte "Aktivierung des Debuggers injizieren" und "Deaktivierung des Debuggers injizieren". Wird der Menüpunkt "Aktivierung..." ausgewählt, so wird der Inhalt der Datei PrfDebug.Start.inc an der aktuellen Cursor-Position eingefügt. Wird der Menüpunkt "Deaktivierung..." gewählt, so geschieht selbiges, jedoch mit der Datei PrfDebug.Stop.inc. Das Hinzufügen der Aktivierung kann auch mit der Tastenkombination Alt+A vorgenommen werden, die Deaktivierung hingegen mit Alt+Y.

Hinweis: Der Inhalt einer Datei wird als Zeichenkette in den SourceCode-Bereich des Debuggers kopiert. Die maximale Länge beträgt 64.000 Zeichen, d.h. dass keine Datei die größer ist, verwendet werden kann.

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


Einschränkungen und Systemvoraussetzungen

Siehe auch Benutzerhinweise und Ratschläge 2WGDZFX.

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ährleistungsausschluss UVKTZS verwiesen. Weiterhin bedarf es für den Betrieb des Debuggers XProfan 9. Die verwendete Bildschirmauflösung sollte mindestens 800 mal 600 Pixel betragen, um den Debugger vollständig auf dem Bildschirm zu sehen. Die eingestellte Schriftauflösung sollte bei 96 dpi (dots per inch) 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.

· Ebenso wie eine Markierung ab der 32766. Zeile nicht mehr angezeigt wird, kann auch kein Haltepunkt ab dieser Zeile mehr gesetzt werden. Wird trotzdem versucht einen Haltepunkt in einer Zeile > 32766 zu setzen, so erscheint ein Hinweis, dass dies nicht möglich ist.

· Werden Dateien verändert, wenn Haltepunkte gesetzt sind, und werden die Haltepunkte nicht gelöscht, so kann es zu undefinierten Markierungen und Verhalten bei der folgenden Programmausführung kommen. Es ist anzuraten, die Haltepunkte, die von der Änderung einer Datei betroffen sind, zu löschen und gegebenenfalls neu zu setzen. Es liegt in der Verantwortung des Anwendersm, den für ihn richtigen Weg zu wählen.

· Haltepunkte in Befehlen über mehrere Zeilen müssen immer in der letzten Zeile gesetzt werden. Wird der Haltepunkt in einer anderen Zeile gesetzt, wird die Programmausführung nicht gestoppt.

· Wird ein neues Programm geladen, so werden nicht automatisch bestehende Haltepunkte gelöscht. Hat das neu geladene Programm einen anderen Namen, sollte es nicht zu Konflikten kommen. Bei gleichen Namen kann es jedoch zu undefinierten Markierungen und Verhalten kommen. Es ist grundsätzlich anzuraten, wenn ein neues Programm in den Debugger geladen wird, alle Haltepunkte zu löschen [image] um Konflikte zu vermeiden.

· Vermeiden Sie die alleinige Verwendung der Befehle TraceOn und TraceOff bei Programmen, die mit dem Debugger überwacht werden. Sie können zu Störungen des Bildschirmaufbaus des Debuggers führen. 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.

· Wird die Funktion @GetFocus in der Ereignisschleife eines Programms zur Abfrage der Betätigung von Steuerelementen verwendet, so kann es zu einer abweichenden Ausführung des Programmes kommen, d.h. der auszuführende Schleifenzweig wird nicht wie erwartet ausgeführt. Dieses Verhalten erklärt sich damit, dass das abgefragte Steuerelement seinen Fokus, wegen der Betrachtung mit dem Debugger, verloren hat. Auf die Verwendung von @GetFocus zum Abfragen der Betätigung von Steuerelementen sollte deshalb verzichtet und stattdessen die Funktion @Clicked oder die Variable %GetFocus verwendet werden.

· Wird eine andere Bildschirmauflösung als 96 dpi verwendet, oder die anwenderspezifischen Einstellungen der Schriftarten weichen extrem vom Standard ab, kann es sein, dass Texte teilweise nicht mehr lesbar sind, da die Größe der Steuerelemente unabhängig von der Bildschirmauflösung fix definiert sind. Obwohl die Texte nicht vollständig zu sehen sind, arbeitet der Debugger korrekt weiter, hierbei handelt es sich nicht um einen Fehler.

· Wenn ein größerer Quelltext geladen und mittels der 'Bild ab'-Taste bzw. Scroll-Balken z.B. an sein Ende verfahren wird, kann es zu Abweichungen zwischen Zeilennummer und zugehöriger Zeile kommen, d.h. die Zeilennummer wird versetzt zu der Zeile angezeigt. Diese Abweichung korrigiert sich automatisch sobald der Text mit der 'Pfeil rauf'- bzw. 'Pfeil runter'-Taste erneut versetzt wird. Alternativ kann auch zum Ende der Datei mit der Tastenkombination Strg + Ende bzw. zum Anfang mit der Tastenkombination Strg + Pos1 gesprungen werden, dann tritt die Abweichung nicht auf.

Created with the Personal Edition of HelpNDoc: Easy to use tool to create HTML Help files and Help web sites


Tipps 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. Siehe hierzu auch die Einschränkungen UVKTWS.

· Die zur Verwendung kommenden Tasten des Debuggers entlehnen sich zum Teil des Debuggers für Visual BASIC. Wer diesen Debugger und den Umgang damit kennt, dem dürfte die Arbeit mit XProfan-Debugger nicht besonders schwer fallen. Abweichungen gibt es eben an den Stellen, die, bedingt durch unterschiedliche Verfahrens- und Arbeitsweisen, unterschiedliche Vorgehensweisen erfordern.

· Haltepunkte [image] bzw. das "Bis über das Kommando" [image] führen die gewählte Anweisung ebenfalls aus und stoppen erst dann die weitere Ausführung. Soll eine Anweisung untersucht werden, so ist der Haltepunkt vor dieser Anweisung zu setzen bzw. die Auswahl des "Bis über das Kommando" entsprechend zu erfolgen.

· Der Debugger legt eine gleichnamige INI-Datei im selben Unterverzeichnis an. In dieser Datei gibt es die Sektion [Einstellungen]. In diesem Bereich können die Vorgaben für die Wartezeit in Millisekunden zwischen den auszuführenden Befehle im Einzelschrittmodus (SingleStepTime) definiert werden, sowie die Anzahl der auftretenden Fehler (WatchDogCommands) pro Zeitraum (WatchDogTime) bevor die Ausnahmeüberwachung die Programmausführung mit ihrer Rückfrage unterbricht.

· Wird ein Programm im Einzelschrittmodus ausgeführt, und es wird z.B. via @MCISend$("PLAY SOUND") eine Audio-Datei gestartet, so ist der entsprechende Sound nicht zu hören. Soll der Sound aber während der Einzelschrittausführung abgespielt werden, so muss @MCISend$("PLAY SOUND WAIT") verwendet werden. Der Debug-Vorgang wird für die Dauer des Sounds gestoppt und der Status der Eingabeverarbeitung gibt erst dann wieder grünes Licht, wenn der Sound vollständig abgespielt wurde.

· Bei der Verwendung von virtuellen Bildschirmen sollte stets darauf geachtet werden, dass eine Umschaltung zu einem anderen Bildschirm erst dann erfolgt, wenn der Eingabestatus des Debuggers das Warten auf die nächste Eingabe, durch die grüne Ampel, signalisiert. Wird während einer Verarbeitung der Bildschirm gewechselt, kann dies zu Wartezuständen führen. Auch kann es bei dieser Vorgehensweise passieren, dass auftretende Hinweis- oder Meldungsdialoge auf anderen Bildschirmen angezeigt werden, und so ein "scheinbarer" Stillstand der Programmausführung im Debugger erreicht wurde.

Created with the Personal Edition of HelpNDoc: Easy to use tool to create HTML Help files and Help web sites


Weiterentwicklung

Wie fast alle Anwendungen, so lebt sie und entwickelt sich durch die 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@prfdebug.de.

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


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 Stefan Schnell. Eine Veränderung, Dekompilierung oder Disassemblierung ist untersagt.

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

Produktnamen, Logos und Warenzeichen werden, sofern verwendet, ausschließlich aus redaktionellen Gründen verwendet und sind das Eigentum der jeweiligen Inhaber, auch wenn explizit kein entsprechender Hinweis darauf erfolgt.

Gewährleistungs- und Haftungsausschluss

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. Ebenso wird auch nicht zugesichert, dass die hier beschriebenen Funktionen einwandfrei auf allen Computern ausgeführt werden.

Das Landgericht Hamburg hat mit Urteil vom 12.05.1998 entschieden, dass man durch die Anbringung eines Links die Inhalte der gelinkten Seite ggf. mit zu verantworten hat. Dies kann - so das Landgericht - nur dadurch verhindert werden, dass man sich ausdrücklich von diesen Inhalten distanziert. Es sind im Debugger Links zu anderen Seiten im Internet gelegt. Für alle diese Links gilt: Es wird ausdrücklich erklärt, dass keinerlei Einfluss auf die Gestaltung und die Inhalte der gelinkten Seiten vorliegt. Aus diesem Grund wird sich hiermit ausdrücklich von allen Inhalten aller gelinkten Seiten distanziert und diese Inhalte werden sich nicht zu Eigen gemacht. Des weiteren wird keinerlei Haftung für jedwede Aussage oder jedwedes Angebot übernommen, die auf den gelinkten Seiten getroffen werden.

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


Literaturverzeichnis

[1] Delphi 3 Lösungen, Andreas Kosch

Feldkirchen, Franzis Verlag, 1997

ISBN 3-7723-4163-2

[2] Debugging, David J. Agans

New York, AMACOM, 2002

ISBN 0-8144-7168-4

[3] WIN32 Programmierung, Windows 95/Windows NT API Bible, Richard J. Simon

Haar bei München, SAMS bei Markt und Technik Verlag

ISBN 3-8272-4502-8

[4] Win32 SDK Reference Help, Microsoft

1997

[5] Methodisches Testen von Programmen, G. J. Myers

München, Oldenbourg Verlag, 2001

ISBN 3-486-25634-3

Created with the Personal Edition of HelpNDoc: iPhone web sites made easy


NeuesDokument

Neues Dokument:

Es wird der aktuelle Fensterinhalt gelöscht und es können neue Notizen eingetragen werden.

Hinweis: Sollte der Fensterinhalt verändert worden sein, ohne dass er vorher gespeichert wurde, erscheint eine Rückfrage, ob die Operation trotzdem durchgeführt werden soll.

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


Öffnen

Öffnen:

Es kann eine Notizendatei im RichTextFormat (RTF) geöffnet und als Notiz geladen werden.

Created with the Personal Edition of HelpNDoc: Easy to use tool to create HTML Help files and Help web sites


Speichern

Speichern:

Die verfassten Notizen können als Datei im RichTextFormat (RTF) gespeichert werden.

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


Ausschneiden

Ausschneiden:

Der markierte Text wird ausgeschnitten und in die Zwischenablage (ClipBoard) kopiert.

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


Kopieren

Kopieren:

Der markierte Text wird in die Zwischenablage (ClipBoard) kopiert.

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


Einfügen

Einfügen:

Der in der Zwischenablage befindliche Text wird an der aktuellen Cursor-Position eingefügt.

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


Entfernen

Entfernen:

Der markierte Text wird gelöscht.

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


Rückgängig

Rückgängig:

Die letzten Änderungen im Text werden rückgängig gemacht.

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


Schriftart

Schriftart:

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit der ausgewählten Schrift formatiert.

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


Schriftgröße

Schriftgröße:

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit der ausgewählten Schriftgröße formatiert.

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


Schriftfarbe

Schriftfarbe:

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit der ausgewählten Schriftfarbe formatiert.

Created with the Personal Edition of HelpNDoc: Produce online help for Qt applications


Schriftstil Fett

Schriftstil "Fett":

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit dem Schriftstil fett formatiert.

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


Schriftstil Kursiv

Schriftstil "Kursiv":

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit dem Schriftstil kursiv formatiert.

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


Schriftstil Unterstrichen

Schriftstil "Unterstrichen":

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit dem Schriftstil unterstrichen formatiert.

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


Schriftstil Durchgestrichen

Schriftstil "Durchgestrichen":

Der markierte Text oder, sofern kein Text markiert ist, ab der aktuellen Cursor-Position wird mit dem Schriftstil durchgestrichen formatiert.

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


Programm laden

Programm laden:

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

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


Code injizieren

Code injizieren:

Es öffnet sich ein Dialog, mit dem eine beliebige Datei ausgewählt werden kann. Nach Auswahl einer Datei wird deren Inhalt an der aktuellen Cursor-Position im SourceCode-Bereich eingefügt.

Hinweis: Die einzufügende Datei darf nicht größer als 64.000 Zeichen sein.

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


Debuggen starten/Ausführen

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, Units, o.ä. geladen werden. Es ist unbedingt vor jeder weiteren Aktion abzuwarten, dass das Ampelsymbol des Status der direkten Eingabeverarbeitung grün angezeigt wird.

Created with the Personal Edition of HelpNDoc: Create HTML Help, DOC, PDF and print manuals from 1 single source


Haltepunkt setzen/löschen

Haltepunkt setzen/löschen:

Die aktuelle Zeile, also die in der sich der Cursor befindet, wird als Haltepunkt markiert, bzw. wenn sie als Haltepunkt bereits markiert ist, wird er gelöscht.

Created with the Personal Edition of HelpNDoc: Free EPub producer


Alle Haltepunkte löschen

Alle Haltepunkte löschen:

Löscht alle Haltepunkte.

Created with the Personal Edition of HelpNDoc: Free Kindle producer


Nächster Schritt

Nächster Schritt:

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

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


Bis über das nächste Return/EndProc

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 Web Help sites


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

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

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

Created with the Personal Edition of HelpNDoc: Create iPhone web-based documentation


Bis zum nächsten Ereignis

Bis zum nächsten Ereignis:

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

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


Bis über das Kommando...

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: Create iPhone web-based documentation


Debuggen unterbrechen

Debuggen unterbrechen:

Wird ein Programmabschnitt ausgeführt, so kann dieser Vorgang hiermit unterbrochen werden.

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


Debuggen neu starten

Debuggen beenden und neu starten:

Beendet den Debug-Vorgang und startet ihn erneut.

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


Debuggen beenden

Debuggen beenden:

Beendet den Debug-Vorgang.

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


Alle Haltepunkte anzeigen

Alle Haltepunkte anzeigen:

Zeigt alle Haltepunkte als Liste in einem Fenster an.

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


Ausgabefenster löschen

Ausgabefenster löschen:

Löscht die Inhalte der Fenster der Reiter, die beim Debugging-Vorgang Informationen erhalten.

Hinweis: Der SourceCode- und Notizen-Bereich wird hiermit nicht gelöscht, sondern nur die Fenster, die originär beim Debugging-Prozess befüllt werden.

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


Debugger beenden

Debugger beenden:

Beendet den Debug-Vorgang und den Debugger.

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


Status der direkten Eingabeverarbeitung

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.

Hinweis: Sollte das Ampelsymbol auf rot stehen, so ist es immer sicherer abzuwarten, bis es wieder grün anzeigt. Diese Strategie führt insgesamt zu einer absolut kontrollierten Ausführung des überwachten Programms.

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


DebugThread aktiv

DebugThread aktiv:

Das Feld DebugThread in der Statuszeile des Programms zeigt mit einem Ampelsymbol an, ob der DebugThread gerade aktiv ist, oder ob er nicht aktiv ist (dann ist die Ampel außer Betrieb).

Created with the Personal Edition of HelpNDoc: Easily create EBooks


Dateityp

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: Full-featured Kindle eBooks generator


Geladene Datei

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: News and information about help authoring tools and software


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: Produce Kindle eBooks easily