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 now officially supports .NET 8.0, Boost 1.85, and Java 22, and Ruby 3.3. These regex flavors are unchanged compared with previous versions.
Perl 5.22 and later support the /n flag to turn unnamed groups into non-capturing groups. RegexBuddy emulates this by adding a regex option that you can switch between “numbered capture” (equivalent to omitting /n in Perl) and “named capture only” (equivalent to specifying /n in Perl). But when you copied the regular expression as a Perl operator via the Copy button on the main toolbar or generated a Perl source code snippet on the Use panel, RegexBuddy never added the /n flag. This has been fixed. RegexBuddy now adds /n to the Perl operator it generates when you select “named capture only“.
RegexBuddy now also sets the “named capture only” regex option when you select Paste Regex from Perl Operator under the Paste button on the main toolbar and the Perl operator on the clipboard includes the /n flag. It will also change the application to Perl 5.22 if you had selected Perl 5.20 or prior as the application prior to pasting a Perl operator that includes the /n flag.
You can use the Insert key on the keyboard to toggle between insert and overwrite mode in the edit controls on RegexBuddy’s main window. In overwrite mode, these edit controls now use the overwrite cursor specified in the text layout configuration in the Preferences. By default this is a block cursor that covers the bottom half of the character that will be overwritten.
On the Create panel you can export the regex tree into various formats, including HTML. The HTML export now properly preserves whitespace and line breaks in the regular expression.
On the Test panel, the List All menu has an option to show non-participating groups. This makes test results that show the matches of capturing groups show n/a for a group that did not participate in the regex match instead of showing nothing for such groups. This allows you to distinguish between groups that didn’t participate and groups that did participate but captured a zero-length match, for which the test results always show nothing as the match. Toggling this menu item now immediately updates the test results if Update Automatically is active or clears the test results if not. This way you won’t end up looking at test results that don’t correspond with the state of this option.
RegexBuddy includes a library with many sample regular expressions. The samples for matching VAT numbers for Belgium, Ireland, and Northern Ireland have been updated to match the latest VAT number formats.
See also: RegexBuddy 4.14.2 version history
RegexBuddy now officially supports .NET 7.0, Boost 1.83, Java 21, Python 3.12, and Ruby 3.2. These regex flavors are unchanged compared with previous versions.
RegexBuddy now correctly emulates that the JGsoft flavor which is used in our own products PowerGREP, EditPad, and AceText is the only one that correctly matches a Unicode grapheme with \X when it is used inside a lookbehind. Java always fails to match \X when it’s inside a lookbehind, possibly causing a negative lookbehind to succeed. All other flavors either don’t support \X at all or don’t support lookbehind at all or treat \X as an error inside lookbehind because they don’t support tokens that match a variable number of characters inside lookbehind.
The behavior of \G differs between regex flavors. With some flavors it matches at the position where the previous match ended or at the start of the string if there is no previous match. With other flavors it matches at the position where the current match attempt began. The difference is important when the previous match was zero-length. Some flavors advance one character through the string after a zero-length match was found before starting the next match attempt. Then the end of the previous match and the start of the current attempt aren’t at the same position. RegexBuddy 4 has always correctly emulated this when highlighting matches and listing matches on the Test panel. But the Debug panel sometimes showed different results. This has been fixed. The Debug panel now correctly shows how \G behaves in your selected regex flavor regardless of whether you’re debugging a single match attempt or all match attempts. If you debug a match that is highlighted on the Test panel then the match attempt on the Debug panel takes into account what the preceding match was on the Test panel.
RegexBuddy now correctly handles conditionals inside lookbehind for the flavors that allow this. The direction of the conditional (lookahead or lookbehind) does not change when it’s inside another lookbehind.
See also: RegexBuddy 4.14.1 version history
RegexBuddy now fully supports Boost 1.80, Java 19, .NET 7.0, PCRE2 10.39, PHP 8.1.12, Python 3.11, R 4.2.1, and Visual C++ 2022.
ECMAScript 2018 added the /s regex flag to the JavaScript standard to turn on dot matches line breaks mode. All the browsers that RegexBuddy emulates except for MSIE have since implemented this. RegexBuddy has emulated this since version 4.9.0 when Chrome was the first browser to implement this. But when copying your regex as a JavaScript operator or when generating a JavaScript source code snippet on the Use panel, previous versions of RegexBuddy did not add the /s flag. Now RegexBuddy adds the /s flag if you have selected “dot matches line breaks” mode in RegexBuddy. Conversely, if you’ve copied a JavaScript regex operator from your source code, selecting Paste from JavaScript operator in RegexBuddy now toggles “dot matches line breaks” mode depending on whether the operator you copied includes the /s flag or not.
JavaScript and R support character escapes such as \n in literal strings. They do not support them as part of the replacement string syntax. So if you add a replacement string as a literal to your source code then you can use \n to represent a line feed. But if your script receives a replacement string from user input or elsewhere then \n is not interpreted as a line feed. RegexBuddy can emulate this distinction. Select “support string syntax” if you’ll be pasting your replacement into your source code. Select “regex syntax only” if you will store the replacement in a data file or will paste it into an input control. RegexBuddy has supported this since version 4.0.0. But due to a bug, if you selected “regex syntax only” and then copied the regex as a JavaScript or R string or generated a source code snippet then the \n was not escaped to prevent it from being interpreted as the string literal. This has been fixed. Conversely, when pasting a JavaScript or R string both \\n and \n are now interpreted correctly. Pasting a string containing \n now switches RegexBuddy to “support string syntax” mode. All of this also applies to all other character escapes supported by JavaScript and R string literals.
Two crash bugs were also fixed. They were triggered by some very specific regex syntax. One occurred with regexes containing a character class range with an escape representing the NULL character such as [\0-\x1F] if the selected application allows such ranges (some regex flavors only allow letters and digits in character class ranges). The other occurred with regexes such as a$b$c that contain multiple dollar signs if the selected application (such as GNU BRE) treats the $ as a literal instead of as an anchor when the $ is not a the end of the regex or a group.
RegexBuddy 4.8.0 through 4.13.0 crash on startup when you try to run them on WINE 7.0. The problem does not occur when running these versions of RegexBuddy on older versions of WINE. RegexBuddy 4.14.0 now catches this error allowing it to start normally on WINE 7.0.
See also: RegexBuddy 4.14.0 version history
This release brings RegexBuddy up-to-date with all the applications that it supports. Newly supported versions are Boost 1.77, C++Builder 11, Delphi 11, Java 17, PCRE 8.45, PCRE2 10.37, PHP 8.0.11, Python 3.10, and R 4.0.11.
ECMAScript 2018 added named capture groups to the JavaScript standard. All the browsers that RegexBuddy emulates except for MSIE have since implemented this. RegexBuddy now allows named capturing groups in JavaScript regular expressions when you select a flavor other than MSIE. RegexBuddy also supports the rr`$<name>` syntax for backreferences in the replacement string that is newly invented by ECMAScript 2018. RegexBuddy also correctly emulates the fact that JavaScript only recognizes named backreferences in the replacement text if the regular expression actually contains one or more named capturing groups. On the Use panel, RegexBuddy can now generate a JavaScript code snippet to retrieve the match of a named capturing group.
RegexBuddy is now aware that empty positive lookahead is an error in Boost instead of always matching a zero-length string and that in older versions of Boost empty negative lookahead was an error instead of always failing to match.
See also: RegexBuddy 4.13.0 version history
This release brings RegexBuddy up-to-date with all the applications that it supports. Newly supported versions are Boost 1.76, Java 16, .NET 5.0, PCRE2 10.36, Perl 5.32, PHP 8.0.6, Python 3.9, R 4.0.5, Ruby 3.0, and XRegExp 5.
RegexBuddy is now aware of over a dozen additional behavioral and syntactic differences between the various regex flavors that it supports. These are listed as regex flavor aspects in the version history. Most of them are corner case issues involving lookbehind, conditionals, and quantifiers.
RegexBuddy was already aware that some regex flavors allow multiple capturing groups to have the same name while still treating those groups as separate groups with different numbers. Only the .NET and JGsoft flavors treat multiple groups with the same name as one and the same group. Previous versions of RegexBuddy already handled that perfectly.
The other flavors (Perl, PCRE, Ruby, and Boost) differ in how they handle backreferences in the regex or replacement string that reference a name used by multiple capturing groups. They can be an error, point to the first group, point to the first group that actually participated in the match, to the preceding group with that name, or to all preceding groups with that name at the same time. RegexBuddy already emulated this accurately when finding regex matches and making replacements on the Test panel.
But the drop-down menu of the Highlight and List All buttons on the Test toolbar would list the same group name multiple times. Selecting one of them would highlight or list the group inconsistently. Now these menus have only one entry for all groups with the same name. Only one of the groups will be highlighted or listed for each regex match. This is exactly the same group that the actual application or programming language returns when you retrieve the group’s match by its name.
When you double-click a highlighted match to see its full match details or select List All Matches with Full Details you get a list of the matches of all the capturing groups. When multiple groups have the same name, only one of those groups is now indicated with its name. That’s again the same group that the actual application or programming language returns when you retrieve the group’s match by its name. This can be a different group from one match to the next if the flavor takes into account whether a group participated in the match when resolving named references. The other groups are indicated by their numbers.
A branch reset group allows multiple alternatives to share the same capturing groups. Some flavors allow the alternatives to use different names for the same groups. This then results in the same group having multiple names. Previous versions of RegexBuddy already correctly emulated backreferences in the regular expression and replacement string using those alternate names. But those names were not listed in the Highlight All and List All drop-down menus or in the full match details. Now the menus list all the group names. The full match details show matches of groups with multiple names multiple times, once for each name. This reflects that the actual application or programming language returns the same group match when you retrieve matches by these group names.
See also: RegexBuddy 4.12.0 version history
This release brings RegexBuddy up-to-date with all the applications that it supports. Newly supported versions are Boost 1.73, C++Builder 10.4, Delphi 10.4, Java 14, PCRE 8.44, PCRE2 10.34, PHP 7.4.6, R 4.0.0, and Ruby 2.7.
You can now use Split mode in RegexBuddy when you select “PowerShell operators” as your application. When you do you can generate a code snippet using PowerShell’s -split operator on the Use panel.
Several fixes were made to the PCRE2 source code snippets that RegexBuddy generates on the Use panel. Most importantly, the 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 now knows that empty atomic groups are a syntax error in Boost. In all other regex flavors that support atomic groups, an empty one simply does nothing.
This release also fixes a few bugs in RegexBuddy’s regex engine. They only occurred in very specific circumstances. The version history has the complete list.
This release brings RegexBuddy up-to-date with all the applications that it supports. Newly supported versions are Boost 1.71, Visual C++ 2019, C++Builder 10.3, Delphi 10.3, Java 13, PCRE 8.43, PCRE2 10.33, Perl 5.30, PHP 7.3.11, Python 3.8, R 3.6.1, and Ruby 2.6.
This release also fixes a few bugs in RegexBuddy’s regex engine. Character class ranges starting with control character escape such as [\t-\r] are now handled correctly. Conditionals using lookaround no longer allow a quantifier on the lookaround. None of the flavors supported by RegexBuddy allow this even though some flavors do allow quantifiers on lookaround that is not used by a conditional.
Since version 4.8.0, RegexBuddy knows that in free-spacing mode many flavors only treat the ASCII space and tab as free whitespace and treat Unicode whitespace as significant. Since then it also knows exactly which line break styles are treated as free whitespace by each flavor. This improvement came with a new bug. Unicode whitespace immediately after a quantifier treated an access violation in free-spacing mode if the regex flavor did not treat it as free whitespace. This is now fixed.
RegexBuddy now knows that in Perl ${0} does not represent the whole regex match in a replacement string even though ${1} represents a numbered backreference. Boost replacement string case conversion is now applied to $0 and ${0}.
See also: RegexBuddy 4.10.0 version history
This release brings RegexBuddy up-to-date with all the applications that it supports. Newly supported versions are Boost 1.68, Java 10, PCRE2 10.31, Perl 5.28, PHP 7.2.0, Python 3.7, R 3.5.1, and XRegExp 4.
With every release of RegexBuddy, the JavaScript flavors are updated to emulate the latest releases of each of the browsers that RegexBuddy supports. The JavaScript (Chrome) flavor now supports lookbehind and the /s flag. These features are included in the ECMAScript 2018 specification. Chrome is the first browser to implement them.
The flavors for PHP 7.0.0 and later now enable the “support string syntax” option for both the regular expression and the replacement string. This allows RegexBuddy to emulate the \u{FFFF} syntax that inserts a Unicode code point into PHP 7 string literals. Select “support string syntax” if your regex will be quoted as a string literal in PHP 7 code. Select “regex syntax only” if your PHP application will read the regex from a file or from user input.
The PostgreSQL flavor now offers a drop-down list to make your regex case sensitive or insensitive. The Use panel will generate PostgreSQL snippets using the ~ or ~* operator depending on your choice. Other matching modes still have to be set using mode modifiers at the start of the regular expression. Though some of PostgreSQL’s functions allow these to be passed as flags outside the regular expression, the ~ operator does not support this.
See also: RegexBuddy 4.9.0 version history
RegexBuddy now officially supports .NET 4.7.2, PCRE 8.42, PHP 7.1.17, and R 3.4.4. These regex flavors are unchanged compared with previous versions.
Many regex flavors support the shorthand \w to match a word character. Traditionally this matches the letters A to Z (and a to z), the digits 0 to 9, and the underscore. Modern flavors add characters from various Unicode categories. RegexBuddy has accurately emulated which Unicode categories are included in \w by which flavors since version 4.0.0. Now, RegexBuddy also emulates that the XML Schema and XPath flavors, unlike all other regex flavors, do not treat the underscore as a word character.
RegexBuddy’s installer has been improved to better deal with Controlled Folder Access. This is the ransomware protection feature added to Windows Defender in the Windows 10 Fall Creators Update. It is unchanged in the April 2018 Update. RegexBuddy’s installation will now go a bit more smoothly when Controlled Folder Access is enabled. RegexBuddy’s installer now knows that when Windows Defender is not operational (because you’re using another anti-malware solution), Controlled Folder Access can’t be active and thus needn’t be dealt with. This avoids conflict between RegexBuddy’s installer and certain heavy-handed anti-malware solutions such as BitDefender.
RegexBuddy now officially supports .NET 4.7.1, PCRE 8.41, PHP 7.1.14, R 3.4.3, and Ruby 2.5. These regex flavors are unchanged compared with previous versions.
The Windows 10 Fall Creators Update adds a new feature to Windows Defender called Controlled Folder Access. It is disabled by default. When enabled, it prevents applications from creating files and modifying files in folders commonly used to save personal data such as the Desktop and Documents folders. The goal is to block ransomware. In practice, it seems to block almost any application unless you specifically add it to the list applications allowed through Controlled Folder Access. Even applications like installers that run with Administrator privileges are blocked by it.
RegexBuddy’s installer has been improved to better deal with Controlled Folder Access. It will no longer show an error message when it can’t create the desktop shortcut. This is the only aspect of RegexBuddy’s installation that is blocked when Controlled Folder Access is enabled with the default settings. During a regular installation, RegexBuddy’s installer adds RegexBuddy to the list of applications allowed through Controlled Folder Access, even when Controlled Folder Access is disabled. This way you won’t run into issues when you try to save files in your Documents folder or on your desktop with RegexBuddy. The installer can’t do this when creating a portable install as then the installer doesn’t have the Administrator privileges needed to modify settings in Windows Defender.
RegexBuddy can make use of multiple monitors. The View menu (3rd button from right on the top toolbar) provides two predefined dual monitor layouts. You can also manually drag panels by their tabs onto another monitor where they become floating windows. These floating windows are logically still part of RegexBuddy’s main window. So they don’t get taskbar buttons and thus can’t be minimized separately. Minimizing RegexBuddy’s main window hides all the floating windows. Restoring RegexBuddy also restores all floating windows. This release fixes a bug that caused floating windows to remain visible after minimizing RegexBuddy in certain circumstances.
The Create panel now better explains how balancing groups actually work. When the balancing group matches, it captures the text between the end of the capture that was subtracted and the start of the match of the balancing group. RegexBuddy has always emulated this correctly on the Test and Debug panels. But the Create panel made it sound like the balancing group would capture the text matched by the balancing group like a regular named group would do.
The GREP panel now correctly handles regular expressions with balancing groups and backreferences to named groups. Previously grepping would fail to start with an access violation error.
RegexBuddy now officially supports Boost 1.65, PHP 7.1.9, and R 3.4.1. These regex flavors are unchanged compared with previous versions.
Some keyboard layouts have a special AltGr key that is used to type special characters when pressed in combination with a letter key. RegexBuddy incorrectly interpreted AltGr+H, AltGr+N, AltGr+O, and AltGr+S as Ctrl+H, Ctrl+N, Ctrl+O, and Ctrl+S. This made it impossible to type certain characters on keyboard layouts that use AltGr+H, AltGr+N, AltGr+O, and/or AltGr+S. Other AltGr combinations were not affected. This bug has been fixed so that all AltGr key combinations work correctly.
Testing a regular expression that contains a subroutine call that points to an empty capturing group failed with an access violation. This has been fixed. The correct behavior is for such a subroutine call to successfully match the empty string, just like an empty group itself matches the empty string. There is little point in having a subroutine call to an empty group or the empty group itself in a regex. But this situation can arise while editing the contents of a group. It would trigger the error while editing if you had the Test panel highlight all matches or automatically update test results.
On some systems, a recent Windows 10 update caused RegexBuddy to fail to run with an error saying GetTextExtentPoint32W failed twice. This has been fixed.
See also: RegexBuddy 4.8.1 version history
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Boost 1.64, Delphi and C++Builder 10.2 Tokyo, PCRE 8.40, PCRE2 10.23, Perl 5.26, PHP 7.1.6, Python 3.6, R 3.4.0, Ruby 2.4, and std::regex in Visual C++ 2017.
Boost has its own ideas about how quantifiers on recursion should work and even changed its mind in version 1.60. RegexBuddy 4.7.0 could not emulate this so it treated all quantifiers other than ‘*‘ as errors when used on recursion with Boost. RegexBuddy 4.8.0 now correctly explains Boost’s behavior on the Create page and correctly emulates it on the Test page. Though you could consider this behavior to be bugged if you’re familiar with recursion in other flavors, it is the way how Boost works. So even in Helpful mode RegexBuddy no longer flags quantifiers on recursion as an error.
Previously, in free-spacing mode, RegexBuddy treated all spaces and line breaks, including Unicode spaces and line breaks, as free whitespace. This is what our own applications do. But they are actually unique in that aspect. RegexBuddy now knows that many flavors only treat the ASCII space and tab as free whitespace and that various line break characters other than the carriage return and line feed may or may not be free whitespace. Many regex flavors are inconsistent in which line breaks they recognize as free whitespace or as the end of a comment when compiling the regex and which line breaks they recognize when matching start and end of line anchors.
RegexBuddy is now better able to detect regexes with the potential for infinite recursion and endless recursion. Some flavors, like Ruby, flag this as a syntax error. RegexBuddy now does so too for those flavors. Some flavors crash upon infinite recursion. This too is now a syntax error in RegexBuddy. Previously it was only a matching error. In Helpful mode, RegexBuddy now flags unavoidable infinite recursion and endless recursion as a syntax error for all flavors as such regexes can never find any matches. RegexBuddy continues to allow potential infinite recursion for regexes that can find matches. When infinite recursion does occur with such regexes, that continues to be a matching error.
A regex syntax error is an error that occurs when the regular expression is parsed or compiled, before it is actually used. A matching error is an error that occurs while the regular expression is being applied to a subject string. In RegexBuddy, the Test panel indicates both types of errors. But the Create panel and syntax highlighting of the regex only indicate syntax errors. So by turning matching errors and crashes into syntax errors you can find them earlier.
RegexBuddy fully supports text written in right-to-left scripts such as Arabic or Hebrew as well as text that is a mixture of left-to-right and right-to-left scripts. You can toggle each multi-line editing control between left-to-right or right-to-left being the dominant text direction by holding down either Ctrl key on the keyboard, pressing and releasing the left hand or right hand Shift key on the keyboard, and then releasing the Ctrl key. This key combination also works in other applications such as Microsoft Notepad. Now the Ctrl+Shift key combination is only enabled in RegexBuddy if you have a keyboard layout for a right-to-left language installed in Windows. This way people who never type right-to-left text won’t be surprised that their text suddenly becomes right-aligned when they accidentally press Ctrl+Shift without including any other keys in the combination.
RegexBuddy is now able to automatically check for updates and other news. You can also make it check on request by selecting Help|News and Updates in the menu. When RegexBuddy shows news or when the check on request tells you there is no news you can click the Settings button to choose which news items you want to see. By default, RegexBuddy automatically shows news and updates for itself and any of our products that you’ve used in the past 30 days.
News settings and history are shared between all our products so you won’t see the same news more than once. Each product automatically shows at most one news item per day and at most one news item on request. So you don’t need to worry about ever being bombarded with news if you haven’t used our software for a while. You won’t see the news item announcing RegexBuddy 4.8.0 either because that is considered to be old news already when you’ve upgraded to RegexBuddy 4.8.0.
See also: RegexBuddy 4.8.0 version history
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are PHP 7.0.13 and R 3.3.2.
But the big news this release is the newly added support for C++ regular expressions using Boost. RegexBuddy supports Boost 1.38, 1.39, and 1.42 through the latest 1.62. Boost 1.40 and 1.41 are not supported as these have some fundamental bugs. Boost 1.38 and 1.39 (which have identical regex features) are supported because the classic Win32 C++Builder compiler is stuck on this version.
Alongside boost::regex you will also see boost::wregex in the list of applications. Choose boost::regex if your C++ code works on arrays of char or std::string. Choose boost::wregex if it works on arrays of wchar_t or std::wstring instead. On the Use panel there are separate functions for working with character arrays and with string objects.
When you select boost::regex as your application, the toolbar with regex options will have an additional drop-down list giving you a choice of six flavors: ECMAScript, basic, extended, grep, egrep, and awk. These are the six regex grammars supported by boost::regex. RegexBuddy fully supports all of them. If your C++ code selects the Perl or JavaScript grammars, then you need to select the ECMAScript flavor option in RegexBuddy. Boost treats Perl, JavaScript, and ECMAScript as synonyms. In reality it’s not really compatible with actual Perl or JavaScript.
In order to accurately emulate all of Boost peculiarities RegexBuddy is now aware of a whole set of new syntactic and behavioral aspects. The version history has the complete list. Most of these are unique to Boost. That long list is the main reason it has taken us so long to make RegexBuddy support Boost.
The Insert Token menu has a new Conditional item that makes it easy to insert a conditional that references a numbered or named group into the regular expression or into the replacement text.
RegexBuddy now scales itself better on systems using 200% or more display scaling. On such systems, toolbar icons are doubled in size. This makes the small icons suitable for 200% display scaling and the large ones for 300% scaling. You can switch between small and large icons via the menu under the View button (3rd button from right on the top toolbar). The about box and demo messages now double or triple their size on systems using 200% or 300% display scaling. These changes mean that RegexBuddy is now perfectly usable on all displays available on the market today, including laptops with 4K screens.
Windows 10 changes the way the mouse wheel works in Windows. In older versions of Windows, the wheel scrolled the window that had keyboard focus, regardless of the position of the mouse pointer. In Windows 10, the wheel scrolls the window under the mouse pointer. RegexBuddy now correctly implements the Windows 10 mouse wheel behavior when running on Windows 10. The mouse wheel behavior in RegexBuddy is unchanged when running on an older version of Windows.
A couple of important bugs affecting the GREP panel have been fixed. A search-and-replace that doesn’t create backup copies did not add error messages to the results for files that could not be overwritten (due to access rights or a lock by another application). This bug was introduced in RegexBuddy 4.0.0 and is now fixed. The Undo and Delete Backup Files commands in the drop-down menu under the GREP button did not do anything other than falsely claiming that they did what they were supposed to do. This bug was introduced in RegexBuddy 4.5.0. It is now fixed allowing you to once again undo GREP actions by restoring files from their backups and to quickly clean up the backups when they are no longer needed.
The PowerGREP button on the GREP panel now launches PowerGREP 5 if you have it installed. If not, it will launch PowerGREP 4 or 3 if you have one of those installed.
Since version 4.6.0, the Open URL button on the Test panel works with HTTPS URLs when the OpenSSL library is available. Version 4.6.1 further enhances this ability by also supporting HTTPS servers that use SNI, and supporting HTTP URLs that redirect to HTTPS.
A few minor bugs were also fixed. The version history has the complete list.
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Delphi and C++Builder 10.1 Berlin, PCRE 8.39, PCRE2 10.22, PHP 7.0.9, PowerGREP 5, R 3.3.1, and Ruby 2.3.
Some of these new versions bring new regex features that RegexBuddy now supports. THe most significant new feature is that PCRE2 10.21’s “extended” flavor and PowerGREP 5 support replacement string conditionals in the form of ${1:+yes:no}, ${name:+yes:no}, (?1yes:no), (?{1}yes:no) and/or (?{name}yes:no). Replacement string conditionals can have an implicit backreference as the “yes” part using the syntax ${1:-no} and ${name:-no}.
Applications can now have multiple replacement string flavors. std::regex supports a “sed” replacement string flavor in addition to the default “ECMAScript” flavor. PCRE2 10.21 has a new “extended” replacement string flavor.
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.
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. 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.
Regular expressions in the help file and PDF manual now have the same syntax coloring as they would have in RegexBuddy itself using the default color preferences.
Some of the regexes in RegexBuddy’s sample library have been updated. Sample regexes for MasterCard credit card numbers now include bin ranges 2221 through 2720. 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.
Opening HTTPS URLs on the Test panel now works if the OpenSSL library is available. If you have EditPad Pro, you can copy libaey32.dll and ssleay32.dll from EditPad Pro’s installation folder to RegexBuddy’s installation folder. Otherwise you can download a ZIP file with the two DLLs at http://indy.fulgan.com/SSL/. If RegexBuddy indicates “x64” next to its version number in the About box then you need the “win64.zip” file. Otherwise you need the “win32.zip” file. If the OpenSSL library is not available, then trying to open an HTTPS URL in RegexBuddy now says that HTTPS is not supported instead of saying something obscure about an IOHandler.
A bunch of minor bugs were also fixed. The version history has the complete list.
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Visual C++ 2015, Delphi and C++Builder 10 Seattle, PCRE 10.20, PHP 5.6.14, Python 3.5, XRegExp 3.0.0, and R 3.1.2. Microsoft Edge has been added as an additional browser option for JavaScript and HTML5 Pattern.
Under the Copy button there are new items for copying the regex or replacement text as a C++11 raw string literal. C++11 raw string literals do not require backslashes or quotes to be escaped and can contain literal line breaks. This makes them much better suited for adding regular expressions to your source code than normal C string literals because there’s no doubling up of all those backslashes. RegexBuddy automatically adapts the raw string delimiter to make sure it does not occur in the regex. The std::regex source code templates for all C++Builder versions and for Visual C++ 2013 and 2015 now use C++11 raw string literals. Earlier versions of Visual C++ do not support them. There are no items for C++ raw strings under the Paste button. The item for pasting C strings now recognizes the R prefix so it correctly pastes C++11 raw string literals in addition to normal C string literals.
When you select a programming language based on .NET as your application, there is now an additional regex option called “flavor choice”. You can switch this between “default flavor” and “ECMAScript”. This corresponds with not passing or passing RegexOptions.ECMAScript to the Regex() constructor. The topic about .NET in the Regular Expressions Tools part in the help file has a new section that discusses the effects of RegexOptions.ECMAScript in detail. The flavor choice is also available on the Convert panel. You can convert a regex that uses RegexOptions.ECMAScript to one that does not use RegexOptions.ECMAScript or vice versa. To see this in action, try converting the regex \d, which normally matches Unicode digits in .NET but only matches ASCII digits in ECMAScript mode.
Applications differ in how they treat an unescaped hyphen in a character class when the hyphen is between two tokens that cannot form a range. The hyphen can be treated as a literal or as a syntax error. Previously, RegexBuddy emulated the behavior of the selected application in both Helpful and Strict mode. Now, RegexBuddy does this in Strict mode only. In Helpful mode, unescaped hyphens that don’t form a valid range and that aren’t the first or last character in the character class are now always treated as an error. This encourages you to write regular expressions that are easier to read and easier to convert between applications by escaping them or by positioning them as the first or last character in the class.
Some cosmetic changes were made to RegexBuddy’s menus and toolbars to better fit the style of Windows 10. These changes only take effect when RegexBuddy is actually running on Windows 10. Screen shots and videos have been updated to show RegexBuddy running on Windows 10.
A bunch of minor bugs were also fixed. The version history has the complete list.
This release fixes a few bugs that were introduced in yesterday’s release that broke the GREP panel and partially broke the Insert Token commands.
See also: RegexBuddy 4.4.1 version history
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Perl 5.22, PHP 5.6.10, and R 3.2.1.
When you move the cursor while editing the regular expression, the Create panel now selects the node that corresponds with the regex token to the right of the cursor, unless there is a selection that starts to the left of the cursor. Previously, it always selected the node for the token to the left of the cursor. This makes the Create panel’s selection correspond better with the edit control for the regular expressions, as the cursor in text editing controls on Windows points points to the character to the right of the cursor.
The History and Library panels did not correctly load the “^$ match at line breaks” option. Regular expressions in Replace or Split mode were always loaded with this option turned on if the target application supports it. Regular expressions in Match mode were correctly loaded with the option on or off as it was saved. If you have libraries that store regular expressions in Replace or Split mode that are intended to be used with “^$ match at line breaks” turned off, then you will need to update those regular expressions to turn the option off as it will have been turned on when the library was loaded and saved by previous RegexBuddy 4.x.x releases.
In Python replacement strings you can use \g<name> named backreferences and \g<1> numbered backreferences. The Just Great Software applications also support these. Previous RegexBuddy releases already emulated this correctly. RegexBuddy now also correctly emulates that Delphi does not support \g<1> even though Delphi supports \g<name>. When you use the Insert Token menu to insert a numbered backreference with Python as the target application, RegexBuddy now inserts \g<1> instead of \1. The Insert Token menu prefers to insert backreferences that separate the number from any literal text that follows, so there are no issues with backreferences that are immediately followed by a digit.
When you convert a replacement string from one application to another, the Convert panel now prefers preserving the syntax used for backreferences if supported by the target flavor and there is no following literal digit to prefer a different syntax. If the target flavor does not support the same syntax, or if there is a literal digit after the backreference, then the Convert panel now prefers generating a backreference that separates the backreference’s number from literal digits that may follow the backreference. Essentially, these changes eliminate needless syntax conversions and make the converted replacement string easier to read and maintain in case of literal digits after backreferences. Replacement string conversions by previous versions of RegexBuddy were all syntactically correct. It never generated \g<1> for Delphi replacement strings, even though the Create and Test panels incorrectly allowed it.
See also: RegexBuddy 4.4.0 version history
Application version numbers were updated to .NET 4.6, PHP 5.6.8, PCRE 8.37, and R 3.2.0. None of these made any changes to their regex flavors.
On 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. Previously they were blue, which looked odd.
The 64-bit build of RegexBuddy no longer crashes on startup when the AllocationPreference registry key forces memory to be allocated from the top down. Since RegexBuddy never comes even close to using 4 GB of RAM, these crashes never occurred during normal use.
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Delphi and C++Builder XE8, PHP 5.6.7, PCRE 8.36, R 3.1.3, and Ruby 2.2. Delphi and PHP made no changes to their regex support. The other 3 made minor changes.
RegexBuddy now fully supports PCRE2 10.10. PCRE2 is the successor to PCRE, by the same author. Key differences between PCRE2 and PCRE are a completely redesigned C programming API, and the ability to substitute regex matches (search-and-replace). PCRE2 is now a separate option next to PCRE in the drop-down list with applications in RegexBuddy. Selecting PCRE2 gives you code snippets using the new PCRE2 API on the Use panel. It also enables the Replace button on the main toolbar, allowing you to test the new PCRE2 replacement string syntax, which is not Perl-compatible at all. There are no separate UTF-8, UTF-16, and UTF-16 choices for PCRE2 in RegexBuddy. The single PCRE2 choice supports all 3. Select the “import regex library” function on the Use panel to get a code snippet that allows you to choose between UTF-8, UTF-16, and UTF-32.
PCRE2 10.10 is the second release of PCRE2. The first release was 10.00. We’ve decided to skip the initial release because it has an important bug in its headline feature: replacement strings that end with a digit that is part of a backreference insert the digit as a literal at the end of each replacement, in addition to substituting the backreference. There are no other changes to the regex and replacement syntax between 10.00 and 10.10.
Python and PCRE2 treat backreferences in the replacement text to non-participating capturing groups as errors. In Helpful mode, RegexBuddy now treats backreferences to optional groups as errors for Python and PCRE2 them as a syntax error. This way you don’t end up with a search-and-replace that sometimes works (when the optional group matches), and sometimes errors out (when the group does not participate in the match). In Strict mode, RegexBuddy now works exactly like Python and PCRE2 do. Backreferences to optional groups are allowed and work without error as long as the groups participate. If your test subject includes one regex match in which the referenced group does not participate, then (and only then) you’ll get an error on the Test panel.
RegexBuddy now knows that Delphi XE6 and later provide an option roNotEmpty to control whether zero-length matches should be skipped when using TRegEx. On the Use panel, 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 shows a tip on the Create panel for regexes like ([0-9][A-Z]){3} that have a capturing group that is repeated. The tip intends to explain that when this regex matches 3 pairs of digits and letters, the capturing group stores only the last pair. It suggests to put a capturing group around the repeated group to capture all 3 pairs. This is not new.
What is new is that double-clicking this tip now performs the suggested change. It also turns the original capturing group into a non-capturing group, if the application supports that. In that case the result is ((?:[0-9][A-Z]){3}). Also new is that a second tip suggests that if you don’t need to capture anything (you just used the capturing group to be able to repeat multiple tokens together), then you can replace the capturing group with a non-capturing one. Double-clicking that tip also performs its suggestion. Finally, no tips will be shown for a regex like (([0-9][A-Z]){3}) where the repeated capturing group is already alone inside a capturing group, making the tip’s suggestion redundant.
Previously, these tips and other tips were shown when the Create panel was in Detailed mode, regardless of whether RegexBuddy was in Strict or Helpful mode. Now, most of these tips are only shown when RegexBuddy is in Helpful mode. Though these tips do not indicate errors, some people have been interpreting that way. They can now make them go away by switching to Strict mode, without being forced to switch the Create panel to Basic mode (which would hide a lot of information that can be quite useful).
See also: RegexBuddy 4.3.0 version history
Most regex flavors treat .*? and .*+ as a dot with a lazy or possessive quantifier, or as errors if lazy or possessive quantifiers are not supported. But some flavors such as GNU ERE allow multiple quantifiers to be combined, treating these regexes as (?:.*)? and (?:.*)+. Ruby also allows quantifiers to be combined, even though Ruby does support lazy or possessive quantifiers. RegexBuddy has correctly emulated combined quantifiers since version 4.0.0. But for most people this behavior is unexpected. So now RegexBuddy treats combined quantifiers that look like lazy or possessive quantifiers in other flavors as errors in Helpful mode, so you don’t accidentally use a combined quantifier when you intended a lazy or possessive quantifier. In Strict mode, RegexBuddy continues to accurately emulate all combined quantifiers in GNU ERE and Ruby.
Most regex flavors allow alternation with empty alternatives. If the engine is eager (stops trying alternatives as soon as one is found to match) then empty alternation outside all groups effectively truncates the regular expression as the engine will will always find a zero-length match at that point. Since this is unlikely to be intentional, RegexBuddy treats such empty alternatives as an error in Helpful mode. In Strict mode, RegexBuddy allows such alternatives if the flavor allows them, but will still add a warning to the regex tree on the Create panel.
Empty alternatives inside groups are another matter. Some flavors treat them as errors. But in most flavors the effect is simply that the group becomes optional. With a regex-directed engine (most engines), the difference between (a||c) and (a|c)? is that the former regex attempts the permutation where the group is optional before the permutation where the group matches c, while the latter regex attempts the permutation where the group is optional only after the permutations where it matches a or c have both failed. This can be a useful optimization technique, so RegexBuddy allows empty alternatives inside groups in both Helpful and Strict modes if the selected application allows them. To make it more obvious that empty alternatives make groups optional, the regex tree on the Create panel now adds a node under an empty alternative to indicate that the alternative will find a zero-length match. Previously empty alternatives were empty in the regex tree.
The icon that completely clears out the History panel has been changed. Previously it showed an empty sheet, which could be seen as a button for adding something new rather than clearing out everything. Now it shows a red X with several document sheets under it, which more clearly indicates that the entire History panel will be cleared. The order of the buttons has also changed to put this button next to the button that deletes the selected regex from the History.
A bunch of bugs were also fixed. In version 4.2.0, regular expressions and replacement strings that did not contain backslashes or line breaks were not correctly formatted as C# strings. The enclosing double quotes were missing. The Update button on the Library panel allowed library regexes to be replaced with blank regexes, which caused errors when that regex was selected later. This was doubly fixed by disabling the Update button when there is no current regex, and by correctly handling library items with blank regexes.
See also: RegexBuddy 4.2.1 version history
This release brings RegexBuddy up-to-date for all the applications that it supports. Newly supported versions are Delphi and C++Builder XE7, Perl 5.20, PHP 5.6.1, and R 3.1.1. Support for the Opera browser has been updated to reflect that it now uses the same JavaScript engine as the Chrome browser.
But the big news this release is the newly added support for C++ regular expressions using std::regex as implemented in the Dinkumware library that is included with Visual C++ 2008 through 2013 and C++Builder XE3 through XE7 for Win64. C++Builder for Win32 incudes boost::regex rather than std::regex. Support for boost::regex and other std::regex implementations is planned for future versions of RegexBuddy.
Alongside std::regex you will also see std::wregex in the list of applications. Choose std::regex if your C++ code works on arrays of char or std::string. Choose std::wregex if it works on arrays of wchar_t or std::wstring instead. On the Use panel there are separate functions for working with character arrays and with string objects. The Copy menu has new items for copying the regex and replacement as L“” strings for C and C++. The Paste from C string items handle strings with and without the L prefix.
When you select std::regex as your application, the toolbar with regex options will have an additional drop-down list giving you a choice of six flavors: ECMAScript, basic, extended, grep, egrep, and awk. These are the six regex grammars supported by std::regex, which are all fully supported by RegexBuddy. Adding this drop-down list 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. The same drop-down list appears on the Convert panel when selecting std::regex as the target application. You can use this to convert a regex to a specific std::regex grammar, regardless of whether the original application was another std::regex grammar or a different application altogether.
Some changes were made to the Insert Token menu. “ASCII character” item was renamed to “8-bit character” to better reflect that it allows you to insert characters from any 8-bit code page for use with 8-bit regex engines. The “Dot” item has been replaced with two new items “Any character including line breaks” and “Any character except line breaks”. These items insert specific tokens such as \p{Any} and \N when supported by your application, to make your regex less dependent on the “dot matches line breaks” options. If your application does not have these specific tokens, then the dot is inserted and the option “dot matches line breaks” is toggled as needed.
In order to accurately emulate std::regex and the latest versions of the other applications, RegexBuddy is now aware of a whole set of new syntactic and behavioral aspects. We also fixed a couple of corner case bugs in RegexBuddy’s regex engine while we were at it. The version history has the complete list of new regex aspects and bug fixes.
In Perl 5.12 and PCRE 8.10 and later you can use \N to match any character except a line break. RegexBuddy has supported this since version 4.0.0. You could think of \N being the opposite of \n. That’s what previous RegexBuddy releases told you. It is true in Perl. But in PCRE it would be more accurate to think of \N as a dot that is not affected by the “single line” or “dot matches line breaks” mode. In PCRE, both \N and . are affected by the line break handling mode. E.g. on Windows you may set PCRE’s line break handling mode to CRLF. Then \N will never match \n or \r and . won’t match those two characters when “dot matches line breaks” is off. RegexBuddy now correctly emulates that \N is affected by the line break handling mode in PCRE and in applications based on PCRE.
On the Create panel you can compare your regular expressions between multiple applications. You can select any of the applications that RegexBuddy supports, even if they have totally different regex flavors. Previous RegexBuddy releases, however, had a bug that could show an incorrect comparison if one of the applications selected for comparison on the Create panel did not support one of the options that you selected in the main toolbar. If you selected C# and “^$ don’t match at line breaks” in the toolbar at the top and selected Ruby for comparison on the Create panel, then RegexBuddy would pretend that Ruby supports the “^$ match at line breaks” option. This has been fixed. Now, RegexBuddy will use the options you specified only for those applications in the comparison that support them. In the same example, the comparison will tell you that in C# the anchors match at the start and end of the string only while in Ruby the anchors match at line breaks.
If you have a regular expression as a // operator in some JavaScript code, you can transfer that to RegexBuddy by copying the entire operator including the slashes and the flags after the second slash to the clipboard. Then select Paste from JavaScript // operator under the Paste button on RegexBuddy’s toolbar. A bug was fixed to make this work correctly even when the selected application is not a JavaScript flavor. RegexBuddy will now change the application to JavaScript. This is necessary to make sure that the flags that are part of the operator can be interpreted correctly.
On the Use panel, you can select the function “String literal with RegexBuddy’s regex tree” to reformat your regular expression as a string that you can paste into your source code that contains a working regular expression and includes the regex tree from the Create panel as comments. A couple of bugs were fixed that broke this string. Alternation operators are now handled correctly. Tree nodes which do not link to a specific part of the regex are now added correctly.
PCRE and Ruby support alternatives of different length inside lookbehind. But each alternative has to be of fixed length. The regex (?<=left|right) fits this restriction. It has two alternatives that are 4 and 5 characters long. But (?<=(left|right)) with an added capturing group does not fit this restriction. Now the lookbehind has only one alternative (the capturing group) which is of variable length (4 or 5 characters). Perl, on the other hand, does not support either of these regexes. Perl only allows alternation inside lookbehind if all alternatives have the same fixed length. RegexBuddy correctly indicated all this in previous versions, but the phrasing of the message that PCRE and Ruby do not support (?<=(left|right)) made it sound like they did not support (?<=left|right). The error messages for lookbehind limitations have now been improved to make this distinction clearer.
Two bugs in RegexBuddy’s regex engine have been fixed. When using the option “dot doesn’t match line breaks”, 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 trying to test them or highlight their matches. Recursion did not properly backtrack trailing optional groups that did not match but that were partially matched during the matching process.
See also: RegexBuddy 4.1.2 version history
On the Create panel, you can invoke RegexMagic to generate (part of) your regular expression with RegexMagic which you can then further edit with RegexBuddy. This integration now fully supports RegexMagic 2. RegexBuddy and RegexMagic now know exactly which applications are supported by the versions you have installed. The integration between them will automatically select the same application. RegexBuddy 4.1.x and RegexMagic 2.0.x support the same applications. If you use RegexBuddy 4.1.1 in combination with an older version of RegexMagic, then the integration still works, but you will need to select an application in RegexBuddy that is supported by your older version of RegexMagic.
On the Convert panel, you can use the “exact spacing” option to convert a free-spacing regex into an exactly spaced one. This can be useful if you prefer to work with free-spacing regexes in RegexBuddy for extra readability but need tightly spaced regexes in your actual application, perhaps because it provides only a single-line edit control for the regex. Or, you can choose “free-spacing” on the Convert panel to do the opposite. RegexBuddy then escapes all literal whitespace escaped in the converted regex, so you can easily reformat it by adding free whitespace and comments. This feature was introduced in version 4.0.0 but has now been improved. The choice you make on the Convert panel now overrides global mode modifiers in the regex.
Exporting to HTML on the Create panel now correctly replaces < and & in the regex or the caption with HTML entities.
See also: RegexBuddy 4.1.1 version history
RegexBuddy 4.1.0 adds support for several new applications. ASP.NET uses the .NET regex flavor with the XML string style and a new ASP.NET source code template. HTML5 Pattern comes in different browser versions. Its regex flavor is the same as that of JavaScript, but with implied anchors. A new source code template makes it easy to generate HTML5 input elements with regex validation. Visual Studio 2012–2013 IDE is the same as the .NET 2.0–4.5 flavor but with “case sensitive” as the only option and “case insensitive” as the default, just like the Search box in the Visual Studio IDE.
RegexBuddy 4.1.0 also adds support for the latest versions of all the applications it previously supported. This includes Delphi XE6, C++Builder XE6, Java 8, PCRE 8.34 and 8.35, PHP up to 5.5.11, Python 3.4, and R 3.0.2 until 3.1.0. The 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). All this means RegexBuddy now comes with 147 predefined applications (counting all versions with different regex features separately).
On the Create panel, the Export drop-down menu has been replaced with an Export button and a Copy button. Both show a dialog box that asks for the caption and for the export format. This means you can now copy HTML to the clipboard in addition to exporting HTML to file. There is also a new Markdown option that produces much better results on web sites that use Markdown such as stackoverflow.com.
When editing the replacement text, Insert Token|Backreference now has additional options for the case of the backreference for applications that can change the case of backreferences in replacement texts. This includes EditPad, PowerGREP, Perl, and R. Case conversions that are not supported by the current application are grayed out.
RegexBuddy now knows which regular expression options are the defaults for each application. There’s a new Reset button on the toolbar that resets all options to their default state for the current application. On the Operation tab in the Preferences there is a new setting to show the regular expression options with toggle buttons instead of drop-down lists. RegexBuddy 3 also had toggle buttons. But there is one key difference in the new toggle buttons in RegexBuddy 4. Since RegexBuddy 4 now knows the default state for each application, the labels of the toggle buttons change to indicate what happens when the option is turned on. Clicking the Reset button thus always unpresses all buttons. If you switch applications between, say, C# and the Visual Studio IDE then the “case insensitive” button changes to “case sensitive” and its state (depressed or not) is toggled. That’s because in C# you use RegexOptions.IgnoreCase to make the regex case insensitive, while in the VS IDE you need to tick a checkbox to make the regex case sensitive. If this sounds confusing, simply continue using the drop-down lists for the regex options. The drop-down lists always indicate the option’s state with a positive label, regardless of the application’s default.
RegexBuddy 4.0.x was inconsistent in whether rotating the mouse wheel while holding down the Control button on the keyboard changed the font size or scrolled one page. Now you can configure this on the Editors tab in the Preferences for all edit controls that are likely to show many pages of text. For the regular expressions editors Ctrl+wheel continues to change the font size only.
RegexBuddy’s emulation of all the flavors that it supports has been further improved. The items labeled “aspects” in the version history give you the details. In total, RegexBuddy now emulates 594 aspects of 105 regular expression flavors, and 100 aspects of 30 replacement text flavors, and 43 aspects of 19 split flavors.
See also: RegexBuddy 4.1.0 version history
RegexBuddy 4.0.3 fixes a few issues that we missed in earlier 4.0.x releases. RegexBuddy 4.0.1 and 4.0.2 constantly used 100% of one CPU core while idle after highlighting matches on the Test panel. The application was set to PowerGREP instead of EditPad when launched from EditPad and the active tab in EditPad was not Untitled. On the test panel, when match highlighting was off, the Find Next button skipped ahead one character instead of starting at the cursor position
Some applications silently remove backreferences from the replacement text if they reference capturing groups that do not exist rather than treating such backreferences as an error. Previous 4.0.x releases always treated such backreferences as errors in both Helpful and Strict mode. Now, RegexBuddy silently removes them in Strict mode if the application does so, while still treating them as an error in Helpful mode.
Other applications leave backreferences as literal text in the replacement if they reference capturing groups that do not exist. Previous 4.0.x releases emulated this behavior in both Helpful and Strict mode. Now, RegexBuddy still does what the application does in Strict mode, but treats the invalid backreference as an error in Helpful mode.
See also: RegexBuddy 4.0.3 version history
RegexBuddy 4.0.2 fixes a bunch of bugs that we missed in 4.0.0 and 4.0.1.
RegexBuddy now correctly emulates that Oracle 10gR2 and later support lazy quantifiers. RegexBuddy 4.0.0 already correctly emulated that Ruby 2.0 treats {n,m}+ as two combined greedy quantifiers that are the equivalent of {n,} rather than as as one possessive quantifier like all other applications that support possessive quantifiers do. But the Insert Token|Quantifier command did not take this into account. Now this command disables the “possessive” radio button for Ruby 2.0 when the minimum and maximum repetition require curly braces to be generated, preventing {n,m}+ from being generated.
Syntax highlighting for the regular expression now uses the correct colors for mode modifiers that are inside a group. Pressing Ctrl+[ while the edit box for the regular expression has keyboard focus now correctly expands the selection to cover the next pair of parentheses.
The Test panel now highlights regular expression matches when the replacement text has syntax errors, as long as the regular expression is valid, as it did in RegexBuddy 3.6.3 and prior. The bottom half of the Test panel still indicates syntax errors in the replacement text. The Test panel’s ability to indicate syntax errors in the regex and replacement while you edit the regex with the Highlight button enabled was added in RegexBuddy 4.0.0.
On the Use panel, the “get a logical vector…” functions for the R language now generate the correct code. Proxy settings are now preserved when restarting RegexBuddy.
See also: RegexBuddy 4.0.2 version history
RegexBuddy 4.0.1 fixes a bunch of bugs that we missed in last month’s major upgrade.
Regexes and replacement texts containing (needlessly) escaped quotes are now correctly converted to PHP strings when copying PHP strings or generating PHP source code snippets. Copying and pasting complete actions on the Library panel now works.
RegexBuddy 4.0.0 supports capturing group recursion and balancing groups. It also emulates that some flavors fail to backtrack capturing groups inside lookaround. This results in non-standard handling of capturing groups, which could cause the debugger in 4.0.0 to hang or crash. This has been fixed.
Also new in RegexBuddy 4.0.0 is that the Create panel explains and the Test panel emulates how regex flavors deal with zero-length matches. Some flavors advance before starting the next match attempt, while others start the next match attempt at the same position but backtrack until the regex finds a non-zero-length match. This introduced a bug on the GREP panel that made it advance after non-zero-length matches when using a flavor that advances after zero-length matches. In 4.0.1 the GREP panel correctly finds adjacent matches.
RegexBuddy 4 emulates whether a flavor allows quantifiers to be used on anchors. Version 4.0.0 correctly handled greedy quantifiers, but crashed when using a lazy or possessive quantifier on an anchor when emulating an application that allows this. Version 4.0.1 correctly handles all quantifiers.
The XRegExp library for JavaScript is one of the new applications supported by RegexBuddy 4. A topic describing this library has been added to the Tools & Languages section in the help file.
On the Use panel, 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) now correctly add ^ and $ for flavors like JavaScript that do not support dedicated string anchors like \A and \z. Syntax highlighting on the Use panel now correctly handles Ruby code snippets using the scan(), gsub(), or split() functions.
See also: RegexBuddy 4.0.1 version history
When you start RegexBuddy 4 for the first time, it may seem that not much has changed since RegexBuddy 3. The user interface is indeed largely unchanged. You’ll feel right at home.
But if you look closer, you’ll see evidence of the tremendous improvements that have been made under the hood in RegexBuddy 4. On the toolbar at the top, the drop-down lists with the regex flavor and replacement flavor have been replaced with a single list of applications. These applications are a combination of regex flavor, replacement flavor, split flavor, string style, and source code template. Select “More applications and languages” at the top of the list to choose any of the 126 predefined applications. The number is so large because RegexBuddy now supports many different versions of the same applications. Where RegexBuddy 3 had only “Java”, RegexBuddy 4 knows the differences between Java 4, 5, 6, and 7. Some applications use the same flavors. VBscript developers, for example, can now select VBscript as their application. With RegexBuddy 3 they had to remember that VBscript uses the JavaScript regex flavor. RegexBuddy 4 supports the latest versions of all the regex flavors that RegexBuddy 3 supported, including Delphi XE5, Java 7, .NET 4.5, PCRE 8.33, Perl 5.18, PHP 5.3.23, Python 3.3, R 3.0.1, Ruby 2.0, and Tcl 5.6. It also supports multiple variations of similar regex flavors, such as the JavaScript implementations in different browsers.
RegexBuddy’s emulation of all the regex and replacement flavors it supports is now far more accurate. RegexBuddy 3 knew which flavors support the caret and anchor to match at the start and end of a line, for example. But RegexBuddy 4 also knows exactly which characters each flavor treats as line breaks. RegexBuddy’s Test panel gives you exactly the same matches (or lack thereof) as your actual application will. The Create panel explains such details if you select the “Detailed” option. In total, RegexBuddy 4 is aware of 574 different aspects (syntactic and behavioral differences) of 94 regular expression flavors, and 96 aspects of 30 replacement text flavors. If you thought most modern regex flavors were all pretty much the same: think again!
In RegexBuddy 3, testing a Split operation always split the subject string along the regex matches in the same way. RegexBuddy 4 introduces split flavors, which describe exactly how the split function in a particular programming language works, along with the options that it accepts. RegexBuddy’s Test panel now splits strings in exactly the same way your actual application will. RegexBuddy 4 is aware of 43 aspects of 17 split flavors.
RegexBuddy’s increased accuracy can sometimes get in the way of helping you create regular expressions, particularly if you’re working with a regex flavor that is different than the one you normally use. To alleviate this, you can now toggle RegexBuddy between Helpful and Strict mode. For example, you may be used to using \A to match the start of the string. But in JavaScript, \A matches a literal A. In Helpful mode, RegexBuddy assumes that if you wanted to match A literally, you’d just enter A as your regex. So if you enter \A, RegexBuddy takes the liberty of telling you that JavaScript does not support \A as a start-of-string anchor. If you double-click the error on the Create panel, RegexBuddy will replace \A with ^ which JavaScript does support. In Strict mode, however, RegexBuddy will tell you that \A matches a literal A in JavaScript, and behave that way on the Test panel.
The matching modes such as “dot matches line breaks” are now implemented as drop-down lists rather than as push buttons. This makes it easier to see which mode you’re using. RegexBuddy now supports many more matching modes that are specific to certain regex flavors, such as explicit capture, line break handling, ungreedy matching, etc. To reduce clutter, RegexBuddy 4 only shows options that the active flavor actually allows you to change. On the Operation tab in the Preferences you can choose to always have all options visible like they were in RegexBuddy 3.
The Create panel can now compare multiple applications. If you’re creating regexes to be used in a library that targets several versions of a programming language, you can select all those flavors. RegexBuddy will tell you if any of the selected versions may interpret the regex differently. This way you can work around those differences while writing your code, so they don’t turn up as unpleasant surprises when testing your code.
The brand new Convert panel allows you to convert regular expressions and replacement texts from one application to another. If the two application’s regex flavors use different syntax for the same thing, the Convert panel will modify your regex to use the target flavor’s syntax. If the two applications support the same feature (using the same or different syntax) but with a difference in behavior that can lead to different matches, then the Convert panel will warn you about such differences. If you ever copy and paste a regex from the Internet, you should use the Convert panel to make sure there aren’t any (subtle) differences that may cause it to fail in your application.
The Test panel now highlights line breaks when they are part of the regex match. They now indicate the line break style instead of showing a generic paragraph symbol. The Line Breaks submenu in the Test panel’s right-click menu now has an additional option for automatic line breaks. This option, which is on by default, tells RegexBuddy to automatically adjust the test subject’s line breaks to those used by the active application. This way, the dot and the start-of-line and end-of-line anchors will always work the way you expect them to. It also mimics the default behavior of most scripting languages do. They read files in text mode, which automatically handles any differences in the line break style used by the text file and the line break style that the language uses internally.
If your regular expression contains a repeated capturing group and you’re using the .NET regex flavor, then the match details that RegexBuddy shows when you double-click a highlighted match on the Test panel now show all the iterations of that capturing group. These are the same strings that you can retrieve via .NET’s CaptureCollection class.
The Language selection was removed from the Use tab. Selecting an application now automatically selects the right source code template for the Use panel. You can still create custom source code templates or use the ones you created for RegexBuddy 3. To put them to use, select “More applications and languages” in the applications list and then create your own application, selecting the flavors it uses and the source code template. The template editor now highlights placeholders which keeps things readable in languages that treat % as an operator. The functions that generate a comment or string with the regex tree are no longer hard-coded. They are now implemented as functions that you can customize in the template editor.
RegexBuddy’s built-in GREP excludes files and folders that are hidden or that look like backup copies by default. In RegexBuddy 4, you can now configure or disable this on the GREP tab in the Preferences.
RegexBuddy 4 makes rich text available on the clipboard whenever you copy some text. This means that syntax coloring is preserved when you paste into a word processor or rich text editor. Your regular expressions, test data with highlighted matches, and code snippets will appear in your word processor as they do in RegexBuddy.
RegexBuddy 4 is a full Unicode application. You can use any mixture of any number of scripts anywhere in RegexBuddy, including in file names. RegexBuddy now supports bidirectional editing, so you can edit text written in right-to-left scripts such as Arabic or Hebrew or text written in a mixture of left-to-right and right-to-left scripts. You can configure text direction, cursor movement, fonts, and character spacing as part of the new text layout configuration system on the Editors tab in the Preferences.
RegexBuddy 4’s interface scales properly and looks crisp when using the high DPI settings in Windows Vista, Windows 7, and Windows 8. This makes RegexBuddy look perfect on the latest ultra high resolution laptops and monitors.
RegexBuddy 4 requires Windows XP, Vista, 7, or 8 to run. The 32-bit and 64-bit editions of these Windows versions are fully supported. Older versions of Windows are no longer supported.
Upgrade your copy of RegexBuddy now and juggle with regular expressions more easily and proficiently than before.
See also: RegexBuddy 4.0.0 version history