VBS RegExp Replacement

[GCuser99]

A continuation of the Discussion started by @hanamichi77777 here...

Given the interest expressed in above, as well as here, I have somewhat formalized the VBS RegExp drop-in replacement wrapper that I wrote for the SeleniumVBA twinBASIC DLL. That class wrapper was intended as an experiment to test @sihlfall's pure VBA vba-regex, which works in my usage cases. Thus far, @sihlfall has been responsive to issue reports and enhancement requests, so it seems like this might be a feasible path for replacing VBS's RegExp if that library is retired by MS in the future.

My RegExp class attempts to maintains backwards compatibility with VBScript's version, as well as extends the functionality to leverage some of StaticRegex's enhanced features, such as named capture groups, and the Split Method.

I'll continue to test/use my RegExp replacement class with @sihlfall's StaticRegex.bas standalone module in the twinBASIC DLL and in other code bases that I maintain. If anyone else (@hanamichi77777?) wishes to use the same in VBA, then I will maintain an updated version in, for lack of a better place, my vba-regex fork here:

https://github.com/GCuser99/vba-regex/tree/master/vbs_regexp/VBA
https://github.com/GCuser99/vba-regex/tree/master/vbs_regexp/twinBASIC

Please obtain the latest all-in-one version of @sihlfall's StaticRegex.bas by running the PowerShell script found here:

https://github.com/sihlfall/vba-regex/blob/master/aio/make_aio.ps1

In order for that to work with the RegExp class, rename the module from "StaticRegexSingle" to "StaticRegex". Hopefully in the future, @sihlfall will make it easier to obtain a copy of the latest all-in-one module.

Cheers,

Mike

[6DiegoDiego9]

Hi guys,

I just AI-coded a zero-dependencies .NET's regular expression engine wrapper for VBA.
Please give it a look: https://github.com/6DiegoDiego9/VBA-dotNET-regex

I compared its speed versus VBScript.RegExp with interesting results:

--- Test 17: Performance Comparison ---
Pattern: '\b([a-z0-9]+)\s*=\s*([0-9.]+)\b'
Iterations: 1
Text length: 1599999
VBScript.RegExp (80000 matches) x 1 iterations: 0.0646 seconds.
CLRRegex (Compiled) (80000 matches) x 1 iterations: 0.2893 seconds.
vb2net (Compiled) (80000 matches) x 1 iterations: 0.0133 seconds.
StaticRegexSingle (0 matches) x 1 iterations: 7.1725 seconds.

--- Performance Summary for 1 iterations ---
VBScript.RegExp time: 0.0646 s
CLRRegex (Compiled) time: 0.2893 s
vb2net (Compiled) time: 0.0133 s
StaticRegexSingle time: 7.1725 s
Fastest engine: vb2net (Compiled) at 0.0133 s

Relative Speeds (lower is better, 1.00x is fastest):
VBScript.RegExp: 4.86x
CLRRegex: 21.73x
vb2net: 1.00x
StaticRegexSingle: 538.73x

---

--- Test 17: Performance Comparison ---
Pattern: '\b([a-z0-9]+)\s*=\s*([0-9.]+)\b'
Iterations: 100
Text length: 15999
VBScript.RegExp (800 matches) x 100 iterations: 0.0656 seconds.
CLRRegex (Compiled) (800 matches) x 100 iterations: 0.3026 seconds.
vb2net (Compiled) (800 matches) x 100 iterations: 0.9479 seconds.
StaticRegexSingle (0 matches) x 100 iterations: 7.2323 seconds.

--- Performance Summary for 100 iterations ---
VBScript.RegExp time: 0.0656 s
CLRRegex (Compiled) time: 0.3026 s
vb2net (Compiled) time: 0.9479 s
StaticRegexSingle time: 7.2323 s
Fastest engine: VBScript.RegExp at 0.0656 s

Relative Speeds (lower is better, 1.00x is fastest):
VBScript.RegExp: 1.00x
CLRRegex: 4.61x
vb2net: 14.44x
StaticRegexSingle: 110.20x

---

Notes:

• CLRRegex is my release on GitHub, using CLR (.NET Framework) with zero-dependencies
• vb2net is my experiment using .NET (formerly .NET Core), which needs a dll helper file
• StaticRegexSingle fails this test likely because of some bugs in interpreting the pattern. For example, because its incomplete function UnicodeReIsWordchar only considers letters (a-z, A-Z) as "word characters.", incorrectly excluding numbers (0-9) and underscores (_).

[GCuser99]

Woah - I'll check it out @6DiegoDiego9!!

[sihlfall]

@6DiegoDiego9 Thanks for testing. Indeed, your test runs into the dummy implementation of \b in vbaRegex. Due to its "pure VBA" requirement, vbaRegex has to use AscW(Mid(...,1)) over and over to extract single characters from the 1.5 million characters string, which I suspect is one of the reasons for its performing much worse than non-VBA engines. For the concrete case, optimizing the quantifier handling of vbaRegex may help. I'll try that when I find time.

[6DiegoDiego9]

I fixed the issue causing 0 matches with StaticRegexSingle, with a little change in my CLRRegexTest module and this fixed UnicodeReIsWordchar function in StaticRegexSingle:

Private Function UnicodeReIsWordchar(c As Long) As Boolean
    ' E5 Section 15.10.2.6.
    ' WordCharacter is [a-zA-Z0-9_]
    Select Case c
        Case &H61& To &H7A&, &H41& To &H5A&, &H30& To &H39&, &H5F&
            UnicodeReIsWordchar = True
        Case Else
            UnicodeReIsWordchar = False
    End Select
End Function

Here are the updated benchmarks in 3 different iteration numbers and text lengths:

---

--- Test 17: Performance Comparison ---
Pattern: '\b([a-z0-9]+)\s*=\s*([0-9.]+)\b'
Iterations: 1
Text length: 1599999
VBScript.RegExp (80000 matches) x 1 iterations: 0.1861 seconds.
CLRRegex (Compiled) (80000 matches) x 1 iterations: 0.4131 seconds.
vb2net (Compiled) (80000 matches) x 1 iterations: 0.0145 seconds.
StaticRegexSingle (80000 matches) x 1 iterations: 8.7662 seconds.

--- Performance Summary for 1 iterations ---
Fastest engine: vb2net (Compiled) at 0.0145 s
Relative Speeds (lower is better, 1.00x is fastest):
VBScript.RegExp: 12.86x
CLRRegex: 28.54x
vb2net: 1.00x
StaticRegexSingle: 605.73x

---

--- Test 17: Performance Comparison ---
Pattern: '\b([a-z0-9]+)\s*=\s*([0-9.]+)\b'
Iterations: 100
Text length: 15999
VBScript.RegExp (800 matches) x 100 iterations: 0.1365 seconds.
CLRRegex (Compiled) (800 matches) x 100 iterations: 0.3879 seconds.
vb2net (Compiled) (800 matches) x 100 iterations: 1.2999 seconds.
StaticRegexSingle (800 matches) x 100 iterations: 10.3198 seconds.

--- Performance Summary for 100 iterations ---
Fastest engine: VBScript.RegExp at 0.1365 s
Relative Speeds (lower is better, 1.00x is fastest):
VBScript.RegExp: 1.00x
CLRRegex: 2.84x
vb2net: 9.52x
StaticRegexSingle: 75.62x

---

--- Test 17: Performance Comparison ---
Pattern: '\b([a-z0-9]+)\s*=\s*([0-9.]+)\b'
Iterations: 10000
Text length: 159
VBScript.RegExp (8 matches) x 10000 iterations: 0.1132 seconds.
CLRRegex (Compiled) (8 matches) x 10000 iterations: 1.5496 seconds.
vb2net (Compiled) (8 matches) x 10000 iterations: 328.9262 seconds.
StaticRegexSingle (8 matches) x 10000 iterations: 15.4716 seconds.

--- Performance Summary for 10000 iterations ---
Fastest engine: VBScript.RegExp at 0.1132 s
Relative Speeds (lower is better, 1.00x is fastest):
VBScript.RegExp: 1.00x
CLRRegex: 13.69x
vb2net: 2906.24x
StaticRegexSingle: 136.70x

[sihlfall]

Did you compile your project before running it?

[6DiegoDiego9]

I run it with F5 in the VBE in Excel