Der Entwickler von twinBASIC, Wayne Philips, ist vor allem für sein Fehlerbehandlungstool vbWatchDog bekannt. Kein Wunder, dass er bei der Programmierung der Entwicklungsumgebung darauf geachtet hat, dass ausreichende Debugging-Möglichkeiten vorhanden sind. Wie Sie diese nutzen, zeigt der vorliegende Beitrag. Dabei lernen Sie die verschiedenen Bereiche wie Variablen, Überwachen, Aufrufliste, Haltepunkte und den Debug-Bereich kennen.
Debugging in twinBASIC
Wenn Sie das Beispielprojekt aus dem Download geöffnet und die einzige enthaltene Datei HelloWorld.twin angezeigt haben, können Sie mit einem Klick auf die Schaltfläche Ausführen und Debuggen am linken Rand die Debugging-Bereiche der twinBASIC-Erweiterung von Visual Studio Code einblenden.
Sie können auch die Tastenkombination Strg + Umschalt + D nutzen, um den linken Bereich sichtbar zu machen. Hier finden Sie gleich vier Bereiche vor:
- Variablen: Zeigt die Inhalte der sichtbaren Variablen an.
- Überwachen: Hier können Sie Ausdrücke zur Überwachung hinzufügen.
- Aufrufliste: Hier werden die aktuell aufgerufenen Routinen abgebildet sowie die Routinen, von denen diese aufgerufen wurden.
- Haltepunkte: Zeigt die aktuellen Haltepunkte an. Per Klick springen Sie zur jeweiligen Zeile im Code.
Außerdem zeigt das Fenster im unteren Bereich noch die Debugging-Konsole an (siehe Bild 1).
Bild 1: Die verschiedenen Debugging-Bereiche
Routinen starten und durchlaufen
Derzeit ist twinBASIC noch eine reine Entwicklungsumgebung für EXEs ohne Benutzeroberfläche, DLLs, COM-Add-Ins et cetera. Da findet Debugging natürlich verstärkt in der Entwicklungsumgebung statt. Standardprojekte auf Basis der HelloWorld-Vorlage enthalten eine Main-Routine, die automatisch beim Start der Anwendung aufgerufen wird.
Um diese Routine direkt in der Entwicklungsumgebung zu starten, haben Sie mehrere Möglichkeiten:
- über den Debugging-Bereich
- durch Markieren der Routine und Betätigen der Taste F5 oder der Schaltfläche zum Starten der aktuell markierten Prozedur
- per Menüeintrag
Routine vom Debugging-Bereich aus aufrufen
Die erste Möglichkeit ist der Aufruf der Routine aus dem Debugging-Bereich heraus. Hier geben Sie den Namen der Routine und gegebenenfalls der Parmaeter an und betätigen die Eingabetaste.
Der Debugging-Bereich sieht etwas anders aus als im VBA-Editor. Sie können hier nicht einfach Befehle in den Bereich eintippen, sondern verwenden dazu den kleinen Bereich mit dem Größer-Zeichen (>). In dieser starten wir die Prozedur Test durch Eingabe des Routinennamens Test und anschließendes Betätigen der Eingabetaste.
Im Debugging-Bereich erfolgt dann die Ausgabe: erstens der Name der Routine, die gerade aufgerufen wurde, dann der Output der Routine mit der Debug.Print-Anweisung und schließlich die für den Aufruf benötigte Zeit (siehe Bild 2).
Bild 2: Starten einer Routine über den Debuggen-Bereich
Sie können die Debug.Print-Anweisung auch direkt von der >-Zeile aus aufrufen. Dann wird die Debug.Print-Anweisung ausgeführt und samt Aufruf und Laufzeit im Debugging-Bereich ausgegeben.
Routine mit F5 starten
Wenn Sie keine Lust haben, den Routinennamen erst in den Debugging-Bereich einzutippen, können Sie auch einfach die Einfügemarke in der auszuführenden Routine platzieren und dann die Taste F5 betätigen – oder die Schaltfläche zum Starten des Debuggings (siehe Bild 3).
Bild 3: Starten des Debuggens per Schaltfläche
Diesen Befehl können Sie auch über den Menüpunkt Ausführen|Debugging starten aufrufen (siehe Bild 4). Hier finden wir noch weitere Befehle, die allerdings zum Zeitpunkt der ersten Preview noch nicht funktionierten:
Bild 4: Debugging-Befehle per Menü
- Debugging starten: Startet die aktuell markierte Routine (Taste F5).
- Ohne Debuggen ausführen: (Tastenkombination Strg + F5)
- Debugging beenden: Beendet das Debuggen (Tastenkombination Umschalt + F5)
- Debugging erneut starten: Startet das Debuggen erneut (Tastenkombination Strg + Umschalt + F5)
Haltepunkte setzen
Genau wie im VBA-Editor können Sie auch in VS Code unter twinBASIC Haltepunkte setzen. Dazu klicken Sie einfach links von der Zeilennummer der Codezeile, in der Sie anhalten möchten. Dort erscheint dann wie in Bild 5 ein roter Punkt.
Bild 5: Setzen eines Haltepunktes
Wenn Sie die Routine etwa mit der Taste F5 gestartet haben, bleibt die Abarbeitung in der Zeile mit dem Haltepunkt stehen (siehe Bild 6).
Bild 6: Erreichen eines Haltepunktes
Code fortsetzen
Um die Abarbeitung des Codes bis zum Ende oder bis zum nächsten Haltepunkt fortzusetzen, betätigen Sie einfach nochmal die Taste F5.
Code im Einzelschritt-Modus durchlaufen
Wenn Sie jedoch nach Erreichen des Haltepunktes den Code Schritt für Schritt durchlaufen wollen, um diesen zu untersuchen, betätigen Sie die Taste F11 – also nicht mit F8 wie im VBA-Editor.
Die Debug.Print-Methode
Das Debugging-Fenster können Sie für die Ausgabe per Debug.Print aus dem Code heraus genauso nutzen wie das des VBA-Editors. Sprich: Sie fügen irgendwo im Code eine Debug.Print-Anweisung ein, geben den auszugebenden Inhalt als Parameter an und lassen den Code laufen.
Die Debug.Print-Methode arbeitet allerdings nicht genau so wie die im VBA-Editor: Es ist (noch) nicht möglich, den auszugebenden Text mit dem Komma- oder Semikolon abzuschließen.
Das führt im VBA-Editor dazu, dass kein Zeilenumbruch an die Ausgabe angehängt wird und die Ausgabe der nächsten Debug.Print-Anweisung in der gleichen Zeile erfolgt – beim Komma durch einen Tabulator vom vorherigen Text getrennt, beim Semikolon unmittelbar hinter dem vorherigen Text.
Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...
den kompletten Artikel im PDF-Format mit Beispieldatenbank
diesen und alle anderen Artikel mit dem Jahresabo