Wer eine wirklich professionelle Fehlerbehandlung zu seiner Access-Anwendung hinzufügen möchte, kommt nicht um das Anlegen von Zeilennummern herum. Wenn man Zeilennummern festgelegt hat, kann man diese im Falle eines Fehlers mit der nicht dokumentierten Erl-Funktion auslesen. Das heißt, dass wir neben der Fehlernummer und der Fehlerbeschreibung noch auf die Zeilennummer zurückgreifen können, um den Fehler zu lokalisieren. Dazu gehört allerdings auch, dass wir in der Fehlermeldung Informationen über das Modul und die Prozedur unterbringen, in denen der Fehler aufgetreten ist – doch dies lässt sich einfach realisieren. Sehr aufwändig ist es hingegen, alle Prozeduren von umfangreichen Anwendungen mit Zeilennummern zu versehen. Um dies zu implementieren, nutzen wir die Bibliothek „Microsoft Visual Basic for Applications Extensibility 5.3“, die alle Möglichkeiten bietet, um auf die enthaltenen Module zuzugreifen und den Code automatisiert nach unseren Wünschen anzupassen.<\/b><\/p>\n
Funktion zum Hinzufügen von Zeilennummern<\/h2>\n
Wichtig für die Fehlerbehandlung sind auch die Zeilennummern. Diese fügen wir mit der Funktion AddLineNumbers <\/b>zu einer Prozedur hinzu. Diese Prozedur statten wir mit den folgenden Parametern aus:<\/p>\n Die Prozedur aus Listing 1 referenziert als Erstes das aktuelle VBA-Projekt und die mit strModule <\/b>angegebene Komponente. Dazu holt sie sich über die CodeModule<\/b>-Eigenschaft noch das passende CodeModule<\/b>-Objekt, mit dem wir auf den Code zugreifen können. Mit lngProcBodyLine <\/b>speichern wir die Zeile, in der die Prozedur aus strProcedure <\/b>beginnt. Wir wollen nur die eigentlichen Anweisungen der Prozedur mit Zeilennummern versehen, also ermitteln wir die Nummer der ersten Zeile hinter dem Prozedurkopf und die Nummer der letzten Zeile vor der End…<\/b>-Zeile der Prozedur. Dazu nutzen wir die beiden weiter hinten beschriebenen Funktionen GetFirstStatementLineNumber <\/b>und GetLastStatementLineNumber<\/b>.<\/p>\n Listing 1: Prozedur zum Hinzufügen von Zeilennummern zu einer Prozedur<\/span><\/b><\/p>\n Die Prozedur durchläuft nun in einer ersten For…Next<\/b>-Schleife alle Zeilen der Prozedur, um eventuell bereits mit Zeilennummern versehene Prozeduren zu erkennen. Findet sie während dieses Durchlaufs in irgendeiner Zeile einen numerischen Wert in den ersten sechs Zeichen, wird die Variable bolNumbers <\/b>auf True <\/b>eingestellt und die Schleife verlassen. In diesem Fall legt die Prozedur keine neuen Zeilennummern an, sondern gibt eine entsprechende Meldung aus.<\/p>\n Anderenfalls durchläuft die Prozedur alle Zeilen von der ersten Anweisung bis zur letzten Anweisung der mit Zeilennummern zu versehenden Routine. Dies geschieht in einer For…Next<\/b>-Schleife mit der Laufvariablen lngLine<\/b>.<\/p>\n Innerhalb der Schleife prüfen wir in einer Select Case<\/b>-Bedingung, ob verschiedene Bedingungen den Wert True <\/b>haben. Dazu weisen wir der Select Case<\/b>-Anweisung das Kriterium True <\/b>zu. Der erste der folgenden Case<\/b>-Zweige, der den Wert True <\/b>liefert, wird demzufolge angesteuert.<\/p>\n Die erste Bedingung prüft, ob die um führende und folgende Leerzeichen erleichterte aktuelle Zeile mit Case <\/b>beginnt. Case<\/b>-Zeilen sind eine der wenigen Zeilen, die nicht mit einer Zeilennummer versehen werden können. Eine Case<\/b>-Zeile soll genau wie die nummerierten Zeilen um sechs Zeichen nach rechts eingerückt werden, auch wenn diese nicht nummeriert wird. Auf diese Weise bleibt die Einrückung gegenüber den nummerierten Zeilen erhalten.<\/p>\n Um die Zeile um sechs Zeichen einzurücken, verwenden wir die ReplaceLine<\/b>-Anweisung des CodeModule<\/b>-Objekts. Diese erwartet als ersten Parameter die Nummer der zu ersetzenden Zeile und als zweiten Parameter den neuen Inhalt der Zeile. Diesen stellen wir aus sechs mit der Space<\/b>-Funktion ermittelten Leerzeichen und der vorherigen Zeile zusammen. Der zweite Case<\/b>-Fall untersucht, ob es sich bei der Zeile um eine Sprungmarke handelt. Dazu verwendet sie die IsLabel<\/b>-Funktion, welche die übergebene Zeile untersucht. Diese Funktion stellen wir später vor. Liefert IsLabel <\/b>den Wert True<\/b>, geschieht nichts weiter mit dieser Zeile. Sprungmarken sollten weder nummeriert noch eingerückt werden (letzteres wird ohnehin wieder rückgängig gemacht).<\/p>\n Der Case Else<\/b>-Zweig tritt für alle weiteren Fälle ein. Dieser sorgt dafür, dass die aktuelle Zeile durch eine neue Zeile ersetzt wird, die aus der aktuellen Zeilennummer im Format 00000<\/b>, einem Leerzeichen und der ursprünglichen Zeile besteht. Warum als Format 00000<\/b>? Weil wir davon ausgehen, dass wir keine Module mit mehr als 99.999 Zeilen verwenden (falls doch, können Sie das Format und die Einrückungen so anpassen, dass diese mehr Stellen abdecken).<\/p>\n Wenn wir die Zeilenzahl 123 <\/b>mit dem Format 00000 <\/b>einfügen, wird daraus 123 <\/b>plus zwei folgende Leerzeichen. Aus 1 <\/b>wird 1 <\/b>plus vier folgende Leerzeichen. Es erfolgt also unabhängig von der Stellenzahl der Zeilennummer eine konstante Einrückung. Auf diese Weise durchlaufen wir alle Zeilen von der ersten bis zur letzten Anweisung der angegebenen Prozedur.<\/p>\n Um die Funktion AddLineNumbers <\/b>aufzurufen, verwenden wir beispielsweise den folgenden Befehl:<\/p>\n Damit fügen wir genau einer Prozedur Zeilennummern hinzu.<\/p>\n Gegebenenfalls wollen wir jedoch nicht nur einer, sondern allen Prozeduren eines Moduls Zeilennummern hinzufügen – oder vielleicht sogar allen Modulen des VBA-Projekts. Dazu bauen wir uns schnell ein paar Routinen. Die erste soll den Namen des Moduls entgegennehmen, deren Prozeduren mit Zeilennummerierungen versehen werden sollen (siehe Listing 2).<\/p>\n Listing 2: Prozedur zum Hinzufügen von Zeilennummern zu allen Prozeduren eines Moduls<\/span><\/b><\/p>\n Sie referenziert über das VBProject<\/b>-Objekt das VBComponents<\/b>-Objekt für das Modul und verwendet dann das CodeModule <\/b>dieses Objekts. Sie ermittelt die Anzahl der Zeilen des Moduls und durchläuft dann alle Zeilen des Moduls. Dabei vergleicht sie jeweils den Namen der Prozedur der aktuellen Zeile mit dem in strProcedure <\/b>gespeicherten Namen.<\/p>\n Diese ist zunächst leer. Sobald die Routine auf die erste Prozedur stößt, wird der Name der Prozedur in strProcedure <\/b>geschrieben und die Prozedur AddLineNumber<\/b> wird für dieses Modul und diese Prozedur aufgerufen. Auf diese Weise durchläuft die Prozedur AddLineNumbersToModule <\/b>alle Prozeduren des Moduls:<\/p>\n Schließlich schauen wir uns noch an, wie wir allen Prozeduren in allen Modulen eines VBA-Projekts Zeilennummern hinzufügen können. Dazu schreiben wir eine weitere Prozedur, welche wiederum die Prozedur AddLineNumbersToModule <\/b>aufruft:<\/p>\n Die Prozedur referenziert das aktive VBA-Projekt und durchläuft alle Elemente der VBComponents<\/b>-Auflistung, die sie dabei mit der Variablen objVBComponent <\/b>referenziert. Sie ruft für jeden Schleifendurchlauf die Prozedur AddLineNumbersToModule <\/b>mit dem Namen des aktuellen VBComponent<\/b>-Objekts auf.<\/p>\n Gegebenenfalls möchte man auch einmal die Zeilennummern wieder entfernen. Beispielsweise dann, wenn man Zeilen zum Code hinzufügen oder entfernen will und nicht die Nummerierung von Hand anpassen möchte.Dazu können wir die Prozedur RemoveLineNumbers <\/b>aus Listing 3 nutzen.<\/p>\n Listing 3: Prozedur zum Entfernen von Zeilennummern einer Prozedur<\/span><\/b><\/p>\n Achtung: Die Prozedur geht davon aus, dass die Prozedur, aus der die Zeilennummern entfernt werden sollen, mit der weiter oben beschriebenen Prozedur AddLineNumbers <\/b>mit Zeilennummern versehen wurde.<\/p>\n Die Prozedur erwartet die folgenden Parameter:<\/p>\n Sie referenziert das aktuelle VBA-Projekt und dann mit objVBComponent <\/b>die mit strModule <\/b>übergebene Komponente. Mit objCodeModule <\/b>referenzieren wir das CodeModule<\/b>-Element, das wir anschließend nutzen, um mit ProcBodyLine <\/b>die erste Zeile der Prozedur aus strProcedure <\/b>zu ermitteln. Mit dieser können wir nun die beiden Funktionen GetFirstStatementLineNumber <\/b>und GetLastStatementLineNumber <\/b>aufrufen, um die Nummern der ersten und der letzten Zeile innerhalb der Prozedur zu ermitteln. Diese Werte verwenden wir als Bereich von zunächst einer For…Next<\/b>-Schleife.<\/p>\n In dieser untersuchen wir die ersten sechs Zeichen der Zeile. Enthalten diese einen numerischen Wert, ist die Prozedur offensichtlich mit einer Zeilennummerierung ausgestattet. Sobald wir einen numerischen Wert in den ersten sechs Zeichen einer Zeile ermittelt haben, stellen wir daher die Variable bolNumbers <\/b>auf True <\/b>ein und verlassen die erste For…Next<\/b>-Schleife. Hat bolNumbers <\/b>danach den Wert True<\/b>, steigen wir in die nächste For…Next<\/b>-Schleife ein. In dieser trennen wir zunächst die ersten sechs Zeichen einer jeden Zeile ab und untersuchen diese anschließend. Ist der Inhalt der ersten sechs Zeichen numerisch, handelt es sich offensichtlich um Zeilennummern. Ist der Inhalt hingegen eine leere Zeichenkette, so ist es eine Zeile, die zuvor eingerückt wurde, ohne dass eine Zeilennummer hinzugefügt wurde. In beiden Fällen werden einfach die ersten sechs Zeichen von vorn entfernt.<\/p>\n Da wir diese Prozedur nicht für jede Prozedur einzeln aufrufen wollen, verwenden wir eine weitere Prozedur namens RemoveLineNumbersFromModule <\/b>(siehe Listing 4), um alle Prozeduren eines Moduls zu durchlaufen und für jede Prozedur die Routine RemoveLineNumbers <\/b>aufzurufen.<\/p>\n Listing 4: Prozedur zum Entfernen von Zeilennummern eines Moduls<\/span><\/b><\/p>\n Dazu referenzieren wir das aktuelle VBA-Projekt und das übergebene Modul mit der Variablen objCodeModule<\/b>. Wir durchlaufen alle Zeilen des Moduls und prüfen, zu welcher Prozedur die aktuelle Zeile gehört. Beim Auffinden einer jeden neuen Prozedur rufen wir einmal die Prozedur RemoveLineNumbers <\/b>für diese Prozedur auf. Dies führen wir solange durch, bis wir alle Zeilen des Moduls durchlaufen haben.<\/p>\n Schließlich verwenden wir noch eine Prozedur namens RemoveLineNumbersFromActiveVBProject<\/b>, um alle Module des aktuellen VBA-Projekts zu durchlaufen und für jedes Modul einmal die Prozedur RemoveLineNumbersFromModule <\/b>aufzurufen.<\/p>\n Damit können wir alle Nummerierungen aus den Modulen des Projekts entfernen:<\/p>\n Die Hilfsfunktion GetFirstStatementLineNumber <\/b>ermittelt die Nummer der ersten Anweisung in einer Prozedur. Damit ist tatsächlich die erste Anweisung gemeint, die auf die Kopfzeile folgt – auch, wenn diese mehr als eine Zeile umfasst. Diese Funktion aus Listing 5 erwartet die folgenden Parameter:<\/p>\n Listing 5: Prozedur zum Einlesen der Nummer der Zeile der ersten Anweisung in einer Prozedur<\/span><\/b><\/p>\n Die mit lngProcBodyLine <\/b>gelieferte Zeilennummer verwenden wir als Ausgangspunkt für die Suche nach der ersten Zeile hinter der Kopfzeile. Die Funktion GetFirstStatementLineNumber <\/b>schreibt zuerst den Wert aus lngProcBodyLine <\/b>in die Variable lngFirstStatementLineNumber<\/b>.<\/p>\n Nun prüft die Funktion, ob die Kopfzeile der Prozedur am Ende einen Unterstrich enthält, was darauf hindeuten würde, dass die Kopfzeile noch mindestens eine weitere Zeile enthält. Ist das nicht der Fall, ist die erste Zeile nach der Kopfzeile die erste Zeile mit einer Anweisung.<\/p>\n Wir brauchen also nur lngFirstStatementLineNumber <\/b>um 1 <\/b>zu erhöhen und zurückzugeben. Anderenfalls springt die Prozedur solange eine Zeile weiter, bis sie die letzte Zeile der Kopfzeile erreicht. Anschließend wird ebenfalls 1 <\/b>zu lngFirstStatementLineNumber <\/b>hinzugezählt und der Wert zurückgegeben.<\/p>\n Auf ähnliche Weise ermitteln wir die Zeile mit der letzten Anweisung. Die dazu verwendete Funktion GetLastStatementLineNumber <\/b>aus Listing 6 ist lediglich etwas umfangreicher und verwendet die gleichen Parameter wie GetFirstStatementLineNumber<\/b>. Das liegt daran, dass sie zuerst die erste Zeile mit einer Anweisung ermittelt und sich von dort bis zur letzten Anweisung der Prozedur durcharbeitet.<\/p>\n\n
Public Sub <\/span>AddLineNumbers(strModule As String<\/span>, strProcedure As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngProcBodyLine As Long<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLastStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>bolNumbers As Boolean<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngProcBodyLine = objCodemodule.ProcBodyLine(strProcedure, intProcType)\r\n lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n lngLastStatementLineNumber = GetLastStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber\r\n strLine = left(objCodemodule.Lines(lngLine, 1), 6)\r\n Select Case True<\/span>\r\n Case <\/span>IsNumeric(strLine)\r\n bolNumbers = True<\/span>\r\n Exit For<\/span>\r\n End Select<\/span>\r\n Next<\/span> lngLine\r\n If <\/span>bolNumbers = False<\/span> Then<\/span>\r\n For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber\r\n Select Case True<\/span>\r\n Case <\/span>left(LTrim<\/span>(objCodemodule.Lines(lngLine, 1)), 5) = \"Case \"\r\n objCodemodule.ReplaceLine lngLine, Space(6) & objCodemodule.Lines(lngLine, 1)\r\n Case <\/span>IsLabel(objCodemodule.Lines(lngLine, 1))\r\n Case Else<\/span>\r\n objCodemodule.ReplaceLine lngLine, Format(lngLine, \"00000\") & \" \" & objCodemodule.Lines(lngLine, 1)\r\n End Select<\/span>\r\n Next<\/span> lngLine\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Prozedur ''\" & strProcedure & \"'' aus Modul ''\" & strModule _\r\n & \"'' scheint bereits Zeilennummern zu enthalten.\", vbOKOnly + vbInformation, \"Zeilennummern vorhanden\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nFunktion zum Hinzufügen von Zeilennummern aufrufen<\/h2>\n
Call<\/span> AddLineNumbers(\"mdlTest\", \"Test\")<\/pre>\nZeilennummern zu allen Prozeduren eines Moduls hinzufügen<\/h2>\n
Public Sub <\/span>AddLineNumbersToModule(strModule As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strProcedure As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n For lngLine = 1 To lngCountOfLines\r\n If <\/span>Not<\/span> strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then<\/span>\r\n strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType)\r\n Call<\/span> AddLineNumbers(strModule, strProcedure)\r\n End If<\/span>\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nZeilennummern zu allen Prozeduren des VBA-Projekts hinzufügen<\/h2>\n
Public Sub <\/span>AddLineNumbersToActiveVBProject()\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n For Each objVBComponent In objVBProject.VBComponents\r\n Call<\/span> AddLineNumbersToModule(objVBComponent.Name)\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\nFunktion zum Entfernen von Zeilennummern aus einer Prozedur<\/h2>\n
Public Sub <\/span>RemoveLineNumbers(strModule As String<\/span>, strProcedure As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngProcBodyLine As Long<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLastStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n Dim <\/span>bolNumbers As Boolean<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n lngProcBodyLine = objCodemodule.ProcBodyLine(strProcedure, intProcType)\r\n lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n lngLastStatementLineNumber = GetLastStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber\r\n strLine = left(objCodemodule.Lines(lngLine, 1), 6)\r\n Select Case True<\/span>\r\n Case <\/span>IsNumeric(strLine)\r\n bolNumbers = True<\/span>\r\n Exit For<\/span>\r\n End Select<\/span>\r\n Next<\/span> lngLine\r\n If <\/span>bolNumbers = True<\/span> Then<\/span>\r\n For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber\r\n strLine = left(objCodemodule.Lines(lngLine, 1), 6)\r\n Select Case True<\/span>\r\n Case <\/span>IsNumeric(strLine), Trim<\/span>(strLine) = \"\"\r\n objCodemodule.ReplaceLine lngLine, Mid<\/span>(objCodemodule.Lines(lngLine, 1), 7)\r\n End Select<\/span>\r\n Next<\/span> lngLine\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Funktion zum Entfernen von Zeilennummern aus einem vollständigen Modul<\/h2>\n
Public Sub <\/span>RemoveLineNumbersFromModule(strModule As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strProcedure As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n For lngLine = 1 To lngCountOfLines\r\n If <\/span>Not<\/span> strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then<\/span>\r\n strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType)\r\n Call<\/span> RemoveLineNumbers(strModule, strProcedure)\r\n End If<\/span>\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nFunktion zum Entfernen von Zeilennummern aus dem vollständigen VBA-Projekt<\/h2>\n
Public Sub <\/span>RemoveLineNumbersFromActiveVBProject()\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n For Each objVBComponent In objVBProject.VBComponents\r\n Call<\/span> RemoveLineNumbersFromModule(objVBComponent.Name)\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\nHilfsfunktion zum Ermitteln der Zeilennummer der ersten Anweisung einer Prozedur<\/h2>\n
Public Function <\/span>GetFirstStatementLineNumber(objCodemodule As <\/span>VBIDE.CodeModule, lngProcBodyLine As Long<\/span>) As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n lngFirstStatementLineNumber = lngProcBodyLine\r\n strLine = objCodemodule.Lines(lngFirstStatementLineNumber, 1)\r\n strLine = Trim<\/span>(strLine)\r\n Do While<\/span> right(strLine, 1) = \"_\"\r\n lngFirstStatementLineNumber = lngFirstStatementLineNumber + 1\r\n strLine = objCodemodule.Lines(lngFirstStatementLineNumber, 1)\r\n strLine = Trim<\/span>(strLine)\r\n Loop<\/span>\r\n GetFirstStatementLineNumber = lngFirstStatementLineNumber + 1\r\nEnd Function<\/span><\/pre>\n\n
Hilfsfunktion zum Ermitteln der Zeilennummer der letzten Anweisung einer Prozedur<\/h2>\n
Public Function <\/span>GetLastStatementLineNumber(objCodemodule As <\/span>VBIDE.CodeModule, lngProcBodyLine As Long<\/span>) As Long<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLastStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strCurrentLine As String<\/span>\r\n lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n For lngLine = lngFirstStatementLineNumber To objCodemodule.CountOfLines\r\n strCurrentLine = objCodemodule.Lines(lngLine, 1)\r\n strCurrentLine = LTrim<\/span>(strCurrentLine)\r\n Select Case True<\/span>\r\n Case <\/span>left(strCurrentLine, 7) = \"End Sub\", left(strCurrentLine, 12) = \"End Function\", _\r\n left(strCurrentLine, 12) = \"End Property\"\r\n lngLastStatementLineNumber = lngLine - 1\r\n Exit For<\/span>\r\n End Select<\/span>\r\n