RegexBuddy Version History

Software Quality at Just Great Software

Don’t let the long lists of issues on this page make you think our products have a lot of problems. Quite to the contrary. All the bugs listed below are bugs that we have fixed. Many of these are corner cases reported by only one or perhaps a handful of our customers. Other software companies often don’t spend any effort addressing such issues, much less list them publicly. We take pride in producing high quality software, and often release free updates to ensure you won’t have any problems with our software.

Your purchase also comes with one year of free major upgrades. So don’t worry if there might be a new major upgrade around the corner just because it’s been a while since the last major upgrade. If there is one around the corner, you’ll get it free, without having to ask. (But you can keep the old version if you prefer.)

If you ever hit a snag with RegexBuddy, check here whether you have the latest version. If you do, simply report the issue on the forum and we’ll help you out as soon as we can.

RegexBuddy 4.14.1 – 16 October 2023

Improvements:

Applications: .NET 7.
Applications: Boost 1.83.
Applications: Java 21.
Applications: Python 3.12.
Applications: Ruby 3.2.
Aspects: Java allows \X inside lookbehind but a \X inside lookbehind always fails to match (possibly causing negative lookbehind to succeed).
Aspects: Only the JGsoft flavor supports \X inside lookbehind.
Aspects: Subroutine calls to capturing groups defined inside lookbehind may be a syntax error (JGsoft V2).
Forum: Conversation and message lists now use the plain text color configured on the Use Colors page in the Preferences for consistency with the editor control for the body text of forum messages.
Preferences|Operation: Turning off the option to preserve the test data now makes RegexBuddy delete any previously saved test data.

Bug fixes:

Debug: Make behavior of \G consistent between the debugger and the Test panel when using “debug everywhere”.
Right-clicking certain files that have a context menu handler in a common file dialog box (used by the various Open and Save As buttons) could crash RegexBuddy; this did not affect any of RegexBuddy’s own file types.
Test: a(.+?)?b was incorrectly optimized into a.*?b causing it to find two separate matches of ab in abab instead of matching abab entirely.
Test: Conditionals inside lookbehind are now handled correctly.

RegexBuddy 4.14.0 – 2 December 2022

New features:

Applications: Java 19.
Applications: Python 3.11.
Applications: R 4.2.1.

Improvements:

Applications: .NET 7.0.
Applications: AceText 4.
Applications: Boost 1.80.
Applications: PCRE2 10.39.
Applications: PHP 8.1.12.
Applications: Visual C++ 2022.

Bug fixes:

Copy to/Paste from JavaScript operator now generates/recognizes the /s flag for the “dot matches line breaks” option.
Copy/Use: JavaScript or R replacement string literal should be “\\n” for the replacement string \n when using the “regex syntax only” option.
Help file was missing the flavor names in the table headers in the regular expressions reference pages (4.13.0 only).
Paste: JavaScript or R string literal should recognize “\\n” as an escaped backslash and a literal n and recognize “\n” as a line break that is only supported when using string syntax.
Regex: Character class range with an escape representing the NULL character such as [\0-\x1F] triggered an error.
Regex: Multiple dollar signs in the middle of the regex as in a$b$c caused RegexBuddy to crash when using a regex flavor such as GNU BRE that treats the $ as a literal instead of as an anchor when the $ is not a the end of the regex or a group.
Use: Boost and std::regex source code templates had the variable name “subject” hard-coded in one line of code in the functions for iterating over all matches.
WINE: 64-bit version failed to start on WINE 7.0 (since 4.8.0).

RegexBuddy 4.13.0 – 25 October 2021

New features:

Applications: C++Builder 11 Alexandria.
Applications: Java 17.
Applications: JavaScript supports named capture (added in ECMAScript 2018).
Aspects: $<name> in the replacement may be a literal or may be silently removed if there is no group by that name depending on whether the regex has named capturing groups at all (ECMAScript 2018).
Aspects: $<name> may insert the match of a named capturing group into the replacement (ECMAScript 2018).
Aspects: \k<name> may match “k<name>” instead of being an error when the regex does not have any named capturing groups at all (ECMAScript 2018).
Aspects: Empty negative lookahead may be an error instead of always failing to match (Boost).
Aspects: Empty positive lookahead may be an error instead of always matching (Boost).
Use: JavaScript function to get the match of a named capturing group.

Improvements:

Applications: Boost 1.77.
Applications: Delphi 11 Alexandria.
Applications: PCRE 8.45.
Applications: PCRE2 10.38.
Applications: PHP 8.0.11.
Applications: Python 3.10.
Applications: R 4.1.1.

Bug fix:

API: DebugAtPos and DebugAfterPos now respect the CharPos parameter.

RegexBuddy 4.12.0 – 20 May 2021

New features:

Applications: .NET 5.0 (no changes since 2.0).
Applications: Java 15 and 16.
Applications: PCRE2 10.36.
Applications: Perl 5.32.
Applications: PHP 8.
Applications: XRegExp 5.
Aspects: (?(<-1>)yes|no) and (?('-1')yes|no) may be conditionals using a relative backreference (Ruby 2.4–3.0).
Aspects: (?(<1>)yes|no) and (?('1')yes|no) may be conditionals using a numbered backreference (Ruby 2.4–3.0).
Aspects: (?(0)yes|no) may be the same as (?:yes|no) ignoring the invalid conditional reference (Python 2.4–3.4).
Aspects: \R may match only the CR in a CRLF pair if that allows it to meet the minimum number of iterations required by its quantifier (Java 15).
Aspects: A quantifier as the first token inside a mode modifier group may nullify the options instead of being an error (Boost).
Aspects: A quantifier on a group that contains nothing but a lookbehind may exclude the group from the matching process entirely if the quantifier makes the group optional (JavaScript).
Aspects: A quantifier using curly braces at the start of the regex, an alternative, or a group may be a literal instead of being an error (Perl).
Aspects: Capturing groups may be an error inside negative lookbehind (Ruby).
Aspects: Conditionals may allow more than two alternatives, matching any of the second or following alternatives if the condition test failed.
Aspects: End-of-string anchors may not be supported inside lookbehind (Ruby).
Aspects: Using * as a nested quantifier may show a warning even though the flavor supports nested quantifiers (Ruby 2.4–3.0).
Aspects: Word boundaries may not be supported inside lookbehind (Ruby 1.9).

Improvements:

Applications: Boost 1.76 (no changes since 1.66).
Applications: JavaScript (Chrome), JavaScript (Firefox) and JavaScript (Edge) now all use the same regex flavor due to improved compatibility between the latest versions of these browsers.
Applications: PowerShell reference topic in the help file now explains both Windows PowerShell and PowerShell Core are supported.
Applications: Python 3.9 (no changes since 3.7).
Applications: R 4.0.5 (no changes since 4.0.0).
Applications: Ruby 3.0 (no changes since 2.4).
Create: Capturing groups that take on the name of a named capturing group in another alternative in a branch reset group now indicate the name of that group in addition to the number of the backreference.
Create: Explain that quantifiers on lookaround serve no purpose other than to eliminate the lookaround if the quantifier makes it optional (and the lookaround doesn’t contain a capturing group).
Create: Quantifiers used after a token that cannot be repeated now have more specific error messages.
Test: Match details now include all the names of capturing groups that have multiple names from different alternatives in a branch reset group.
Test: Match details now indicate the name of the group only for the group that can actually be retrieved by its name if the flavor allows multiple capturing groups to have the same name without actually treating them as a single group; other groups with that name are indicated by their numbers.

Bug fixes:

Create: Second and following alternation operators inside a conditional are now indicated as errors in the regex tree.
Debug: Debug Till End does not correctly continue after a zero-length match if the flavor allows a non-zero-length match at the same position as a previous zero-length match.
Library: Double-clicking within a library item’s regex triggered an “invalid class typecast” error.
Library: Parameters grid did not scale correctly on high DPI systems.
Regex: Subroutine call with characters that are invalid in capturing group names such as (?&a!) or (?<) triggered access violation errors if there was no capturing group with that (invalid) name.
Test: End-of-string anchors inside lookbehind matched at the start of the string instead of at the end of the string.
Test: Highlight button no longer has duplicate entries for capturing groups with the same name when the regex flavor allows multiple groups to share the same name without actually treating them as a single group.
Test: Negative lookbehind that had a quantifier making it optional was not treated as optional if the flavor allows quantifiers on lookaround.
Test: Non-capturing groups that had a quantifier making them optional and that contained nothing but a negative lookbehind were not treated as optional.
Test: Selecting a test method and turning on Update Automatically and then editing the regex made the test results empty instead of showing an error message if the edited regex contained a syntax error.

RegexBuddy 4.11.0 – 27 May 2020

New features:

Applications: Boost 1.73.
Applications: Delphi 10.4 and C++Builder 10.4.
Applications: Java 14.
Applications: PCRE 8.44.
Applications: PCRE2 10.34.
Applications: PHP 7.4.6.
Applications: PowerShell -split operator.
Applications: R 4.0.0.
Applications: Ruby 2.7.

Improvement:

Aspects: Empty atomic groups may be a syntax error (Boost).

Bug fixes:

Regex: A lookahead containing a capturing group containing alternatives with different lengths was flagged as an lookbehind error for regex flavors that do not allow alternatives of different lengths within a group within lookbehind.
Regex: A subroutine call to a capturing group that contains an subroutine call to a non-existent group caused regex syntax coloring to disappear and triggered an error if you tried to search with it.
Regex: Empty atomic groups with a quantifier triggered an access violation error.
Regex: Lookbehind at the very start of the regex containing a forward reference to a capturing group was not handled correctly; the forward reference should never be able to match anything.
Replacement strings consisting of two or more valid named backreferences followed by a token that represents the entire regex match caused RegexBuddy to hang.
Test: Capturing group may capture the wrong part of the match if it has a lazy quantifier.
Use: PCRE2 function for iterating over all capturing groups needs to retrieve the number of capturing groups using PCRE2_INFO_CAPTURECOUNT instead of PCRE2_INFO_BACKREFMAX.

RegexBuddy 4.10.0 – 22 November 2019

New features:

Applications: Boost 1.71.
Applications: Delphi 10.3 and C++Builder 10.3.
Applications: EditPad 8.
Applications: Java 13.
Applications: PCRE 8.43.
Applications: PCRE2 10.33.
Applications: Perl 5.30.
Applications: PHP 7.3.11.
Applications: Python 3.8.
Applications: R 3.6.1.
Applications: Ruby 2.6.
Applications: Visual C++ 2019.

Improvements:

Aspects: ${0} may not represent the whole regex match in replacement strings even when ${1} represents a backreference.
Forum: Attachments can now be renamed while the message they are attached to has not been sent yet.

Bug fixes:

Help window no longer becomes unresponsive if RegexBuddy shows a modal dialog box while the help window is already visible.
Regex: Character class ranges starting with control character escape are now handled correctly.
Regex: Conditional using lookaround can't have a quantifier on the lookaround even if the flavor allows quantifiers on other lookarounds.
Regex: Unicode whitespace after a quantifier triggered access violations in free-spacing mode if the flavor does not treat Unicode whitespace as free whitespace (since 4.8.0).
Test: Boost case conversion was not applied to $0 and ${0}.

RegexBuddy 4.9.0 – 12 September 2018

New features:

Applications: Boost 1.66–1.68.
Applications: Chrome now supports the /s flag to make the dot match line breaks.
Applications: Chrome now supports unrestricted lookbehind.
Applications: Java 9 and 10.
Applications: PCRE2 10.30 and 10.31.
Applications: Perl 5.28.
Applications: PHP 7.2.x.
Applications: Python 3.7.
Applications: R 3.5.0–3.5.1.
Applications: XRegExp 4.
Aspects: (?xx) turns on free-spacing mode with free-spacing character classes.
Aspects: \R may match only the CR in a CRLF pair if the \R does not have a quantifier and is followed by a token that needs to match the LF (bug in Java 9 and 10).
Aspects: \R with a greedy quantifier may backtrack into the middle of a CRLF pair (bug in Perl and older versions of PCRE).
Use: Source code templates can now support languages with separate modes for turning on free-spacing with exactly spaced character classes and free-spacing with freely spaced character classes.

Improvements:

Debug: Folding icons now scale on high DPI systems.
Options: Case sensitivity option for PostgreSQL that makes the Use panel use the ~* operator.
Options: String syntax option now also applies to PHP regular expressions; this allows RegexBuddy to emulate \u{FFFF} which PHP 7 supports as part of string literals but not as part of the regex syntax.

RegexBuddy 4.8.3 – 18 May 2018

Improvements:

Applications: .NET version number updated to 4.7.2 (no changes since .NET 2.0).
Applications: PCRE 8.42 (no changes since 8.40).
Applications: PHP version numbers updated through 7.1.17 (no changes to regex flavors).
Applications: R 3.4.4 (no changes since 3.1.3).
Windows 10: Installer now deals with Controlled Folder Access more efficiently when Windows Defender is operational and ignores it when Windows Defender is not operational, ensuring a smoother installation on Windows 10 1709 (Fall Creators Update) and 1803 (April 2018 Update).

Bug fix:

Flavors: XML Schema and XPath do not match _ with \w.

RegexBuddy 4.8.2 – 19 February 2018

Improvements:

Applications: .NET version number updated to 4.7.1 (no changes since .NET 2.0).
Applications: PCRE 8.41 (no changes compared with 8.40).
Applications: PHP version numbers updated through 7.1.14 (no changes to regex flavors).
Applications: R 3.4.3 (no changes since 3.1.3).
Applications: Ruby 2.5 (no changes compared with 2.4).
Windows 10: Installer adds RegexBuddy as an allowed application to Controlled Folder Access in Windows Defender in the Fall Creators Update.
Windows 10: Installer no longer complains that it can’t create the desktop shortcut if that was blocked by Controlled Folder Access.

Bug fixes:

Create: Balancing groups capture the text between the end of the capture that was subtracted and the start of the match of the balancing group rather than the match of the balancing group itself.
Create: Insert Token|Backreference was disabled for flavors that do not support conditionals even if they do support backreferences.
GREP: Grepping failed to start, showing an access violation error, if the regular expressions used a named backreference or a balancing group.
Minimizing RegexBuddy did not hide the floating window after restarting RegexBuddy when it was using a dual monitor layout.

RegexBuddy 4.8.1 – 22 September 2017

Improvements:

Applications: Boost 1.65 (same as 1.64).
Applications: PHP version numbers updated through 7.1.9 (no changes to regex flavors).
Applications: R 3.4.1 (no changes since 3.1.3).

Bug fixes:

Error saying “GetTextExtentPoint32W failed twice” prevented RegexBuddy from running.
Keyboard: AltGr+H, AltGr+N, AltGr+O, and AltGr+S were incorrectly handled as Ctrl+H, Ctrl+N, Ctrl+O, and Ctrl+S, making it impossible to type certain special characters on keyboard layouts that use these AltGr combinations.
Regex: Subroutine calls to empty capturing groups triggered an access violation.

RegexBuddy 4.8.0 – 19 June 2017

New features:

Applications: Boost 1.64.
Applications: Delphi and C++Builder 10.2 Tokyo.
Applications: PCRE2 10.23.
Applications: PCRE 8.40.
Applications: Perl 5.24 and 5.26.
Applications: Python 3.6.
Applications: Ruby 2.4.
Applications: std::regex in Visual C++ 2017.
Aspects: (?(DEFINE)…) may be a conditional rather than a subroutine definition group if there is a capturing group named DEFINE.
Aspects: A subroutine call to a group that is inside another group that has a quantifier making it optional may cause the regex engine to crash (PCRE 4.4 and prior).
Aspects: Circular subroutine calls may be a syntax error if they can lead to infinite recursion (e.g. (a|\g<2>)(z|\g<1>) in Ruby).
Aspects: Conditional (?(R0)…) may check for recursion of the whole regex only (Perl) or it may check for recursion of the regex or any capturing group (PCRE).
Aspects: Conditionals to a named group may be misinterpreted if there is another group with a longer name too (PCRE 8.34 & 8.35).
Aspects: Free whitespace between the [ and ^ at the start of a character class may or may not allow the ^ to negate the character class.
Aspects: Free-spacing character classes may or may not treat line breaks as free whitespace.
Aspects: Free-spacing comments started with a # may or may not end at line breaks other than the line feed character.
Aspects: Free-spacing mode may or many not treat Unicode spaces as free whitespace.
Aspects: Free-spacing mode may or may not treat the vertical tab, next line, line separator, and paragraph separator characters as free white space.
Aspects: Infinite recursion that is not a syntax error may simply fail to match rather than being a matching error.
Aspects: Recursion at the start of the first alternative may be treated as an error (potential infinite recursion) even though recursion at the start of the second or later alternatives is allowed; in Helpful mode this is now a syntax error if the flavor treats it as a syntax error or if the flavor treats infinite recursion as a matching error; in Strict mode it is an error if the flavor treats it as a syntax error.
Aspects: Recursion conditionals may be misinterpreted if there is a named capturing group that has a name starting with R (PCRE 8.39 and prior and PCRE2 10.22 and prior).
Aspects: Recursion may only match the first alternative in the regex instead of the whole regex.
Aspects: Recursion without a non-recursive alternative may be a syntax error rather than simply failing to match; in Helpful mode this is now an error for all flavors; in Strict mode it is an error if the flavor treats it as a syntax error.
Aspects: Turning off options may be supported in group modifiers even when it’s not supported in global modifiers (Python 3.6).
Aspects: Turning off the free-spacing option after leading free space or leading free comments may cause regex compilation to fail (PCRE 8.38 and prior and PCRE2 10.20 and prior).
Aspects: Turning off the free-spacing option in the middle of the regex may cause regex compilation to fail (PCRE 6.7 and prior).
Aspects: Turning the same option on and off in the same modifier may be an error (Python 3.6).
Help|News & Updates: New version announcements and other news about RegexBuddy and optionally other Just Great Software products can now be shown automatically or upon request.
Options: Separate “free-spacing” and “free-spacing […]” options that both use free-spacing outside character classes but respectively use exact spacing and free-spacing inside character classes.

Improvements:

Applications: .NET version number updated to 4.7 and .NET Core added (no changes since .NET 2.0).
Applications: PHP version numbers updated through 7.1.6 (no changes to regex flavors).
Applications: R 3.4.0 (no changes since 3.1.3).
Applications: Visual Studio IDE version number updated to 2017 (no changes since 2012).
Aspects: Infinite recursion may cause an application to crash; in Helpful mode this is now a syntax error; in Strict mode this aborts the match attempt with an error like before.
Convert: Converting a regex using recursion to a flavor that supports subroutine calls but not recursion of the whole regex now adds a capturing group around the whole regex so that the recursion can be converted into a call to that group.
Convert: Mode modifer spans are no longer converted into needless (non-capturing) groups if the target flavor does not support mode modifier spans.
Ctrl+Shift no longer switches text direction in editor controls if you don’t have a keyboard layout for a right-to-left language installed.
GREP: PowerGREP button can now launch PowerGREP 5 when it is installed only for the current user.
Library: Preserve line break handling option when storing test subjects.
Proxy password is now encrypted when stored in the .ini file.

Bug fixes:

Convert: If free-spacing was on for both the original regex and the converted regex and the regex contained (?-x) then spaces after the (?-x) were needlessly escaped in the converted regex.
Insert Token|Unicode Characters: Row headers for rows U+001X through U+0FFX were incorrectly indicated as 010 through FF0 instead of 001 through 0FF.
Library: Alt+A keyboard shortcut did not always work correctly.
Test: CRLF line break indicators did not highlight matches of \r and highlighted the entire CRLF for matches of \n instead of highlighting only the CR for \r and only the LF for \n.
XPath regexes support non-capturing groups even though XML Schema regexes do not.

RegexBuddy 4.7.0 – 8 December 2016

New features:

Applications: boost::regex 1.38–1.39 & 1.42–1.62.
Aspects: $^N and $LAST_SUBMATCH_RESULT and ${^LAST_SUBMATCH_RESULT} may be replacement string backreferences to the highest numbered group that actually participated in the match.
Aspects: $LAST_PAREN_MATCH and ${^LAST_PAREN_MATCH} may be replacement string backreferences to the highest numbered group in the regex.
Aspects: $MATCH and ${^MATCH} may be replacement string tokens that insert the whole regex match.
Aspects: $POSTMATCH and ${^POSTMATCH} may be replacement string tokens that insert the part of the subject string to the right of the regex match.
Aspects: $PREMATCH and ${^PREMATCH} may be replacement string tokens that insert the part of the subject string to the left of the regex match.
Aspects: ?1yes:no, ?{1}yes:no and/or ?{name}yes:no may be replacement string conditionals.
Aspects: [:^alpha:] may be a negated POSIX class.
Aspects: [:h:] and [:v:] may be POSIX classes for horizontal and vertical whitespace.
Aspects: [:unicode:] and \p{Unicode} may match only characters represented by values >= 0x100 or >= 0x101 in the active encoding (code points >= U+0100 or >= U+0101 when using Unicode).
Aspects: \c in replacement strings may allow characters other than ASCII letters, taking either the last 5 bits to indicate the control character or flipping bit 0x40.
Aspects: \cA through \cZ and \ca through \cz may be control character escapes in replacement strings.
Aspects: \E may be a literal E when not preceded by \Q, \L, or \U.
Aspects: \g<1>, \g<-1>, \g<name>, \g’1’, \g’-1’, and \g’name’ may be backreferences rather than subroutine calls.
Aspects: \h and \v may or may not match horizontal or vertical whitespace characters outside the active code page.
Aspects: \p{…} may not be supported inside characters even though it is supported outside character classes.
Aspects: \pd, \pl, \ps, \pu, and \pw may represent the POSIX classes “digit”, “lower”, “space”, “upper”, and “word”.
Aspects: \Q…\\ may be an error at the end of the regex.
Aspects: \Q…\E may not be supported inside characters even though it is supported outside character classes.
Aspects: \R may or may not treat U+0085 (next line), U+2028 (line separator), and/or U+2029 (paragraph separator) as line break characters.
Aspects: \v may represent just the vertical tab inside character classes even when \v is a shorthand matching all vertical whitespace outside character classes.
Aspects: \x{FFFF} may only use the least significant byte of the hexadecimal number to match an 8-bit character.
Aspects: \Z may match before any number of trailing line breaks at the end of the string.
Aspects: Backreferences to a name shared by multiple named capturing groups may point to the rightmost group with that name that is to the left of the backreference.
Aspects: Boost has its own ideas about which characters are combining characters and which are not.
Aspects: Boost-style replacement string case conversion.
Aspects: Character class ranges that are not subsets of A-Z, a-z, or 0-9 may be an error or may not work correctly.
Aspects: Conditionals that check for recursion of non-existing named capturing groups may always match the “else” part rather than being an error.
Aspects: Lookbehind containing alternatives of different lengths may not be handled correctly.
Aspects: Mode modifier P may be ignored when it is the first mode modifier in the group even though P is not a valid mode modifier.
Aspects: Mode modifiers that turn off options in the middle of the regex may cause incorrect matches.
Aspects: Multiple negated shorthands in a character class may have the negated union of the regular shorthands added to the class instead of the union of the negated shorthands.
Aspects: Named capturing groups may or may not get numbers in explicit capture mode (which makes all unnamed groups non-capturing).
Aspects: Named capturing groups may or may not have a negative number as their name.
Aspects: Named capturing groups may or may not have names that start with a non-word character.
Aspects: Named capturing groups that have a number as their name may or may not support named backreferences using that number as the name.
Aspects: Named capturing groups that have a number as their name may support numbered backreferences using that number instead of having a separate numbered counted from left to right.
Aspects: Negated shorthands may add the regular shorthand’s characters to the character class and then negate the entire character class instead of adding the negated shorthand’s characters to the character class.
Aspects: Non-word-boundaries may or may not match at the start or end of the string when the first or last character in the string is not a word character.
Aspects: Quantifiers on mode modifiers may cause incorrect matches rather than being an error.
Aspects: Recursive calls with quantifiers other than * and {0,} may produce incorrect matches.
Aspects: Regex recursion may be atomic while subroutine calls are not atomic.
Aspects: Shorthands may be supported inside character classes even though the backslash is otherwise a literal inside character classes.
Aspects: Shorthands may be supported inside character classes even though they are not supported outside character classes.
Aspects: When negated shorthands negate the entire character class, two negated shorthands in the same character class may or may not cancel out the negation.
Aspects: Word boundaries \< and \> may recognize non-ASCII word characters in the active code page even when they do not support Unicode.
Create: Insert Token|Conditional.

Improvements:

Applications: PHP version numbers updated through 7.0.13 (no changes to regex flavors).
Applications: R 3.3.2 (no changes compared with 3.3.1).
Paste: Pasting a replacement from a Java or Groovy string now turns on the “string syntax” option if the pasted string contains character escapes.
Toolbar icons are now doubled up in size on systems using 200% or more display scaling making the small icons suitable for 200% display scaling and the large ones for 300% scaling.
Use: Java 7 and later source code template that includes functions for retrieving the matches of named capturing groups.
Windows 10: Mouse wheel scrolls the control pointed to by the mouse pointer instead of the control that has keyboard focus.

Bug fixes:

GREP: No error messages were added to the results for files that could not be overwritten during a search-and-replace that does not create backup copies (versions 4.0.0 through 4.6.1).
GREP: Undo and Delete Backup Files commands did not do anything other than falsely claiming that they did what they were supposed to do (versions 4.5.0 through 4.6.1 only).
Test: Capturing groups repeated between 0 and 1 times and containing nothing but an anchor were not matched correctly.
Test: Hexadecimal item in the context menu is now checked after restarting RegexBuddy when it has remembered a test subject in hexadecimal mode, allowing hexadecimal mode to be turned off by selecting that item once instead of having to select it twice.
Test: Regexes with non-capturing groups that contained only free whitespace and had a quantifier triggered an access violation.

RegexBuddy 4.6.1 – 19 September 2016

Improvements:

GREP: PowerGREP button now launches PowerGREP 5 if available.
Test: Opening HTTP URLs that redirect to HTTPS now works if the OpenSSL library is available.
Test: Opening HTTPS URLs on servers using SNI now works if the OpenSSL library is available.

Bug fixes:

GREP: Opening all matched files in EditPad attempted to open the matched files as folders when the cursor did not point to a file on the GREP panel (4.6.0 only).
View: Turning on the Office 2003 style and closing RegexBuddy caused the tick mark next to the Office 2003 menu item to be reversed next time you ran RegexBuddy.

RegexBuddy 4.6.0 – 22 August 2016

New features:

Applications: Delphi and C++Builder 10.1 Berlin (no changes compared with 10 Seattle).
Applications: PCRE 10.21–10.22.
Applications: PCRE 8.39 (no changes compared with 8.37).
Applications: PHP versions through 7.0.9.
Applications: PowerGREP 5.
Applications: R 3.3.1 (no changes compared with 3.2.2).
Applications: Ruby 2.3 (no changes compared with 2.2).
Aspects: ${1:+yes:no} and ${name:+yes:no} may be replacement string conditionals.
Aspects: ${1:-no} and ${name:-no} may be replacement string conditionals with an implicit backreference as the “yes” part.
Aspects: (?1yes:no), (?{1}yes:no) and/or (?{name}yes:no) may be replacement string conditionals.
Aspects: [:l:] and [:u:] may be shorthands for [:lower:] and [:upper:].
Aspects: \l and \u may be shorthands for [:lower:] and [:upper:].
Aspects: A capturing group with a quantifier that makes it optional may capture the fact that it didn’t participate in the match rather than not capturing anything at all so that when the capturing group is inside another group that is repeated, a match captured during the parent’s previous repetition may either be forgotten or retained when the capturing group does not participate during the parent’s next repetition.
Aspects: Escaping letters and digits with backslashes may be an error in replacement strings even when escaping other characters with backslashes is allowed.
Aspects: Octal escapes between \0400 and \0777 may ignore the most significant bit, reducing the escape from 9 bits to 8 bits.
Aspects: PCRE2-style replacement string case conversion.
Aspects: POSIX classes “upper” and “lower” may or may not include title case letters, modifier letters, other letters, and/or letter numbers.
Aspects: Replacement string case conversion may be ASCII-only.
GREP: Clipboard contents can be grepped directly by setting the folder to clipboard: and leaving the file mask blank or setting the file mask to something that matches clipboard.txt.
Insert Token: Shorthands for lowercase and uppercase letters.
Options: PCRE2 10.21 has a new “extended” replacement string flavor.
Options: std::regex supports a “sed” replacement string flavor in addition to the default “ECMAScript” flavor.

Improvements:

Aspects: Unescaped dollar signs are now treated as errors rather than as literals in Perl replacement strings; in actual Perl they trigger variable interpolation which RegexBuddy cannot emulate.
Documentation: Regular expressions in the help file and PDF manual now have syntax coloring.
GREP: Files larger than 2GB are now skipped with a clear error message indicating RegexBuddy is limited to 2 GB files rather than finding incorrect or no matches.
Library: Ctrl+wheel now changes the font size in the editor for the description of library items.
Library: Sample regexes for MasterCard credit card numbers now include bin ranges 2221 through 2720.
Library: Sample regexes for matching email addresses now allow top-level domains up to 63 characters; new samples were added to show how to limit the maximum length on email addresses.
Test: Opening HTTPS URLs now works if the OpenSSL library is available; if not the error message now says that HTTPS is not supported instead of saying something obscure about an IOHandler.

Bug fixes:

Create: Double-clicking the tree node of a backreference did not always select the correct group in the Insert Backreference dialog.
Options: std::regex supports “skip zero-length matches” in Replace mode too.
Test: Capturing groups containing nothing but a lookbehind caused the lookbehind to be handled incorrectly for flavors that match lookbehind from left to right.
Test: Column headers in the test results were not updated or removed when the regular expression does not match the test subject.
Use: PHP code snippet for splitting strings did not pass the PREG_SPLIT_NO_EMPTY and PREG_SPLIT_DELIM_CAPTURE flags to the preg_split() call that are needed to make PHP use the “don’t add empty strings” and “add groups” options.

RegexBuddy 4.5.0 – 14 October 2015

New features:

Applications: Microsoft Edge.
Applications: PCRE 10.20.
Applications: PHP versions through 5.6.14.
Applications: PowerShell operators as a separate application next to PowerShell, to better handle that PowerShell operators only allow case sensitivity to be controlled outside the regex and that they’re case insensitive by default, unlike the Regex class in .NET.
Applications: Python 3.5.
Applications: R 3.2.2 (no changes to regex flavor).
Applications: std::regex in C++Builder 10 Seattle.
Applications: std::regex in Visual C++ 2015.
Applications: XRegExp 3.
Aspects: When shorthands match Unicode characters, the negated shorthands may not exclude those Unicode characters, even though they should.
Copy/Paste/Use: C++11 raw string literals.
Options: ECMAScript flavor choice for .NET.

Improvements:

Create: Always treat unescaped hyphens that are not at the start or end of the character class as an error in Helpful mode.
GREP: Edit button’s drop-down menu should list “open all matched files in EditPad” when the cursor does not point to a file but the GREP panel does show matched files.
Preferences|GREP: The option to hide (permanently exclude) hidden files and folders from the GREP panel no longer affects system files and folders, for which there is now a separate option.
Windows 10: New look for the menus and toolbars on Windows 10 to add a bit more contrast to RegexBuddy’s user interface.

Bug fixes:

Aspects: For flavors that treat invalid two-digit backreferences as a single-digit backreference and a literal rather than as an error, such two-digit backreferences were incorrectly treated as an error if there were enough capturing groups for the same two-digit backreference to be valid if its second digit were zero.
E.g. \23 would be treated as an error if there were 20 or more but fewer than 23 capturing groups. \23 was correctly treated as \2 followed by a literal 3 if there were fewer than 20 capturing groups. This affected the JGsoft, Java, and XPath flavors.
Convert: Replacement strings that contained backreferences preceded and followed by literal text that has characters that require escapes to be added in the converted replacement string sometimes had the backreference escaped too.
Copy: Copying a regex or replacement string that starts with a backslash or a quote as a JavaScript string failed to escape the initial backslash or quote.
Create: Insert Backreference dialog selected the group after the cursor if you entirely selected a group inside the regex and that group was immediately followed by another; there was no issue if you clicked inside the group you want as the dialog’s label instructs.
GREP: Open matched files in EditPad does not open all matched files when EditPad is not yet running.
Options: Support string syntax did not work for applications where that option only affects replacement strings.
Regex: A conditional with no contents and no closing parenthesis followed by free whitespace or a comment and nothing else triggered an access violation.
Regex: Empty groups inside lookbehind using a flavor that does not support infinite repetition inside lookbehind caused a division by zero error.
Test: \K did not work when used at the start of a superfluous non-capturing group.

RegexBuddy 4.4.1 – 30 June 2015

Bug fixes:

Create: Moving the cursor to the end of the regular expression or replacement text did not always select the last node in the regex tree or replacement tree (4.4.0 only).
Create: Using the mouse to place the cursor between two adjacent groups did not always select the group to the right of the cursor in the regex tree, which also caused the Insert Token menu to insert its tokens at the previous cursor position (4.4.0 only).
GREP feature was broken in 4.4.0.
GREP: If the regular expression contained a syntax error, attempting to grep with it would show a progress meter stuck at 0% in addition to the error message about the syntax error.

RegexBuddy 4.4.0 – 29 June 2015

New features:

Applications: Perl 5.22.
Applications: PHP versions through 5.6.10.
Applications: R 3.2.1 (no changes to regex flavor).

Improvements:

Aspects: Replacement flavors that support \g<name> named backreferences may or may not support \g<1> numbered backreferences.
Bracket matching now highlights the bracket to the left of the cursor if the cursor is between two brackets and there is a selection that starts to the left of the cursor.
Convert: Prefer converting replacement text backreferences using syntax that separates the backreference from following literal digits even when not strictly required.
Convert: Prefer preserving the syntax used for replacement text backreferences if supported by the target flavor and there is no following literal digit to prefer a different syntax.
Create: Clicking in the regex now selects the node that corresponds with the part of the regex to the right of the cursor, unless there is a selection that starts to the left of the cursor.
Insert Token: Numbered backreferences in Python replacement strings are now inserted as \g<1> instead of \1 to avoid issues with backreferences that are followed by literal digits.
Installer no longer asks to accept the license agreement if you already have RegexBuddy 4.x.x installed.
Installer now puts a single shortcut directly in the Start menu which better fits the Start menu on Windows 10.
Use: Code snippets using multi-line string styles now look at the (?x) mode modifier at the start of the regex in addition to the free/exact spacing option outside the regex to determine whether indentation should be added to the string or not.

Bug fix:

Library/History: The option “^$ match at line breaks” was always turned on when restarting RegexBuddy or loading a library if the regex was in Replace or Split mode.

RegexBuddy 4.3.1 – 8 May 2015

Improvements:

Applications: .NET version number updated to 4.6 (no changes since 2.0).
Applications: PCRE version number updated to 8.37 (no changes to regex flavor).
Applications: PHP version numbers updated through 5.6.8 (no changes to regex flavors).
Applications: R version number updated to 3.2.0 (no changes to regex flavor).
Applications: Visual Studio IDE version number updated to 2015 (no changes since 2012).

Bug fixes:

64-bit build crashed on startup when the AllocationPreference registry key forces memory to be allocated from the top down.
Windows 8 and 8.1: The edges of the panels on the main window are now gray like they are on previous versions of Windows, instead of blue.

RegexBuddy 4.3.0 – 9 April 2015

New features:

Applications: PCRE 8.36.
Applications: PCRE2 10.10.
Applications: R 3.1.3.
Applications: Ruby 2.2.
Aspects: (?(VERSION>=10.00)yes|no) PCRE2 version check.
Aspects: \x{} may be a NULL character, an invalid character, an error, or the literal x{} in flavors that support \x{FFFF} Unicode escapes.
Aspects: \x{whatever} may be a NULL character, an error, or the literal x{} in flavors that support \x{FFFF} Unicode escapes.

Improvements:

Applications: Delphi and C++Builder version numbers updated to XE8 (no changes compared with XE7).
Applications: PHP version numbers updated through 5.6.7 (no changes to regex flavors).
Aspects: Backreferences in the replacement text to non-participating capturing groups may be an error when the search-and-replace is executed (e.g. Python); RegexBuddy treats them as a syntax error in Helpful mode for these flavors.
Create: Double-clicking an error node that says that word boundaries that match specifically at the start or end of a word are not supported now replaces them with the generic word boundary that is supported as indicated in the error message.
Create: Repeated capturing groups no longer show the suggestion to put a capturing group around them if such a surrounding group already exists and double-clicking the suggestion inserts the surrounding group.
Create: Repeated capturing groups now get a suggestion to replace the group with a non-capturing group which is done when the suggestion is double-clicked.
Create: Suggestions to improve the regex that could be interpreted as errors if one doesn’t fully understand the suggestion are now only shown when RegexBuddy is in Helpful mode and the Create panel is in Detailed mode.
Test and Convert panel now clearly indicate when a regular expression is too long, as the Create panel already did.

Bug fixes:

Applications: Delphi XE6 and later provide an option roNotEmpty to control whether zero-length matches should be skipped when using TRegEx.
Create: For flavors that have [[:<:]] and [[:>:]] as the only word boundaries that match specifically at the start or end of a word, error messages about \m, \M, \<, and \> being unsupported no longer say that the flavor doesn’t have any word boundaries that match specifically at the start or end of a word.
Insert Token|Unicode Block: Hovering the mouse over the grid now shows a tooltip with the code point of the character under the mouse pointer.
Use: PCRE code snippets now correctly pass the option to skip zero-length matches to pcre_exec() (instead of to pcre_compile() where it has no effect).

RegexBuddy 4.2.1 – 12 December 2014

Improvements:

Aspects: Combined quantifiers like .*? and .*+ in GNU ERE that look like lazy or possessive quantifiers in other flavors are now treated as errors in Helpful mode; the actual behavior of GNU ERE is still emulated in Strict mode.
Create: Empty alternatives inside a group or a conditional now have a node indicating that empty alternatives find zero-length matches.
History: Different icon for the Clear button which erases the history, unlike the New button on the Library toolbar which starts a new library without deleting the previous library.

Bug fixes:

Copy/Use: Regular expressions and replacement strings that did not contain backslashes or line breaks were not correctly formatted as C# strings (4.2.0 only).
Create: Combined quantifiers like .*? in GNU ERE had their nodes on the Create panel in reverse order.
Debug: Debugging a regular expression sometimes failed with a “division by zero” error.
Library: If a library entry somehow ended up with a blank regex then selecting that blank entry in the library could cause errors.
Library: Update button allowed a regex in the library to be replaced with a blank regex; now the Update button is disabled when there is no current regex, just like the Add button is disabled then.
Use: String literals with the regex tree had an extra concatenation operator at the end if the application does not support multi-line strings or free-spacing regexes and if the regex tree ended with warning nodes that aren’t linked to a part of the regex.

RegexBuddy 4.2.0 – 7 October 2014

New features:

Applications: Delphi and C++Builder XE7.
Applications: Perl 5.20.
Applications: Visual C++ and C++Builder (Win64) using std::regex.
Aspects: \p{Any}, \p{All}, \p{Assigned}, and \p{Unicode} with or without “Is” prefix.
Aspects: Newline may be an alternation operator.
Aspects: POSIX collation names for ASCII characters.
Aspects: Shorthand character classes using POSIX character class notation [[:d:][:s:][:w:]].
Convert: Flavor choice for applications that offer multiple regex syntax choices in a single library, allowing you to convert the regex to any of the syntax choices offered by the application; presently this is only used for std::regex.
Options: Flavor choice for applications that offer multiple regex syntax choices in a single library; presently this is only used for std::regex and allows us to have one entry for std::regex and one for std::wregex for each version of Visual C++ or C++Builder, instead of having 6 separate entries for the 6 different regex flavors for every version of std::regex and std::wregex.
Test: Keyboard shortcuts for going to the next (Alt+N) and previous (Alt+P) highlighted match, and for going to the first (Alt+F) and next (Alt+N) match when matches are not highlighted.

Improvements:

Applications: Opera applications now use Chrome flavors as Opera is now based on the WebKit engine used by Chrome meaning the two now have identical regex flavors; Opera flavors have been removed.
Applications: PHP version numbers updated through 5.6.1 (no changes to regex flavors).
Applications: R version number updated to 3.1.1 (no changes to regex flavor).
Applications: Regex syntax that makes Perl print deprecation warnings is now treated as an error by the Perl flavors in RegexBuddy.
Aspects: \] may be an error even while an unescaped ] that does not close a character class is also an error.
Aspects: \c may allow characters other than ASCII letters, taking either the last 5 bits to indicate the control character or flipping bit 0x40.
Aspects: \u007F may be supported even when \uFFFF is not supported.
Aspects: \xFF may eat up all hexadecimal digits that follow it and trigger an error if the hexadecimal number exceeds FF or FFFF.
Aspects: An unescaped backslash or dollar at the end of the replacement text may be treated differently than an unescaped backslash or dollar in the middle of the replacement text.
Aspects: Case insensitivity may be applied to ASCII characters only.
Aspects: Case insensitivity may not be applied to character classes.
Aspects: Empty capturing groups may be an error.
Aspects: Negated shorthand character classes may not be handled correctly when combined with other tokens inside a character class.
Aspects: POSIX class “alnum” may or may not include \p{No}.
Aspects: POSIX class “blank” may include vertical whitespace (which makes it identical to the “space” class).
Aspects: POSIX class “print” may or may not include Unicode whitespace or marks.
Aspects: POSIX class “punct” may or may not include Unicode symbols or symbols in the active code page.
Copy/Use: C L“” string which supports \uFFFF escapes.
Copy/Use: C string now supports \xFF escapes.
Insert Token: “ASCII character” item was renamed to “8-bit character” to better reflect what the item really does.
Insert Token: “Dot” item has been replaced with “Any character including line breaks” and “Any character except line breaks” items that may insert the dot or more appropriate tokens.
Insert Token|Anchors: Insert mode modifiers if supported and needed to make it possible to insert the requested anchor, instead of disabling the menu item when global options cannot be changed.

Bug fixes:

Create: When capturing groups with the same name have the same number, the number was only indicated for the first group.
Test: Capturing groups containing nothing but a negative lookaround were not handled correctly.
Test: Ctrl+H did not toggle hexadecimal mode as indicated in the context menu.
Test: Restore capturing groups upon exiting recursion did not work correctly with capturing groups after the recursion token.

RegexBuddy 4.1.3 – 14 August 2014

Bug fixes:

Aspects: \N is affected by regex options that determine which characters are line break characters in the same way that the dot is.
Create: Comparison did not take into account that the compared flavors may not support certain options.
Paste: Paste from JavaScript // operator now works correctly when the active application is not a JavaScript flavor.
Use: String literal with RegexBuddy’s regex tree had doubled alternation operators.
Use: String literal with RegexBuddy’s regex tree was missing explanatory tree nodes that do not select a part of the regular expression.

RegexBuddy 4.1.2 – 7 July 2014

Improvement:

Create: Improve wording for the lookbehind (?<=(AND|OR)) which is not supported by PCRE because it is not fixed length (PCRE supports alternation inside lookbehind but not alternation inside groups inside lookbehind).

Bug fixes:

Test: Recursion did not properly backtrack trailing optional groups that did not match but that were partially matched during the matching process.
Test: Regular expressions that contained an optional dot followed by an optional negated character class at the start of the regex or only preceded by optional or zero-length tokens failed with an access violation error when using the option “dot doesn’t match line breaks”.

RegexBuddy 4.1.1 – 27 May 2014

Bug fixes:

Convert: Exact spacing option does not have the intended effect if the regular expression contains a mode modifier and the target application supports (?x).
Create: HTML export did not replace < and & in the regex or the caption with HTML entities.
Preferences: Color buttons did not always indicate the correct color when selecting “Default”.
RegexMagic integration now supports RegexMagic 2 and requires a version of RegexMagic that supports the application you have selected in RegexBuddy.

RegexBuddy 4.1.0 – 1 May 2014

New features:

Applications: ASP.NET.
Applications: Delphi XE6 and C++Builder XE6.
Applications: HTML5 pattern. Like JavaScript, but with implied anchors.
Applications: Java 8.
Applications: PCRE 8.34 and 8.35.
Applications: PHP up to 5.5.11.
Applications: Python 3.4.
Applications: R 3.0.2 until 3.1.0.
Applications: Visual Studio 2012 IDE. This is the .NET 2.0–4.5 flavor but with “case sensitive” as the only option and “case insensitive” as the default.
Create: Export regex tree formatted with Markdown for use on web sites such as stackoverflow.com.
Insert Token: Backreferences with case conversion in the replacement text.
Options: Reset button to reset all options to the application’s defaults.
Preferences|Editors: Ctrl+Wheel changes font size instead of scrolling one page.
Preferences|Operation: Toggle buttons instead of combo boxes for the regex options. Checkbox labels indicate the state of the option when it is turned on. In other words, the label indicates the opposite of the default behavior. The label will change when changing to a regex flavor with the opposite default.

Improvements:

API: CheckActionVersion() can now be used to query the active RegexBuddy version more specifically so that RegexBuddy and the client application can determine the set of flavors that both support, as new flavors may be added in free minor updates that do not otherwise change the API.
Applications: Delphi flavor names have been updated to include Delphi 2010 (same as Delphi 2009) as well as Delphi 2006 and prior (same as Delphi 2007).
Aspects: .NET loses the first numbered capturing group after each conditional using explicit lookaround.
Aspects: Java 4 and 5 do not always correctly evaluate lookbehind with variable repetition, causing the lookbehind to fail when it should succeed.
Aspects: Java 6 and later evaluate lookbehind from left to right going through each possible starting position depending on the minimum and maximum possible length of the lookbehind; this can lead to different results when the lookbehind contains capturing groups compared with evaluating the lookbehind from right to left.
Aspects: JavaScript backtracks zero-length iterations of quantifiers when the minimum number of iterations has already been satisfied, while other regex flavors simply stop the iteration and proceed with the remainder of the regex. MSIE and Opera don’t always do this correctly. This means that capturing groups inside the zero-length iteration will have the matches of the previous non-zero-length iteration restored, while other flavors would leave the capturing groups empty. This yields unexpected (compared with other flavors) behavior for lazy optional quantifiers inside groups in which everything is optional and that have a variable quantifier.
Aspects: JavaScript clears all nested capturing groups when entering a group that has a quantifier. If the parent group can match without attempting a nested group then in JavaScript the nested group does not store a match if it did not participate in the most recent iteration of the parent group. In other flavors, the nested group is only be empty if it did not participate in any iterations of the parent group. Otherwise it holds the match of the most recent iteration of the parent group in which it did participate.
Create: Exporting to file now asks for the caption and format before asking for the file.
Options: Split with limit now allows negative limits if the selected application allows negative limits.
Use: PCRE code snippets now set the PCRE_UTF8, PCRE_UTF16, or PCRE_UTF32 flag to better match the template description of being PCRE with UTF-8, UTF-16, or UTF-32. If your code uses PCRE with an 8-bit code page, then you’ll need to remove these flags.
Use: XPath code snippets now have a parameter for the quote so you can choose between single or double quotes instead of having hard-coded double quotes.

Bug fixes:

Aspects: Lookbehind containing a lookahead conditional has a different outcome depending on whether the regex inside the lookbehind is evaluated from right-to-left (.NET) or from left-to-right (Perl and PCRE).
Debug: Regular expressions containing subroutine definitions that contain subroutine calls could not be debugged.
Test: Switching between text and hexadecimal mode does not immediately show or hide the line break style drop-down list.
Use: C# and Delphi for .NET code snippets for iterating over all capturing groups need to include matchResults.Groups.Count in the iteration just like the VB.NET code snippet does.
Use: Functions that need to prepend mode modifiers to the regex did not check whether the regex already starts with mode modifiers, possibly leading to redundant mode modifiers in the generated code snippet.

RegexBuddy 4.0.3 – 17 December 2013

Improvement:

Create: Backreferences in the replacement text to undefined capturing groups are now treated as errors in Helpful mode when the application treats them as literal text.

Bug fixes:

Create: Backreferences in the replacement text to undefined capturing groups were treated as errors in Strict mode when the application silently removes them from the replacement text.
RegexBuddy 4.0.1 and 4.0.2 constantly used 100% of one CPU core while idle after highlighting matches on the Test panel.
RegexBuddy set the application to PowerGREP instead of EditPad when launched from EditPad and the active tab in EditPad was not Untitled.
Test: When match highlighting is off, Find Next skips ahead one character instead of starting at the cursor position.

RegexBuddy 4.0.2 – 15 November 2013

Bug fixes:

Flavors: Oracle 10gR2 and later support lazy quantifiers.
Insert Token|Quantifier now disables the “possessive” radio button for Ruby 2.0 when the minimum and maximum repetition require curly braces to be generated. This prevents {n,m}+ from being generated, which Ruby 2.0 interprets as two combined quantifiers rather than as a single possessive quantifier.
Proxy settings were not preserved when restarting RegexBuddy.
Regex: Ctrl+[ did not select the text between the next level of brackets when the selection already spans a pair of brackets.
Regex: Mode modifiers inside groups were highlighted with the wrong colors.
Test: Match highlighting disappeared when the regex is valid but the replacement text has syntax errors; toggling the Highlight button off and on made it reappear.
Use: R functions “get a logical vector…” should call R’s grepl() function instead of lgrep() which does not exist.

RegexBuddy 4.0.1 – 24 October 2013

Bug fixes:

Copy/Use: Regexes and replacement texts containing (needlessly) escaped quotes were not correctly converted to PHP strings.
Create: Splitter between the regex tree and replacement tree did not preserve its position when restarting RegexBuddy.
Debug: Regular expressions with non-standard handling of capturing groups caused the debugger to hang or crash even though the same regexes could be tested correctly on the Test panel. This includes regexes with lookahead for flavors that don’t backtrack capturing groups inside lookahead as well as regexes using recursion and balancing groups.
GREP: If the flavor advances after zero-length matches then the GREP in RegexBuddy 4.0.0 advanced after all matches, preventing it from finding matches adjacent to each other.
Help: XRegExp help topic was missing.
Library: Copy and Paste of complete actions in the library was broken in 4.0.0.
Preferences: Default text layout was “monospaced ideographic width” if the default language in Windows was Chinese, Japanese, or Korean, which does not work well with regular expressions and other text that is mainly ASCII.
Test: Buttons to show the previous or next highlighted match were not disabled when matches could not be highlighted due to an error in the regular expression; clicking them caused a harmless access violation.
Test: Crash when trying to test a regular expression that uses a lazy or possessive quantifier on an anchor with an application that allows quantifiers on anchors.
Test: Highlighting was not updated when editing the replacement text, causing the replacement shown in the match details when you double-click a match to be out of sync with the replacement text.
Use: Functions that use the options to add start-of-string and end-of-string anchors to the regex to make it match strings entirely (or not at all) did not correctly add ^ and $ for flavors like JavaScript that do not support dedicated string anchors like \A and \z.
Use: Ruby code snippets using the scan(), gsub(), or split() functions were generated correctly but did not have the regex objects highlighted correctly.

RegexBuddy 3.6.3 – 24 October 2013

This release fixes one bug introduced in 3.6.2 that broke Copy and Paste of complete actions in the library.

RegexBuddy 4.0.0 – 16 September 2013

RegexBuddy 4 is a major upgrade and comes with a very long list of new features and improvements. Per our upgrade policy this major upgrade comes with an upgrade fee for anyone who purchased RegexBuddy before 16 September 2012. The page for buying the upgrade lists the most important new features and enhancements. The version history you’re looking at now shows everything that has changed.

New features:

Aspects: \h and \v are shorthands for horizontal and vertical whitespace; \H and \V are the negated versions.
Aspects: \K to “keep” the match so far from the overall match result.
Aspects: \N matches any character except \n regardless of the “single line” mode modifier.
Aspects: \R matches a Unicode line break and matches CRLF as a pair.
Aspects: Backreferences to a capturing group at a specific recursion level relative to the recursion level of the group (if any) containing the backreference.
Aspects: Backreferences using new-fangled syntax \k{name}, \g1, \g{1}, or \g{name}.
Aspects: Backreferences using relative numbers like \k<-1>, \k’-2’, \k{-3}, \g-4, or \g{-5}.
Aspects: Balancing groups.
Aspects: Branch reset group (?|regex) that uses the same capturing group numbers in all the alternatives.
Aspects: Branch reset groups may allow named capturing groups with the same name as long as the same sequence of names is used in each alternatives, even when the regex flavor does not otherwise allow named capturing groups to share the same name.
Aspects: Branch reset groups may or may not allow named capturing groups to have different names in each alternative.
Aspects: Case conversion escapes \u, \l, \L…\E and \U…\E.
Aspects: Case conversion escapes \U…\E and \L…\E may or may not affect literal text in the replacement text in addition to affecting backreferences.
Aspects: Character class intersection. E.g. [\p{Nd}&&\p{Thai}] or [\p{Nd}&&[\p{Thai}]] matches only Thai digits.
Aspects: Conditional that tests whether the regex engine is inside a recursion of the whole regex or a subroutine call to any capturing group.
Aspects: Conditional that tests whether the regex engine is presently inside a recursion of or subroutine call to a particular capturing group.
Aspects: Conditionals using relative numbers (?(-1)then|else) and/or (?(+1)then|else).
Aspects: Mode modifier (?J) toggles whether multiple capturing groups can have the same name.
Aspects: Mode modifier (?X) makes escaping letters with a backslash an error in PCRE.
Aspects: Mode modifiers can be reset with (?^).
Aspects: Modifier (?d) and UNIX_LINES option to make the caret, dollar, and dot treat only \n as a line break (Java).
Aspects: Named backreferences using $+{name} in the replacement text.
Aspects: Nested character classes. In flavors that support them [[a-z][0-9]] is the same as [a-z0-9] and [[a-z] is an error. In other flavors, [[a-z][0-9]] is the same as [\[a-z][0-9]\] and [[a-z] is the same as [\[a-z].
Aspects: Octal escapes are supported by some replacement text flavors.
Aspects: PCRE_NEWLINE* options to control which characters are treated as line breaks by the caret, dollar, and dot.
Aspects: POSIX word boundaries [[:<:]] and [[:>:]].
Aspects: Quantifiers immediately following anther quantifier may be combined rather than being an error (e.g. Ruby, GNU).
Aspects: Quantifiers that make a backreference optional may not work correctly (bug in some versions of PCRE).
Aspects: Recurse the whole regular expression with (?R) or (?0).
Aspects: Recursion into or subroutine calls to a capturing group may or may not make the capturing group store the text matched during the recursion or subroutine call (Ruby yes, Perl no).
Aspects: Recursion into or subroutine calls to capturing groups with (?1) or \g<1> or (?P>name) or (?&name).
Aspects: Recursion may or may not be atomic (PCRE yes, Perl no).
Aspects: Recursion may or may not isolate backreferences from capturing groups at different recursion depths (Perl yes, PCRE no).
Aspects: Recursion that may lead to an infinite loop may be a syntax error even if it could find valid matches in certain subject strings (PCRE yes, Perl no).
Aspects: Splitting a string may add the highest-numbered capturing group that participated in the match to the returned array, without adding any other capturing groups.
Aspects: Splitting a string may include text matched by capturing groups in the returned array. Non-participating groups and groups that match empty strings may or may not be added too.
Aspects: Splitting a string may or may not add empty strings to the returned array when regex matches are adjacent to each other or to the very start or end of the string.
Aspects: Splitting a string with a limit may interpret the limit as the number of elements the array should have or as the number of times the string should be split.
Aspects: Splitting a string with a negative limit may split the string as many times as possible, not split the string at all, or be an error.
Aspects: Splitting a string with the limit set to zero and/or to a negative number may trim empty strings from the end of the returned array.
Aspects: Subroutine calls to capturing groups with the quantifier {0} may not have any effect.
Aspects: Subroutine definitions inside a (?(DEFINE)…) group.
Aspects: Ungreedy (lazy) matching mode via the (?U) mode modifier or the /U flag.
COM interface: SetTestStringEx and SetTestFileEx functions that allow you to specify an encoding, test scope, and line break mode.
Command line: /clipboarddelimiter parameter that allows matching options and a replacement text to be passed via the clipboard along with the regular expression.
Command line: Parameters to force conversion to a specific application or regex flavor.
Convert: New panel to convert the regular expression and replacement text from one application (flavor combination) to another. In RegexBuddy 3, regular expressions could only be converted by generating a source code snippets on the Use panel. Now, conversion is done separately on the Convert panel.
Convert: Option to make a free-spacing regex tightly spaced or make a tightly spaced regex free-spacing.
Convert: Option to strip comments from the regular expression.
Create: Basic or detailed explanations. E.g. basic explanation only says \w matches a word character; detailed explanation also indicates which characters are considered word characters.
Create: Select one or more additional flavors to compare with the flavor selected in the top toolbar. If those flavors interpret parts of the regex differently, add multiple nodes for those parts saying “flavor X interprets this part differently”.
Create: Token tree for the replacement text.
Editor: Proper editing of text and regular expressions using complex scripts and right-to-left scripts.
Flavors: Delphi 2007 till Delphi XE4 using the TRegEx and TPerlRegEx classes.
Flavors: Helpful or strict interpretation of the regular expression and replacement text. E.g. in helpful mode for JavaScript, the regex \A is interpreted as the error “JavaScript does not support the \A anchor” (guessing at the user’s intention). In strict mode, the same regex matches a literal A (which is what JavaScript really does).
Flavors: JavaScript + XRegExp.
Flavors: Separate flavors for Oracle 10gR1 and 10gR2 (and later), which differ from each other and from POSIX ERE (which RegexBuddy 3 used for Oracle).
GREP: Option to disable searching through binary files.
Insert Token|Lookaround|Keep out of overall match (\K).
Insert Token|Non-printable character|Any line break (\R).
Options: Add or do not add empty strings to the returned array when splitting a string finds adjacent matches (e.g. PREG_SPLIT_NO_EMPTY).
Options: Add or do not add text matched by capturing groups to the returned array when splitting a string (e.g. PREG_SPLIT_DELIM_CAPTURE).
Options: Enable or disable support for syntax that is not supported by the flavor’s regex or replacement text syntax but is supported by literal strings in the programming language that the flavor is normally used with.
Options: Explicit capture option that disables numbered capturing groups, leaving only named capturing groups.
Options: Line break handling mode.
Options: Named groups can share the same name or not (e.g. PCRE_DUPNAMES).
Options: UnGreedy matching mode (e.g. /U in PHP).
Preferences, GREP: Configure which files, if any, are permanently excluded from GREP. By default, files that look like backup files or working copies are excluded.
Preferences, GREP: Option to grep hidden and system files.
Preferences: Configure colors of visualized spaces and paragraph markers.
Test: Automatic Line Breaks mode that automatically converts the line break style of the test subject to the line break style that the current application’s regex flavor works best with.
Test: Match details show all iterations of a capturing group as stored in a .NET CaptureCollection when .NET is the active regex flavor.
Use: Oracle 11g source code templates.
Use: pcre16 and pcre32 source code templates.
Use: POSIX source code snippets.
Use: Regex tree placeholder %REGEXTREECOMMENTXML% that makes it possible to add the regex tree to XML comments in languages such as C#.
Use: Regex tree placeholders %REGEXTREECOMMENT% and %REGEXTREESTRING% that make it possible to use the regex tree in custom code snippets.
Use: Replacement tree placeholders %REPLACETREECOMMENT%, %REPLACETREESTRING%, and %REPLACETREECOMMENTXML%.
Use: XRegExp source code snippets.
View: Save custom layouts.

Improvements:

Aspects: \0 inserts a NULL byte in some replacement text flavors.
Aspects: \0 matches a NULL character in some flavors, but is an error or a literal zero in other flavors.
Aspects: \P{^…} (double negation of a Unicode property) can be the same as \p{…} or can be an error.
Aspects: \p{ASCII} or \p{IsASCII} may be supported as a Unicode property when POSIX classes are not supported.
Aspects: \Q… escape sequences at the end of the regex may or may not be allowed to end with a single backslash.
Aspects: \Q…\E escape sequences may or may not be allowed to end with a single backslash before the \E.
Aspects: \xFF can have less or more than 2 hexadecimal characters with some flavors.
Aspects: Alternation may return the leftmost longest match as specified in the POSIX standard instead of being eager and stopping as soon as one alternative matches.
Aspects: Anchors and word boundaries inside character classes may be silently ignored instead of being an error (Python).
Aspects: Backreferences to a name shared by multiple named capturing group are an alternation from right to left of all the backreferences to all the groups with that name that appear to the left of the backreference in the regex in Ruby.
Aspects: Backreferences to a name shared by multiple named capturing groups point to the leftmost group with that name in PCRE.
Aspects: Backreferences to a name shared by multiple named capturing groups point to the leftmost group with that name that actually participated in the match so far in Perl.
Aspects: Backreferences to non-existing capturing groups may silently fail to match instead of being an error.
Aspects: Backreferences used before the group they point to (forward references) or inside the group they point to (nested references) may work normally, be an error, always fail to match, or always match nothing; the behavior may be different for named and numbered references, and may be different for forward and nested references.
Aspects: Backreferences used inside the group they point to (nested references) may force that group to be an atomic group.
Aspects: Capturing group names may or may not be allowed to start with a digit or consist entirely of digits.
Aspects: Capturing groups inside atomic groups or lookaround may or may not be backtracked when the atomic group or lookaround is backtracked.
Aspects: Caret and dollar may be literal characters rather than anchors when used in any position other than the start or end of the regex, a group, or an alternation.
Aspects: Caret and dollar may or may not match before and after \r, \f, \v, \p{Zl}, and/or \p{Zp} when “^ and $ match at line breaks” is on.
Aspects: Case insensitivity mode modifier may or may not apply to character escapes such as \u0074.
Aspects: Case insensitivity mode modifier may or may not apply to the POSIX classes [[:lower:]] and [[:upper:]] and the Unicode categories \p{Lu} and \p{Ll}.
Aspects: Comments using the (?#comment) syntax may or may not be an error when the closing ) is missing.
Aspects: Dot may or may not match \r, \f, \v, \p{Zl}, and/or \p{Zp} when “dot matches line breaks” is off.
Aspects: Escaped letters like \q that don’t form a metacharacter may be an error or may be literal characters.
Aspects: Explicit capture may be enabled automatically if the regex contains named capturing groups (Ruby 1.9).
Aspects: JavaScript does not support unescaped ] at the start of a character class, instead allowing for empty character classes that always fail to match.
Aspects: Mode modifiers may be case insensitive. (?IMNSX) is the same as (?imnsx) in .NET.
Aspects: Mode modifiers that appear in the middle of the regex may be applied to the entire regex rather than just the remainder of the group containing the mode modifier.
Aspects: Named backreference syntax may or may not be used to reference numbered capturing groups.
Aspects: Named backreferences with an empty name are now more clearly indicated as errors.
Aspects: Named capturing groups with an empty name may be treated as numbered capturing groups rather than as errors; if they are errors, RegexBuddy now indicates the error more clearly.
Aspects: Named conditional (?(name)then|else) is interpreted by .NET as a conditional with implicit lookahead using “name” as literal text if there is no capturing group called “name” instead of as an invalid named conditional; it is only a named conditional if there is a group called “name”.
Aspects: Named conditionals may or may not be able to reference named groups that are opened after the named conditional.
Aspects: Named conditionals must be written as (?()then|else) or (?(‘name’)then|else) in Perl.
Aspects: Negated shorthands may or may not be supported inside character classes.
Aspects: Numbered backreference syntax may or may not be used to reference named capturing groups.
Aspects: Octal escapes may use various notations, with or without a leading zero, and varying numbers of digits.
Aspects: POSIX class “ascii” may not be supported even when other POSIX classes are as the “ascii” class is not included in the official POSIX standard.
Aspects: POSIX class “blank” may or may not include the zero width space U+200B character.
Aspects: POSIX class “cntrl” may or may not include the ASCII control characters 0x00 to 0x1F (bug in Tcl 8.4).
Aspects: POSIX class “print” may or may not include ASCII whitespace control characters such as tabs and line breaks.
Aspects: POSIX class “space” may or may not include the next line U+0085 and zero width space U+200B characters.
Aspects: POSIX class “word” may not be supported even when other POSIX classes are as the “word” class is not included in the official POSIX standard.
Aspects: POSIX class “word” may or may not include \p{M}, \p{Nl}, \p{No}, and \p{Pc}.
Aspects: POSIX classes “alpha” and “alnum” may or may not include \p{Lm}, \p{Lo}, \p{M}, and \p{Nl}.
Aspects: POSIX classes “upper” and “lower” may add nothing to the character class when the regex is case insensitive, possibly resulting in a character class that matches no characters at all (bug in Ruby 1.8).
Aspects: POSIX classes “upper” and “lower” may match all letters when the regex is case insensitive.
Aspects: POSIX classes “upper” and “lower” may match any character when negated and the regex is case insensitive.
Aspects: POSIX classes may include characters other than letters in their names (even though all such names would be invalid).
Aspects: POSIX classes may match only ASCII characters, only characters in the system code page, or all relevant Unicode characters.
Aspects: Python 3.2 and prior do not support \uFFFF as part of the regex syntax but do support it as part of literal strings.
Aspects: Quantifier {0,n} may be written as {,n} in flavors such as Python.
Aspects: Quantifiers after anchors or word boundaries may be allowed, be an error, or be interpreted as literal characters.
Aspects: Quantifiers in invalid positions may be literals or may be silently ignored rather than being errors.
Aspects: Quantifiers on lookaround may be an error, may be ignored, may make the lookaround optional, or may eliminate the lookaround; this will lead to different results when there are capturing groups inside the lookaround.
Aspects: Shorthand \s may or may not include the vertical tab U+000B, form feed U+000C, next line U+0085, and zero width space U+200B characters.
Aspects: Shorthand \w may or may not include \p{Lm}, \p{M}, \p{Nl}, \p{No}, \p{Pc}, \p{P}, and \p{S}.
Aspects: Shorthand classes may match only ASCII characters, only characters in the system code page, or all relevant Unicode characters.
Aspects: Unicode categories \p{Lu} and \p{Ll] may match all letters when the regex is case insensitive.
Aspects: Unicode categories \p{Lu} and \p{Ll] may match any character when negated and the regex is case insensitive.
Aspects: Unicode property syntax may allow different combinations of spaces, hyphens, and underscores (if any).
Aspects: Warn that RegexBuddy does not yet emulate control verbs (Perl and PCRE).
Aspects: Warn that RegexBuddy does not yet emulate extended character classes (Perl 5.18).
Aspects: Word boundaries may support only ASCII word characters, only word characters in the system code page, or all Unicode word characters.
Aspects: XML Schema only matches the whole string, or not at all. RegexBuddy now emulates this on the Test tab. Set the Scope to “page by page” or “line by line” to be able to test multiple strings at once.
COM interface: The variant structure for a list of regular expressions now has a field to indicate the currently selected regular expression, so the receiving application can focus the same regex as the sending application.
Convert: Add a warning when converting a regex that uses variable repetition inside lookbehind from a flavor that supports this to one that doesn’t.
Convert: Replacement text conversion now leaves backslashes that are escaped with another backslash as such instead of converting them into a single literal backslash when the target replacement flavor supports both.
Convert: When a token that cannot be converted is used more than once in the regex, add only one comment with the conversion error message for that token.
Copy/Use: Python strings are no longer prefixed with “u” when they contain Unicode escapes unless the active regex flavor is Python 2 as strings are Unicode by default in Python 3.
Copying the regular expression, replacement text, test subject, or source code snippet now places rich text onto the clipboard which preserves syntax highlighting when pasted into a word processor or rich text editor.
Create: Explanation for tokens like \x74 indicates the actual character if it is printable.
Create: Regex tree images have a refreshed design and were expanded from 18 to 32 distinct icons to provide a clearer image of the regular expression.
Flavors: Browser-specific JavaScript flavors.
Flavors: Flavors are now selected as applications, which are a combination of regex flavor, replacement flavor, split flavor, string style, and source code template.
Flavors: Ruby 2.0 (Onigmo) and Ruby 1.9 (Oniguruma) as a separate flavors from Ruby 1.8 (classic engine emulated by RegexBuddy 3).
Flavors: Separate flavors for .NET 1.1 (covering .NET 1.0 and 1.1) and .NET 2.0 (covering .NET 2.0, 3.0, 3.5, and 4.0).
Flavors: Separate flavors for all versions of PCRE from PCRE 4.0 until PCRE 8.31.
Flavors: Separate flavors for all versions of PHP from PHP 4.3.3 until PHP 5.4.13.
Flavors: Separate flavors for Java 4, Java 5, Java 6, and Java 7.
Flavors: Separate flavors for Perl 5.8, Perl 5.10, Perl 5.12, Perl 5.14/5.16, and Perl 5.18.
Flavors: Separate flavors for R 2.14.0–2.14.1, R 2.14.2, and R 2.15.0–3.0.1.
Flavors: Separate flavors for Tcl 8.4/8.5 and Tcl 8.6.
Flavors: Separate Tcl BRE and Tcl ERE flavors to handle (?b) and (?e) in Tcl regular expressions, which are slightly different from the POSIX BRE and POSIX ERE flavors (which RegexBuddy 3 used for (?b) and (?e) in Tcl).
Forum: HTTP proxy server support extended with more authentication methods.
Forum: SOCKS proxy server support.
Forum: The button to delete messages is now labeled Cancel for messages that are being edited, to make it more obvious that this button deletes the edited message, but leaves the original message in place.
GREP: Respect the “^ and $ match at line breaks” option when the “line-based” option is off, instead of always matching ^ and $ at line breaks like PowerGREP does.
Highlighting: Highlight ranges in character classes in a different color. E.g. make it obvious that 4-7 is a range in [014-79].
Highlighting: Highlighting of backreferences in the replacement text now takes into account whether the capturing groups actually exist in the regular expression.
Highlighting: Literal characters that are escaped with a backslash are now highlighted so they can be easily distinguished from literal characters that aren’t escaped.
Keyboard shortcuts for as many toolbar buttons as possible.
Keyboard: F1 key for context-sensitive help now shows the same help topic shown by the Explain Token button when the Regex or Create panel has keyboard focus.
Library: Read Only checkbox is checked and disabled if the file is read-only on disk.
Library: Remember positions of the splitter bars when restarting RegexBuddy.
Settings and history are now stored in .ini files under %APPDATA%\JGsoft\RegexBuddy 4 instead of in the registry.
Test: Errors in the regex that cause highlighting to disappear are now indicated in the bottom half of the Test panel.
Test: Line break symbols (if enabled) are highlighted when they are part of a regex match.
Test: Line break symbols (if enabled) indicate the actual line break style instead of showing a generic paragraph marker.
Test: Line numbers are displayed on a different background color so they’re not confused with the test data.
Test: Single-clicking a highlighted match selects the replacement that corresponds with that match in the test results.
Test: Split results are now highlighted and clickable.
Unicode: RegexBuddy is now a full Unicode application, so Unicode characters can be used anywhere, rather than just in the regular expression and test subject.
Use: Python 2.7 and 3.1+ templates that use the flags parameter instead of embedding mode modifiers for re.sub() and re.split().
Use: Regular expression and replacement text are now inserted into the code snippet without any error checking and without any conversion, other than formatting them as literal strings.
Use: Template editor now asks whether you want to save the template if it has unsaved changes when you close the editor.
Use: Template editor now highlights placeholders which keeps things readable in languages that treat % as an operator.
Vista, 7 & 8: RegexBuddy now scales itself instead of letting Windows handle the scaling when the font size in Windows has been increased by more than 125% (i.e. the display resolution is more than 120 DPI) resulting in a much crisper appearance of RegexBuddy.

Bug fixes:

Insert Token|Character Class should correctly position or escape the metacharacters ^-] when they need to be added as literals.
Insert Token|Literal Text now uses character class escaping rules instead of the normal regex escaping rules when adding to a character class.
RegexBuddy crashes when pasting a large amount of text (rather than a working regex) into the edit box for the regular expression.
Use: PCRE code snippets for iterating over matches now correctly handle advancing after zero-length matches; PCRE does not do so automatically.

RegexBuddy 3.6.2 – 12 September 2013

Bug fixes:

Copy/Use: Backslashes were escaped when copying a regex as a Groovy slashy string.
Copy/Use: Dollar signs were not escaped when copying a regex or replacement text as a double-quoted Groovy string; now RegexBuddy only copies single-quoted Groovy strings.
Copy/Use: Regular expressions and replacement texts ending with a $ were not correctly formatted as dollar-quoted PostgreSQL strings.
Create/Test: Length of alternatives containing anchors, lookaround, or quantifiers with fixed repetition was not tracked correctly for the purpose of warning that Perl and Python require all alternatives in lookbehind to have the same length.
Debug: Placing the cursor right after the last match in a step did not highlight that match.
Debug: Scrolling by dragging the thumb of the vertical scroll bar allowed the debugger to be scrolled too far, resulting in blank space at the bottom, if the debugger was showing more than 32,000 steps.
Forum continued to use the old proxy settings until you restarted RegexBuddy if you changed the proxy settings after having successfully connected to the forum.
GREP: Browsing for a folder did not update the folder view if folders were added or deleted since the last time you browsed for a folder.
GREP: PowerGREP button failed to locate PowerGREP 3 when using portable installs of RegexBuddy and PowerGREP.
Integration: /putonclipboard command line parameter caused the Send button to clear the clipboard without putting the regex on the clipboard.
Library: Loading a test subject from the library correctly updated the Scope drop-down list on the Test panel, but did not immediately apply that scope to the actual highlighting on the Test panel; this could cause highlighting to disappear if the previously used scope does not allow the loaded regex to find any matches; the correct scope was applied as soon as the regex was edited.
Test: Editing the regex or test subject at the exact millisecond that RegexBuddy begins to highlight matches in the test subject caused the highlighting to crash with an “invalid class typecast” error.
Use: R code snippets did not work with R 2.11.0 and later because the “extended” parameter was removed in R 2.11.0. RegexBuddy’s code snippets for R now explicitly name the parameters, so they’ll work with all versions of R.

RegexBuddy 3.6.1 – 12 March 2013

Bug fixes:

Create: Zero-repeated groups like (group){0} were not indicated as such.
Test: Zero-repeated groups like (group){0} were matched as if they were optional groups like (group){0,1}.
Test: Editing a regex resulting in a syntactically invalid character class containing a hyphen such as [\u1234-\u567] and then editing the character class to make it valid again (such as typing an 8 after 7) caused the regex to be parsed incorrectly, adding a literal hyphen to the character class. Any subsequent edits that leave the character class valid would cause the regex to be parsed correctly again.
Copy/Use: Replacement texts ending in an odd number of backslashes were not correctly converted into Python raw strings or PHP strings.
Use: Replacement texts containing \r, \n, or \t were not converted correctly if the source replacement text flavor treats these as literal text while the target regex flavor treats them as character escapes.
Use: Replacement texts containing a literal backslash (escaped or unescaped) followed by \r, \n, or \t were not converted correctly if the target flavor does not require literal backslashes to be escaped and the target flavor treats \r, \n, and \t as character escapes.
Use: Visual Basic.NET code snippets using free-spacing regular expressions that span across lines did not have the necessary line continuation characters before and after the regex.

RegexBuddy 3.6.0 – 25 October 2012

Improvements:

Test: Open URL window should allow right-click Paste.
Windows 8: Uninstall shortcut is no longer pinned to the start screen by the installer (but it won’t unpin any shortcuts that were previously pinned).

Bug fixes:

GREP: Trying to open a RegexBuddy GREP file sometimes failed with a false error saying the file is not a valid RegexBuddy GREP file.
List All: Clicking the List All button makes RegexBuddy forget which capturing group you had it list matches for.
Test: Debug Here and Debug Till End triggered an “invalid class typecast” error if the test subject editor was in hexadecimal mode.
Test: If a regular expression contained an inverted range with a \xFF escape and the active flavor does not support inverted ranges then RegexBuddy would continue to complain about the inverted range even after you corrected the regular expression.
Test: Regular expressions with character classes with just a single NULL byte (e.g. [\x00] or [^\x00]) caused RegexBuddy to behave incorrectly.
Windows 8: Toolbar combo boxes did not properly display their drop-down arrows.

RegexBuddy 3.5.5 – 22 March 2012

Improvements:

Test: Update Automatically is preserved between RegexBuddy sessions even when not preserving test data.
Test: Update Automatically switches to the last used Match/Replace/Split testing command when switching between Match/Replace/Split modes.

Bug fixes:

GREP: If the regex consisted of nothing but a case sensitivity modifier and literal text such as (?i)sometext then the case sensitivity modifier was ignored.
Installer: The default folder for portable installations created via the installation program was “RegexBuddy 3” with a space before the number. This caused portable installs of PowerGREP, EditPad Pro, and RegexMagic on the same device to fail to locate RegexBuddy when you tried to invoke RegexBuddy from these products.
Paste: PHP preg strings with regular expressions containing doubly escaped forward slashes that are also delimited with forward slashes were not pasted correctly.
Use: \‘ was translated into \A instead of a literal ‘ when the source flavor does not support \‘ to match the start of a string.

RegexBuddy 3.5.4 – 4 November 2011

Improvement:

Installer: Create portable installation without admin rights.

Bug fixes:

Copy/Use: The regex \\n (literal backslash and literal n) was not converted properly when coping C-style or Java strings or generating C or Java code snippets.
Preferences: Line numbers were always shown or hidden in the test results depending on the line number setting for the test subject, even when the test results are for a test command that ignores the line number setting.

RegexBuddy 3.5.3 – 22 June 2011

Bug fix:

Create Portable Installation item in the Help menu was broken in 3.5.2.

RegexBuddy 3.5.2 – 17 June 2011

Improvements:

GREP: Edit with EditPad command now works with EditPad Lite 7 and EditPad Pro 7. It still works with EditPad Pro 4, 5, and 6 too and gives preference to these versions if you use them alongside EditPad Lite or Pro 7.
GREP: Loading a grep action should add the regex to the History panel rather than overwrite the current item (unless the current item has no regex).

Bug fixes:

Flavors: Python does not support \e.
Flavors: Python matches \Z at the end of the string only. Python does not allow \Z to match before the final line break like in most other regex flavors.
Flavors: XML Schema and XPath do not support \a, \e, \f, and \v.
Keyboard: Pressing Alt+F4 activated Split mode instead of exiting RegexBuddy.
Regex: In flavors that support Unicode, \w should match only decimal digits just like \d does. Letter numbers and other numbers should not be matched.
Test: \Q.*+?{}()[]|\ didn’t match the backslash in .*+?{}()[]|\ even though \Q.*+?{}()[]|\\E did and the Create tab correctly indicated both regexes should match the backslash.
Use: Replacement texts using the JGsoft flavor that control the case of backreferences now preserve the case control character when the target replacement text flavor is JGsoft, and show an error if another replacement text flavor is the target.

RegexBuddy 3.5.1 – 18 February 2011

Bug fixes:

Library: Double-clicking in the regular expression or test subject caused errors.
Test: The Split button sometimes caused RegexBuddy to crash (possibly later) if the scope was set to “line by line” or “page by page”.
Use: Code snippets to match the entire string incorrectly appended \z to free-spacing regexes that end with a comment.

RegexBuddy 3.5.0 – 3 September 2010

New features:

Use: C++Builder XE using the new RegularExpressions and RegularExpressionsCore units.
Use: Delphi XE using the new RegularExpressions and RegularExpressionsCore units.

Improvements:

Copy/Use: Visual Basic strings now use named constants such as vbCrLf instead of chr(13) & chr(10) for non-printable characters for which such constants exist.
JavaScript help topic should explain the full replacement text syntax.
Paste: Visual Basic strings now recognize character constants such as vbCrLf, ControlChars.CrLf, and Environment.Newline.

Bug fixes:

Flavors: PCRE, Python, Ruby, and Tcl don’t allow a space between a quantifier and the ? that makes the quantifier lazy in free-spacing mode. The JGsoft, .NET, Java, and Perl flavors allow this.
Insert Token: The Matched Text replacement text token now inserts \g<0> for Python instead of being disabled.
Test: Listing all matches or all matches of a group after listing all matches in columns did not restore the normal tab widths.
Test: Regexes that subtract negated character classes such as [^123-[7890]], [^123-[^456]], or [123456-[^456]]+ were not matched correctly.
Test: Regular expressions beginning with .* or .*? immediately followed by a group with two or more alternatives were not matched correctly if “dot matches newlines” was turned on.
Test: Test results are not shown correctly in hexadecimal mode.
Use: Converting a replacement text to Python from a flavor that supports $& or similar to represent the matched text now converts this into \g<0> instead of saying that Python does not have a token to represent the matched text.
Use: Source code snippets with RegexBuddy’s regex tree went blank when clicking the “dot matches newline”, “^$ match at line breaks”, and “free-spacing” buttons.
Use: String literal with regex tree added an erroneous | at the start of a group such as (a|b)+ that contains alternation and has a quantifier.
Use: VB 6 and VBscript functions for iterating over all matches did not set the myRegExp.Global = True which is required to be able to find more than one match.

RegexBuddy 3.4.2 – 11 March 2010

Improvements:

GREP: Portable installations of RegexBuddy now detect portable installs of PowerGREP on the same device if installed into the default folder.
GREP: PowerGREP button now launches PowerGREP 4 if available.
Library: Double-click a regex to use it.
Test: Literal line breaks in the regular expression (inserted by pressing enter, as opposed to using the regex tokens \r and \n) now match a line break in any style (Windows, UNIX, or Mac) rather than only a Windows-style line break. This makes it easier to test multi-line regular expressions against files that may not use Windows-style line breaks. The assumption is that in your actual application, the literal line breaks in your regular expression use the same line break style as the text you’re matching against.
Use: PowerShell code snippets using Select-String to grep.

Bug fixes:

Copy/Use: Delphi strings are now broken into pieces of at most 255 elements because the Delphi compiler does not support string literals with more than 255 elements.
Create: Literal line breaks in regular expressions were not indicated correctly.
Create: Repetition operators attached to conditionals were not shown.
Debug: The “Beginning match attempt at character” labels now indicate character positions as the label says instead of byte positions.
Flavors: XML Schema treats ^ and $ as literal characters; RegexBuddy incorrectly treated them as unsupported metacharacters.
Forum: Clicking on a header in the list of conversations or messages before connecting to the forum caused a harmless access violation error.
Library: Loading a regular expression from the library should not change the flavor selection when the flavor selection is locked by the application that invoked RegexBuddy but convert the regular expression instead.
Regex: The Latin-1Supplement Unicode block did not work.
Test: Nested infinite repetition of a single token was not handled correctly. a(?:b+)*c was interpreted as ab?c instead of as ab*c causing it to fail to match abbc when it should.
Test: Position of the splitter between the test subject and test results was not preserved properly between RegexBuddy sessions.
Toolbar combo boxes did not properly display their drop-down arrows on Windows 7.
Use: \w outside a character class was converted into [[:alnum:]] instead of [[:alnum:]_] if the target flavor supports POSIX but not shorthand character classes.
Use: Numbered backreferences to named capturing groups were not always adjusted correctly.
Use: PHP preg “search and replace through a string” now correctly passes the name of the callback function as a string.

RegexBuddy 3.4.1 – 16 October 2009

New feature:

Forum: Pressing Ctrl+C while the focus is on the list of conversations or the list of messages copies the URL of the selected conversation or message.

Bug fixes:

Flavors: PCRE does not support finite repetition inside lookbehind. PCRE only supports alternation of strings of different lengths. Previously, RegexBuddy allowed finite repetition for PCRE.
Flavors: Perl and Python allow alternation inside lookbehind if all the strings have the same length. Previously, RegexBuddy did not allow any alternation inside lookbehind for Perl and Python.
Insert Token, Character Class: Literal hyphens in character class ranges were not escaped.
Menu and toolbar icons were gray or black squares on Windows 98, ME, and 2000 (3.4.0 only).
Portable installations of RegexBuddy saved the test subject on the host PC instead of on the portable device when the option to preserve the test data was turned on in the Preferences.
Regex: POSIX equivalence classes for characters other than plain A to Z such as [[=à=]] were not parsed correctly.
RegexBuddy failed to close if it could not save its state (e.g. because it’s running from a write-protected device).
Test: Atomic groups as the first token inside a needless non-capturing group lost their “atomic” property causing RegexBuddy to find matches when it shouldn’t.
Test: Column headers in the test results aren’t displayed correctly when the default language for non-Unicode applications is set to Chinese.

RegexBuddy 3.4.0 – 5 August 2009

New feature:

Create: RegexMagic button to invoke RegexMagic to generate a regular expression or to insert a partial regular expression generated with RegexMagic. Requires RegexMagic 1.0.2 or later.

Improvements:

Create: When flagging \‘ and \’ in flavors that don’t support these as anchors, indicate how to match them as a literal character in addition to saying such anchors aren’t supported.
Paste: XML character entities such as 
 and 
 are now interpreted when pasting a regular expression or replacement text from XML.

Bug fixes:

Create: Negated character classes containing only a single hexadecimal escape \uFFFF or \xFF were not indicated as being negated in the regex tree.
Create: Subtracted character classes containing only a single shorthand were not indicated as being subtracted in the regex tree.
Flavors: GNU BRE regexes using \| for alternation were not converted correctly on the Use tab.
Forum: When detecting Internet Explorer proxy settings, RegexBuddy now correctly interprets proxy server settings that include an http:// protocol specification.
GREP: Backup drop-down list was not enabled when RegexBuddy started with preserved grep settings that create target files.
GREP: F9 showed the GREP drop-down menu instead of running a preview when RegexBuddy was in Replace mode.
GREP: The “single *.~*” backup naming style did not work, causing RegexBuddy not to update any files.
Regex: A contrived regular expression such as (?::?(?:(?:\#?)\s*(?:s)*)+) with groups nested multiple levels deep with everything inside the groups being optional caused RegexBuddy to crash.
Regex: Regexes that consisted solely of lookbehind statements failed with an access violation error.
Test: A regular expression that ends with a vertical bar did not find a zero-length match at each character position as it should.
Test: Find First would skip over a zero-width match at the start of the test subject, selecting the second match instead, or saying the regex can’t match if the initial zero-width match is the only match.
Test: RegexBuddy did not close immediately if the Test tab was still working on a regex that exhibits catastrophic backtracking.
Test: RegexBuddy incorrectly optimized a(?=(?:bc){10}) into a(?=bc){10} causing a in abc to match when it shouldn’t.
Test: The last match in the results of List All Matches with Full Details was not always displayed correctly.
Use: Many PowerShell source code snippets had $subject hardcoded instead of using the parameter name you provided.

RegexBuddy 3.3.0 – 8 April 2009

New features:

Copy/Paste: Delphi Prism strings. Delphi Prism supports double-quoted multi-line strings in addition to the traditional single-quoted single-line Delphi strings.
Copy/Paste: Groovy strings, which supports ‘string’, “string”, ‘“string’”, “”“string”“”, and /regex/
Forum: Links in the help file to start a conversation on a particular help topic, or to join an existing conversation on that topic.
Forum: RSS feeds for a all groups, one whole group, conversations the user participated in, conversations the user started, and individual conversations.
Replace: Insert ASCII character.
Replace: Insert non-printable characters \n, \t, \r.
Replace: Insert Unicode character.
Use: Delphi Prism source code snippets.
Use: Groovy source code snippets.

Improvements:

Create: The ASCII character and Unicode character items in the Insert Token menu are now also available for flavors that do not support ASCII and Unicode character escapes. For those flavors, literal characters are inserted.
Debug: If the cursor is at the end of the line, scrolling vertically should automatically scroll horizontally too to keep the ends of as many lines as possible visible.
Debug: Stricter catastrophic backtracking detection for the regex debugger than normally used by the regex engine in RegexBuddy and other Just Great Software products, to make sure it doesn’t run out of memory. Catastrophic backtracking causes excessive memory usage in the debugger, because the debugger has to keep track of all steps of the matching process. The normal regex engine uses very little memory, because it immediately discards backtracking positions that can no longer lead to a match.
Forum: Context menu with cut/copy/paste etc. for the box where you type in your message.
Forum: Messages are now shown with their original post date and last edited date, rather than just the last edited date.
History: Adjust the column widths each time a regex is added, deleted, moved, or renamed.
Test: Highlighting of regex matches is now updated instantly when editing the regular expression, instead of after a 2-second delay.
Test: Results should not scroll back to the top when they are automatically updated.
Test: Significantly improved the responsiveness of the Test tab when editing the test subject while highlighting and/or automatically updating the results of a complex regular expression.
Test: The message “The regular expression does not match the test subject” is now followed by the notice “Because you set the test scope to “line by line“, RegexBuddy will not find any regex matches that span across lines” if the test scope is set to “line by line”, and the regular expression includes tokens that can match line breaks.

Bug fixes:

Create: Regex tree nodes explaining a negated character class with a single token such as [^x] had a duplicate particle in their English sentences.
GREP: Opening a .rbg file created with RegexBuddy 2.x caused RegexBuddy 3 to claim the file is not a RegexBuddy GREP file. RegexBuddy 3 can open Library and GREP files saved by RegexBuddy 2. RegexBuddy 2 will not be able to open those files again after you’ve modified them with RegexBuddy 3.
GREP: Settings on the GREP tab were not preserved, even when that option was turned on in the Preferences (3.2.1 only).
Paste: Paired regex delimiters (), {}, [], and <> were not handled correctly when pasting a PHP preg string.
Paste: When pasting a Perl operators using flags other than /ismx RegexBuddy ignored all flags after the first flag that is not one of /ismx.
Regex: In certain specific situations where a regex used the same shorthand character class twice with a flavor that only includes ASCII characters in the shorthand, RegexBuddy did not backtrack the shorthands correctly.
Regex: Optional tokens at the end of a group nested inside another group were not backtracked correctly. E.g. ((\d{2,5}\s?){2,})\b matches 087 33 instead of 087 33 77 in 087 33 77 (notice the extra space at the end of the subject).
Test: [\W] (non-word-characters inside a character class) matched a few letters with regex flavors where \w includes only ASCII characters, if you turned on the case insensitive option.
Test: [\x41-\x5A] did not match lowercase letters and [\x61-\x7A] did not match uppercase letters when used in a character class with the case insensitivity option turned on.
Test: Regular expressions that start with a lookbehind and have capturing groups sometimes showed “ghost” matches for capturing groups that did not participate in the regex match.
Use: Escaped spaces and hash symbols in free-spacing regular expressions lost their backslashes.
Use: Regular expressions using Unicode properties \p{} were not properly converted to the Java flavor.

RegexBuddy 3.2.1 – 9 December 2008

Improvements:

Create: Exporting to HTML no longer results in an HTML page with a needless scroll bar.
Create: The fact that \_ is an error in the .NET regex flavor is now indicated with a specific error message rather than a generic “invalid token” error message.
Create: When flagging \< and \> in flavors that don’t support these as word boundaries, indicate how to match them as a literal character in addition to saying such word boundaries aren’t supported.
Debug: The Debug tab now shows an explanation instead of only white space when the regex debugger hasn’t been used yet.
Library: Use the label the regex has in the History list as the default description when adding a regex to the Library.
Portable installation: Lists of files previously opened files should survive changing drive letters.
Use: When converting a regex to Perl, always escape $ signs in character classes to prevent unintended variable interpolation in Perl. Perl tries to be clever about interpreting $ signs in regular expressions. Depending on where a $ occurs, it will be treated as the start of a variable name, or as the regex anchor $. An escaped $ is always treated as a literal $. Therefore, RegexBuddy can’t just escape all $ signs when formatting a regex as a Perl m// operator. Escaping $ signs in character classes when converting the regex to the Perl flavor works around this limitation.

Bug fixes:

Copy: Basic-style strings missed the _ line continuator when RegexBuddy converted a multi-line free-spacing regular expression into a concatenation of multiple strings.
Create: [\}] is indicated as matching U+0000 rather than a literal }.
Create: XML character class subtraction immediately after a hyphen was not handled correctly. The JGsoft flavor treats the first hyphen in [a--[x]] as a literal. The .NET and XML flavors treat the first hyphen as an error, because the range is incomplete.
Debug: Clicking on the white space in the debug tab before actually debugging the regex caused a harmless access violation.
Flavors: Backslashes were not properly treated as literal characters with the .NET and JavaScript replacement text flavors.
Flavors: Python does not support \0 to insert the whole regex match into the replacement text, but does support \g<0>. RegexBuddy did correctly support \g<0> in the regex and on the Test tab, but did not convert \0 or $0 into \g<0> on the Use tab when generating a Python source code snippet from a regex in another flavor.
Paste: Pasting a regex in free-spacing mode that is a concatenation of multiple string in a string format that doesn’t support multi-line strings did not properly interpret the line break characters in the string that are added to the string by the Copy command (as of 3.2.0).
Regex: An character class with two subtracted classes such as [x-[x]-[x]] caused RegexBuddy to get stuck on access violations if the current flavor supports character class subtraction (JGsoft, .NET, XML Schema, and XPath). The second subtraction is now correctly marked as an error for these flavors.
Test: \r, \n and \t did not work in character classes if the flavor was set to Tcl or one of the POSIX or GNU flavors. E.g. the regex a[\r\n]*b did not match a and b when separated by a line break.
Test: Listing the results for a capturing group, turning on automatic update, and then removing the capturing group from the regex, caused an error.
Test: The POSIX classes [[:space:]] and [[:blank:]] did not match tab characters.
Use: Regular expressions using XML or .NET character class subtraction lost the -[ characters that begin the character class subtraction.
Vista: RegexBuddy would lock up under Windows Vista if you edited the regular expression while the last List All/Replace/Split command on the Test tab was still running.

RegexBuddy 3.2.0 – 4 October 2008

New features:

Copy/Paste: JavaScript string in addition to JavaScript operator. You can use this to insert your regular expressions as literal strings into your JavaScript code or in a JSON data file. The R language uses the same string syntax as JavaScript.
Copy/Paste: PowerShell String. Supports single-quoted and double-quoted strings and here strings.
Flavors: R language replacement text flavor. This is now the default replacement flavor for the GNU ERE and GNU BRE regex flavors, and an additional replacement text flavor available for the PCRE regex flavor.
History: Drag-and-drop to rearrange items or to move items between multiple instances of RegexBuddy.
Library: Examples to validate all XML Schema basic data types, using the XML Schema regex flavor.
Use: PowerShell. Uses the .NET flavor.
Use: R language. Uses GNU ERE (default in R), GNU BRE and PCRE (used by RegexBuddy code snippets) flavors.

Improvements:

Debug: After pressing the End key on the keyboard, moving the cursor up and down will also move it horizontally to keep it at the end of the match attempt you moved it to.
Debug: Indicate the number of steps on the line that says “match attempt failed” or “match found” to make the number visible when the steps are collapsed.
Debug: Warn if the match attempt failed because the debugger stopped at the end of a line or page due to the matching scope.
Flavors: The JGsoft flavor now supports \p{Alpha} like Java, and \p{IsAlpha} like Perl.
GREP: Keyboard mnemonics (underlined letters) for the default items in the Edit File submenu.
GREP: Regular expressions beginning with a lookbehind that contains a capturing group to which there are no backreferences where executed much slower than the same regex with a non-capturing group in the lookbehind. Now they will run at the same speed.
Regex: The limit at which RegexBuddy’s regex engine aborts a match attempt because the regex is too complex (catastrophic backtracking) now adapts to the length of the match. Catastrophic backtracking detection previously aborted a regex like ^.*?(a+|d{7}) if the match to be found was very large (500,000 or more characters). This regex does do a serious amount of backtracking, because the lazy dot is followed by a complex group. However, all that backtracking is linear, not at all catastrophic.
Test: If the testing mode is “line by line” and “dot matches newline” is turned on, automatically change the testing mode to “whole subject”.
Test: Results for the “search-and-replace all matches” test now use the line numbering settings from the preferences. Test results for other actions will show or hide the line numbers as appropriate for the way they display their results, regardless of the line numbering setting in the preferences.
Test: Set default encoding to UTF-16 instead of UTF-8, to avoid issues with match positions and lengths being reported as bytes rather than as characters.

Bug fixes:

Copy/Paste: Basic-style strings now correctly preserve free-spacing regular expressions.
Copy/Paste: Character sequences that trigger variable interpolation in Ruby strings were not escaped.
Create: Double-clicking on a node indicating that the flavor does not support \p{L&} did not replace it with [\p{Lu}\p{Ll}\p{Lt}] if the flavor does support Unicode properties, but not Perl’s L& invention.
Debug: If a simple token (i.e. not a group) matched one or more characters but ultimately failed to match the minimum required repetitions, the debugger would drop as many characters matched by previous tokens from the ongoing match as the failed token matched (3.1.x). E.g. debug aaa(b{7,})?bbbccc on aaabbbccc.
Debug: Moving the cursor over a “backtrack” indicator did not highlight the regex token that was backtracked (3.1.x only).
Debug: Pressing End when the cursor is on a line with just one item saying “backtrack” caused a harmless “list index of out bounds” error (3.1.x only).
Debug: Running the debugger again after moving the cursor down in debug results with multiple attempts caused RegexBuddy to hang (3.1.x only).
Flavors: In Java source code snippets, a literal [ in character classes should be escaped.
Flavors: Perl supports the \p{IsAlpha} notation for POSIX character classes, similar to Java’s support for \p{Alpha}.
Flavors: Python always skips zero-width matches if they occur at the same position where a previous match ended. The JGsoft flavor does the same, while other flavors only do so if the previous match is also zero-width.
Flavors: Python does not support \0 in the replacement text to reinsert the overall regex match.
Flavors: Python, Tcl and XPath support double-digit backreferences, but not forward references. For these flavors, RegexBuddy checked for forward references using only the first digit of two-digit backreferences. ((((((((((x)))))))))\10) caused an error that \1 references an unclosed group, while actually \10 is a valid backreference.
Flavors: RegexBuddy would lock up on a regular expression like (a(b)c\2)d that has a backreference inside a capturing group when a flavor that does not allow backreferences to unclosed capturing groups as in (a(b)c\1)d was selected (3.1.x only).
GREP: Pressing F9 executed the grep regardless of which panel was active. But it did not bring the GREP panel to the front.
GREP: RegexBuddy did not correctly grep regular expressions that contained only literal text and one or more \uFFFF code points above \u007F.
Insert Token, Unicode Properties: The Unicode properties were not always inserted correctly when “letter with case” was selected.
Paste: Pasting a JavaScript or Ruby // operator left the leading / delimiter as part of the regular expression.
Paste: RegexBuddy did not properly handle the flags after the regex when pasting a string with a PHP preg operator.
Preferences, Appearance: Line numbering was not restored when starting RegexBuddy again.
Test: “List All Group Matches in Columns” did not always correctly build the results if the test subject was very large.
Test: $ and \Z failed to match at the end of the test subject if they occurred at the start of a non-alternated regular expression, and the test subject did not end with a line break.
Test: A backreference would match if part of the text held by the backreference occurred and the very end of the test subject, and case insensitivity was turned on.
Test: Atomic groups containing a single token were optimized incorrectly, making the group non-atomic. 0\.\d{2}(?>[1-9]?)(\d+) should not match 0.234.
Test: Double-clicking in the test results when there were no highlighted matches in the results caused a harmless access violation error.
Test: RegexBuddy would fail to find zero-width matches if the regular expressions used alternation with one of the alternatives making everything optional. E.g. a+|b* would find all aaa and bbb correctly, but skipped over all zero-width matches allowed by the b* alternative.
Test: Regular expressions that started with a lookbehind and used alternation outside any groups did not work correctly, e.g.: (?<=ab)c|(?<=de)f.
Use, Copy: \n, \r and \t must be escaped if they are used in a free-spacing regular expressin and the programming language supports these at the string level. In free-spacing mode, \n at the string level is interpreted as whitespace to be ignored, while \n at the regex level is a token to be matched.
Use: “String literal with RegexBuddy’s regex tree” was not generated correctly when the language was set to Java and free-spacing mode was on.
Use: In free-spacing mode, escaped spaces lost their backslashes, turning them from literal spaces into ignored spaces.
Use: Multi-line free-spacing regexes are converted into a concatenation of multiple strings for languages that don’t support multi-line strings. The line break characters were left out, causing a comment on one line to comment out the remainder of the regex.
Use: The .NET-specific syntax for a conditional using lookahead, i.e. (?(if)then|else) instead of (?(?=if)then|else) caused RegexBuddy to drop the last closing parentheses from the regex and show an error about a missing opening bracket.

RegexBuddy 3.1.1 – 3 April 2008

New features:

Command line: -flavor and -flavorreplace to set the regular expression and replacement text flavors.
Setup: Create Portable Installation directly from the self-extracting setup. The Install on Removable Drive menu item in the Help menu was renamed for consistency.
Use: PHP code snippet using preg_replace_callback().
Use: wxWidgets C++ source code snippets.

Improvements:

Create: Export to HTML now resizes the tree to make it fit the browser window.
Forum: When attaching/downloading a test subject, also set the test scope. The file type will now say “RegexBuddy test subject” instead of “Text file” for attachments with scope information. “Text file” attachments can still be opened. RegexBuddy 3.1.0 and prior will not know how to handle “RegexBuddy test subject” attachments. They will indicate them as “Unknown”.
Test: Preserve the status of the “update automatically” setting when the option to preserve the test subject is turned on in the preferences. The command last used is not remembered, so you still need to select a command like List All for automatic updating to begin.
Use: Backslashes that needlessly escape literal characters such as % are now automatically stripped from the regular expression in the source code snippet.

Bug fixes:

Copy/Use: If a regular expression contained an escaped forward slash, RegexBuddy escaped the backslash when formatting the regex as a JavaScript or Ruby // operator.
Create: \ca through \cz (lowercase) were explained as matching characters 33 to 58 instead of 1 to 26. RegexBuddy did match these correctly on the Test tab.
Create: A quantifier on a capturing group inside lookbehind was not marked as an error for flavors that do not support (infinite) repetition inside lookbehind. (?<=(.)*) should show the same error on the Create tab as (?<=.*) for flavors like Java
Create: Export to HTML now properly formats free-spacing regular expressions.
Create: The Alternation item in the Insert Token menu was disabled for the GNU BRE flavor, which supports alternation through \|.
Flavors: For Perl and Python, which only support fixed-length lookbehind, RegexBuddy now treats alternation inside lookbehind as an error, like Perl and Python do.
Flavors: Python and PCRE do not allow two named capturing groups to use the same name, unlike the .NET and JGsoft flavors. RegexBuddy now emulates this restriction for Python and PCRE.
Flavors: RegexBuddy did not emulate the fact that the .NET engine treats \_ as an error. Most regex flavors treat escaped letters that don’t form a metacharacter as an error, but treat an escaped underscore as a literal. The .NET flavor treats the underscore like a letter.
Flavors: RegexBuddy required all literal hyphens inside character classes to be escaped for flavors that treat [\d-z] as an error (since 3.0.4). This was overly restrictive. E.g. [---] is still valid with these flavors.
GREP: In Match mode, when the target option was set to save results, search terms would appear duplicated in RegexBuddy (but only once in the actual file).
Library: Don’t delete test results when clicking on another regex in the library.
Library: Using the test subject from a library regex did not properly set the test scope stored in the library on the Test tab.
Regex: \X to match a Unicode grapheme was not backtracked properly, causing a regex like \X+a to fail on graphemes consisting of more than one Unicode code point. This could only happen on Unicode files that use combining marks, which is rare.
Regex: A regex that started with a lookbehind immediately followed by an infinitely repeated dot would fail to match on the Test tab if “dot matches newlines” is on.
Regex: Conditionals referencing a capturing group defined after the conditional and without a “then” part did not work correctly (new feature in 3.1.0).
Regex: Mode modifiers using the (?i) syntax did not work correctly inside lookaround.
Regex: RegexBuddy’s regex engine did not detect catastrophic backtracking when the regex (a|aa)+b is applied to a long string of a characters.
Test: A character class range between the same character like [a-a] was marked as an inverted range. Though [a-a] makes no sense, it is valid and equivalent to [a].
Test: If a regex started with consecutive literal characters, like bbc or b{2}c, RegexBuddy would match them incorrectly if the test subject used a character encoding that uses a variable number of bytes per character (like UTF-8 or DBCS).
Test: List All Group Matches in Columns did not indicate named capturing groups in the header.
Test: RegexBuddy would sometimes lock up when editing the test subject while a “list all” or similar command was still busy with the test subject.
Test: Testing a regex with an empty alternative like one||three caused an error about an empty alternative. Though empty alternatives don’t make sense, they’re not an error. The Create tab and syntax highlighting will still show a warning.
Use: When converting quantifiers using curly braces inside lookaround and checking support for variable and infinite repetition, RegexBuddy treated variable quantifiers like {1,3} as infinite like {3,} and vice versa.

RegexBuddy 3.1.0 – 20 December 2007

New features:

Copy/Use: Java string type, which differs from the C-style string type previously used for Java in that it will not put a \ in front of Unicode escapes \uFFFF.
Copy/Use: JavaScript string type, which differs from the C-style string type previously used for JavaScript in that it will not put a \ in front of Unicode escapes \uFFFF and Latin-1 escapes \xFF.
Create: Export to clipboard.
Flavors: GNU BRE and GNU ERE. These flavors are used by the GNU implementations of grep, egrep, sed, awk, etc. which use POSIX BRE/ERE with a few extensions.
Flavors: The “XPath” flavor is the regex flavor defined in the “XQuery 1.0 & XPath 2.0 Function and Operators” standard. It is used in XSLT 2.0 too.
Flavors: VBScript replacement text flavor to go along with the JavaScript regex flavor. JavaScript supports \xFF and \uFFFF in string literals, but VBScript does not.
Forum: Use .rba file extension instead of .xml for regular expressions so they can be saved to file and opened directly into RegexBuddy.
Insert Token: Easy way to insert mode modifiers. These can be used then the global options aren’t available, such as when editing a list of regular expressions for PowerGREP.
Insert Token: POSIX classes.
Regex: Forward references (i.e. a backreference to a group defined after it) are now supported. E.g. (\2two|(one))+ will match oneonetwo instead of triggering an error when a flavor that supports forward references is selected.
Replace: Support Unicode escapes like \uFFFF and \x{FFFF} in the replacement text syntax for those languages that apply such processing to literal strings in code, similar to \r and \n which RegexBuddy already handles.
Replace: Support hexadecimal escapes like \xFF in the replacement text for flavors that support it, and for languages that do this as part of their string processing.
Test: Item under the paste button and on the right-click menu of the results to use the test result as the new test subject.
Test: Option at the bottom of the List All and Replace buttons to automatically update the results of the operation when the test subject or regex change. When this option is off, the results will be automatically cleared, so you won’t be confused by old results.
Test: Option at the bottom of the List All button to show n/a for groups that did not participate in the match at all, rather than showing nothing. This helps differentiate with groups that did participate but didn’t capture.
Test: Save button drop-down menu with an option to save the test results to a file.

Improvements:

Copy/Use: In free-spacing mode, convert a multi-line regex into concatenated strings on multiple lines for C, Java, JavaScript and Pascal (which don’t support multi-line strings).
Copy/Use: Literal tabs and line breaks in the regular expression are no longer converted into \t\r\n for Perl, PHP/preg and Ruby regex operators, as these can span multiple lines.
Copy/Use: \xFF character escapes are now supported in Python strings.
Create: Highlight backreferences to undefined capturing groups as errors.
Create: Highlight forward references to capturing groups as errors for flavors that don’t support them.
Debug: Ctrl+Arrow Left and Ctrl+Arrow Right now jump to the previous/next regex token’s match. (Matches from different tokens are highlighted in alternating shades of blue.)
Debug: Ctrl+Arrow Up and Ctrl+Arrow Down now jump to the previous/next match attempt. (The debugger will only try multiple attempts if you use Debug Till End or Debug Everywhere.)
Debug: Moving the cursor through the debugger output now automatically selects the corresponding regex token (which also moves the highlight in the debugger), without having to double-click in the debugger.
Debug: Moving the cursor through the debugger output selects the part of the regex match the cursor points to in the debugger on the Test tab. You’ll have to arrange the Test and Debug tabs side by side to benefit from this.
Debug: Pressing + or - on the keyboard will now fold and unfold match attempts.
Debug: The debug display’s internal mechanism was redesigned from scratch. The visible portion of the display is now built on-the-fly, resulting in a dramatic reduction of memory usage.
Debug: The debugger’s limitation of 100,000 steps now only kicks in between match attempt when using Debug till End or Debug Everywhere. Single match attempts will now display all steps that the regex engine attempted. The regex engine’s internal backtracking limitations still apply. However, these are far higher than the 100,000 steps debug limit.
Debug: The header indicating the start of the match and the footer indicating success or failure for each match attempt now stay put against the left margin when scrolling the debugger horizontally.
Debug: The left margin now displays match attempt and match step numbers instead of debugger line numbers. This makes it easy to count the steps when using Debug till End or Debug Everywhere.
Forum: Searching the forum no longer filters out messages that are being composed, so you can search without losing track of what you’re writing.
History: Clearing the history no longer changes the regular expression flavor back to JGsoft.
Test: Match highlighting is now updated much faster when typing at the end of the test subject when the scope is set to “line by line” or “page by page”.
Use: Multi-line regular expressions and replacements are now placed on separate lines and indented (as long as the extra whitespace is ignored).
Use: Numbered backreferences are now properly renumbered if needed (e.g. if .NET named groups and numbered groups are mixed and the target flavor does not support .NET named capture).
View: Changing layouts is now faster, with much less flickering.
View: Changing layouts now makes all toolbars visible again.

Bug fixes:

C# code snippet “Use regex object to replace all matches in a string” incorrectly specified the matching options.
Copy/Use: If the replacement text contained non-printables like \r\n\t, copying or using the replacement as a PostgreSQL stirng resulted in an empty string being copied or inserted.
Create: A literal hyphen at the end of a character class was incorrectly highlighted as an error for some regex flavors (3.0.5 only). The Test tab did handle these correctly.
Create: A quantifier separated from its token by a comment was marked as an error. The Test tab did correctly ignore the comment and apply the quantifier to the preceding actual token.
Create: Java-style negated POSIX classes like \P{Digit} are now correctly indicated as being negated in the regex tree.
Create: The regex tree stripped off the last character of unclosed comments. It was marked as the closing bracket in the regex highlighting.
Flavors: Backreferences were handled incorrectly on the Test tab when the POSIX BRE flavor was selected. The regex $a$\1 would match aa1 instead of aa.
Flavors: Java strips unescaped backslashes from the replacement text; RegexBuddy did not do this on the test tab when the Java flavor is selected.
Flavors: JavaScript and Ruby allow backreferences to non-existent groups. These always result in a zero-width match. While RegexBuddy simulates the JavaScript and Ruby behavior on the Test tab, it will still highlight these as an error on the Create tab, as referencing a non-existent group is pointless.
Flavors: POSIX BRE uses $ and $ for capturing groups. RegexBuddy’s regex syntax highlighting highlighted ( and \) rather than $ and $.
Flavors: REALbasic strips unescaped backslashes from the replacement text (RegexBuddy left them as literals with the REALbasic flavor selected).
Flavors: REALbasic’s treatment of unescaped dollar signs that aren’t part of a valid replacement text token seems to be erratic. RegexBuddy will now flag them as errors.
Flavors: Tcl does not support \z.
Flavors: The JGsoft flavor always skips zero-width matches at the same position where a previous match ended, while other flavors only do so if the previous match is also zero-width. RegexBuddy now correctly emulates the other flavors. Replacing \d* with x in 123rn456rn789 yields xrxnxrxnx with the JGsoft flavor and xxrxnxxrxnxx with other flavors.
Flavors: The POSIX BRE flavor treats the syntax for lookbehind and named capture in other flavors as literal text rather than as an error.
Forum: The Source Code Templates submenu under the Add Attachments button never listed any templates to attach; it should list all custom-created templates.
GREP: If RegexBuddy was in Match mode, and you previously entered a replacement text in Replace mode, a grep action to save matches into a file would save the replacement text rather than the search match.
GREP: Setting the target to save results to file and then specifying an invalid target file caused an access violation. Now, the GREP command will be disabled until you type in a valid path or choose not to save the results.
History: Switching between two regular expressions that are identical other than the selected flavor does not cause the highlighting to be updated.
Integration: Clicking the Send button when the regular expression is blank caused an access violation when no library is opened.
Regex: A lookaround inside a capturing group at the very start of the regex caused RegexBuddy to crash (3.0.x only).
Test: Unclosed (?#…) comments did not trigger an error.
Use: Comments were not stripped from the regex if the original flavor selected in the main toolbar supports comments, but the target flavor on the Use tab doesn’t.
Use: If the source flavor was POSIX BRE, which treats ( and ) as literal characters, and the target flavor uses ( and ) for grouping, then a literal ) was dropped from the regex instead of being converted into \).
Use: Perl and Ruby syntax highlighting now supports regular expressions that span multiple lines.

RegexBuddy 3.0.5 – 24 September 2007

Bug fixes:

Contents of various panels are invisible until RegexBuddy is resized or a splitter between the panels is moved (3.0.4 only).
Create: For regular expressions using the POSIX BRE flavor, backreferences like \1 were followed by an extraneous literal text node in the Create tree.
Flavors: Octal escapes are not supported by JavaScript regular expressions according to the ECMA-262 standard for JavaScript. Though most browsers do support them, RegexBuddy will now flag octal escapes as unsupported by JavaScript. On the Use tab, octal escapes will be converted into hexadecimal ones. E.g. \0377 becomes \xFF.
Flavors: RegexBuddy did not always treat backslashes inside POSIX bracket expressions as literal characters.
Forum: Deleting the message in an unposted (i.e. new) conversation left behind an empty conversation that had to be deleted separately.
GREP: Right-clicking on a highlighted match and selecting an external editor to open file file causes a View/Preferences/Help popup menu to appear that cannot be dismissed (3.0.4 only).
Regex: Conditionals without a “then” part like (?(1)|else) or even (?(1)) were not handled properly on the Test tab. (?(1)|else) finds a zero-width match if the capturing group participated in the match, or tries to match “else” otherwise. (?(1)) acts like an assertion that matches if the capturing group participated in the match.
Regex: The change in version 3.0.4 to allow free spacing in character classes for the Java flavor caused the character class [ ] that should match a single space in free-spacing mode in all other flavors to treat the closing bracket as a literal character.
Test: Using the List All/Replace All/Split commands with a regular expression that has capturing groups on a very long test subject while match highlighting is turned on sometimes caused RegexBuddy to crash.
Use: When generating Perl code snippets, named capturing groups in the regular expression (written for a flavor other than Perl) are now converted into numbered capturing groups. Perl 5.8 does not support named capture.

RegexBuddy 3.0.4 – 4 September 2007

New feature:

Test: Line Break submenu in the right-click menu of the test subject with items that indicate the line break style being used and that can change the line break style.

Improvements:

Create: The regex tree now warns that if you put a quantifier directly after a \Q…\E sequence, only the last character is repeated.
Create: Warn about empty alternatives at the end of a group or regex.
Create: When exporting the regex tree into a text file, RegexBuddy now uses UTF-8 rather than the default Windows code page to save the text file. (When exporting to HTML, RegexBuddy already used UTF-8.)
Forum: Option to receive email notifications for all posts, regardless of participation.
Library: The regular expression flavor for the selected library regex is now indicated along with the matching modes above the regular expression.
Test: Significantly reduced memory usage when highlighting very large numbers of regex matches and/or very long regex matches.

Bug fixes:

Create: Character class ranges that had either or both ends specified with an octal escape were often erroneously marked as being reversed.
Create: Java syntax for POSIX-alike character classes like \p{Alpha} was not handled properly in the regex tree if it was used outside a character class. (Real POSIX classes like [:alpha:] can only appear inside a bracket expression, e.g. [[:alpha:]]. In Java, [\p{Alpha}] and \p{Alpha} are equivalent.) RegexBuddy treated the token as being inside a character class, resulting in character class syntax coloring and errors when quantifiers were used.
Create: Octal escapes were not indicated with an error in the regex tree if a regex flavor that doesn’t support them was selected.
Create: The regex tree indicated [\d-c] as a range consisting of the shorthand \d and the literal “c” rather than a shorthand \d and two literals “-” and “c” as this is actually interpreted.
Create: The regex tree now correctly indicates that the .NET flavor does not support \Q…\E sequences.
Create: \B inside a character class was not indicated with an error in the regex tree if the regex flavor wasn’t Tcl ARE.
Flavors: .NET allows (?(?=conditional)yes|no) to be written as (?(conditional)yes|no).
Flavors: Backreferences in the JavaScript regex flavor match an empty string if the referenced capturing group didn’t participate in the match attempt (instead of failing to match like most other regex flavors).
Flavors: Java ignores whitespace and comments in character classes in free-spacing mode.
Flavors: Most flavors treat [\d-c] and/or [c-\d] as a syntax error instead of treating the - as a literal like the JGsoft and PCRE flavors. RegexBuddy now emulates this.
Flavors: Shorthand character classes \d, \w and \s now adapt to the selected regex flavor; i.e. some flavors include Unicode characters, while others don’t.
Flavors: Word boundary tokens now adapt to the selected regex flavor; some flavors use Unicode properties while other flavors use strictly a-z0-9_ to detect word boundaries.
Forum: When RegexBuddy was launched from EditPad or PowerGREP, you accessed the forums, then closed RegexBuddy and launched it again from the same EditPad or PowerGREP instance, trying to use the forum would cause access violation errors.
GREP: Clicking the PowerGREP button caused PowerGREP to open with the regular expression from RegexBuddy, but also display an error about an incorrect command line parameter.
Library: Hyphens forming character class ranges were highlighted in red (3.0.3 only).
Regex: RegexBuddy now correctly emulates the Perl and PCRE behavior of only repeating the last character in a \Q…\E sequence if you put a quantifier directly after the \E.
Regex: Typing in a character class containing \s (resulting in an unclosed character class with \s during typing) with the Highlight button turned on would cause \s and \S to fail to match properly for the rest of the RegexBuddy session (3.0.x only).
Regex: When “^$ match at line breaks is” is turned on, an unalternated ^ at the start of the regex would match at the start of the match attempt instead of after the line break if the line break after the match attempt was a sole \r (Mac-style line break).
RegexBuddy would fail to start with an access violation if the history of regular expressions could not be read from the registry.
Test: Closing RegexBuddy while the Test pane was still highlighting matches in the background caused RegexBuddy to crash.
Test: Find Next would stay stuck at the second match when highlighting was off (3.0.3 only).
Test: Switching between text and hexadecimal mode did not properly redraw the text or keep the cursor at the same character position.
Test: Switching from hexadecimal to text mode caused an access violation if the test subject was longer than 64K.

RegexBuddy 2.4.3 – 4 September 2007

Improvement:

Test: Significantly reduced memory usage when highlighting very large numbers of regex matches and/or very long regex matches.

Bug fixes:

Create: Character class ranges were not indicated correctly (2.4.2 only).
Regex: Typing in a character class containing \s (resulting in an unclosed character class with \s during typing) with the Highlight button turned on would cause \s and \S to fail to match properly for the rest of the RegexBuddy session (2.4.x only).
Regex: When “^$ match at line breaks is” is turned on, an unalternated ^ at the start of the regex would match at the start of the match attempt instead of after the line break if the line break after the match attempt was a sole \r (Mac-style line break).

RegexBuddy 3.0.3 – 18 July 2007

New feature:

Replacement: Insert Token item in the right-click menu of the box for entering the replacement text, with commands to insert literal text, backreferences, and match context. This feature was mistakenly omitted from version 3.0.0.

Improvement:

GREP: If any errors occur, display a second results box with the error messages just like PowerGREP does.

Bug fixes:

Command line: The -getfromclipboard command line parameter caused a history item to be duplicated when the option to preserve the history was turned on.
Flavors: Lookbehind is limited to fixed-length strings in Perl and Python, rather than to finite-length strings like Java and PCRE.
Flavors: RegexBuddy allowed character class ranges to be specified in reverse order, e.g. [z-a] instead of [a-z], even though most regex flavors don’t allow this.
Forum: Proxy settings were not saved unless a change was made to RegexBuddy’s preferences after changing the proxy settings.
GREP: Target drop-down list was not updated when changing the mode between Match and Replace.
Regex: ((?:abc)+) was optimized into (abc)+ which is not the same (the former captures all iterations; the latter only the last one) (3.0.x only).
Regex: In free-spacing mode, RegexBuddy did not allow whitespace between a quantifier and the ? or + that follows it to make the quantifier lazy or possessive.
Regex: In free-spacing mode, RegexBuddy did not properly handle space between a token and quantifiers using the curly braces syntax.
Regex: Octal escapes inside character classes caused an access violation.
Test: The Find First, Find Next (when highlighting is off), List All and Split buttons would highlight the characters in the replacement text rather than in the regular expression, or show an error that it could not activate an invisible window.
Use: Editing or downloading templates sometimes got RegexBuddy stuck on “list index out of bounds” errors.
Use: The | operator was missing from the “string literal with RegexBuddy’s regex tree” code snippets.

RegexBuddy 2.4.2 – 18 July 2007

Bug fixes:

Debug: Debugging a regular expression with a single token in a capturing group like (.*) caused an access violation (2.4.x only).
Regex: ((?:abc)+) was optimized into (abc)+ which is not the same (the former captures all iterations; the latter only the last one) (2.4.x only).
Regex: Octal escapes inside character classes caused an access violation.

RegexBuddy 3.0.2 – 1 July 2007

RegexBuddy 3.0.0 and 3.0.1 stopped working on July 1st, because we stupidly forgot to remove the timeout from the beta test. Beta test versions will stop working on a certain date, but release versions will work forever. Version 3.0.2 will never expire.

RegexBuddy 3.0.1 – 29 June 2007

Improvements:

Forum: Remember the forum that was last accessed.
Forum: The message filter box now advertises itself with a “search here” label.

Bug fixes:

Debug: The debugger now takes the scope setting on the Test tab into account.
Forum: Attachments disappeared from the interface (but not from the actual forum) upon editing a message.
Preferences, Editor: Selecting a font for the Create tree had no effect.
Regex: Capturing groups inside negative lookaround did not work. This also caused the debugger to fail on regexes with negative lookaround. (Versions 2.4.0 and 3.0.0 only)
Regex: Certain cases of catastrophic backtracking were not detected, causing RegexBuddy to keep on trying the regex far too long. This occurred in versions 3.0.0 and 2.4.0 only. We did intentionally relax RegexBuddy’s catastrophic backtracking detection to allow more complicated and/or very long matches to succeed. This fix does not change that.
Template Editor: Help toolbar button didn’t do anything.
Test: After turning on the Highlight button, the highlighting sometimes would not appear until you edited the regular expression (3.0.0 only).
Test: Highlighting did not disappear when the regular expression became invalid (3.0.0 only).
Test: RegexBuddy did not allow the test subject to be edited after you opened a file that has its read only attribute set.
Test: RegexBuddy failed to preserve the test subject if it wasn’t modified since RegexBuddy was last started.
Test: The Find First button only searched the first test subject if the scope was “page by page” or “line by line”. Now it will search all scopes from the beginning until it finds a match.

RegexBuddy 2.4.1 – 29 June 2007

Bug fix:

Regex: Capturing groups inside negative lookaround did not work. This also caused the debugger to fail on regexes with negative lookaround. (Versions 2.4.0 and 3.0.0 only)
Regex: Certain cases of catastrophic backtracking were not detected, causing RegexBuddy to keep on trying the regex far too long. (Versions 3.0.0 and 2.4.0 only)

RegexBuddy 3.0.0 – 13 June 2007

New features:

COM interface: Debug method to show the debugger output at a particular byte position in the test data.
COM interface: InitAction and FinishAction can now pass a list of actions to populate and retrieve the whole History list. The caption of the History panel will change to “List for appname” when InitAction is used this way.
COM interface: New variant structure with FreeSpacing and Flavor fields.
COM interface: ability to specify test data or the path to a test file to be loaded into the Test tab.
COM interface: function to disable certain options; e.g. EditPad Pro and PowerGREP force the JGsoft regex flavor with “^$ match at line breaks” turned off.
COM interface: support for additional programming languages when passing regular expressions as strings.
Command line interface: -testclipboard parameter to paste the contents of the clipboard into the Test tab.
Command line interface: -testfile parameter to load a file into the Test tab.
Command line interface: Additional parameters for passing regexes as strings in various programming languages.
Copy/paste C# strings, which uses verbatim strings when appropriate.
Copy/paste: Support for all the string styles used by the programming languages newly supported on the Use tab.
Create: Indicate features used in the regular expression that are available in some flavors, but not in the selected flavor. Double-clicking such an error replaces it with the equivalent syntax (if any) in the selected flavor.
Debug Everywhere: Runs the debugger at each position in the test subject, rather than only at the current position of the text cursor.
Debug Till End: Runs the debugger from the current position of the cursor until the end of the test subject.
Flavors: RegexBuddy now has the unique ability to emulate the limitations of all the regular expression flavors that it supports. Simply select the flavor you’re working with on the main toolbar.
Forum: Discuss and share regular expressions with other RegexBuddy users.
Fully modular interface: the tabs in RegexBuddy 2 are now panels that can be arranged in tabs, side by side or made to float independently. The layout is automatically remembered between RegexBuddy sessions.
GREP: Button to open the file in EditPad or another editor instead of the Test pane.
GREP: Keyboard shortcuts for preview, execute and quick execute like in PowerGREP.
History: List of regular expressions to easily compare different regular expressions in a single RegexBuddy session.
Insert Token: Unicode blocks.
Insert Token: Unicode properties.
Insert Token: Unicode properties, scripts and blocks can now be added directly when adding or editing character classes.
Insert Token: Unicode scripts.
Library: Export without test data and comments but with a unique ID for each regex, so the library can be used as a data file for applications as an alternative to hard-coding regular expressions.
Library: Store test data with each regular expression.
Preferences, Editor: Option to toggle word wrap in the “test” editors.
Preferences: Option to configure whether code snippets on the Use tab use spaces or tabs, and how many, for indentation.
Preferences: Option to remember the GREP settings.
Preferences: Option to remember the test data between RegexBuddy sessions.
Preferences: Regex tree font on the Create page.
Regex: (?n) explicit capture modifier, as supported by the .NET framework.
Regex: Ability to select a regex flavor to make RegexBuddy mimic the syntax and limitations of the selected flavor.
Regex: Character class subtraction, as supported by XML schema and the .NET framework.
Regex: Dummy support for PCRE callouts (?C1) through (?C255) when the flavor is set to “PCRE”.
Regex: Free-spacing option and (?x) free-spacing mode modifier.
Regex: POSIX character classes.
Regex: \Q…\E escape sequence for escaping a string of metacharacters.
Regex: \cA through \cZ ASCII control characters Ctrl+A through Ctrl+Z; equivalent of \x01 through \x1A; can be used inside and outside character classes.
Regex: \p{Arabic} through \p{Yi} tokens for matching any character in a particular Unicode script; \p{IsArabic} syntax also supported.
Regex: \p{InBasicLatin} through \p{InSpecials} tokens for matching any character in a particular Unicode block; \p{IsBasicLatin} and \p{BasicLatin} alternatives also supported; BasicLatin can also be written as Basic_Latin, Basic-Latin and Basic Latin.
Regex: \p{IsL} and \P{IsL} alternative syntax to \p{L} and \P{L}; using the \p{IsL} syntax is not recommended, as \p{L} has much wider support; RegexBuddy supports it for compatibility with Perl and Java which support both \p{L} and \p{IsL}.
Regex: \p{^…} syntax as an alternative syntax to \P{…}; using the \p{^…} syntax is not recommended, as only Perl supports it; Perl also supports \P{…}; RegexBuddy only supports it for Perl compatibility.
Regex: \x{FFFF} alternative to \uFFFF. This syntax is used by Perl. While \uFFFF must always specify 4 hex digits, the \x{FFFF} syntax allows leading zeros to be omitted.
Replace: Support for $&, $‘, $’, $_ and $+ and corresponding backslash versions.
Test: Hexadecimal mode.
Test: List All option to show all capturing groups in columns.
Test: List All option to show match details folded under each match.
Test: List All subitem to list lines or pages without matches when processing the subject line by line or page by page.
Test: Open a URL to test a regex on the HTML source of a web page.
Test: Option to process the test subject line by line. This makes RegexBuddy behave like traditional grep, and also makes it easier to test a regex against multiple subjects, one on each line.
Test: Option to process the test subject page by page, so page breaks can be used to delimit multiple subject strings.
Test: Save test data into a text file.
Test: The Replace button now has an option to produce a list of replacements, without the unmatched text.
Undo and redo buttons that undo changes made to the regular expression and replacement text, either directly or via the Insert Token command.
Use: Customizable templates to create and edit code snippets for programming languages that use one of the regex flavors supported by RegexBuddy.
Use: If the regex flavor selected in the main toolbar does not correspond with the regex flavor needed by the programming language selected on the Use tab, RegexBuddy will automatically convert it to the needed flavor, or show an error if it can’t.
Use: MySQL.
Use: Oracle.
Use: PostgreSQL.
Use: String literal with RegexBuddy’s regex tree.
Use: Tcl.
Use: XML Schema.

Improvements:

Copy/paste: All the different string styles are now listed in submenus, with the string styles corresponding to the selected regex flavor and/or programming language listed directly in the Copy and Paste menus.
Create: Eliminate duplicates from “match a character in the list” for character classes, to make it clearer that a character class matches characters instead of words.
Debug: If the only output is backtrack; match attempt failed, explain that the match was only attempted at the current cursor location.
GREP: .rbg files now use an XML-based format that can be easily created and read in other applications. RegexBuddy 3 can read binary .rbg files saved by RegexBuddy 2, but can only write the new XML-based format.
GREP: Show the number of matches per file and the clickable file header on one line. This halves the number of lines needed when not showing match details (e.g. after a “quick execute”), and leaves the total visible when collapsing file nodes.
Insert Token, Anchors: Label the menu items for ^ and $ as “beginning/end of line” and make them turn on the “^ and $ match at line breaks” option.
Insert Token: ASCII character map now allows you to select the code page to be displayed.
Insert Token: Unicode character map now indicates code point numbers in a tooltip.
Library: .rbl files now use an XML-based format that can be easily read in other applications. RegexBuddy 3 can read binary .rbl files saved by RegexBuddy 1 and 2, but can only write the new XML-based format.
Library: Using a regular expression from the library now keeps the previous regex in the history list, making it easy to revert to it.
Test: Highlight backreferences in the match details. When double-clicking a backreference, highlight that backreference in the results.
Use: C# code snippets should use verbatim strings when the regex contains backslashes or free-spacing line breaks.
Use: Comments with RegexBuddy tree should indicate matching options.
Use: PHP preg operators now add the /u modifier if your regular expression uses a Unicode token.

RegexBuddy 2.4.0 – 12 June 2007

Improvements:

Copying and pasting the regex as a PHP string is now more conservative with adding and removing backslashes.
Debug: Matches of anchors and lookaround tokens are now indicated as “ok” in the debugger’s output instead of being invisible (as they don’t match any text to be highlighted).
GREP: Detect text encoding based on the HTML Content-Type meta tag.
Regex: For better compatibility with the next versions of EditPad Pro and PowerGREP, RegexBuddy 2.4.0 uses the new version of the JGsoft regex engine developed for RegexBuddy 3.0.0.

Bug fixes:

Create: The explanations for the dot, caret and dollar now take into account local option groups like (?ms:group).
Regex: Backreferences to capturing groups that participated in the match but didn’t capture anything failed to match at the end of the subject string. E.g. (a?)b\1 failed to match the last b in bbb though it should match all three individually.
Regex: Backreferences to empty capturing groups that participated in the match always failed. E.g. a()\1 would fail to match a.
Regex: Lookahead nested inside lookbehind was treated as lookbehind. E.g. (?<=x(?=y)). did not match the y in xy.
Regex: Redesigned internal backtracking system, to support repeated backtracking of groups nested inside other groups.
Regex: \xFF and \0377 failed to match in many cases for values greater than \x7F and \0177 depending on the character encoding used in the test subject.
Test: If the highlighted matches included zero-with matches, the Next button would not advance to the next match if the cursor was at a zero-width match.
Use: Two Delphi code snippets referenced the non-extistant TPerlRegEx.MatchExpressionCount property instead of SubExpressionCount.

RegexBuddy 2.3.2 – 20 February 2007

Bug fixes:

Create: Explain Token button would open the help file, but not the correct topic (2.3.1 only).
Use: The ^ to negate a character class was incorrectly changed into \A when using the regex in a Ruby script, when “^$ match at line breaks” is off.
Vista: Checkboxes and buttons in dialog boxes no longer disappear when you press the Alt key.

RegexBuddy 2.3.1 – 4 January 2007

Improvements:

Help|Install on Removable Drive: Option to force RegexBuddy to treat any drive as a removable drive.

Bug fixes:

GREP: When processing a Unicode file without a byte order marker, the target file sometimes used the default ANSI encoding rather than the Unicode encoding of the source file.
Regex: The upper limit on a lazy quantifier {m,n}? was not respected; e.g. a{1,3}b would match aaaaab entirely.
Test: When dropping files onto the Test tab dragged from another application, RegexBuddy always inserted the contents of the first file dropped during the current RegexBuddy session.
Use: JavaScirpt search-and-replace snippets did not convert \1 in the replacement text into $1.
Vista: Attempting to invoke RegexBuddy from within EditPad Pro, PowerGREP or AceText would cause the invoking program to lock up, waiting for RegexBuddy to respond. Eventually the calling program would time out and say RegexBuddy is not installed.

RegexBuddy 2.3.0 – 18 September 2006

New feature: Generate code snippets in REALbasic on the Use tab.
Improvement: RegexBuddy will now auto-detect Unicode files without a byte order marker when opening them on the Test tab or searching through them on the GREP tab.
Bug fix: JavaScript code snippet to search-and-replace using a regex object didn’t put the /g flag in the correct spot.

RegexBuddy 2.2.3 – 18 July 2006

The GREP button did not work in version 2.2.2.

RegexBuddy 2.2.2 – 8 July 2006

New features:

Use: “comment with regex tree inside region” for C#, VB.NET and Delphi for .NET. This style of comment can be collapsed in Visual Studio and most other C# and VB.NET code editors.
Use: C#/VB.NET/Delphi.NET code snippet to search-and-replace through a string, adapting the replacement to each match using a MatchEvaluator.

Improvements:

Library: If RegexBuddy is launched from another application and the Send button is clicked without a regular expression being entered at the top in RegexBuddy, send the regex from the library to the application.
Use: Adapt PHP preg regex delimiters to the regular expression, i.e. don’t use / as a delimiter when the regular expression contains / characters, so they don’t have to be escaped.
Use: The default parameter names for Java source code snippets now start with lowercase letters.

Bug fixes:

Copy/Use: RegexBuddy incorrectly escaped \ characters in the replacement text in Perl s/// operators.
Create: Clicking on a node in the Create tree selected one character too many in the regular expression.
Create: If the regular expression contains an atomic group or option group that is repeated, the regex tree did not show a node indicating the quantifier.
Create: The Use Backreference item in the Insert Token menu caused an Access Violation error (version 2.2.1 only).
GREP: None of the items in the drop-down menu of the Open button on the GREP tab worked.
GREP: Opening a previously saved grep action does not update the items available in the Target list if opening the action requires RegexBuddy to switch from the Match to the Replace tab or vice versa.
Regex: Doubly nested repeating capturing groups caused RegexBuddy to hang or crash when attempting to try the regex on the Test page.
Regex: If the regular expression started with a literal character, and that literal character was repeated a fixed number of times with the {n} operator, and the following regex token is another literal character, then RegexBuddy incorrectly expanded the quantifier when applying the “literal start” optimization. E.g. a{2}b would fail to match aab while \w{2}b, a{2}\w and a{2,3}b all matched properly. RegexBuddy optimized a{2}b into (?:aab){2} instead of aab. Note that not all regular expression engines optimize a{2}b into aab, so typing in aab instead of a{2}b is recommended.
Regex: Negative lookaround containing nothing except one of the anchors ^, $, \A, \z or \Z would match at any position, while it should fail at positions where the anchor matches. This bug was introduced in version 2.0.3 by the fix preventing RegexBuddy from infinitely repeating greedy groups that resulted in zero-length matches, such as in the regular expression (a*)*
Regex: RegexBuddy did not backtrack repeated atomic groups. E.g. (?>[ab])+b did not match aab as it should. RegexBuddy incorrectly treated (?>group)+b as (group)++b. In (?>group)+ the regex won’t backtrack into group, but will backtrack +. In (group)++ neither group nor the + are backtracked. The equivalent of (group)++ using atomic grouping notation is (?>(group)+).
Use: Java code snippet for iterating over all matches and capturing groups didn’t iterate over the last group.
Use: PHP preg code snippet for getting an array of all regex matches didn’t use the Result variable name as entered on the Use tab.

RegexBuddy 2.2.1 – 20 February 2006

New feature:

Test: The List All button now has a drop-down menu allowing you to select a capturing group. This will build a list of that group’s matches rather than overall regex matches.

Improvement:

Use: VB6, VB.NET and VBScript do not support \r and \n in the replacement text. These are now substituted with chr(13) and chr(10).

Bug fixes:

Library: The Parameters tab did not pick up parameters that are only used in the replacement text
Regex: Conditionals without an “else” alternative would fail if the conditional test failed. Since an empty regex always matches, the conditional should match if the “else” part is omitted or empty.
Regex: Groups with an empty alternative at the end were not made optional, i.e. (a|b|) was treated as (a|b) instead of (a|b)?
RegexBuddy’s regular expression optimizer incorrectly made greedy tokens followed by lookbehind possessive, if the characters matched by the token and the lookbehind are mutually exclusive.
When run with very restricted privileges (e.g. from a removable disk on a public system), RegexBuddy would show an error message caused by its inability to register as a COM server.

RegexBuddy 2.2.0 – 12 January 2006

New features:

Install on Removable Drive item in the Help menu makes it possible to carry RegexBuddy with you on a removable disk, flash card or USB key. (Windows version only.)
Use: VBScript language support, using the built-in RegExp object.
Use: Visual Basic 6 language support, using the VBScript RegExp object.

Improvements:

Debug: Line breaks in the regex matches are now inserted as \r\n instead of actual line breaks. This keeps multi-line regex matches together on a single line in the debugger, making the regex engine’s progress much easier to follow.
GREP: If the Match tab is active and the target type is set to save the output to a file, the GREP button will now show its Preview/Execute/QuickExecute drop-down like it does when the Replace tab is active, instead of automatically doing a Preview.

Bug fixes:

Create: Dragging a regex tree node onto the regular expression caused an access violoation instead of displaying a “cannot drop here” symbol. (Version 2.1.0 only.)
Debug: Horizontal scroll bar was missing.
Debug: Line numbers were not shown completely.
Regex: If a single token was repeated and also made optional in a group all by itself, e.g. (a{3})?, RegexBuddy incorrectly optimized the token as a{0,3} on the Test tab. E.g. the regex ^[a-zA-Z]{2}[0-9]+([a-zA-Z]{2})?[0-9]+ matched AU0159116A5 entirely instead of only matching AU0159116.
Regex: Initial lookbehind optimization caused regexes with a capturing group inside the initial lookbehind to fail if the capturing group was referenced later in the regular expression. E.g. (?<=<(\w+)>).*(?=<\/\1>)
Regex: Octal escapes like \037 were not handled properly
Regex: With “^$ match at line breaks” and “dot matches newlines” turned off, the regular expression $. caused RegexBuddy to get stuck in an infinite loop. Note that this regular expression could never match anywhere. The $ will match before the end of the string, or before the line break at the very end of the string (if any). At this position, the dot could never match, since it requires a character that is not a line break character.
Use: Perl snippets to extract the text matched by a regex and search-and-replace into a new string didn’t work.
Use: Regular expressions with escaped backslashes (\\) were not properly converted into 4 backslashes when generating PHP preg code.

New documentation:

Example: How to match an email address.
RegexBuddy: Topic explaining how to benchmark regular expressions with RegexBuddy’s debugger.
Tutorial: Added a practical example to the topic on atomic grouping.

RegexBuddy 2.1.0 – 21 October 2005

New features:

Copy/paste regular expressions as XML (i.e. special XML characters like < encoded as entities like <)
Preferences: Option to preserve the regular expression and/or test page between RegexBuddy sessions

Improvements:

Copy as Perl-style // operator was replaced with two separate items for JavaScript and Ruby. Though they use the same Perl-style operator, they support different mode modifiers (thereby creating quite a mess).
Create: When inserting a character class token, you can now click the Clear button to clear all settings on the Character Class dialog box (it defaults to the settings of the last inserted character class).
Library: Do not truncate the items in the list, so the entire first line of the description can be seen when the list is made wider
Preserve splitter positions (e.g. between the search/replace/split tabs) between RegexBuddy sessions
Use: Ruby code snippets with if…else block now add the “end” keyword to the end of the block

Bug fixes:

Copying and pasting from RegexBuddy into another application did not work on Windows 95, 98 and ME (versions 2.0.x only).
Pasting a PHP operator like ‘/regex/i’ results in “regexi” instead of “regex” with the case insensitive option turned on
Regex: (?:a|b|c)|d|e was optimized into a|d|e|b|c instead of a|b|c|d|e which would cause the wrong alternative to match if more than one could be matched at the same position
Use: JavaScript code snippets for matching a string entirely now use ^ and $ instead of \A and \z, since the official JavaScript standard does not support \A and \z (though some JavaScript implementations may support them).
Use: Ruby code snippets now use /m instead of /s for the “dot matches newlines” options. (Contrary to Perl, which uses /s, Ruby uses /m for this option.)

RegexBuddy 2.0.6 – 11 August 2005

Improvements:

Regex: Empty alternatives in the main regex are now treated as an error. They will always find a zero-width match, effectively truncating the regular expression at that point. This is usually a typing error rather than the user’s intention.
Use: The language and function selection now persists between RegexBuddy sessions. (Note: In version 2.0.6 for Windows, this improvement caused RegexBuddy to incorrectly state that the license information could not be found until you selected another language or function. This issue was corrected in the interim release 2.0.6b, released on August 25th.)
Use: Java source code snippets now use the boolean primitive type instead of the Boolean class type.

Bug fixes:

Debug and GREP tabs did not have an Alt+digit keyboard shortcut. Right-click on the tabs to get a list with the shortcut for each tab.
Debug: Selecting the entire regular expression and clearing it with the Debug tab active caused an Access Violation. Now doing so will switching back to the Test tab. This already happened when editing the regular expression with the Debug tab active.
GREP: Alt+G now starts the grep instead of debugging the regular expression (which should only be possible on the Test tab).
GREP: Linux: Some of the labels were clipped.
Regex: A group with an empty alternative such as (|a|b) caused an access violation.
Regex: Alternation inside capturing groups did not always work properly, e.g. Z([ui]|ue)rich did not match Zuerich. This problem did not occur with non-capturing groups, e.g. Z(?:[ui]|ue)rich worked properly.
Regex: Due to an over-optimization, (a?) was treated like (a)? where “a” is a single regex token. The difference is that if “a” cannot be matched, \1 will successfully match (nothing) in the first case, but fail to match in the second case.
Test: Invalid regular expressions with a repeat operator after an opening bracket such as (*.?) did not trigger an error message. The Create page and regex syntax highlighting did properly flag the error.
Test: RegexBuddy would hang on a regular expression starting with a lookbehind with more than one alternative, e.g. (?<=joe|jane)doe
Use: Java code snippets for splitting a string called Split() with uppercase S instead of split() with lowercase s.
Use: JavaScript code snippets for regexes with the “dot matches newlines” option turned on now add a warning comment to the code snippet, instead of adding the /s flag which JavaScript does not support.

RegexBuddy 2.0.5 – 16 April 2005

Improvements:

Copying and pasting the regex as a PHP preg string is now more conservative with adding and removing backslashes
Debug: Character classes are now highlighted as single tokens.
Paste from string: If the text on the clipboard does not contain any quote characters, treat the whole text on the clipboard as the string with omitted delimiting quotes. When pasting a string, RegexBuddy eliminates everything outside the quote characters. This makes it quick to copy and paste a regular expression, as you can copy a full line of source code and RegexBuddy will automatically extract the string from it.

Bug fixes:

Create: Typing \P{M} (negated Unicode property) into the regular expression with the Create tab active caused an access violation.
Debug: Regular expressions with lookbehind can now be properly debugged.
Pasting /\d/ as a Perl-style operator removed the backslash before the d.
Regex: Greedy tokens were sometimes incorrectly made possessive by the optimization introduced with RegexBuddy 2.0.2.
Regex: Typing in negative lookahead slowly, so RegexBuddy will try to evaluate the regular expression with an unclosed lookbehind, caused RegexBuddy to stop finding any matches at all, until RegexBuddy is restarted.
Regex: automic groups were not treated as being atomic in certain circumstances.
Regex: conditionals didn’t always work properly.
\b incorrectly matched at the start and the end of the subject string when the string did not start or end with a word character.

RegexBuddy 2.0.4 – 17 March 2005

Improvements:

Debug: Changing the regular expression now automatically clears the debugger output. Press Debug on the Test page again to debug the modified regular expression.
Test: Highlighting is now done in the background, so testing complex regular expressions on a large amount of text doesn’t slow down or lock up RegexBuddy. Highlighting will disappear while matches are being found, and automatically reappear when done.
Test: List All, Replace All and Split now perform their task in the background, so you don’t have to wait for the job to be completed. Taking any action on the Test page that produces match details automatically cancels any pending operation.
Test: Selecting a group from the Highlight button’s drop-down menu now instantly changes the group highlighting, without finding all regex matches anew. If the selected group was already being highlighted, the group highlight is removed (only the overall match highlight remains).

Version 2.0.x bugs fixed:

RegexBuddy would crash when alternating identical regular expressions, such as test in “abc|test|test|xyz”
RegexBuddy’s regular expression optimizer incorrectly made greedy tokens followed by negative lookahead possessive, if the characters matched by the token and the lookahead are mutually exclusive.
Using a caret inside a lookbehind, and turning on the option for caret and dollar to match at line breaks caused an error.
When ((.)a)+ matches 1a2a3a4 the second backreference contained 4 (character matched in the last unsuccessful attempt) instead of 3 (character matched in the last successful match).

Linux-only version 2.0.x bugs fixed:

Linux: Create page, Insert Token button, Use Backreference item did nothing except show an error message
Linux: Ellipsis (...) button for Unicode characters in the character class screen (create page, insert token, character class) had no effect at all
Linux: Trying to cut or copy text to the clipboard did nothing except show an error message

RegexBuddy 2.0.3 – 22 February 2005

New features:

GREP: Search through files on a network share by entering a UNC path as the folder (e.g. \\server\share\folder)

Improvements:

Regex: You can now use all regex tokens inside lookbehind in RegexBuddy. Note that besides RegexBuddy, the .NET framework is the only regex engine that supports this.
RegexBuddy now immediately aborts a match attempt when it detects “catastrophic backtracking”. Though RegexBuddy’s new regex engine (introduced with version 2.0) would not crash in case of catastrophic backtracking (unlike most regex engines), it would continue to look for further matches (like most regex engines), making RegexBuddy unresponsive.
Test: Highlighting is now done in the background, so testing complex regular expressions on a large amount of text doesn’t slow down or lock up RegexBuddy.

Version 2.0.x bugs fixed:

Regex: \x00 and \u0000 now properly match a NULL character.
RegexBuddy would infinitely repeat greedy groups that resulted in zero-length matches, such as in the regular expression (a*)*. Note that repeating a group that can result in zero-width matches is not useful. This regular expression is better written as (a+)* or even (a+)
When using lookaround containing a single literal character, preceded in the regex by nothing except literal characters, the lookaround character was matched as a literal character. E.g. q(?=u) was matched as qu.

RegexBuddy 2.0.2 – 8 February 2005

New features:

Preferences, Regex Colors: Option to disable syntax coloring of regular expressions

Improvements:

Library: Expanded RegexBuddy’s library with regular expressions for dealing with words, quote characters, credit card numbers, postal codes, blank lines, passwords, etc.

Version 2.0.x bugs fixed:

Create: HTML Export caused an access violation with regular expressions using character classes.
Create: InsertToken->Use Backreference would cause an access violation when the edit box for entering the regular expression is completely empty.
Test: Certain regular expressions caused intermittent access violations.

RegexBuddy 2.0.1 – 28 January 2005

Improvements:

Test: Highlight is now on by default when starting RegexBuddy.

Version 2.0.0 bugs fixed:

Test: Highlight drop-down menu items caused an access violation when the highlighting was not active already, rather than turning on highlighting.
Regex: A regex with alternation inside a group nested in another group, or alternating groups inside a group, caused an access violation.

RegexBuddy 2.0.0 – 24 January 2005

New features:

Debug: Get a complete view of how the regular expression engine steps through the entire matching process. You will see which regex token matches what, at which point, and how it interacts with the rest of the regular expression. This is the best way of learning why a particular regular expression works exactly the way it does. It takes the guesswork out of fixing regular expressions that match something you don’t want, or don’t match something you want.
GREP: Search or search-and-replace through files and folders. Useful for quick searches and edits that don’t require PowerGREP’s wealth of options.
Create, Test: Unicode regex tokens \p{property}, \P{property} and \uFFFF and \X. \p, \P and \u can be used both inside and outside character classes.
Full Unicode support. All edit boxes for entering regular expressions now fully support Unicode. The edit box on the Test page supports Unicode and a variety of other code pages. Right-click to change the encoding.
Regex: Named capturing groups can now be used as the “if” part in an “if-then-else” conditional.
Test: List All button to collect a list of all matches in the test data.
Test: Double-click any highlighted match to get complete details about the match and its backreferences.
Test: Matches are counted when double-clicking on a highlighted match. The details will show the number of the match, and the total amount of matches.
Use: Delphi Win32 language support, based on the free TPerlRegEx VCL component which is a full-featured wrapper around PCRE.
Use: Ruby language support.
Copy and paste PHP preg ‘//’ strings as well as JavaScript and Ruby // operators
Preferences: Option to show line numbers on the Test page.

Improvements:

Create: RegexBuddy now recognizes hexadecimal escapes \xFF and octal escapes \0377 inside character classes.
Double-clicking on the regular expression now selects the entire regex token that was clicked on, rather than the entire word. (e.g. \bword\b now highlights \b or word, rather than bword).
Library: Last used library is automatically opened when starting RegexBuddy the next time.
Preferences: Selected text color can now be configured.
Test: Multiple named capturing groups can now have the same name. Note that not all regular expression flavors allow this (.NET does, Python and PCRE do not).
Test: Replace All highlights the replacements in the result.
\t, \r and \n are now treated as regex tokens in the replacement text.
Backreferences are now highlighted in the replacement text.
RegexBuddy will no longer crash when testing a regular expression that is too complex because of “catastrophic backtracking”. Instead, RegexBuddy will abort the match attempt and note in the test or debug results that the regular expression is too complex.

Bug fixes:

Use: Ctrl+C shortcut key did not work properly on the Use page.
Create: Inserting a repetition operator no longer puts a non-capturing group around a single regex token consisting of multiple characters in the regex syntax.
Use: PCRE code snippets declared “erroffset” but used “erroroffset”.
Linux Fedora Core 2: RegexBuddy would fail to run at all, aborting with a segmentation fault. This was due to a new security feature in Fedora Core 2 (and later) preventing RegexBuddy from running (even though there was no security risk).

RegexBuddy 1.2.1 – 29 September 2004

New features:

If-then-else regex conditionals are now supported by the regex syntax coloring and the regex tree on the Create page.
The Library page now indicates the file name of the open library.
Edit boxes on the Test and Use pages now have context menus with the typical items such as cut, copy and paste.

Bug fixes:

Linux only: Clicking on the regex tree did not highlight the corresponding token in the regular expression.
Use: C# and Delphi.NET snippet “Iterate over all matches and capturing groups in a string” contained an extraneous closing parenthesis.
Use: RegexBuddy incorrectly escaped backslashes in the JavaScript /regex/ notation. Backslashes only need to be escaped when writing a regex as a string literal (dubbed “alternative” notation by RegexBuddy).

RegexBuddy 1.2.0 – 1 June 2004

New features:

Create: Support for .NET-style named capture (?<name>group) and named backreferences \k<name>. .NET-style named capture is automatically converted into Python-style named capture when the regular expression is implemented in a code snippet on the Use page for PHP/preg, Python or PCRE.
Create: Support for Python-style named capture (?P<name>group) and named backreferences (?P=name). Python-style named capture is automatically converted into .NET-style named capture when the regular expression is implemented in a code snippet in a .NET language on the Use page.
Replace: Support for .NET-style named references ${name} and Python-style named references \g<name> in the replacement text.
Use: Function to extract the text matched by a named capturing group for C#, VB.NET, Delphi for .NET and PCRE.
Use: Python language support

Improvement:

Use: Selecting another language now keeps the same function selection, if it is available in the newly selected language

Bug fix:

Use: PHP preg code snippets used “preg” instead of “preg_match” to test if a regex matches a string

RegexBuddy 1.1.0 – 17 May 2004

New features:

RegexBuddy can now automatically generated code snippets for Delphi for .NET

Bug fixes:

Test: Changed the shortcut for Find Next from Alt+N to Alt+X. Alt+N will launch a new instance of RegexBuddy.
Test: Find First and Find Next now scroll the test subject to bring the match into view.

RegexBuddy 1.0.1 – 10 May 2004

The release of RegexBuddy has gone very smoothly. No serious issues have been reported. A few minor corrections are made in version 1.0.1.

Improvements:

Alt+S shortcut to send a regex to the application RegexBuddy was invoked from
Use: The PowerGREP button now works like the Send To button when RegexBuddy was activated from within PowerGREP. If RegexBuddy was not launched from PowerGREP, the Use button starts a new instance of PowerGREP via the command line.

Bug fixes:

Library: Delete button was not disabled when the library is read only
Preferences: The options to show spaces and paragraphs markers did not have any effect
Sending a regex from an application to RegexBuddy now properly updates the Create, Test and Use tabs

RegexBuddy 1.0.0 – 3 May 2004

First public release of RegexBuddy.

Page URL: https://www.regexbuddy.com/history.html
Page last updated: 16 October 2023
Site last updated: 15 March 2024