Anwendung im EGL-Debugger schrittweise durchgehen

In diesem Abschnitt sind die grundlegenden Schritte beim Debug eines Programms im EGL-Debugger beschrieben.

Die Strategien für das Anwendungsdebugging sind zu umfangreich für die vorliegende Dokumentation. Generell dient der Debuggingprozess jedoch dazu, die Quelle eines Problems im Code zu ermitteln. Falls Ihr Programm beispielsweise abnormal beendet wird, können Sie den Code mit dem Debugger schrittweise durchgehen und den Punkt ermitteln, an dem das Programm fehlschlägt. Falls das Programm eine nicht erwartete Ausgabe zurückgibt, können Sie mit dem Debugger die Werte von Variablen überwachen und den Punkt ermitteln, an dem die Ausgabe von den Erwartungen abweicht.

Der Debugger beginnt das Debugging immer bei einem Programmabschnitt. Falls Sie das Debug für einen anderen Logikabschnitt (z. B. eine Bibliothek) ausführen wollen, müssen Sie aus einem Programm eine Step-Into-Aktion für den anderen Logikabschnitt ausführen. In manchen Fällen kann es sinnvoll sein, ein einfaches Programm zu schreiben, dessen einzige Funktion im Aufruf des Logikabschnitts besteht, dessen Debug ausgeführt werden soll.

Voraussetzungen

Das folgende Beispiel stellt ein Programm mit einem einfachen Fehler dar, mit dem Sie den Debugger testen können:
program myDebugTestPgm type BasicProgram 

  function main()

    //Provide some initial values for the array of items.
    customerItems items[3];
    customerItems[1].itemNumber=1;
    customerItems[2].itemNumber=2;
    customerItems[3].itemNumber=3;
    customerItems[1].itemCost=12.50;
    customerItems[2].itemCost=200;
    customerItems[3].itemCost=49.95;
    customerItems[1].itemQuantity=30;
    customerItems[2].itemQuantity=10;
    customerItems[3].itemQuantity=60;

    counter int;
    orderTotal float=0;

    //Calculate the total cost of the items.
    //Use the discountPrice function to get the discounted cost of each item.
    for (counter from 1 to customerItems.getSize() by 1)
      orderTotal += discountPrice(customerItems[counter].itemCost, 
                                  customerItems[counter].itemQuantity);
    end // for loop

    //Write the output to the console.
    SysLib.writeStderr("The total cost for the order is $" + orderTotal);
  end // main

  //Return a total price for a group of items 
  //based on the item price and a quantity discount.
  function discountPrice(itemCost float in, itemQuantity int in) returns(float)
    discountRate float=0;
    quantCost float=0;

    //Determine the discount for each quantity.
    //Discount 20% for more than 50 items.
    //Discount 5% for more than 20 items.
    case
      when (itemQuantity > 50)
        discountRate = 1/5;
     when (itemQuantity > 20 && itemQuantity <= 50)
       discountRate = 1/20;
     otherwise
       //bug - division by zero
       discountRate = 1/0;
     end

    //Multiply the cost of the item, the number of items, 
    //and the discounted price.
    quantCost = itemCost*itemQuantity*(1-discountRate); 
    quantCost = MathLib.round(quantCost, -2);

    return (quantCost);
  end // function discountPrice

end // program

record items type BasicRecord
  itemNumber    int;
  itemCost      float;
  itemQuantity  int;
end
Wenn Sie dieses Programm generieren und ausführen, gibt EGL einen Fehler zurück, der auf die Funktion discountPrice und den Ausdruck 1/0 verweist. In diesem Fall ist der Fehler leicht erkennbar. Es kann jedoch auch Situationen geben, in denen der Fehler nicht so einfach ermittelt werden kann. Zur Ermittlung der Fehlerquelle müssen Sie zunächst das Programm mit Unterbrechungspunkten im Debugger ausführen, um den Punkt zu ermitteln, an dem das Programm fehlschlägt.

Unterbrechungspunkte hinzufügen

Sie können eine oder mehrere Codezeilen als Unterbrechungspunkte markieren. Sobald der Debugger einen Unterbrechungspunkt findet, wird er vor der Ausführung der zugehörigen Codezeile angehalten. Sie haben dann die Möglichkeit, die aktuellen Werte von Programmvariablen zu prüfen, bevor Sie den Debugger anweisen, wie er fortfahren soll. Unterbrechungspunkte wirken sich in keiner Hinsicht auf die Quelle aus und sind nur während des Debuggingprozesses von Bedeutung.

Um einen Unterbrechungspunkt hinzuzufügen, doppelklicken Sie im EGL-Editor auf den grauen Rand links neben dem Code. Im obigen Beispiel könnte es sinnvoll sein, Unterbrechungspunkte in der Funktion discountPrice hinzuzufügen, weil in der Fehlernachricht angegeben ist, dass der Fehler in dieser Funktion auftrat. Unterbrechungspunkte werden durch blaue Kreise in diesem grauen Bereich gekennzeichnet:

Abbildung der blauen Kreise für die Kennzeichnung von Unterbrechungspunkten im Code

Sie können einen Unterbrechungspunkt bei den meisten EGL-Codezeilen hinzufügen, mit denen Logik durchgeführt wird. Hierzu zählen auch die folgenden Beispiele:
  • Zuordnungsanweisung, z. B.
    myString = "Hello";
  • Variablendeklaration mit einer Zuordnung, z. B.
    myInt int = 5;
  • Aufruf einer Systemfunktion oder einer anderen EGL-Funktion, z. B.
    SysLib.writeStderr("Hello");
  • Schleifen- oder Vergleichsanweisung, z. B.
    if (myInt == 5)
Bei den folgenden Codezeilen können jedoch keine Unterbrechungspunkte hinzugefügt werden:
  • Variablendeklaration ohne Zuordnung
  • Anweisung end
  • Codezeile, die mit function, program oder package beginnt, oder eine andere Zeile, die einen Logikabschnitt deklariert. Allerdings können Sie eine Vorgabe definieren, damit der Debugger die erste Zeile jedes Programms so behandelt, als ob sie einen Unterbrechungspunkt enthielte. Lesen Sie dazu Benutzervorgaben für den EGL-Debugger definieren.
  • Zeile in einem Datenabschnitt
  • Leere Zeile oder reine Kommentarzeile

Weitere Anweisungen für die Verwendung von Unterbrechungspunkten finden Sie unter Unterbrechungspunkte im EGL-Debugger verwenden.

Sie können das Debug für ein Programm auch ohne Unterbrechungspunkte ausführen. Falls Sie die Vorgabe Fenster > Benutzervorgaben > EGL > Debug > Bei der ersten Zeile eines Programms stoppen auswählen, hat dies denselben Effekt wie die Festlegung eines Unterbrechungspunkts bei der ersten ausführbaren Zeile innerhalb der Funktion main() des Programms. Von diesem Punkt aus können Sie die nachfolgenden Codezeilen schrittweise durchgehen, also eine einzelne Zeile ausführen und dann die Ausführung anhalten. Weitere Informationen zu den Step-Befehlen enthält der Abschnitt Steuerelemente für den EGL-Debugger.

Programm im EGL-Debugger ausführen

Nachdem Sie Unterbrechungspunkte zu Ihrem Programm hinzugefügt oder die Option für das Stoppen bei der ersten Zeile festgelegt haben (siehe hierzu den obigen Abschnitt 'Unterbrechungspunkte hinzufügen'), können Sie das Programm im Debugger ausführen.

Der Debugger benötigt eine Startkonfiguration, in der beschrieben ist, wie die Anwendung ausgeführt werden soll. Für die Erstellung einer Startkonfiguration gibt es zwei Möglichkeiten:
  • Sie können beim Beginn des Debuggings automatisch eine Startkonfiguration vom Debugger erstellen lassen.
  • Sie können eine Startkonfiguration manuell erstellen. Weitere Informationen finden Sie unter Startkonfiguration im EGL-Debugger erstellen.
Bei den meisten Programmen können Sie die automatisch erstellte Startkonfiguration verwenden.
  1. Klicken Sie in der Sicht 'Projektexplorer' mit der rechten Maustaste auf das EGL-Quellenprogramm, dessen Debug Sie ausführen wollen, und klicken Sie dann auf Debug ausführen als > EGL-Programm. Der Debugger führt daraufhin die folgenden Tasks aus:
    • Falls für das Programm keine Startkonfiguration vorhanden ist, erstellt der Debugger eine Standardstartkonfiguration. Sie können diese Konfiguration anzeigen, indem Sie auf Ausführen > Debug klicken.
    • Je nach den Vorgaben, die Sie für die Workbench festgelegt haben, wechselt der Debugger möglicherweise automatisch in die Perspektive 'Debug' oder fordert Sie hierzu auf. Sie können manuell zwischen den Perspektiven wechseln, indem Sie auf Fenster > Perspektive öffnen > Andere > Debug klicken.
    • Der Debugger beginnt mit der Ausführung des Programms.
  2. Nachdem der Debugger die Ausführung des Programms gestartet hat, wird diese fortgesetzt, bis ein Unterbrechungspunkt festgestellt wird bzw. bis die erste Zeile mit ausführbarem Code erreicht wurde (sofern Sie die entsprechende Vorgabe festgelegt haben). An dieser Stelle wird der Debugger angehalten und zeigt die folgenden Informationen an:
    • Im EGL-Editor wird die Zeile, deren Ausführung ansteht, hervorgehoben.
    • In der Sicht 'Variablen' wird der Wert aller Variablen im aktuellen Logikabschnitt angezeigt. Dies schließt auch die Werte von Systemvariablen ein. In dieser Sicht können Sie den Wert einer Variablen im Programmverlauf überwachen. Während der Debugger an einem Unterbrechungspunkt angehalten wurde, können Sie den Wert einer Variablen auch ändern.
    • In der Sicht 'Debug' sind die Threads aufgelistet, die in der aktuellen Ausführungseinheit ausgeführt werden. Einfach ausgedrückt zeigt diese Sicht also, welcher Programm- oder Logikabschnitt gerade ausgeführt wird. In dieser Sicht können Sie den Debuggingprozess fortsetzen oder stoppen.
    • Die Sicht 'Unterbrechungspunkte' enthält eine Liste der Unterbrechungspunkte im Programm. Über diese Sicht können Sie einen Unterbrechungspunkt vorübergehend inaktivieren, indem Sie das zugehörige Kontrollkästchen abwählen.
  3. Sobald Sie den Debugger fortsetzen wollen, klicken Sie oben in der Sicht 'Debug' auf die Schaltfläche Wieder aufnehmen. Der Debugger wird bis zum nächsten Unterbrechungspunkt fortgesetzt. Sie können auch eine der Schaltflächen für Step-Befehle verwenden, damit das Programm die nächste Zeile ausführt und erneut angehalten wird.

    Im Beispielprogramm können Sie das Programm von Unterbrechungspunkt zu Unterbrechungspunkt ausführen, bis der Debugger die Zeile discountRate = 1/0; erreicht hat. An diesem Punkt gibt der Debugger denselben Fehler zurück, der bei der Ausführung des Programms auch in der Konsole angezeigt wird.

  4. Sobald Sie das Debugging fertig gestellt haben, klicken Sie oben in der Sicht 'Debug' auf die Schaltfläche Beenden, um den Debugger zu stoppen, oder auf die Schaltfläche Wieder aufnehmen, damit das Programm bis zum Ende ausgeführt werden kann.

Feedback