20241004; version 4.058: * Now modifiers (?ims-ims:) are enabled by default. 20240922; version 4.057: * Fixed an issue that caused the pattern compiler not to return an error even when an invalid Unicode property name or value is specified in \p{}/\P{} since version 4.054. * Removed replace() and split() from basic_regex. * Removed SRELL_CPP* macros. * Updated misc/conftest.cpp. The wrong mask value bug fix (same fix in srell.hpp 4.052) and changes for the removal of SRELL_CPP* macros. * Updated unicode/updataout3.cpp. 20240911; version 4.056: * Updated ucfdata2.h and updata3.h to support Unicode 16.0.0. * Other minor modifications. 20240904; version 4.055: * Adjusted the prefilter for UTF-8/UTF-16 so that search against a string containing not a few characters encoded in multiple code units (0080..10FFFF in UTF-8, 10000..10FFFF in UTF-16) would not be slowed down to excess. * Lowered the default value of limit_counter from 1 << 24 to 1 << 21. * Removed all member functions from regex_traits as unused. 20240831; version 4.054: * Code size reduction. Unified parsers that had been separate for u-mode and v-mode. 20240824; version 4.053: * Simplified the creation of the predefined character classes. * Improved internal UTF-8 iterators. Reduced the number of conditional jumps. 20240818; version 4.052: * Fixed the wrong mask value in utf16_traits. * Minor improvements. 20240816; version 4.051: * Reimplemented the optimisation introduced in 4.050 in a different way to minimise memory usage. * Minor improvements. 20240810; version 4.050: * Added a new optimisation for C{n,m} where C is a character or character class and n < m != infinity. * Minor improvements. 20240720; version 4.049: * Added the new flag, "sticky" to syntax_option_type. * Added split_aptrange() to regex_iterator2. * Removed the feature of generating a data file in an old format from ucfdataout2.cpp and updataout3.cpp. 20240714; version 4.048: * Removed two types of internal iterators, which read a codepoint value at the current position or the previous position with keeping its pointing position. * Modified internal UTF-8 iterators not to accept non-shortest forms. 20240707; version 4.047: * Performance improvement in searching with srell::regex (only if CHAR_BIT is 8), srell::u8cregex, or srell::u8regex. 20240613; version 4.046: * Code size reduction. SRELL no longer gives priority to finding a literal sequence. * Various minor improvements and fixes. 20240608; version 4.045: * Implemented the regex modifiers feature. But until the proposal is merged into the draft specification of ECMAScript, this feature is disabled and available only when SRELL_ENABLE_MODIFIERS is defined. * Added a missing check to see whether a backreference number exceeds the max number of capturing groups or not, which should have been added with the modification for the duplicate named capturing groups support in version 4.043. 20240602; version 4.044: * Added several missing #if ~ #endif directives for SRELL_NO_NAMEDCAPTURE. * Retired the older state insertion function in favour of the newer one. 20240526; version 4.043: * Implemented the duplicate named capturing groups feature. 20240524; version 4.042: * Expanded the scope of the optimisation for * and + also to support C{n,} where C is a character or character class and n >= 2. * Introduced the unified stack, which is used when either of the following conditions is met: 1) The iterator passed to the matching function is a pointer, or 2) std::is_trivially_copyable is supported by the compiler and for the type I of the passed iterator, std::is_trivially_copyable::value is true. Otherwise separate stacks that have been present from early versions are used. 20240519; version 4.041: * Completed the temporary fix in 4.040. * Removed unused functions. * Fixed a potential issue on systems where memory of more than 64 GB can be allocated. 20240131; version 4.040: * Restored one more line for ?? (non-greedy {0,1}) not to cause an optimisation bug. 20240127; version 4.039: * Restored some code that had been removed mistakenly in 4.037. 20240124; version 4.038: * Fixed a bug that caused /(?:ab)+|cd/ to match "ababcd". Condition: Both sides of | begin with different characters, and the left side character is contained in (?:)+. * Minor improvements. 20240122; version 4.037: * Fixed an optimisation bug that caused /(?:a|ab|abc)$/ to match "ac" since version 4.021. Condition: (?:A|B|C) where A is a prefix of B, and B is a prefix of C. -> A path from the end of A to a suffix of C occured through the wrong optimisation. This path was usually hidden, but could be used when backtracking is performed. * Other various improvements and fixes. 20240114; version 4.036: * Improvement and bugfix of lookaround (lookahead and lookbehind): 1. Removed unnecessary stack operations. 2. Restored the state type that had been removed in version 3.003 so that the value of the first capturing group in /(?:(?=(\w))|b)c$/ against "abc" will be undefined, not "b". Condition: 1. A lookaround assertion contains a capturing group, 2. After the lookaround assertion is successful, matching with succeeding expressions fails, 3, Another subpattern separated by '|' is tried and a match with total expressions is found. -> A subsequence captured by the group in the lookaround remained without being reverted to "undefined". * Replaced misc/sample01.cpp with conftest.cpp. * Tagged each kind of epsilon. 20231229; version 4.035: * Improved case folding of character classes. (Compilation of \p{Any} was a bit slow when the icase flag was set). * Several preparations for (?i:) support. * Updated updataout3.cpp. It could not be compiled because an internal namespace was changed in the previous version. 20231209; version 4.034: * Modified to use std::contiguous_iterator when it is available, to check if the iterator passed to the matching function is a contigous_iterator. * Modified match_results::operator[]() not to throw error_backref when a group name not existing in the regular expression is passed to as an argument, but to return a reference to a sub_match object representing an unmatched sub-exression. In accordance with this change, now match_results::operator[](size_type n) also returns the same object when n >= size(). (Behaviour accordant to std::regex. Until the previous version, this object was returned only when SRELL_STRICT_IMPL is defined). * Implemented the no throw/exception mode. * For the no throw mode, added basic_regex::ecode() that returns error_type that should have been thrown during the previous pattern compilation. * For the no throw mode, added match_results::ecode() that returns error_type that should have been thrown during the previous pattern matching/searching. 20230926; version 4.033: * Fixed a bug that could cause a crash on 64-bit systems since version 4.020 (Thanks to Yuriy Skvortsov for the bug report). Condition: 3 or more Alternatives begin with the same character such as /ab|ac|ad/. * Removed an unused member function from utf_traits. * Some clean-ups. 20230916; version 4.032: * Added directives for decoders of UTF-8/UTF-16 to be always inlined. * Improved several internal functions that call the automaton. 20230913; version 4.031: * Updated ucfdata2.h and updata3.h to support Unicode 15.1.0. * Updated updataout3.cpp so that the "Unknown" value can be used as a value for Script/Script_Extensions of Unicode property escapes. Although this value is mentioned in Scripts.txt, SRELL did not support it because it was not included in the table in the ECMAScript specification which shows what script names must be supported. However, as the table was removed from the specification and the rationale to exclude it has disappeared, SRELL has begun to support this value, following V8. 20230909; version 4.030: * Modified the pattern compiler not to create a rewinder only for ^, $, or \b/\B. * Introduced the binary search to look up names and values for Unicode properties. * In accordance with the change above, updated unicode/updataout2.cpp to updataout3.cpp. Furthermore, since the ECMAScript specification ceased to list the script names that must be supported, modified to read them from Scripts.txt and PropertyValueAliases.txt. * Changed the suffix of Unicode data files from *.hpp to *.h. * Updated unicode/ucfdataout2.cpp to follow the suffix change above. 20230903; version 4.029: * Updated unicode/updataout2.cpp to fix an issue that caused compilation error because internal integer types were unified in version 4.023. * Recreated srell_updata2.hpp (Data for the two scripts that were newly added to Unicode 15 were missing from the previous version. Apparently, it was output by the previous version of updataout2.cpp). 20230831; version 4.028: * Improved not to call the automaton for Unicode code point values that cannot be held by a single char/wchar_t when the regex or wregex type is used. 20230821; version 4.027: * Fixed a bug that caused the first capturing group to be empty in the match result of /(?:(\d+-)?)+(\d{1,2})-(\d{1,2})/ against "2023-8-21" (This bug had been existing from an early version). * Fixed a bug that caused the entire match to be only "23-8-21" in the same match result (This bug was introduced in 4.019 and was not covered by the fix in 4.026). 20230820; version 4.026: * Fix a bug that caused a search for /(\d+-)?\d{1,2}-\d{1,2}/ in "2023-8-20" matched only "23-8-20" since version 4.019. 20230819; version 4.025: * To avoid movzx, changed the type to hold a flag in the internal representation from bool to an integer type. * Repleaced names of member variables in structs that are used frequently in the automaton with shorter names. 20230817; version 4.024: * Commented out the code for an optimisation that had become unused since 4.019. * Various minor improvements and fixes. 20230804; version 4.023: * Unified two internal integer types to one type. * Simplified several optimisations that had become less effective because of the entry state selector introduced in 4.019. * Improved the entry state selector. * Corrected misnamed variable names. 20230730; version 4.022: * Refinement of source code and various minor fixes. 20230727; version 4.021: * Improved the branch optimisation so that SRELL can optimise Alternatives without inserting new additional internal states. 20230724; version 4.020: * Simplified the method of converting properties of strings to internal representations. * Other minor improvements. * [4.000-4.019, v flag mode] Because there was a mistake in the setting for compiling my own source files to a release version, the v flag mode was not correctly implemented in SRELL 4.000-4.019. Adding the following line at the last of the optimise_pos() function fixes the problem: insert_btbranch(piece, ins_bt); The bug originated from the fact that this function was not called from anywhere. 20230114; version 4.019: * Implemented a new entry state selector. 20230109; version 4.018: * Cancelled the mergence of automata that was done in version 4.016, because once I began to modify the pattern compiler for i-modifier support, icase search performance degradation that had not surface in preliminary examinations appeared. 20230107; version 4.017: * Fixed a bug that caused compilation to fail since version 4.006 when bidirectional iterators were passed to the matching function. 20230106; version 4.016/3.018 (@ only): * Merged four automata into two (preparation for i-modifier support). @ Fixed the pattern compiler not to treat /a{0,0}/ as an error. @ Other minor fixes. 20221227; version 4.015: * Fixed a minor issue in regex_iterator2 that was treated as an error by VC when _ITERATOR_DEBUG_LEVEL >= 1. * Other improvements. 20221220; version 4.014: * Supplemented some member functions that were missing accidentally from match_results in the previous release. * Simplified regex_token_iterator. 20221220; version 4.013: * Fixed a minor issue in split(). When splitting "abc" by /$/, split() had returned {"abc", ""} instead of {"abc"} that is correct. * Reduced the number of overload functions of replace(). Now when the lambda expression is used, the type of match_results that will be passed to a callback function needs specifying explicitly as the template argument. * Added regex_iterator2. 20221216; version 4.012: * Fixed replace(). VC2005 could not compile it. 20221214; version 4.011/3.017 (@ only): @ [LWG Issue 3204] Added swap() to sub_match. * Modified replace() so that it can replace any container type that looks like std::basic_string. * Added srell::str_clip. * Added overload functions to split() that support a pair of iterators and a pointer. 20221212; version 4.010: * Adjusted the behaviour of split() in accordance with the document. While the document says sub_match is pushed to a list container, in the code basic_string was pushed to the list container. * Added overloads to the sub_match class that support implicit and explcit converting to std::basic_string instantiated with a custom traits/allocator. 20221210; version 4.009/3.016 (@ only): @ Fixed a problem so that regex_iterator.prefix().matched can be set to true in incrementing after it matched an empty sequence. @ Fixed the core of the matching functions not to cause a compilation error when an object of match_results instantiated with a custom allocator is provided. * Added new member functions to basic_regex as API extensions. 20221130; version 4.008: * Priority was given back to the BMH matcher from the finder introduced in 4.006. * Minor improvements of ^ and $ in the multiline mode and \b, \B. 20221124; version 4.007: * Added support for the un-bounded flag modifiers ((?ims-ims)), which are available only at the beginning of a regular expression (the same as Python 3.11). Note: This feature is not defined in the ECMAScript specification nor compatible with the regexp-modifiers proposal. This feature can be disabled by defining SRELL_NO_UBMOD. 20221123; version 4.006: * Added a new finder for expressions whose first matching character is a single character. 20221030; version 4.005/3.015 (@ only): @ Fixed a problem that caused undefined behaviour in conditions where sizeof (int) != sizeof (long), e.g. LP64 (4/8/8). (Thanks to Travers Ching for the report). * Updated unicode/ucfdataout2.cpp and updataout2.cpp. Now they can compile even without srell_ucfdata2.hpp and srell_updata2.hpp. * Some clean-ups. 20221022; version 4.004/3.014: * Updated srell_ucfdata2.hpp and srell_updata2.hpp to support Unicode 15.0.0. * Updated unicode/updataout2.cpp to support Unicode 15. (Support in advance new script names that are expected to be available in RegExp of ECMAScript 2023). * Removed some code that had become unused or meaningless as a result of the previous backreference bug fixes. 20221012; version 4.003/3.013: * Re-refixed the backreference bug. Incidentally, this bug was introduced along with the addition of the variable-length lookbehind feature. Therefore, SRELL versions 2.000- have this bug. (It originated from the fact that in a variable length lookbehind assertion, it is possible that the parser encounters a backreference prior to the corresponding bracket pair, such as /(?<=\1\s+(\d+))/, and the parser cannot know immediately whether the corresponding capturing bracket pair really exists in the expression). 20221012; version 4.002/3.012: * Refixed the backreference bug in a different way because the fix of 20221011 did not cover the problem caused by such an expression as /(?:\1+)*()/. Fixed also an infinite loop caused by an expression like /()(?:\1+)*/. 20221011; version 4.001/3.011 (@ only): @ Fixed a bug that caused dereferencing a null pointer or infinite loop when a backreference is followed by * or +, and the backreference appears prior to the close bracket of the corresponding pair of capturing brackets, such as /\1*()/, /(\1+)/. (Thanks to @datadiode, the author of srellcom, for finding the bug). * In accordance with the ECMAScript specification, restricted positions where '-' can be written without escaping in character classes. Now '-' following a predefined character class such as \d, \s causes an error, unless it is the final character in a character class. ([\s-0] causes an error, [\s-] is accepted). * Adjusted internal UTF-8 iterators. 20220618; version 4.000: * Added support for the v-flag mode that is expected to be added to a future version of ECMAScript. * Changed the format of srell_updata.hpp and renamed to srell_updata2.hpp. * In accordance with the change above, unicode/updataout.cpp was updated and renamed to updataout2.cpp. * Fixed an issue of a struct layout that clang-tidy warns as "excessive padding" on 64-bit systems (Thanks for the report). * Updated unicode/ucfdataout2.cpp. 20220529; version 3.010: * Reduced the amount of memory used to hold a character class that contains Unicode property escapes. * Changed the value of error_type thrown when an invalid name or value is specified in curly brackets of \p or \P, from regex_constants::error_escape to newly-introduced regex_constants::error_property. * Other minor improvements. 20220511; version 3.009: * Fixed an optimisation bug that caused /abcd|ab/ not to match "abc". 20220504; version 3.008: * Fixed the behaviour of [^\P{...}] when the icase flag is set, as it behaved similarly to the one in v-mode that has been proposed in TC39. 20220429; version 3.007: * Further modification to the counter mechanism. 20220428; version 3.006: * Modified the mechanism of the counter used for repetition. * Re-removed the implementation of linear search for small character classes. 20220424; version 3.005: * Fixed a bug that caused /(?<=$.*)/ not to match the end of "a" when the multiline flag is set * Preparations for \A, \z, (?m:) that have been proposed in TC39. 20220420; version 3.004: * Added a new optimisation for /A*B/ and /A+B/ where a character class A overlaps a character or character class B, such as /[A-Za-z]+ing/, /".*"/. 20220416; version 3.003: * Combined two optimisation functions into one. * Reduced the amount of code for lookaround (lookahead and lookbehind) assertions. 20220416; version 3.002: * Fixed a bug that caused regex_match or regex_search with the match_continuous flag being set to fail when the entry state selector introduced in version 3.000 was used internally. 20211025; version 3.001: * Removed the code for splitting counter as it seemed to be no effect or to make performance a bit worse. * Fixed potential bugs. * Minor improvements. 20211023; version 3.000: * Updated srell_ucfdata2.hpp and srell_updata.hpp to support Unicode 14.0.0. * Updated unicode/updataout.cpp to support Unicode 14. (Support in advance new script names that are expected to be available in RegExp of ECMAScript 2022). * Changed the type used to store a Unicode value when char32_t is not available, from an "unsigned integer type with width of at least 21 bits" to a "one of at least 32 bits". * Changed the type used to store a repetition count or character class number when char32_t is not available, from "unsigned int" to "unsigned integer type of at least 32-bit width". * Added overflow check in the function that translates digits into a numeric value. For example, while up to the previous version /a{0,4294967297}/ was treated as /a{0,1}/ because of overflow when the unsigned int type is 32-bit width, SRELL now throws error_brace in cases like this. * Fixed a bug that caused /[^;]*^;?/ not to match the beginning of an input string when the multiline flag is not set. * Implemented a very simple and limited entry state selector. 20211004; version 2.930: * Added new typedefs whose prefix is u1632w- and support UTF-16 or UTF-32 depending on the value of WCHAR_MAX. (When 0xFFFF <= WCHAR_MAX < 0x10FFFF, u1632w- types are aliases of u16w- types. When 0x10FFFF <= WCHAR_MAX, u1632w- types are aliases of u32w- types). * Reduced the amount of memory used for Eytzinger layout search. * Various improvements. (Some of them are based on suggestions to NIRE by Marko Njezic). 20210624; version 2.920: * Added a new optimisation for the quantifier '?' (I.e., {0,1}). * Changed the version number of the ECMAScript specification referenced in misc/sample01.cpp to 2021. 20210429; version 2.912: * Fixed another bug in the optimisation introduced in version 2.900, which caused /aa|a|aa/ not to match "a" (Thanks to Jan Schrötter for the report). Incidentally, this optimisation can be disabled by defining SRELLDBG_NO_BRANCH_OPT2 prior to including srell.hpp. 20210424; version 2.911: * Fixed a bug in the optimisation introduced in version 2.900, which caused /abc|ab|ac/ not to match "ac". (Thanks for the bug report [As my email to the reporter was rejected by the email server and returned, it is unclear whether mentioning the name here is okay with the reporter. So, I refrain]). 20210407; version 2.910: * Fixed a potential memory leak in move assignment operators used by the pattern compiler since 2.900. (Thanks to Michal Švec for the report). 20210214; version 2.901: * Removed redundant template specialisations. 20210214; version 2.900: * Added a new optimisation for the alternative expression that consist of string literals, such as /abc|abd|acde/. * Fixed the problem that brought u(8|16)[cs]regex_(token_)?iterator (i.e., regex (token) iterators specialised for char8_t or char16_t) to a compile error. * Minor improvements. 20210131; version 2.810: * Improved internal UTF-8 iterators. 20200724; version 2.800: * Introduced the Eytzinger layout for binary search in the character class. * Reimplemented linear search for small character classes. * Modified handling of the property data used for parsing the name for a named capturing group. Now they are loaded only when needed instead of being loaded into an instance of basic_regex always. 20200714; version 2.730: * Added code to prevent redundant save and restore operations when nested capturing round brackets are processed. * Improved regex_iterator. 20200703; version 2.720: * Improved case-insensitive (icase) search using the Boyer-Moore-Horspool algorithm for UTF-8 string that includes non-ASCII characters or UTF-16 string that includes non-BMP characters. * Fixed a bug that caused regex_iterator->prefix().first to point to the beginning of the subject string instead of the end of the previous match (regression introduced in version 2.650, when three-iterators overloads were added to regex_search()). * In accordance with the fix above, when a three-iterators version of regex_search() is called, now match_results.position() returns a distance from the position passed to as the lookbehind limit (3rd param of regex_search) and match_results.prefix().first points to the position passed to as the beginning of the subject string (1st param of regex_search). * Fixed a bug that could cause a valid UTF-8 sequence being adjacent to an invalid UTF-8 sequence to be skipped when the BMH algorithm was used (regression introduced in version 2.630, when UTF-8 handling was modified). 20200701; version 2.710: * Minor modifications to Boyer-Moore-Horspool search. 20200630; version 2.700: * Optimisation adjustments. 20200620; version 2.651: * Move the group name validity check to after parsing the \u escape. * Updated misc/sample01.cpp to version 1.103. Changed the version number of the ECMAScript specification referenced by to 2020 (ES11). 20200618; version 2.650: * To element access functions in match_results, added overload functions for specifying the group name by a pointer. * When a three-iterators version of regex_search() is used, SRELL now sets match_results::prefix::first to the position passed to as the lookbehind limit (third param) instead of the position passed to as the beginning of the subject (first param). * Removed some operations that seem to be redundant. 20200601; version 2.643: * Added "inline" to operators in syntax_option_type and match_flag_type types, based on a report that it is needed not to cause the multiple definition error. * Minor improvements. 20200530; version 2.642: * Reduced the size of memory allocated by the basic_regex instance. 20200528; version 2.641: * The fix in 2.640 was incomplete. Fixed the optimisation bug 1 again. * Optimisation adjustments. 20200516; version 2.640: * Fixed an optimisation bug 1: It was possible for regex_match to pass the end of a subject string under certain conditions. * Fixed an optimisation bug 2: ^ and $ were not given a chance to match an appropriate position in some cases when the multiline flag is set to true. * Updated srell_ucfdata2.hpp and srell_updata.hpp. 20200509; version 2.630: * SRELL's pattern compiler no longer permits invalid UTF-8 sequences in regular expressions. It throws regex_utf8. (Invalid UTF-8 sequences in the subject string are not treated as an error.) * Fixed BMH search functions not to include extra (invalid) UTF-8 trailing bytes following the real matched substring, in a returned result. * Fixed minor issues: 1) basic_regex.flags() did not return the correct value in some cases, 2) match_results.format() did not replace $ with an empty string when any capturing group whose name is NAME did not exist. 20200502; version 2.620: * Removed methods used for match_continuous and regex_match in the class for the Boyer-Moore-Horspool algorithm. Now SRELL always uses the automaton like earlier versions when they are processed. * Some clean-ups. 20200428; version 2.611: * Fixed a bug that caused /\d*/ not to match the head of "abc" but to match the end of it. (regression introduced in version 2.210.) 20200426; version 2.610: * Fixed a bug that caused case-insensitive (icase) BMH search to skip a matched sequence at the beginning of the entire text, when 1) search is done against UTF-8 or UTF-16 text, and 2) the searched pattern ends with a character that consists of multiple code units in that encoding. * Now SRELL parses a capturing group name according to the ECMA specification and strictly checks its validity. Group names like /(?<,>...)/ cause regex_error. 20200418; version 2.600: * To pass to regex_search() directly the limit of a sequence until where the automaton can lookbehind, added three-iterators versions of regex_search(). * [Breaking Change] Removed the match_lblim_avail flag from match_flag_type and the lookbehind_limit member from match_results which were added in version 2.300. * Updated srell_ucfdata2.hpp and srell_updata.hpp to support Unicode 13.0.0. * Updated unicode/updataout.cpp to support Unicode 13. (Support in advance new script names that will be available in RegExp of ECMAScript 2020). 20191118; version 2.500: * Modified basic_regex to hold precomputed tables for icase matching, instead of creating them from case folding data when its instance is first created. * In accordance with the change above, srell_ucfdata.hpp and ucfdataout.cpp were replaced with srell_ucfdata2.hpp and ucfdataout2.cpp, accordingly. * Changed the method of character class matching from linear search to binary search. * Changed the timing of optimisation of a character class from "when a closing bracket ']' is found" to "every time a character or character range is pushed to its character class array". * Removed all asserts. * Modified the pattern compiler to interpret sequential \uHHHH escapes as a Unicode code point value if they represent a valid surrogate pair. (By this change, incompatibilities with the ECMAScript specification disappeared.) * Fixed the position of an endif directive that caused a compiler error when -DSRELL_NO_NAMEDCAPTURE is specified. * Updated updataout.cpp to version 1.101. * Added a standalone version of SRELL in the single-header directory. 20190914; version 2.401: * Reduced the size of basic_regex. (It was bloated by my carelessness when support for Unicode property escapes was added). * Improved basic_regex::swap(). 20190907; version 2.400: * Improved the performance of character class matching. * Modified the pattern compiler to interpret the \u escape sequence in the group name in accordance with the ECMAScript specification. * Updated ucfdataout.cpp to version 1.200. A new member has been added to the unicode_casefolding class in srell_ucfdata.hpp that ucfdataout.cpp generates. Because SRELL 2.400 and later need this added member, they cannot be used with srell_ucfdata.hpp output by ucfdataout.cpp version 1.101 or earlier. (No problem in using an older version of SRELL with a newer version of srell_ucfdata.hpp). * Some clean-ups and improvements. 20190902; version 2.304: * Fixed regex_iterator that had been broken by the code clean-up in version 2.303. 20190810; version 2.303: * Refixed the problem that was fixed in version 2.302 as the fix was incomplete. * Cleaned up code. 20190809; version 2.302: * Bug fix: When (?...) has a quantifier, strings captured by round brackets inside it were not cleared in each repetition but carried over to the next loop. For example, /(?:(ab)|(cd))+/.exec("abcd") returned ["abcd", "ab", "cd"], instead of ["abcd", undefined, "cd"]. (The latter is correct). * Updated misc/sample01.cpp to version 1.102. Rewrote the chapter numbers in accordance with ECMAScript 2019 (ES10). 20190724; version 2.301: * In accordance with the ECMAScript spec, restricted the characters which can be escaped by '\', to the following fifteen characters: ^$\.*+?()[]{}|/ Only in the character class, i.e., inside [], '-' also becomes a member of the group. 20190717; version 2.300: * Added a feature for specifying the limit until where the automaton can lookbehind, separated from the beginning of a target sequence. (Addition of the match_lblim_avail flag to match_flag_type and the lookbehind_limit member to match_results). And, lookbehind_limit of match_results being private and used internally in regex_iterator is also set in its constructor. * Removed order restriction of capturing parentheses and backreferences, in accordance with the ECMAScript spec. Now /\1(.)/, /(?<=(.)\1)/, and /\k(?.)/ are all okay. * Updated misc/sample01.cpp to version 1.101. Added one compliance test from misc.js. 20190714; version 2.230: * Improved the performance of searching when regular expressions begin with a character or character class followed by a '*' or '+'. (E.g. /[A-Za-z]+ing/). 20190707; version 2.221: * Changed the feature test macro used for checking availability of std::u8string, from __cpp_char8_t to __cpp_lib_char8_t. * When icase specified, if all characters in a character class become the same character as a result of case-folding, the pattern compiler has been changed to convert the character class to the character literal (e.g. /r[Ss\u017F]t/i -> /rst/i). * Fixed a minor issue. 20190617; version 2.220: * Changed the internal representation of repetition in the case that it becomes more compact by not using the counter. * Fixed an optimisation bug that caused searching for /a{1,2}?b/ against "aab" to return "ab" instead of "aab". (Condition: a character or character class with a non-greedy quantifier is followed by its exclusive character or character class). 20190613; version 2.210: * Improved a method of matching for expressions like /ab|cd|ef/ (where string literals separaterd by '|' begin with a character exclusive to each other). 20190603; version 2.202: * Fixed a bug that caused regex_match to behave like regex_search in the situation where the BMH algorithm is used. 20190531; version 2.200: * For searching with a ordinary (non-regex) string, added an implementation based on the Boyer-Moore-Horspool algorithm. * Improved UTF-8 iterators. * Fixed behaviours of \b and \B when icase specified, to match /.\B./i against "s\u017F". * Fixed minor issues. 20190508; version 2.100: * Fixed a bug that caused failure of capturing when 1) a pair of capturing brackets exists in a lookbehind assertion, and 2) variable length expressions exist in both the left side of and the inside of the pair of brackets. E.g. given "1053" =~ /(?<=(\d+)(\d+))$/, no appropriate string was set for $2. * Updated srell_ucfdata.hpp and srell_updata.hpp to support Unicode 12.1.0. * Updated unicode/updataout.cpp to support Unicode 12. (Support in advance a new binary property and new script names that will be available in RegExp of ECMAScript 2019 and new script names that are anticipated to be available in RegExp of ECMAScript 2020). * Changed the newline character in srell.hpp from CR+LF to LF. * Modified unicode/*.cpp to output LF as a newline instead of CR+LF. * Updated misc/sample01.cpp to version 1.100: 1. Rewrote the chapter numbers in subtitles of compliance tests, in accordance with ECMAScript 2018 Language Specification (ES9). (The old chapter numbers were based on ECMAScript specifications up to version 5.1). 2. Added one compliance test from ECMAScript 2018 Language Specification 21.2.2.3, NOTE. * Modified the macros for detecting C++11 features. * Changed the method of the character class. * For all the constructors and assign functions of basic_regex to have a default argument for flag_type, reimplemented syntax_option_type and match_flag_type (missed changes between TR1 -> C++11). * Experimental support for the char8_t type. If a compiler supports char8_t (detected by the __cpp_char8_t macro), classes whose names have the "u8-" prefix accept a sequence of char8_t and handle it as a UTF-8 string. If char8_t is not supported, the classes handle a sequence of char as a UTF-8 string, as before. * As classes that always handle a sequence of char as a UTF-8 string, new classes whose names have the "u8c-" prefix were added. They correspond to the classes having the "u8-" prefix in their names up to version 2.002: * u8cregex; u8ccmatch, u8csmatch; u8ccsub_match, u8cssub_match; u8ccregex_iterator, u8csregex_iterator; u8ccregex_token_iterator, u8csregex_token_iterator. 20180717; version 2.002: * Changed the maximum number of hexdigits in \u{h...} from six to 'unlimited' in accordance with the ECMAScript specification. ("one to six hexadecimal digits" of the old implementation was based on the proposal document). * Updated updataout.cpp to version 1.001. Encounting unknown (newly-encoded) script names is no longer treated as an error. * Updated srell_ucfdata.hpp and srell_updata.hpp to support Unicode 11.0.0. 20180204; version 2.001: * When icase is specified, [\W] (a character class containing \W) no longer matches any of [KkSs\u017F\u212A] (ecma262 issue #512). 20180127; version 2.000: * Added the following features that are to be included into RegExp of ECMAScript 2018: * New syntax option flag for '.' to match every code point, dotall, was added to srell::regex_constants as a value of syntax_option_type and to srell::basic_regex as a value of flag_type. * New expressions to support the Unicode property, \p{...} and \P{...}. * Named capture groups (?...) and the new expression for backreference to a named capture group, \k. * The behaviors of lookbehind assertions changed. Now both (?<=...) and (?" to compile() in basic_regex::assign(). 2. Implemented operator=() functions explicitly instead of using default ones generated automatically. * unicode/ucfdataout.cpp revised and updated to version 1.001. 20140622; version 1.101: Updated srell_ucfdata.hpp to support Unicode 7.0.0. 20121118; version 1.100: The first released version.