RegexBuddy Changelog

What's new in RegexBuddy 4.14.1

Oct 16, 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.

New in RegexBuddy 4.13.0 (Oct 25, 2021)

New in RegexBuddy 4.12.0 (May 20, 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:
API: DebugAtPos and DebugAfterPos now respect the CharPos parameter.
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 (?

New in RegexBuddy 4.11.0 (May 27, 2020)

New in RegexBuddy 4.10.0 (Nov 22, 2019)

New in RegexBuddy 4.9.0 (Sep 12, 2018)

New in RegexBuddy 4.8.3 (May 18, 2018)

New in RegexBuddy 4.8.2 (Feb 19, 2018)

New in RegexBuddy 4.8.1 (Sep 22, 2017)

New in RegexBuddy 4.8.0 (Jun 29, 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.

New in RegexBuddy 4.7.0 (Dec 8, 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, g, g, 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.

New in RegexBuddy 4.6.1 (Sep 20, 2016)

New in RegexBuddy 4.6.0 (Aug 22, 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: 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 400 and 777 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.

New in RegexBuddy 4.5.0 (Oct 14, 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.

New in RegexBuddy 4.4.1 (Jun 30, 2015)

New in RegexBuddy 4.4.0 (Jun 29, 2015)

New in RegexBuddy 4.3.1 (May 8, 2015)

New in RegexBuddy 4.3.0 (Apr 9, 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 [[::]] as the only word boundaries that match specifically at the start or end of a word, error messages about \m, \M, \ 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).

New in RegexBuddy 4.2.1 (Dec 12, 2014)

New in RegexBuddy 4.2.0 (Dec 12, 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.

New in RegexBuddy 4.1.3 (Aug 14, 2014)

New in RegexBuddy 4.1.2 (Jul 7, 2014)

New in RegexBuddy 4.1.1 (May 27, 2014)

New in RegexBuddy 4.1.0 (May 1, 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.

New in RegexBuddy 4.0.3 (Dec 17, 2013)

New in RegexBuddy 4.0.2 (Nov 15, 2013)

New in RegexBuddy 4.0.1 (Oct 24, 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.

New in RegexBuddy 4.0.0 (Sep 19, 2013)

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, \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 [[::]].
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 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.

New in RegexBuddy 3.6.2 (Sep 19, 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.

New in RegexBuddy 3.6.1 (Mar 12, 2013)

New in RegexBuddy 3.6.0 (Oct 25, 2012)

New in RegexBuddy 3.5.5 (Mar 22, 2012)

New in RegexBuddy 3.5.4 (Nov 18, 2011)

New in RegexBuddy 3.5.3 (Jun 22, 2011)

New in RegexBuddy 3.5.2 (Jun 17, 2011)

New in RegexBuddy 3.5.1 (Feb 18, 2011)

New in RegexBuddy 3.5.0 (Sep 3, 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 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 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.

New in RegexBuddy 3.4.2 (Mar 11, 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.

New in RegexBuddy 3.4.1 (Mar 11, 2010)

New in RegexBuddy 3.4.0 (Aug 5, 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.

New in RegexBuddy 3.3.0 (Apr 8, 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.

New in RegexBuddy 3.2.1 (Dec 9, 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 to insert the whole regex match into the replacement text, but does support g. RegexBuddy did correctly support g in the regex and on the Test tab, but did not convert or $0 into g 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: ,
and 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[
]*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.

New in RegexBuddy 3.2.0 (Oct 3, 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 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)c2)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)c1)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 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.: (?

New in RegexBuddy 3.1.1 (Apr 4, 2008)

New in RegexBuddy 3.1.0 (Dec 20, 2007)

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 and
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.
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
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.
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
, 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.

New in RegexBuddy 3.0.5 (Sep 24, 2007)

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. 377 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.

New in RegexBuddy 3.0.4 (Sep 10, 2007)

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.
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.
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 (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.

New in RegexBuddy 3.0.3 (Jul 18, 2007)

New in RegexBuddy 3.0.2 (Jul 2, 2007)

New in RegexBuddy 3.0.0 (Jun 13, 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 can 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 with 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.