<\/p>\n
Reguläre Ausdrücke dienen mitunter nicht nur der Mustererkennung, sondern leisten hervorragende Dienste beim Ersetzen bestimmter Zeichenfolgen. Damit Sie unter VBA von regulären Ausdrücken profitieren können, lernen Sie in diesem Beitrag die grundlegenden Techniken kennen und erfahren, wie Sie beinahe beliebige Ausdrücke in Zeichenketten erkennen und ersetzen können. Schließlich liefert der Betrag ein Beispiel zum Erkennen der VBA-Schlüsselwörter in Codemodulen.<\/b><\/p>\n
Reguläre Ausdrücke (Regular Expressions<\/b>, kurz RegExp<\/b>) dienen zum Suchen und Ersetzen von Textelementen.<\/p>\n
Reguläre Ausdrücke sind kein Bestandteil von VBA, sondern müssen über das Setzen eines Verweises auf die Bibliothek Microsoft VBScript Regular Expressions 5.5 <\/b>verfügbar gemacht werden.<\/p>\n
Im Code erzeugen Sie dann eine Instanz des Objekts RegExp <\/b>und speichern den Verweis darauf in einer entsprechenden Objektvariablen:<\/p>\n Das RegExp<\/b>-Objekt hat einige wenige Eigenschaften, die folgende Aufgabe haben:<\/p>\n Aktionen<\/b><\/p>\n Prinzipiell können Sie mit RegExp suchen oder suchen und ersetzen. Wenn Sie einfach nur prüfen möchten, ob ein Ausdruck in einem anderen Ausdruck vorkommt, geben Sie das Pattern an und prüfen den zu durchsuchenden Ausdruck mit der Test<\/b>-Funktion. Diese liefert True<\/b> oder False <\/b>zurück.<\/p>\n Wenn Sie den gefundenen Ausdruck gleich ersetzen möchten, verwenden Sie statt Test <\/b>die Replace<\/b>-Methode. Diese erwartet entsprechend gleich zwei Parameter, nämlich den zu durchsuchenden String sowie die Zeichenkette, die statt des in Pattern angegebenen Ausdrucks verwendet werden soll.<\/p>\n Einfache Suche<\/b><\/p>\n Die einfachste Suche realisieren die folgenden Codezeilen. Die Funktion prüft schlicht, ob sich der mit strSuchbegriff <\/b>übergebene Ausdruck in strOriginal <\/b>befindet und gibt entweder True <\/b>oder False <\/b>zurück:<\/p>\n Der folgende Ausdruck würde im Direktfenster also beispielsweise den Wert True <\/b>zurückliefern:<\/p>\n Einfaches Suchen und Ersetzen<\/b><\/p>\n Die einfachste Suchen- und Ersetzen-Funktion bildet (fast) die Replace<\/b>-Funktion von VBA ab. Sie erwartet die gleichen Parameter, also den Originalausdruck, den zu ersetzenden Ausdruck und den Ersatzausdruck.<\/p>\n Der Unterschied ist jedoch, dass hier nur das erste Auftreten des gesuchten Begriffs ersetzt wird. Der Grundaufbau ist wie beim reinen Suchen, allerdings kommt hier nicht die Test<\/b>-Funktion, sondern die Replace<\/b>-Funktion zum Einsatz.<\/p>\n Diese erwartet zusätzlich den Ersatzbegriff als Parameter und liefert auch keinen Boolean-Wert zurück, sondern gleich die geänderte Zeichenkette:<\/p>\n Ein einfacher Aufruf sieht wie folgt aus und liefert das entsprechende Ergebnis zurück:<\/p>\n Es kann auch sein, dass der Suchbegriff gleich mehrfach im Originalausdruck vorkommt. Um die Replace<\/b>-Funktion von VBA vollwertig abzubilden, müssen wir den Suchbegriff an allen vorkommenden Stellen ersetzen. Dazu brauchen Sie einfach noch die Eigenschaft Global <\/b>von objRegExp <\/b>auf True <\/b>einzustellen.<\/p>\n Alle Fundstellen einzeln betrachten<\/b><\/p>\n Gegebenenfalls sollen nicht alle Suchergebnisse über einen Kamm geschert werden, sondern Sie möchten diese einzeln behandeln.<\/p>\n Dann sind das MatchCollection<\/b>– und das Match<\/b>-Objekt interessant. Sie müssen für beide eine Objektvariable deklarieren:<\/p>\n Danach übergeben Sie das Ergebnis der Execute<\/b>-Methode im MatchCollection<\/b>-Objekt und durchlaufen alle darin enthaltenen Match<\/b>-Objekte und geben einige Information pro Fundstelle aus:<\/p>\n Ein Beispielaufruf sieht etwa so aus:<\/p>\n Das Match<\/b>-Objekt liefert nützliche Informationen. Im obigen Beispiel geben wir die folgenden drei je Fundstelle aus:<\/p>\n Ausdrücke zusammenstellen<\/b><\/p>\n Nachdem Sie wichtige Grundtechniken für den Einsatz regulärer Ausdrücke kennengelernt haben, schauen wir uns nun die Ausdrücke beziehungsweise die sogenannten Pattern selbst an.<\/p>\n Die einfachste Möglichkeit ist natürlich die Angabe einer konkreten Zeichenkette. Sicher kennen Sie das Sternchen und das Fragezeichen als Platzhalter für beliebig viele beziehungsweise ein einziges Zeichen in Access-SQL-Bedingungen.<\/p>\n Reguläre Ausdrücke bieten hier wesentlich aufgefeiltere Möglichkeiten:<\/p>\n <\/p>\n Suchen und ersetzen<\/b><\/p>\n Mit der Kenntnis der möglichen Ausdrücke und ein wenig Übung werden Sie schnell die gewünschten Zeichenketten finden. Es gibt jedoch noch einen sehr wichtigen Tipp für das Ersetzen von Zeichenketten.<\/p>\n Bei der Replace<\/b>-Funktion von VBA tauschen Sie einfach einen Teilausdruck gegen einen anderen aus, wobei ersterer dem Suchbegriff entspricht. Wenn Sie dort nun beispielsweise den Ausdruck cde <\/b>nicht überall durch xyz<\/b> möchten, sondern nur dort, wo der Ausdruck in einem bestimmten Kontext steht (also beispielsweise dort, wo er in bestimmte andere Zeichenfolgen eingefasst ist – beispielsweise abcdefg<\/b>), müssen Sie erst nach abcdefg <\/b>suchen und dann mühsam mit weiteren Zeichenkettenfunktionen den darin enthaltenen Ausdruck ersetzen.<\/p>\n ab <\/b>und fg <\/b>stehen hier stellvertretend für variable Ausdrücke – sonst könnten Sie ja auch einfach abcdefg <\/b>durch abxyzfg <\/b>ersetzen!<\/p>\n Reguläre Ausdrücke bieten hier eine tolle Variante: Sie können dort einfach den Bereich, der nicht ausgetauscht werden soll, in Klammern einfassen und diesen nachher in den neuen Ausdruck integrieren. Sie suchen also nach folgendem Ausdruck:<\/p>\n Nun soll der mittlere Teil (cde) überall durch xyz ersetzt, die umschließenden Teile aber beibehalten werden. Dann geben Sie als neuen Ausdruck einfach den folgenden an:<\/p>\n $1 <\/b>wird in diesem Fall durch den ersten in Klammern eingefassten Ausdruck ersetzt, $2 <\/b>durch den zweiten. Auf diese Weise können Sie beliebig viele Elemente des Suchausdrucks in den Ersatzausdruck hinüberretten.<\/p>\n Vertauschen<\/b><\/p>\n Mit dieser Technik können Sie natürlich auch einfach Ausdrücke vertauschen. Wenn Sie beispielsweise das Datumsformat in einem Text von DD.MM.YYYY <\/b>in YYYY\/MM\/DD <\/b>ändern möchten, lautet der Suchausdruck wie folgt:<\/p>\n Der neue Ausdruck sieht so aus:<\/p>\n Das bedeutet: Ein Auftreten von ein oder zwei Zahlen, einem Punkt, weiteren ein oder zwei Zahlen, einem weiteren Punkt und vier Zahlen soll ersetzt werden durch die vier Zahlen, einen Schrägstrich, die mittleren ein oder zwei Zahlen, einen weiteren Schrägstrich und die vorderen zwei Zahlen.<\/p>\n Beispiel Pfad-\/Dateiname<\/b><\/p>\n Wenn Sie aus einem Dateinamen mit Pfad nur den Pfad erhalten möchten, geht das zwar auch mit den Zeichenkettenfunktionen von VBA recht einfach. Aber es ist ein gutes Beispiel für eine erste Übung.<\/p>\n Wie lautet die Anforderung, wenn wir aus c:\\test\\test.txt <\/b>den Teil c:\\test\\ <\/b>erhalten möchten Genau: Liefere alles, was mit einem Backslash endet. Der entsprechende Ausdruck sieht so aus:<\/p>\n Der Ausdruck liefert beliebig viele Zeichen, wobei das letzte ein Backslash sein muss. Warum liefert RegExp nicht nur c:\\<\/b><\/p>\n Weil es gierig ist: Es ermittelt erst die Zeichenfolge aus beliebig vielen Zeichen (.*<\/b>) und geht dann von hinten nach vorne zum ersten Backslash zurück.<\/p>\n Um nun nur den Dateinamen, also test.txt <\/b>zu erhalten, probieren wir es andersherum:<\/p>\n Dies gelingt jedoch nicht: RegExp sucht erst einen Backslash und hängt dann die folgenden Zeichen an. Das Ergebnis sieht so aus:<\/p>\n Die richtige Lösung lautet:<\/p>\n Das Dollar-Zeichen sorgt dafür, dass der Ausdruck das Ende der Zeichenkette einschließt, und der vordere Teil liefert beliebig viele aufeinanderfolgende Zeichen, die kein Backslash sind.<\/p>\n Komplexes Beispiel: Schlüsselwörter in VBA-Code markieren<\/b><\/p>\n Im Beitrag Berichte ohne Datenherkunft <\/b>(www.access-im-unternehmen.de\/****<\/b>) sollen in einem Beispiel Schlüsselwörter in VBA-Code farbig ausgegeben werden.<\/p>\n Die Vorarbeit dazu soll mit Hilfe regulärer Ausdrücke erledigt werden, und zwar durch Hervorheben der gesuchten Schlüsselwörter durch Voranstellen einer speziellen Zeichenkombination (hier \\@<\/b>).<\/p>\n Für einen ersten Versuch wollen wir die folgende typische Zeile anpassen:<\/p>\n Diese soll nach dem Bearbeiten so aussehen:<\/p>\n Die notwendige Funktion sieht wie folgt aus, wobei diese zunächst einen Suchausdruck enthält, der nur aus wenigen Schlüsselwörtern besteht:<\/p>\n Der Aufruf erfolgt beispielsweise so und liefert gleich ein entsprechendes Ergebnis:<\/p>\n Der erste Ansatz für den Suchausdruck soll zunächst nur die erste Zeile einer Prozedur durchforsten und enthält daher nur die dort verwendeten Begriffe (die Datentypen fehlen noch):<\/p>\n Der Ausdruck sucht nach einem der optionalen Schlüsselwörter (optionale Ausdrücke werden in Klammern eingefasst und durch das Pipe-Zeichen voneinander getrennt).<\/p>\n Das zweite Klammernpaar sorgt dafür, dass die Prozedur sich den Ausdruck merken kann.<\/p>\n Beim Ersetzen mit der Replace<\/b>-Methode soll dann der entsprechende Ausdruck wiederverwendet und um das führende \\@ <\/b>ergänzt werden.<\/p>\n Wenn Sie die Prozedur gleich mit einer kompletten VBA-Routine durchexerzieren möchten, brauchen Sie einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/b>. Sie können dann mit der folgenden Funktion auf den Code eines Moduls zugreifen:<\/p>\n Der Aufruf der Funktion SchluesselwoerterErsetzen<\/b> für das Modul, indem diese Funktion selbst gespeichert ist, sorgt dann auch gleich für rege Betriebsamkeit im Direktfenster, wie Bild 1 zeigt.<\/p>\n Bild 1: Dieser Bericht druckt den Inhalt einer Textdatei.<\/span><\/b><\/p>\n Allerdings ist die Funktion ein wenig übereifrig: Die im Suchausdruck-String angegebenen Schlüsselwörter wurden nämlich ebenfalls fleißig mit dem Präfix \\@ versehen – und das ist nicht beabsichtigt. Wir müssen also Schlüsselwörter innerhalb von Anführungszeichen ausschließen.<\/p>\n Solche Ausnahmefälle wie zu ignorierende Suchbegriffe innerhalb von Anführungszeichen treten oft auf. So oft, dass wir die Schlüsselwörter zunächst einmal separat betrachten und uns dann um Vereinfachung bemühen.<\/p>\n Option-Schlüsselwort entfernen<\/b><\/p>\n Das Option<\/b>-Schlüsselwort ist einfach zu behandeln: Es steht sicher nur am Beginn einer Zeile. Die folgende Prozedur sucht nach dem Ausdruck ^(Option)( )<\/b>, also nach einem Zeilenbeginn, dem Schlüsselwort Option <\/b>und einem Leerzeichen.<\/p>\n Der Ausdruck Option <\/b>und das Leerzeichen werden jeweils in Klammern eingefasst, damit wir diese Ausdrücke beim Ersetzen mit $1 <\/b>und $2 <\/b>referenzieren können.<\/p>\n Es werden also alle Vorkommen dieses Ausdrucks durch den gleichen Ausdruck mit vorangestelltem \\@ <\/b>und abschließendem \\\\ <\/b>ersetzt (Letzteres scheint notwendig, damit Nicht-Schlüsselwörter wieder anders formatiert werden können):<\/p>\n Die ersten beiden Zeilen eines typischen Access-Mdols sehen dann wie folgt aus:<\/p>\n Machen wir beim Schlüsselwort Compare <\/b>weiter, das offensichtlich immer von zwei Leerzeichen eingefasst wird und fügen die folgenden beiden Zeilen zur Prozedur hinzu:<\/p>\n Für das Schlüsselwort Database<\/b> können wir das Zeilenende-Symbol $ <\/b>verwenden:<\/p>\n Die ersten beiden Zeilen des Moduls sehen nun so aus:<\/p>\n Das schreit nach einer Vereinfachung, denn schließlich tauchen beide Zeilen jeweils im Zusammenhang auf.<\/p>\n Die zeilenweise Behandlung sieht so aus:<\/p>\n Dies ist das Ergebnis:<\/p>\n Unser eigentliches Ziel, nämlich das Vorbereiten des Codes für die Ausgabe in einen Bericht und gleichzeitiges Einfärben der Ausdrücke zwischen den Markierungen \\@ und \\\\ (s. Beitrag Berichte ohne Datenherkunft<\/b>, www.access-im-unternehmen.de\/****<\/b>), rückt damit auch näher: Immerhin gelingt das Einfärben weniger großer Zeichenketten dort sicher schneller als die Bearbeitung vieler kleiner Zeichenketten.<\/p>\n Nun kann Option Compare <\/b>neben Database <\/b>noch die Optionen Text <\/b>und Binary <\/b>annehmen, sodass wir diese kleine Erweiterung zum Pattern hinzufügen:<\/p>\n Hier werden nun alle drei möglichen Zeilen (Option Compare Database<\/b>, Option Compare Text <\/b>und Option Compare Binary<\/b>) berücksichtigt.<\/p>\n Prozedurköpfe suchen<\/b><\/p>\n Bei Prozedurköpfen wird es interessanter. Eine Prozedur kann mit Public<\/b>, Private <\/b>oder Friend <\/b>beginnen (oder auch ohne einen dieser Ausdrücke), dann folgt gelegentlich das Schlüsselwort Static <\/b>und schließlich Sub <\/b>oder Function<\/b>.<\/p>\n In Klassen arbeiten wir auch mit Properties – dann folgt statt Sub <\/b>oder Function <\/b>der Ausdruck Property Get<\/b>\/Let<\/b>\/Set<\/b>. Der passende reguläre Ausdruck und die Ersetzung sehen so aus:<\/p>\n Das heißt: Beginne am Zeilenbeginn und suche Ausdrücke, die mit ein oder keinmal Public<\/b>, Private <\/b>oder Friend <\/b>enthalten, ein oder keinmal das Schlüsselwort Static<\/b>, eines der Schlüsselwörter Sub<\/b>, Function <\/b>oder Property <\/b>und schließlich ein oder keinmal Get<\/b>, Let <\/b>oder Set<\/b>.In allen Fällen sind die Leerzeichen wichtig – gerade bei Get<\/b>\/Let<\/b>\/Set<\/b>: Wenn Sie dort das Leerzeichen weglassen, findet der Ausdruck nämlich auch Texte wie Public Sub GetMember<\/b>.<\/p>\n Parameterlisten, Rückgabewerte und Deklarationen<\/b><\/p>\n Prozedurköpfe können aber noch mehr Elemente enthalten, nämlich Parameter und Rückgabewerte. Diese sind aus dem Variablennamen, dem Schlüsselwort As <\/b>und dem Datentyp aufgebaut, also beispielsweise Date <\/b>oder String<\/b>.<\/p>\n An dieser Stelle behandeln wir lediglich die Datentypen der VBA-Bibliothek. Das Pattern und die Ersetzung sehen so aus:<\/p>\n Bei den Deklarationen wie etwa Dim str As String <\/b>fehlt noch das erste Schlüsselwort, also beispielsweise Dim<\/b>, Public <\/b>oder Private<\/b>.<\/p>\n Diese greifen wir mit dem folgenden Pattern ab:<\/p>\n Damit erwischen wir alle Auftreten von Dim<\/b>, Public<\/b>, Private <\/b>oder Static<\/b>, die direkt am Zeilenbeginn stehen oder die maximal durch ein oder mehrere Leerzeichen vom Zeilenbeginn getrennt werden.<\/p>\n If…Then-Bedingungen<\/b><\/p>\n Die erste Zeile einer If… Then<\/b>-Bedingung besteht aus keinem, einem oder mehreren Leerzeichen gefolgt von If<\/b>, einem Ausdruck von einem oder mehreren beliebigen Zeichen und dem Then<\/b>:<\/p>\n Der Else<\/b>-Teil besteht schlicht aus keinem, einem oder mehreren Leerzeichen und dem Schlüsselwort Else<\/b>:<\/p>\n ElseIf ist dann wieder genauso aufgebaut wie die eigentliche If…Then<\/b>-Zeile:<\/p>\n Die End If<\/b>-Zeile haken wir direkt gemeinsam mit der End Select<\/b>-Zeile ab. Dies sieht dann so aus:<\/p>\n Select Case<\/b><\/p>\n Damit kommen wir gleich zum Select Case<\/b>-Konstrukt.<\/p>\n Die Select Case<\/b>-Anweisung beginnt nach keinem, einem oder mehreren Leerzeichen hinter dem Zeilenbeginn und besteht aus dem Select Case<\/b>-Schlüsselwort sowie einem aus einem oder mehreren Zeichen bestehenden Ausdruck:<\/p>\n Die Case<\/b>– und die Case Else<\/b>-Zeile werden prinzipiell gleich behandelt: Nach dem Zeilenbeginn folgen beliebig viele Leerzeichen gefolgt vom jeweiligen Schlüsselwort.<\/p>\n Da Case <\/b>aber in Case Else <\/b>enthalten ist, kann es bei der falschen Reihenfolge beim Ersetzen dazu kommen, dass erst Case <\/b>durch \\@Case\\\\ <\/b>ersetzt und dann Case Else <\/b>nicht mehr erkannt wird. Also prüfen wir erst auf Case Else<\/b>:<\/p>\n Erst danach kümmern wir uns um die übriggelassen Case<\/b>-Zeilen:<\/p>\n Die End Select<\/b>-Zeile haben wir ja bereits erledigt.<\/p>\n VBA-Funktionen und -Prozeduren<\/b><\/p>\n Interessant ist das Auftreten von VBA-Funktionen und -Methoden.<\/p>\n Eine solche folgt im Regelfall auf ein Leerzeichen wie in folgendem Beispiel:<\/p>\n VBA-Funktionen werden aber auch gern verschachtelt wie in folgendem Beispiel:<\/p>\n Das bedeutet, dass wir nach führenden Leerzeichen und öffnenden Klammern suchen, gefolgt von der VBA-Funktion und einer schließenden Klammer oder auch einem Leerzeichen<\/p>\n Dies erledigt der folgende Ausdruck:<\/p>\n Die Menge der VBA-Funktionen und -Prozeduren ist natürlich nicht vollständig – Sie können diese nach Ihren eigenen Wünschen ergänzen.<\/p>\n Ausstieg aus …<\/b><\/p>\n Sowohl aus Funktionen, Prozeduren, Property-Prozeduren, Bedingungen und Schleifen können Sie per VBA aussteigen. Dies gelingt mit der Exit<\/b>-Anweisung, die Sie wie folgt erkennen:<\/p>\n Debug.Print<\/b><\/p>\n Das Debug<\/b>-Objekt liefert neben der Print<\/b>-Methode auch noch die Assert<\/b>-Methode. Beide finden Sie mit der folgenden Beschreibung:<\/p>\n Prozedurfüße<\/b><\/p>\n Die End<\/b>-Zeile nennen wir der Einfachheit halber Prozedurfuß. Dieser zeichnet sich vor allem durch das einleitende Schlüsselwort End <\/b>aus. Danach folgen entweder Sub<\/b>, Function <\/b>oder Property<\/b>. Leichte Beute, die wir mit dem folgenden Ausdruck erlegen:<\/p>\nDim objRegExp As RegExp\r\nSet objRegExp = New RegExp<\/pre>\n
\n
Public Function EinfacheSuche( _\r\n strOriginal As String, _\r\n strSuchbegriff As String) As Boolean\r\n Dim objRegExp As RegExp\r\n Set objRegExp = New RegExp\r\n With objRegExp\r\n .Pattern = strSuchbegriff\r\n EinfacheSuche = .Test(strOriginal)\r\n End With\r\n Set objRegExp = Nothing\r\nEnd Function<\/pre>\n
EinfacheSuche("cd", "abcdef")<\/pre>\nPublic Function SuchenUndErsetzen( _\r\n strOriginal As String, _\r\n strSuchbegriff As String, _\r\n strErsatzbegriff As String) As String\r\n Dim objRegExp As RegExp\r\n Set objRegExp = New RegExp\r\n With objRegExp\r\n .Pattern = strSuchbegriff\r\n SuchenUndErsetzen = _\r\n .Replace(strOriginal, strErsatzbegriff)\r\n End With\r\n Set objRegExp = Nothing\r\nEnd Function<\/pre>\n
EinfachesSuchenUndErsetzen("abcdef", "cd", "xx")\r\nabxxef<\/pre>\nDim objMatchCollection As MatchCollection\r\nDim objMatch As Match<\/pre>\n
Set objRegExp = New RegExp\r\nWith objRegExp\r\n.Pattern = strSuchbegriff\r\n.Global = True\r\nSet objMatchCollection = _\r\n.Execute(strOriginal)\r\nFor Each objMatch In objMatchCollection\r\n Debug.Print "Position: " _\r\n & objMatch.FirstIndex, "Wert: " _\r\n & objMatch.Value, "Länge: " _\r\n & objMatch.Length\r\nNext objMatch\r\nEnd With<\/pre>\n
SuchergebnisseEinzelnBearbeiten "abcdefcd", "cd"\r\nPosition: 2 Wert: cd Länge: 2\r\nPosition: 6 Wert: cd Länge: 2<\/pre>\n
\n
\n
(ab)cde(fg)<\/pre>\n
$1xyz$2<\/pre>\n
(\\d{1,2})\\.(\\d{1,2}).(\\d{4})<\/pre>\n$3\/$2\/$1<\/pre>\n
.*\\\\<\/pre>\n
\\\\.*<\/pre>\n
\\test\\test.txt<\/pre>\n
[^\\\\]*$<\/pre>\n
Public Sub Test()<\/pre>\n
\\@Public \\@Sub Test()<\/pre>\n
Public Function SchluesselwoerterErsetzen(_\r\n strModul As String) As String\r\n Dim objRegExp As RegExp\r\n Dim strSchluesselwoerter As String\r\n Set objRegExp = New RegExp\r\n strSchluesselwoerter = "((Public|Private\r\n |Friend|Sub|Function|Property|Get|\r\n Set|Let|As|Optional))"\r\n With objRegExp\r\n .Pattern = strSchluesselwoerter\r\n .Global = True\r\n SchluesselwoerterErsetzen = _\r\n .Replace(strModul, "\\@$1")\r\n End With\r\n Set objRegExp = Nothing\r\nEnd Function<\/pre>\n
SchluesselwoerterErsetzen("Public Sub Test()")\r\n\\@Public \\@Sub Test()<\/pre>\n((Public|Private|Friend|Sub|Function|Property|Get|Set|Let|As|Optional))<\/pre>\n
Public Function GetModuleCode(strModule As _\r\n String) As String\r\n Dim objCodeModule As CodeModule\r\n Set objCodeModule = VBE.ActiveVBProject.\r\n VBComponents(strModule).CodeModule\r\n GetModuleCode = objCodeModule.Lines(1,\r\n objCodeModule.CountOfLines)\r\nEnd Function<\/pre>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_06\/RegExp_5-web-images\/pic001.png\")
<\/p>\nPublic Function SchluesselwoerterErsetzen( _\r\n strModul As String) As String\r\n Dim objRegExp As RegExp\r\n Set objRegExp = New RegExp\r\n With objRegExp\r\n .Multiline = True\r\n .Global = True\r\n .Pattern = "^(Option)( )"\r\n strModul = .Replace(strModul, "\\@$1\\\\$2")\r\n End With\r\n SchluesselwoerterErsetzen = strModul\r\n Set objRegExp = Nothing\r\nEnd Function<\/pre>\n
\\@Option\\\\ Explicit\r\n\\@Option\\\\ Compare Database<\/pre>\n
.Pattern = "( )(Compare)( )"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\$3")<\/pre>\n
.Pattern = "( )(Database)$"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\")<\/pre>\n
\\@Option\\\\ Explicit\r\n\\@Option\\\\ \\@Compare\\\\ \\@Database\\\\<\/pre>\n
.Pattern = "^(Option Compare Database)"\r\nstrModul = .Replace(strModul, "\\@$1\\\\")\r\n.Pattern = "^(Option Explicit)"\r\nstrModul = .Replace(strModul, "\\@$1\\\\")<\/pre>\n
\\@Option Explicit\\\\\r\n\\@Option Compare Database\\\\<\/pre>\n
.Pattern = "^(Option Compare Database|Text|Binary)"<\/pre>\n
.Pattern = "^(Public |Private |Friend )(Static )(Sub |Function |Property )(Get |Let |Set )"\r\nstrModul = .Replace(strModul, "\\@$1$2$3$4\\\\")<\/pre>\n
.Pattern = "( As )(Byte|Boolean|Integer|Long|\r\nCurrency|Decimal|Single|Double|Date|String|\r\nObject|Variant)"\r\nstrModul = .Replace(strModul, "\\@$1$2\\\\")<\/pre>\n
.Pattern = "^( *)(Dim |Public |Private |Static )"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\")<\/pre>\n
.Pattern = "( *)(If )(.+)( Then)"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\$3\\@$4\\\\")<\/pre>\n
.Pattern = "( *)(Else)"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\")<\/pre>\n
.Pattern = "( *)(ElseIf )(.+)( Then)"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\$3\\@$4\\\\")<\/pre>\n
.Pattern = "^( *)(End )(If|Select)$"\r\nstrModul = .Replace(strModul, "$1\\@$2$3\\\\")<\/pre>\n
.Pattern = "^( *)(Select Case )(\\w+)"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\$3")<\/pre>\n
.Pattern = "^( *)(Case Else)"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\")<\/pre>\n
.Pattern = "^( *)(Case )"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\")<\/pre>\n
str = Left("bla", 2)<\/pre>\nstr = Right(Left("bla",2),1)<\/pre>\n.Pattern = "(\\(| *)(Len|Left|Mid|Right|Split|UBound|LBound|InStr|InStrRev|Trim|LTrim|RTrim|MsgBox|RGB|Replace)( |\\()"\r\nstrModul = .Replace(strModul, "$1\\@$2\\\\$3")<\/pre>\n
.Pattern = "(Exit )(Sub|Function|For|Do|Property)"\r\nstrModul = .Replace(strModul, "\\@$1$2\\\\")<\/pre>\n
.Pattern = "(Debug.)(Print|Assert)"\r\nstrModul = .Replace(strModul, "\\@$1$2\\\\")<\/pre>\n
.Pattern = "^(End )(Sub|Function|Property)"\r\nstrModul = .Replace(strModul, "\\@$1$2\\\\")<\/pre>\n