<\/p>\n
Wann immer ein Fehler auftritt, dessen Ursache nicht bekannt ist, oder eine Anwendung unerwartete Ergebnisse liefert, ist es Zeit fürs Debugging (zu deutsch: austesten, entwanzen, Fehler suchen und beseitigen). Unter Access spielt sich dies zum größten Teil in der VBA-Entwicklungsumgebung ab. Wir erläutern, wie Debugging funktioniert, welche Werkzeuge die gute alte VBA-IDE liefert und welche Tricks Sie einsetzen können.<\/b><\/p>\n
Den VBA-Editor kann man in seiner jetzigen Form fast schon als altehrwürdig einstufen. An ihm perlt mühelos ab, was die Benutzer anderer, modernerer Entwicklungsumgebungen auf Trab hält: nämlich ständige Innovationen.<\/p>\n
Mit dem Wechsel zu Access 2007 gab es genau eine änderung, die den meisten Entwicklern noch nicht einmal aufgefallen sein dürfte: Für den Einsatz des Mausrades zum Scrollen durch die Zeilen eines Moduls braucht man nun kein separates Tool mehr. Falls Sie Access 2007 verwenden und dieses Tool trotzdem installiert haben: Sie können es von der Festplatte werfen.<\/p>\n
Davon abgesehen ist auf den VBA-Editor schon Verlass: Er bildet zusammen mit Access ein eingespieltes Team und fällt eher durch Beständigkeit denn durch stetige Weiterentwicklung auf.<\/p>\n
Das ist aber kein Grund, ihn nicht einmal genauer unter die Lupe zu nehmen und zu zeigen, wie Sie Fehlern und Fehlverhalten mit seiner Hilfe auf die Schliche kommen. Immerhin bietet der VBA-Editor einige Möglichkeiten zum Debuggen des enthaltenen Codes.<\/p>\n
Gründe für das Debugging<\/b><\/p>\n
Eigentlich ist es ja so: Sie programmieren etwas, probieren es aus und entweder es funktioniert oder nicht. Falls nicht, möchten Sie natürlich gern herausfinden, woran dies liegt. Im besten Fall tritt einfach irgendwo ein Fehler auf und der VBA-Editor stößt Sie mit der Nase darauf, indem er eine entsprechende Meldung ausgibt und die fehlerhafte Zeile gelb hervorhebt.<\/p>\n
Mit etwas Glück lässt sich die Herkunft des Fehlers in unmittelbarer Umgebung entdecken; falls nicht, ist eine umfangreichere Analyse angezeigt. Wir sprechen hier nicht von Kompilier- oder Syntaxfehlern, sondern von Laufzeitfehlern, die oft bei der Verarbeitung falscher oder inkompatibler Daten auftreten. Noch unangenehmer sind Fehler, die nicht in einer Fehlermeldung resultieren, sondern schlicht falsche oder unerwartete Antworten der Anwendung erzeugen.<\/p>\n
Arten von Debugging<\/b><\/p>\n
Dieser Beitrag unterscheidet zwei Arten von Debugging: Die erste enthält alle Aktivitäten, die mit der änderung von Code zum Zwecke des Debuggings einhergehen, die zweite beschäftigt sich mit dem „berührungslosen" Debugging: Hier wird der eigentliche Code nicht angefasst, sondern durch das Setzen von Haltepunkten und externes Abfragen von Informationen etwa über das Direktfenster oder das Überwachungsfenster analysiert.<\/p>\n
Bevor wir diese beiden Arten vorstellen, schauen wir uns kurz die Grundzüge an, das manuelle Debuggen von Code ohne weitere Hilfsmittel.<\/p>\n
Code manuell durchlaufen<\/b><\/p>\n
Um Code manuell zu durchlaufen, positioniert man einfach die Einfügemarke auf der Prozedur, die man durchlaufen möchte, und wählt entweder den Menüpunkt Debuggen|Einzelschritt <\/b>aus oder drückt gleich auf die Taste F8<\/b>.<\/p>\n
Es erscheinen dann wie in Bild 1 ein gelber Pfeil und eine gelbe Markierung der aktuellen Zeile. Das Debuggen kann beginnen – weiteres Drücken der Schaltfläche F8 <\/b>arbeitet den Code schrittweise ab, wobei die Deklarationszeilen übergangen werden. F8 <\/b>springt auch zu Prozeduren, welche die aktuelle Prozedur aufruft.<\/p>\n
Unter Umständen ist das nicht gewünscht, weil die von dort aufgerufene Prozedur eine Menge Code enthält, den Sie in Ihrer Untersuchung nicht berücksichtigen möchten. In diesem Fall verwenden Sie die Tastenkombination Umschalt + F8<\/b>. Damit durchlaufen Sie nur die in der aktuellen Prozedur enthaltenen Zeilen. Unterroutinen werden nicht berücksichtigt.<\/p>\n
Wenn Sie sich einmal in einer Unterroutine befinden und feststellen, dass es hier keine relevanten Informationen zu holen gibt, können Sie mit Strg + Umschalt + F8 <\/b>zum Ende der Routine springen. Sie landen dann in der aufrufenden Routine, und zwar in der ersten Zeile hinter dem Aufruf.<\/p>\n
Fehlt nur noch eine Taste, die den Ablauf ohne weitere Zwischenschritte fortsetzt. Mit dieser können Sie auch komplette Routinen vom Start weg einfach aufrufen. Es handelt sich um die Taste F5<\/b>.<\/p>\n
Haltepunkte<\/b><\/p>\n
Manchmal möchte man sich nicht mühsam per Einzelschritt bis zur interessanten Stelle im Code vorarbeiten, sondern direkt dorthin springen. Dafür gibt es Haltepunkte. Sie setzen einen Haltepunkt in eine Zeile, indem Sie die Einfügemarke in der Zeile positionieren und die Taste F9 <\/b>beziehungsweise den Menübefehl Debuggen|Haltepunkte ein\/aus <\/b>verwenden.<\/p>\n
Zum Entfernen aller Haltepunkte dienen der Menübefehl Debuggen|Alle Haltepunkte löschen <\/b>oder die Tastenkombination Strg + Umschalt + F9<\/b>.<\/p>\n
Haltepunkte können Sie auch mit der Maus setzen. Dazu klicken Sie einfach auf der Höhe der betroffenen Zeile auf den links davon befindlichen grauen Balken.<\/p>\n
Zurück nach oben<\/b><\/p>\n
Manchmal möchte man sich im Code nicht vor-, sondern zurückbewegen – beispielsweise um einer Variablen testweise einen neuen Wert per Direktfenster zuzuweisen und eine Anweisung erneut zu testen, ohne direkt die ganze Prozedur neu zu starten.<\/p>\n
Dazu ziehen Sie einfach den gelben Pfeil mit der Maus an die gewünschte Stelle (siehe Bild 2).<\/p>\n
![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic003_opt.jpeg\")
<\/p>\n
Bild 2: Per Drag and Drop des gelben Pfeils können Sie Zeilen wiederholt ausführen oder auch überspringen.<\/span><\/b><\/p>\n Alternativ positionieren Sie die Einfügemarke dort, wo VBA den Code fortsetzen soll, und betätigen die Tastenkombination Strg + F9<\/b>. <\/p>\n Mit beiden Varianten können Sie übrigens nicht nur zurück, sondern auch vorwärts springen und so die Ausführung der dazwischen liegenden Zeilen unterbinden.<\/p>\n Debugging per Code<\/b><\/p>\n Wenn Sie sicherstellen möchten, dass ein bestimmter Codeteil durchlaufen wird, oder feststellen möchten, welchen Wert eine Variable zu einem bestimmten Zeitpunkt hat, können Sie einfach eine Zeile zum Code hinzufügen, welche die benötigte Information liefert.<\/p>\n Dies geschieht entweder durch den Einsatz der MsgBox<\/b>– oder der Debug.Print<\/b>-Anweisung. Eine weitere Alternative ist die Debug.Assert<\/b>-Methode, die das Anhalten des Codes unter bestimmten Bedingungen erlaubt.<\/p>\n Ausgabe per MsgBox<\/b><\/p>\n Die Entscheidung, ob man zu Debugging-Zwecken die MsgBox<\/b>– oder die Debug.Print<\/b>-Anweisung einsetzt, hängt von den persönlichen Vorlieben, vom Umfang der benötigten Ausgaben und weiteren Faktoren ab. <\/p>\n Wenn Sie nur an ein oder zwei Stellen Informationen ausgeben möchten, ist ein Meldungsfenster sicher in Ordnung. Wenn Sie dieses jedoch in eine Schleife mit vielen Durchläufen einbauen, werden Sie schnell vom ständigen Wegklicken der Meldungen genervt sein. Hier ist die Arbeit mit der Debug.Print<\/b>-Anweisung doch wesentlich entspannter: Sie brauchen die Routine einfach nur durchlaufen zu lassen und können sich die gesuchten Informationen dann bequem im Direktfenster ansehen (das man übrigens am schnellsten mit Strg + G <\/b>einblendet, falls es nicht ohnehin schon sichtbar ist).<\/p>\n Debug.Print<\/b><\/p>\n Die Debug.Print<\/b>-Anweisung zeigt den angegebenen Ausdruck im Direktfenster des VBA-Editors an. Die einfachste Variante ist, einen einzelnen Ausdruck auszugeben.<\/p>\n <\/p>\n Die folgenden Zeilen bewirken die Ausgabe der Zeichenfolge Hallo<\/b>:<\/p>\n Mehrere Werte lassen sich mit dem Kaufmanns-Und verknüpfen:<\/p>\n Da es im Direktfenster keine Schönheitspreise zu gewinnen gibt, tun es auch Tabulatoren, die man durch Trennen der gewünschten Ausdrücke durch Kommata erreicht:<\/p>\n Sie können auch die Ausgabe mehrerer aufeinanderfolgender Debug.Print<\/b>-Anweisungen in einer Zeile ausgeben. Dazu fügen Sie der Debug.Print<\/b>-Anweisung, die mit der folgenden fortgesetzt werden soll, einfach ein Semikolon an:<\/p>\n Dies ergibt:<\/p>\n Wenn sich zwischen den Ausdrücken beispielsweise ein Tabulator befinden soll, ergänzen Sie vor dem Semikolon ein Komma. Das kann wie folgt aussehen:<\/p>\n Wenn Sie mehrere Ausdrücke ohne Leerzeichen oder Tabulator zusammenführen möchten, können Sie diese einfach hintereinander angeben:<\/p>\n Debug.Assert<\/b><\/p>\n Weitgehend unbeachtet, aber wertvoll ist die Debug.Assert<\/b>-Anweisung. Stellen Sie sich vor, Sie möchten den Programmablauf an einer Stelle unter bestimmten Bedingungen unterbrechen, um sich dort umzusehen. Manche Programmierer bauen dann etwa das Konstrukt aus Bild 3 ein und setzen einen entsprechenden Haltepunkt.<\/p>\n Bild 3: Dieses Konstrukt sorgt im Programmablauf für einen Halt an der gewünschten Stelle.<\/span><\/b><\/p>\n Das ist definitiv zu viel Aufwand und lässt sich erheblich leichter lösen, nämlich so:<\/p>\n Auch diese Routine hält bei intZaehler = 500 <\/b>automatisch an, und das mit nur einer Zeile und ohne explizites Setzen eines Haltepunktes. Zu beachten ist, dass Debug.Assert <\/b>einen bool'schen Ausdruck erwartet und nur dann den laufenden Code anhält, wenn dieser Ausdruck den Wert False <\/b>aufweist – daher die Formulierung Not intZaehler = 500<\/b>.<\/p>\n Bedingtes Debugging<\/b><\/p>\n Eine der einfachsten Arten, während des Programmablaufs zu prüfen, ob bestimmte Codeabschnitte überhaupt erreicht werden oder welche Werte Variablen zu einem bestimmten Zeitpunkt haben, ist das Einfügen der MsgBox<\/b>-Anweisung in den Code. Wie bereits weiter oben erwähnt, kann das ständige Erscheinen von Meldungsfenstern den Fluss aber schon sehr stören.<\/p>\n Wenn Sie dennoch mit der MsgBox<\/b>-Funktion arbeiten möchten, aber keine Lust haben, alle für das Debugging vorhandenen Meldungsfenster zu entfernen und wieder einzufügen, können Sie diese mit der bedingten Kompilierung ein- und ausschalten.<\/p>\n Die beiden Elemente der bedingten Kompilierung sind eine Konstante, die einen Wert festlegt, sowie ein If…Then<\/b>-Konstrukt mit spezieller Syntax und einigen Sonderregeln.<\/p>\n Ein einfaches Beispiel wäre das folgende. Die Konstante bolTest <\/b>legt fest, ob man sich im Debug-Betrieb befindet oder nicht – in diesem Fall ja:<\/p>\n Die folgende Routine zeigt, wie man eine MsgBox<\/b>-Anweisung einbettet, damit diese nur für bolDebug = True <\/b>angezeigt wird:<\/p>\n Wenn Sie diese Meldung nicht mehr erhalten möchten, stellen Sie bolDebug<\/b> auf False <\/b>ein:<\/p>\n Es erscheint nun kein Meldungsfenster mehr. Möglicherweise fragen Sie sich, was denn nun diese Vorgehensweise von der mit einer herkömmlichen If…Then<\/b>-Anweisung unterscheidet. Das ist einfach: Wenn Sie die Anwendung kompilieren, werden die Elemente der bedingten Kompilierung und die in den If…Then<\/b>-Konstrukten eingebetteten Anweisungen schlicht nicht berücksichtigt.<\/p>\n Die Konstanten für die bedingte Kompilierungen gelten jeweils modulweit, egal, ob sie im Modulkopf oder innerhalb einer Routine deklariert wurden.<\/p>\n Daher muss man entweder für jedes einzelne Modul eine Konstante festlegen oder man verwendet die einzige Möglichkeit, eine globale Konstante für diesen Zweck anzulegen – nämlich in der Eigenschaft Argumente für bedingte Kompilierung <\/b>im Eigenschaftsfenster des aktuellen Projekts (Extras|Eigenschaften <Projektname><\/b>). Der dortige Ausdruck entspricht dem, was hinter der #Const<\/b>-Anweisung steht, also etwa bolDebug = True<\/b>.<\/p>\n Erheblich mehr über die bedingte Kompilierung erfahren Sie im Beitrag Bedingte Kompilierung am Beispiel des PDF-Exports <\/b>(Shortlink 622).<\/p>\n Berührungsloses Debugging<\/b><\/p>\n Soweit möglich sollten Sie die Tools der VBA-Entwicklungsumgebung für das Debugging einsetzen. Dazu gehören das bereits oben genannte Direktfenster, das Überwachungsfenster, das Aufrufefenster und das Lokalfenster, und auch das Codefenster selbst hilft mit.<\/p>\n Variableninhalte ermitteln<\/b><\/p>\n Das Direktfenster haben Sie ja bereits kennengelernt. Es zeigt die Informationen an, die innerhalb der VBA-Prozeduren per Debug.Print <\/b>ausgegeben werden. Wenn Sie eine Prozedur im Einzelschrittmodus durchlaufen, können Sie das Direktfenster nutzen, um die Inhalte der Variablen der aktuellen Prozedur auszugeben. Dazu verwenden Sie die gleiche Anweisung, die Sie auch innerhalb des Codes verwenden würden. Das Direktfenster bietet jedoch die Vereinfachung, dass Sie statt Debug.Print <\/b>schlicht <\/b>schreiben können, also etwa so:<\/p>\n Auch im Codefenster selbst können Sie die Inhalte von Variablen ermitteln. Dazu platzieren Sie entweder die Maus auf einem Wert (siehe Bild 4) oder auf einer Funktion, welche die Routine auf den Wert anwendet (siehe Bild 5).<\/p>\n Bild 4: Der ToolTip-Text im VBA-Editor zeigt Variableninhalte an …<\/span><\/b><\/p>\n Bild 5: … und liefert in einigen Fällen auch das Ergebnis von Funktionen.<\/span><\/b><\/p>\n Natürlich liefert das Direktfenster hier noch bessere Möglichkeiten – so könnten Sie beispielsweise auch auf Methoden und Eigenschaften von Objekten zugreifen.<\/p>\n Hilfreich ist das etwa, wenn Sie ein Recordset erzeugt haben und sich testhalber den Inhalt des ersten Feldes des ersten Datensatzes ausgeben lassen möchten. Mit einer Objektvariablen wie etwa rst <\/b>im Gepäck gelingt das wie folgt:<\/p>\n Streng bewacht<\/p>\n Ein weiteres praktisches Instrument ist das Überwachungsfenster. Wenn Sie es über Ansicht|Überwachungsfenster <\/b>einblenden, zeigt es zunächst keine Informationen an. Damit dies geschieht, legen Sie einen Überwachungsausdruck an. Dieser betrifft in der Regel einen Ausdruck aus dem Quellcode.<\/p>\n Das folgende Beispiel untersucht das Recordset<\/b>-Objekt rst<\/b>. Zum Anlegen des Überwachungsausdrucks markieren Sie die Variable und wählen dann aus dem Kontextmenü den Eintrag Überwachung hinzufügen… <\/b>aus (siehe Bild 6). Dies öffnet den Dialog aus Bild 7, mit dem Sie einige weitere Einstellungen vornehmen können. Behalten Sie diese Einstellungen zunächst bei.<\/p>\n Bild 6: Hinzufügen eines Überwachungsausdrucks<\/span><\/b><\/p>\n Bild 7: Einstellungen eines Überwachungsausdrucks<\/span><\/b><\/p>\n Betrachten Sie dann das Überwachungsfenster und durchlaufen Sie eine Beispielroutine mit einem Recordset<\/b>-Objekt im Einzelschrittmodus. Vor dem Start hat rst <\/b>in der Überwachungsliste noch den Wert <Außerhalb des Kontexts><\/b>, was auch logisch ist, denn die Variable ist noch nicht einmal deklariert.<\/p>\n Beim Starten der Routine mit F8 <\/b>ändert sich dieser Wert in Nothing<\/b>: Die Variable ist deklariert, aber noch nicht auf ein neues Recordset<\/b>-Objekt gesetzt. Nach der Anweisung Set rst = … <\/b>verschwindet dann der Wert und links neben dem Variablennamen erscheint ein Plus-Zeichen.<\/p>\n Klicken Sie auf dieses, zeigt sich dann das Bild aus Bild 8. Hier können Sie sich nach Herzenslust austoben und auf alle Eigenschaften zugreifen, die auch VBA bietet, also auch etwa die Eigenschaften der einzelnen Felder des Recordsets ansehen und, in Abhängigkeit vom in der Prozedur bearbeiteten Datensatz, auch dessen aktuelle Werte.<\/p>\n Bild 8: Das Recordsetobjekt lässt sich im Überwachungsfenster komplett untersuchen.<\/span><\/b><\/p>\n Überwachen bis …<\/b><\/p>\n Wenn Sie aus dem Kontextmenü eines Überwachungsausdrucks den Eintrag Überwachung bearbeiten… <\/b>auswählen, zeigt der VBA-Editor wieder den Dialog aus Bild 7 an. Hier finden Sie unter Art der Überwachung <\/b>noch zwei weitere Optionen:<\/p>\n Überwachen per Drag and Drop<\/b><\/p>\n Eine nette Erleichterung ist es, dass Sie beliebige Ausdrücke direkt vom Codefenster in das Überwachungsfenster ziehen können. Der VBA-Editor legt automatisch einen passenden Überwachungsausdruck an.<\/p>\n Überwachen … oder doch nicht<\/b><\/p>\n Wenn Sie einen Ausdruck nicht direkt zum Überwachungsfenster hinzufügen, sondern erst einmal den aktuellen Wert betrachten möchten, markieren Sie den Wert und betätigen die Tastenkombination Umschalt + F9<\/b>.<\/p>\n Der VBA-Editor zeigt dann ein Fenster wie in Bild 9 an, das sowohl den aktuellen Wert des markierten Ausdrucks liefert als auch die Möglichkeit, den Ausdruck in die Liste der Überwachungsausdrücke aufzunehmen.<\/p>\n Bild 9: Wem der ToolTip-Text nicht reicht, der kann den Inhalt eines Ausdrucks auch in einem richtigen Fenster anzeigen lassen – ohne direkt das Überwachungsfenster heranzuziehen.<\/span><\/b><\/p>\n Wer hat mich aufgerufen<\/b><\/p>\n In größeren Projekten werden Routinen unter Umständen von vielen anderen Prozeduren aufgerufen. Wenn dann in einer Routine ein Fehler auftritt, weil von der aufrufenden Instanz ein unerwarteter oder fehlerhafter Parameter übergeben wurde, ist es interessant zu erfahren, woher der Aufruf kommt.<\/p>\n Dies ermöglicht die Aufrufliste, die Sie über Ansicht|Aufrufliste… <\/b>oder die Tastenkombination Strg + L <\/b>anzeigen (siehe Bild 10). Durch Auswahl des gewünschten Eintrags und einen Klick auf Anzeigen <\/b>springen Sie direkt zur aufrufenden Prozedur. Die Aufrufliste verschwindet dann und der VBA-Editor zeigt im Codefenster die Zeile mit dem Aufruf in der übergeordneten Prozedur an – markiert durch einen grünen Pfeil (siehe Bild 11).<\/p>\n Bild 1: Start des manuellen Debuggings einer Prozedur<\/span><\/b><\/p>\n Bild 10: Die Aufrufliste zeigt die Hierarchie der Routinen, die zum Aufruf der aktuellen Prozedur geführt haben.<\/span><\/b><\/p>\n Bild 11: Der dreieckige Pfeil markiert die Zeile, die für den Aufruf der Prozedur verantwortlich ist.<\/span><\/b><\/p>\n Lokalpatriot<\/b><\/p>\n Zu guter Letzt werfen wir noch einen Blick auf das Lokalfenster. Es liefert prinzipiell die gleichen Informationen wie das Überwachungsfenster, allerdings mit dem kleinen, aber feinen Unterschied, dass man nicht selbst die Ausdrücke festlegt, sondern dass es die Werte aller im aktuellen Kontext vorhandenen Variablen anzeigt.<\/p>\n Wenn Sie den Code also beispielsweise mitten in einer Prozedur anhalten und das Lokalfenster einblenden, zeigt dieses dreierlei Objekte:<\/p>\nDim str As String\r\nstr = "Hallo"\r\nDebug.Print str<\/pre>\n
Debug.Print rst!Vorname & " " & rst!Nachname\r\nAndré Minhorst<\/pre>\n
Debug.Print rst!Vorname, rst!Nachname\r\nAndré Minhorst<\/pre>\n
Debug.Print "André";\r\nDebug.Print "Minhorst"<\/pre>\n
AndréMinhorst<\/pre>\n
Debug.Print "André", ;\r\nDebug.Print "Minhorst"<\/pre>\n
Debug.Print rst!Vorname rst!Nachname<\/pre>\n
![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic001_opt.jpeg\")
<\/p>\nPublic Sub TestAssert()\r\n Dim intZaehler As Integer\r\n For intZaehler = 1 To 1000\r\n 'tu irgendwas\r\n Debug.Assert Not intZaehler = 500\r\n Next intZaehler\r\nEnd Sub<\/pre>\n
#Const bolDebug = True<\/pre>\n
Public Sub TestBedingteKompilierung()\r\n #If bolDebug Then\r\n MsgBox "Ich bin im Debugbetrieb!"\r\n #End If\r\nEnd Sub<\/pre>\n
#Const bolDebug = False<\/pre>\n
strVorname\r\nAndré<\/pre>\n
![\"pic004.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic004_opt.jpeg\")
<\/p>\n![\"pic005.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic005_opt.jpeg\")
<\/p>\nDebug.Print rst.Fields(0).Value<\/pre>\n
![\"pic006.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic006_opt.jpeg\")
<\/p>\n![\"pic007.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic007_opt.jpeg\")
<\/p>\n![\"pic008.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic008_opt.jpeg\")
<\/p>\n\n
![\"pic011.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic011_opt.jpeg\")
<\/p>\n![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic009.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic009_opt.jpeg\")
<\/p>\n![\"pic010.tif\"](\"..\/fileadmin\/_temp_\/2008_04\/Debugging-web-images\/pic010_opt.jpeg\")
<\/p>\n