Neue Dateien 01
Ich habe den Part mal übersetzt.
Ist ja zum Teil hanebüchen, was da im Original steht. Habe die sachlichen Fehler auch korrigiert.
EDIT:
Was mich etwas stutzig macht in diesem Thraed: ALLE von dir geposteten Dateien sind weit mehr als 100-mal heruntergeladen - UND NIEMAND hat etwas übersetzt?! 
Ist das denn so schlimm, dass der Close-Button zwar vorhanden ist, aber halt disabled?
Nein, ist nicht schlimm. Kann ich durchaus mit leben. - Aber irgendwie ärgert es einen, wenn man es nicht verbiegen kann. 
um neben dem Ausgrauen des Close-Buttons wie bei autoBerts Vorschlag auch noch die System-Menü-Einträge zu verstecken
Das ist leider nicht zielführend. Ich kann ja den Close-Button kpl. "verschwinden" lassen durch Überzeichnen. Aber dann sind die Min/Max-Button etwas "verloren" positioniert. Dann schon lieber disabled.
Ich hatte schon probiert, eine neue Menüleiste zu erstellen und alle Elemente außer dem Close-Button zu kopieren und dann mit anderer Position zu platzieren. Leider ist diese Menüleiste wohl tief im System verankert. Mir gelingt es bisher nicht die Informationen der einzelnen Menüelemente vollständig zu rekonstruieren.
Was bei Übersetzungen aus meiner Sicht immer problematisch ist, es ist ein schmaler Grat herauszufinden wo es sinnvoll ist deutsche Begriffe zu verwenden und wo man besser beim Original bleiben sollte. Wenn man alleine übersetzt kann man hier einfach festlegen: Dat muss so! 
Ich persönlich würde z.B. weder "capture group" noch damit zusammenhängende Ausdrücke (capturen) übersetzen. Das ist eine Begrifflichkeit, die man einmal erklären kann und dann weiß jeder Bescheid. Ist ein bischen, wie bei "Computer", da würde auch niemand auf die Idee kommen den deutschen Terminus zu benutzen (wäre übrigens: Rechenknecht 
).
Erläuternde Texte sind sinnvollerweise komplett zu übersetzen, aber bei Begriffen kann es durchaus sinnvoll sein, diese nach Erläuterung im Original weiter zu verwenden.
Ich verwende seit vielen Jahren nur noch die englische Hilfe, kann mich aber erinnern, dass ich bei der deutschen manchmal unsicher war, was gemeint war und dann auch zum Verstehen das Original angeschaut habe. Es ist einfach ziemlich schwierig etwas in einer Fremdsprache klar formuliert Vorliegendes mit derselben Klarheit in der Muttersprache auszudrücken (um so höher ist natürlich der Einsatz von Tweaky zu bewerten).
Wenn wir in AutoIt Optionsparameter verwenden, sind dies üblicherweise Werte in 2er Potenzen, die mittels BitOr in einem Wert verknüpft sind und über BitAnd selektiv geprüft werden.
Das ist in Nim ebenso möglich, aber nicht empfehlenswert, da es eine wesentlich performantere Lösung gibt: Sets.
Sets sind eine Art Liste, was den Vorteil hat, dass man auf Inhalt mit "in" prüfen kann. Es gibt Einschränkungen bei den verwendbaren Datentypen, da muss man ein Auge drauf haben (s. hier: https://nim-lang.org/docs/manual.html#types-set-type).
Bsp.
const
foo = 1.int16
bar = 2.int16
baz = 3.int16
proc SomeProc(flag: set[int16]): string =
var flags = ""
if foo in flag: flags = "foo "
if bar in flag: flags &= "bar "
if baz in flag: flags &= "baz"
result = flags
echo SomeProc({foo,baz})Allerdings finde ich es viel zu lang.
Vor allem das Pattern sollte deutlich kürzer werden, damit man auch versteht was gesucht wird.
Jetzt schön kurz und mit detaillierter Erklärung.
$sTest = _
"Func Foo()" & @CRLF & _
" Return ""Foo""" & @CRLF & _
"EndFunc" & @CRLF & @CRLF & _
"Func Bar($param1, $param2)" & @CRLF & _
" Return $param1 & $param2" & @CRLF & _
"EndFunc" & @CRLF
$sPattFunc = "(?im)^Func\s(\w+)\h*\(([^\)]*)\)"
#cs
(?im) Flags: insensitive, multiline
^Func\s Am Zeilenanfang "Func" gefolgt von einem Leerzeichen
(\w+) Eine Folge von Zeichen [a-zA-Z_0-9], in einer Gruppe aufgefangen - der Funktionsname
\h*\( Mögliche horizontale Leerzeichen gefolgt von öffnender Klammer
([^\)]*) Alle Zeichen außer schließender Klammer, 0-mal bis beliebig oft - evtl. Parameter
\) Am Ende eine schließende Klammer
#ce
$aMatch = StringRegExp($sTest, $sPattFunc, 1)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; ==> Foo
$aMatch = StringRegExp($sTest, $sPattFunc, 2)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; ==> Func Foo() Foo
$aMatch = StringRegExp($sTest, $sPattFunc, 3)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; ==> Foo Bar $param1, $param2
$aMatch = StringRegExp($sTest, $sPattFunc, 4)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; ==> [a]Func Foo() Foo [a]Func Bar($param1, $param2) Bar $param1, $param2 Kannst du ein einfacheres Bsp erstellen?
Werde ich machen. 
Ich habe mir noch mal überlegt, wie man die ganze Thematik eindeutiger und verständlicher formulieren könnte.
Also fangen wir mit einem Glossar an, vielleicht so:
• Pattern
Eine Regel mit der eine Zeichenfolge erkannt wird.
• SubPattern
Ein Pattern kann Suchfolgen enthalten, die separat in einer Gruppe aufgefangen werden.
• Match
Wird mit einem Pattern eine gültige Zeichenfolge erkannt, ist diese der Match.
Je nach Art des Patterns und Inhalt des Teststrings sind mehrere Matches möglich.
• SubMatch
Die mittels eines SubPatterns gefundene Zeichenfolge.Auf Basis dieser Bezeichnungen hier nochmal eine Erklärung der Flags
• $STR_REGEXPMATCH
Ein Pattern führt zu einem Match oder nicht. (1 oder 0)
• $STR_REGEXPARRAYMATCH
Es wird nur der erste SubMatch zu jedem Match ausgegeben. (Array)
• $STR_REGEXPARRAYFULLMATCH
Im Ergebnisarray wird an [0] der gesamte erste Match ausgegeben, an [1..n] folgen die SubMatches des ersten Matches
• $STR_REGEXPARRAYGLOBALMATCH
Im Ergebnisarray werden von allen Matches alle Submatches ausgegeben
• $STR_REGEXPARRAYGLOBALFULLMATCH
Im Ergebnisarray wird für jeden Match ein Array gespeichert. Diese Arrays enthalten: an [0] den gesamten Match, an [1..n] folgen die SubMatches dieses MatchesDann kommen wir zu der Frage, für welche Aufgabenstellung sich welches Flag eignet.
Vielleicht habt ihr hierfür ja auch noch andere Ideen.
• $STR_REGEXPMATCH
Existiert eine gesuchte Zeichenfolge, die mit dem Pattern übereinstimmt?
• $STR_REGEXPARRAYMATCH
Ich benötige für ein Pattern nur den ersten gültigen Match (bzw. von diesem den SubMatch).
Z.B. wenn sicher ist, dass im Teststring mein Suchbegriff nur einmal (oder nur einmal je Zeile) auftreten kann.
• $STR_REGEXPARRAYFULLMATCH
Ich suche nur einen Match (mit SubMatches).
Ich möchte auch den gesamten Match mit den enthaltenen SubMatches verarbeiten.
• $STR_REGEXPARRAYGLOBALMATCH
Ich brauche alle Submatches.
• $STR_REGEXPARRAYGLOBALFULLMATCH
Ich möchte sowohl alle Matches mit den enthaltenen SubMatches als auch die SubMatches einzeln.Und nachdem ich das alles geschrieben habe, kann ich auch die folgende Frage beantworten:
Und was sind z. B. globale Übereinstimmungen?
Wir unterscheiden bei den Flagnamen in ..Match und ..FullMatch.
Ein Match ist ein einzelner "Treffer", ein globaler Match sind alle "Treffer".
Das wird dann durch "Full" erweitert auf alle SubMatches in einem Match.
Insofern ist die Flagbezeichnung sauber durchdacht und benennt exakt das zu erwartende Ergebnis.
Global bedeutet hier also: Alles und nicht nur den ersten Treffer.
hier eine Frage: Im zweiten Beispiel-Code, also nach "Für die Verwendung weisen wir das dann einer Variablen zu:" wofür sind da die @CRLFs? Nur zur Optik, wenn man die Variable ausgeben will, oder haben die eine Bedeutung für das Pattern?
Das Pattern muss in einzelnen Zeilen geschrieben werden, wenn du die Kommentare in dieser Form darstellen willst (alternativ wäre alles in einer Zeile mit (?'Kommentar) - aber dann ist die Übersicht ja wieder weg). Der Zeilenumbruch signalisiert das Ende des Kommentars. Wenn in einer Zeile kein Kommentar stehen würde, könnte man es weglassen.
Hier mal noch eine Erklärung in anderen Worten:
$STR_REGEXPARRAYMATCH
Es wird nur der erste Treffer jeder Capture Group gezeigt
$STR_REGEXPARRAYFULLMATCH
An Match[0] wird der gesamte erste Treffer gezeigt, an Match[1..n] folgen die Capture Groups des ersten Treffers
$STR_REGEXPARRAYGLOBALMATCH ** Das einzig wirklich brauchbare Flag imho
Es werden von allen Treffern alle Capture Groups angezeigt
$STR_REGEXPARRAYGLOBALFULLMATCH
Array von Arrays: für jeden Match ein Array mit: [0]=gesamter Treffer, [1..n]=alle Groups des TreffersEDIT
Mir ist gerade ein sehr vernünftiger Grund für die Flags 2 und 4 eingefallen: Man bekommt die Möglichkeit auf den ganzen Match zu zugreifen OHNE diesen in einem Capture aufzufangen.
OK, ich glaube so richtig deutlich wird es erst, wenn mehrere Ergebnisgruppen vorliegen:
$sTest = _
"; ================================================================================================================" & @CRLF & _
"; Name...........: _WinGetControls" & @CRLF & _
"; Description ...: Liefert ein 2D-Array für die Controls eines Fensters." & @CRLF & _
"; Das Array enhält für jedes Control die folgenden Informationen:" & @CRLF & _
"; |[0] HWND - HWND des Controls" & @CRLF & _
"; |[1] Class - Klasse des Controls" & @CRLF & _
"; |[2] NN - ClassNN des Controls" & @CRLF & _
"; |[3] ID - ID des Controls" & @CRLF & _
"; |[4] Visible - Sichtbar? 1 = ja, 0 = nein" & @CRLF & _
"; Das Feld Array[0][0] enthält die Anzahl der Controls." & @CRLF & _
"; Syntax.........: _WinGetControls($hWnd)" & @CRLF & _
"; Parameters ....: $hWnd - HWND des Fensters (z.B. Rückgabewert von GUICreate)" & @CRLF & _
"; Return values .: Erfolg: Controlarray" & @CRLF & _
"; Fehler: False, @error = 1" & @CRLF & _
"; Author ........: Großvater (www.autoit.de)" & @CRLF & _
"; Modified.......:" & @CRLF & _
"; Remarks .......:" & @CRLF & _
"; Related .......:" & @CRLF & _
"; Link ..........:" & @CRLF & _
"; Example .......:" & @CRLF & _
"; ================================================================================================================" & @CRLF & _
"Func _WinGetControls($hWnd)" & @CRLF & _
" Local $hCB" & @CRLF & _
" If Not IsHWnd($hWnd) Then Return SetError(1, 0, False)" & @CRLF & _
" __WinGetControlsAddControl(""Init"", 0)" & @CRLF & _
" $hCB = DLLCallbackRegister(""__WinGetControlsAddControl"", ""Int"", ""HWND;LPARAM"")" & @CRLF & _
" DllCall(""User32.dll"", ""Int"", ""EnumChildWindows"", ""HWND"", $hWnd, ""Ptr"", DllCallbackGetPtr($hCB), ""LPARAM"", $hWnd)" & @CRLF & _
" If @error Then Return SetError(DllCallbackFree($hCB), 0, False)" & @CRLF & _
" DllCallbackFree($hCB)" & @CRLF & _
" Return __WinGetControlsAddControl(""Result"", 0)" & @CRLF & _
"EndFunc" & @CRLF & _
@CRLF & _
"; #INTERNAL_USE_ONLY# ============================================================================================" & @CRLF & _
"; Name...........: __WinGetControlsAddControl" & @CRLF & _
"; Description ...: Callback-Funktion für DLLCall ""EnumChildWindows"" in _WinGetControls" & @CRLF & _
"; Remarks .......: Weil ich globale Variable für die Rückgabe von Funktionswerten nicht mag und die Implementierung" & @CRLF & _
"; der statischen Arrays recht rudimentär ist, sind die maximale Anzahl von Controls auf 1024" & @CRLF & _
"; und die maximale Anzahl von Klassen auf 256 begrenzt." & @CRLF & _
"; ================================================================================================================" & @CRLF & _
"Func __WinGetControlsAddControl($hWnd, $lParam)" & @CRLF & _
" Local Static $UControls = 1024" & @CRLF & _
" Local Static $UClasses = 256" & @CRLF & _
" Local Static $aControls[$UControls + 1][6]" & @CRLF & _
" Local Static $aClasses[$UClasses + 1][2]" & @CRLF & _
" Local $aResult, $C, $Class, $ClassExist, $ID, $NN" & @CRLF & _
" Switch $hWnd" & @CRLF & _
" Case ""Init""" & @CRLF & _
" $aControls[0][0] = 0" & @CRLF & _
" $aClasses[0][0] = 0" & @CRLF & _
" Return" & @CRLF & _
" Case ""Result""" & @CRLF & _
" $C = $aControls[0][0] + 1" & @CRLF & _
" $aResult = $aControls" & @CRLF & _
" Redim $aResult[$C][6]" & @CRLF & _
" Return $aResult" & @CRLF & _
" EndSwitch" & @CRLF & _
" $aResult = DllCall(""User32.dll"", ""Int"", ""GetClassNameW"", ""HWND"", $hWnd, ""WStr"", "", ""Int"", 260)" & @CRLF & _
" If @error Or $aResult[0] = 0 Then Return True" & @CRLF & _
" $Class = $aResult[2]" & @CRLF & _
" $aResult = DllCall(""User32.dll"", ""Int"", ""GetDlgCtrlID"", ""HWND"", $hWnd)" & @CRLF & _
" If @error Or $aResult[0] = 0 Then Return True" & @CRLF & _
" $ID = $aResult[0]" & @CRLF & _
" $ClassExist = False" & @CRLF & _
" $C = $aClasses[0][0]" & @CRLF & _
" For $I = 1 To $C" & @CRLF & _
" If $aClasses[$I][0] = $Class Then" & @CRLF & _
" $NN = $aClasses[$I][1] + 1" & @CRLF & _
" $aClasses[$I][1] = $NN" & @CRLF & _
" $ClassExist = True" & @CRLF & _
" ExitLoop" & @CRLF & _
" EndIf" & @CRLF & _
" Next" & @CRLF & _
" If Not $ClassExist Then" & @CRLF & _
" $NN = 1" & @CRLF & _
" $C += 1" & @CRLF & _
" If $C > $UClasses Then Return False" & @CRLF & _
" $aClasses[0][0] = $C" & @CRLF & _
" $aClasses[$C][0] = $Class" & @CRLF & _
" $aClasses[$C][1] = $NN" & @CRLF & _
" EndIf" & @CRLF & _
" $C = $aControls[0][0] + 1" & @CRLF & _
" If $C > $UControls Then Return False" & @CRLF & _
" $aControls[0][0] = $C" & @CRLF & _
" $aControls[$C][0] = $hWnd" & @CRLF & _
" $aControls[$C][1] = $Class" & @CRLF & _
" $aControls[$C][2] = $NN" & @CRLF & _
" $aControls[$C][3] = $ID" & @CRLF & _
" $aControls[$C][4] = ControlCommand(HWnd($lParam), "", $ID, ""IsVisible"", "")" & @CRLF & _
" $aControls[$C][5] = __myCtrlGetClass($hWnd)" & @CRLF & _
" Return True" & @CRLF & _
"EndFunc" & @CRLF
$sPattFunc = "(?im)^Func\s(?#FuncName)(\w+)\h*(?#FuncParam)\(([^\)]*)\)"
$aMatch = StringRegExp($sTest, $sPattFunc, 1)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; _WinGetControls $hWnd
$aMatch = StringRegExp($sTest, $sPattFunc, 2)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; Func _WinGetControls($hWnd) _WinGetControls $hWnd
$aMatch = StringRegExp($sTest, $sPattFunc, 3)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; _WinGetControls $hWnd __WinGetControlsAddControl $hWnd, $lParam
$aMatch = StringRegExp($sTest, $sPattFunc, 4)
ConsoleWrite("$aMatch --> " & _cwArray($aMatch) & @LF) ; [a]Func _WinGetControls($hWnd) _WinGetControls $hWnd [a]Func __WinGetControlsAddControl($hWnd, $lParam) __WinGetControlsAddControl $hWnd, $lParam Nun, ich habe mir bisher keine Gedanken gemacht, warum die Flags so heißen.
Ich weiß nur, dass ich für Flag 2 und 4 bisher eigentlich nie eine Anwendung hatte. Wie die einzelnen Flags arbeiten ist sehr exakt in den Remarks erläutert. Das macht die möglichen Unklarheiten in der Flagbezeichnung locker wett. Insofern aus meiner Sicht kein Handlungsbedarf.
EDIT:
Vielleicht wird es deutlicher, wenn man einfach mal einen Test mit allen Flags ausführt:
$sTest1 = "Das ist ein Text mit den Zahlen 1 und 2 und 3 und 4 und 18."
$sTest2 = "Das ist ein Text ohne Zahlen"
$sPattern = "(\d+)"
; Flag 0 ($STR_REGEXPMATCH) - Standard
$result = StringRegExp($sTest1, $sPattern)
ConsoleWrite("$result --> " & $result & @LF) ; ==> 1 ' Match
$result = StringRegExp($sTest2, $sPattern)
ConsoleWrite("$result --> " & $result & @LF) ; ==> 0 ' kein Match
; Flag 1 ($STR_REGEXPARRAYMATCH)
$result = StringRegExp($sTest1, $sPattern, 1)
ConsoleWrite("$result --> " & _cwArray($result) & @LF) ; ==> 1
; Flag 2 ($STR_REGEXPARRAYFULLMATCH)
$result = StringRegExp($sTest1, $sPattern, 2)
ConsoleWrite("$result --> " & _cwArray($result) & @LF) ; ==> 1 1
; Flag 3 ($STR_REGEXPARRAYGLOBALMATCH)
$result = StringRegExp($sTest1, $sPattern, 3)
ConsoleWrite("$result --> " & _cwArray($result) & @LF) ; ==> 1 2 3 4 18
; Flag 4 ($STR_REGEXPARRAYGLOBALFULLMATCH)
$result = StringRegExp($sTest1, $sPattern, 4)
ConsoleWrite("$result --> " & _cwArray($result) & @LF) ; ==> [a]1 1 [a]2 2 [a]3 3 [a]4 4 [a]18 18
Func _cwArray($a)
Local $s
For $i = 0 To UBound($a) -1
If IsArray($a[$i]) Then
$s &= "[a]" & _cwArray($a[$i])
Else
$s &= $a[$i] & " "
EndIf
Next
Return $s
EndFuncReguläre Ausdrücke übersichtlich darstellen
Zur Übersichtlichkeit (und zum besseren Verständnis) sind Kommentare nicht nur im Programmcode unverzichtbar.
Bei kurzen Regulären Ausdrücken kann man darauf sicher verzichten, aber wenn es umfangreicher wird ist es zu empfehlen.
Die einfachste Form des Kommentars ist das Kommentar-Token. Syntax: (?#KOMMENTAR)
Dieser kann an jeder Stelle des Pattern eingefügt werden. Sinnvoll ist ihn vor einem zu kommentierenden Patternelement zu platzieren.
Bsp. zum Splitten eines Windows/UNC-Datei-Pfades in: Lw | Ordner[optional] | Datei-mit-Erweiterung | Dateiname | Erweiterung
^(?i)((?#drive)[a-z]:|\\\\[a-z0-9]+)\\((?#folder)[^\/:*?"<>|\r\n]*\\)?((?#file)((?#filename)[^\\\/:*?"<>|\r\n]+)\.((?#extension)\w+))$
Noch bessere Übersicht erreicht man durch eine umfangreiche Kommentierung und das möglichst neben jedem Teilausdruck.
Das ist möglich, wenn das Flag für "extended" gesetzt wird: (?x)
Bedeutung des Flags:
• Leerzeichen werden ignoriert, Pattern darf mehrzeilig dargestellt werden
• "#" dient als Kommentarzeichen, es wird mit allem Text danach in der Zeile ignoriert
• Soll "#" Bestandteil eines Pattern sein, muss es maskiert werden: "\#"
So ließe sich das folgende Pattern (Kommentarblock, geschachtelt) dann lesbarer darstellen:
(?mi)(^\h*#(?>cs|comments-start)\b(?sU:(?>(?R)|.)*)^\h*#(?>ce|comments-end)\b.*\R)
(?xmi) # Flags: extended, multiline, insensitiv
(^\h*\# # Zeilenanfang: evtl. horiz. Spaces, Hash
(?>cs|comments-start) # Atomic group Kommentar Start (kein Capture/Backtracking, längste mgl. Teilzeichenfolge in der Gruppe)
\b # Position an einer Wortgrenze
(?sU:(?>(?R)|.)*) # Flag: single line & ungreedy, Atomic group mit Wdhlg. ges. Pattern od. bel. Zeichen auch öfter
^\h*\# # Zeilenanfang: evtl. horiz. Spaces, Hash
(?>ce|comments-end) # Atomic group Kommentar Ende
\b # Ende Wortgrenze
.*\R ) # bel. Zei. bel. oft, Unicode-ZeilenumbruchFür die Verwendung weisen wir das dann einer Variablen zu:
$sPattern = _
"(?xmi) # Flags: extended, multiline, insensitiv" & @CRLF & _
"(^\h*\# # Zeilenanfang: evtl. horiz. Spaces, Hash" & @CRLF & _
"(?>cs|comments-start) # Atomic group Kommentar Start (kein Capture/Backtracking, längste mgl. Teilzeichenfolge in der Gruppe)" & @CRLF & _
"\b # Position an einer Wortgrenze" & @CRLF & _
"(?sU:(?>(?R)|.)*) # Flag: single line & ungreedy, Atomic group mit Wdhlg. ges. Pattern od. bel. Zeichen auch öfter" & @CRLF & _
"^\h*\# # Zeilenanfang: evtl. horiz. Spaces, Hash" & @CRLF & _
"(?>ce|comments-end) # Atomic group Kommentar Ende" & @CRLF & _
"\b # Ende Wortgrenze" & @CRLF & _
".*\R ) # bel. Zei. bel. oft, Unicode-Zeilenumbruch"
$sFile = FileRead("PFAD\zur\Datei.au3")
$sFile = StringRegExpReplace($sFile, $sPattern, "")Eine weitere Möglichkeit ist das Definieren von Pattern in einer benannten Capturing Group.
So kann ich z.B. einen AutoIt-String, eingefasst in einfachen/doppelten Anführungszeichen definieren und damit suchen:
(?x)(?(DEFINE) # Einleitung der Definition
(?<String> "(?> [^"]+ | \" )*" # doppelt markierter String
|
'(?> [^']+ | \' )* # einfach markierter String"
)
) # Ende Definition
(?&String) # Aufruf des Patterngeht das eventuell besser?:
Ah, fein. Das Pattern benötigt im Schnitt 26.000 Schritte je Match. Gegenüber meiner Million mal eine deutliche Verbesserung. 
Ein Nachtrag:
Es funktioniert zwar (in dem kleinen Musterbeispiel). Aber auf eine größere Datei losgelassen verweigert die Engine auf regex101.com etwa nach 100 Zeilen den Dienst (> 1.000.000 Steps!).
Catastrophic backtracking has been detected and the execution of your expression has been halted. To find out more what this is, please read the following article: Runaway Regular Expressions
OK, das ist dann tatsächlich etwas heftig. Vielleicht läßt sich das Pattern noch besser designen. Kann aber sein, dass für diese Aufgabe ein komplexes RegEx nicht das Mittel der Wahl ist. Dann doch lieber zeilenweise iterieren.
Ich habe mir dazu die folgende Lösung erstellt: https://regex101.com/r/4AxTjS/3
Aber warum wird die 2.te Zeile des ersten Kommentarblocks nicht erkannt?
Es versteht sich glaube ich von selbst, das nur gültige Funktionen geparst werden sollen. Fehlt das EndFunc, ist die Funktion ungültig.
Naja, kann man geteilter Meinung sein. Wenn ein User der Meinung ist, eine Funktion nur "zur Hälfte" schreiben zu müssen, kann er nicht erwarten, dass Zusatztools das abfangen. Jedenfalls erwarte ich im Bereich des Programmierens schon ein adäquates Verhalten. Dass man beim Endanwender von Anwendungen mit jedem Schei.. rechnen und entsprechend abfangen muss ist leider unabwendbar.
Also aus meiner Sicht ist das overdressed und da das Thema Geschwindigkeit ja wohl auch im Raum stand somit auch bremsend.
Deshalb vielleicht
Erfüllt doch die Bedingung.
Es sollen "Funktionsköpfe" gefunden werden, die gültig sind. Und diese Anforderung wird erfüllt.
Von Prüfung auf Gültigkeit der Deklaration der Funktion selbst war keine Rede.
'(?i)Func (\w+\h*\(.*\)\h*)\R\h*EndFunc.*\R'
Warum prüfst du FunktionsBody und -Footer?
Durch Einleitung der Zeile mit "Func" ist die Deklaration einer Funktion eindeutig definiert. Da du den Rest der Funktion nicht verwertest, brauchst du ihn auch nicht matchen.
Um übersichtlich mit mehreren Ausnahmen zu arbeiten (und die Lesbarkat + Verständlichkeit der Pattern auch nach Jahren zu gewährleisten) empfehle ich die Arbeit mit Pattern-Definition: https://regex101.com/r/4AxTjS/2
