| Name | +Role | +
|---|---|
|
+
+ Nicholas Wilson + `nicholas@nicholaswilson.me.uk` + Currently of Microsoft Research Cambridge, UK + + |
+ + + * General project administration & maintenance + * Release management + * Code maintenance + + | +
|
+
+ Zoltán Herczeg + `hzmester@freemail.hu` + Currently of the University of Szeged, Hungary + + |
+ + + * Code maintenance + * Ownership of `sljit` and PCRE2's JIT + + | +
-Philip Hazel
-
-Retired from University Computing Service
-
-Cambridge, England.
-
+The current maintainers of PCRE2 are Nicholas Wilson and Zoltan Herczeg.
+
+PCRE2 was written by Philip Hazel, of the University Computing Service, +Cambridge, England. Many others have also contributed.
-Putting an actual email address here is a spam magnet. If you want to email me, -use my two names separated by a dot at gmail.com. +To contact the maintainers, please use the GitHub issues tracker or PCRE2 +mailing list, as described at the project page: +https://github.com/PCRE2Project/pcre2
-Last updated: 27 August 2021
+Last updated: 18 December 2024
Copyright © 1997-2021 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2_compile.html b/mingw32/share/doc/pcre2/html/pcre2_compile.html
index f0080eabe45..ee933f38983 100644
--- a/mingw32/share/doc/pcre2/html/pcre2_compile.html
+++ b/mingw32/share/doc/pcre2/html/pcre2_compile.html
@@ -57,6 +57,7 @@
-The first argument is a pointer that was returned by a successful call to -pcre2_compile(), and the second must contain one or more of the following -bits: +The availability of JIT support can be tested by calling +pcre2_compile_jit() with a single option PCRE2_JIT_TEST_ALLOC (the +code argument is ignored, so a NULL value is accepted). Such a call +returns zero if JIT is available and has a working allocator. Otherwise +it returns PCRE2_ERROR_NOMEMORY if JIT is available but cannot allocate +executable memory, or PCRE2_ERROR_JIT_UNSUPPORTED if JIT support is not +compiled. +
++Otherwise, the first argument must be a pointer that was returned by a +successful call to pcre2_compile(), and the second must contain one or +more of the following bits:
PCRE2_JIT_COMPLETE compile code for full matching PCRE2_JIT_PARTIAL_SOFT compile code for soft partial matching @@ -46,11 +55,13 @@There is a complete description of the PCRE2 native API in the pcre2api diff --git a/mingw32/share/doc/pcre2/html/pcre2_set_max_pattern_compiled_length.html b/mingw32/share/doc/pcre2/html/pcre2_set_max_pattern_compiled_length.html index ab570cf60d1..a40f41e450c 100644 --- a/mingw32/share/doc/pcre2/html/pcre2_set_max_pattern_compiled_length.html +++ b/mingw32/share/doc/pcre2/html/pcre2_set_max_pattern_compiled_length.html @@ -27,9 +27,9 @@pcre2_jit_compile man page
option is deprecated and may be removed in the future.-The yield of the function is 0 for success, or a negative error code otherwise. -In particular, PCRE2_ERROR_JIT_BADOPTION is returned if JIT is not supported or -if an unknown bit is set in options. The function can also return -PCRE2_ERROR_NOMEMORY if JIT is unable to allocate executable memory for the -compiler, even if it was because of a system security restriction. +The yield of the function when called with any of the three options above is 0 +for success, or a negative error code otherwise. In particular, +PCRE2_ERROR_JIT_BADOPTION is returned if JIT is not supported or if an unknown +bit is set in options. The function can also return PCRE2_ERROR_NOMEMORY +if JIT is unable to allocate executable memory for the compiler, even if it was +because of a system security restriction. In a few cases, the function may +return with PCRE2_ERROR_JIT_UNSUPPORTED for unsupported features.
There is a complete description of the PCRE2 native API in the diff --git a/mingw32/share/doc/pcre2/html/pcre2_set_compile_extra_options.html b/mingw32/share/doc/pcre2/html/pcre2_set_compile_extra_options.html index 4924ed79b5e..cb62022a22e 100644 --- a/mingw32/share/doc/pcre2/html/pcre2_set_compile_extra_options.html +++ b/mingw32/share/doc/pcre2/html/pcre2_set_compile_extra_options.html @@ -43,6 +43,10 @@
pcre2_set_compile_extra_options man page
PCRE2_EXTRA_ESCAPED_CR_IS_LF Interpret \r as \n PCRE2_EXTRA_MATCH_LINE Pattern matches whole lines PCRE2_EXTRA_MATCH_WORD Pattern matches "words" + PCRE2_EXTRA_NEVER_CALLOUT Disallow callouts in pattern + PCRE2_EXTRA_NO_BS0 Disallow \0 (but not \00 or \000) + PCRE2_EXTRA_PYTHON_OCTAL Use Python rules for octal + PCRE2_EXTRA_TURKISH_CASING Use Turkish I case folding
This function sets, in a compile context, the maximum size (in bytes) for the -memory needed to hold the compiled version of a pattern that is compiled with -this context. The result is always zero. If a pattern that is passed to -pcre2_compile() with this context needs more memory, an error is +memory needed to hold the compiled version of a pattern that is using this +context. The result is always zero. If a pattern that is passed to +pcre2_compile() referencing this context needs more memory, an error is generated. The default is the largest number that a PCRE2_SIZE variable can hold, which is effectively unlimited.
diff --git a/mingw32/share/doc/pcre2/html/pcre2_set_optimize.html b/mingw32/share/doc/pcre2/html/pcre2_set_optimize.html new file mode 100644 index 00000000000..47caeb267ae --- /dev/null +++ b/mingw32/share/doc/pcre2/html/pcre2_set_optimize.html @@ -0,0 +1,57 @@ + + ++Return to the PCRE2 index page. +
+
+This page is part of the PCRE2 HTML documentation. It was generated
+automatically from the original man page. If there is any nonsense in it,
+please consult the man page, in case the conversion went wrong.
+
+
+SYNOPSIS
+
+
+#include <pcre2.h> +
++int pcre2_set_optimize(pcre2_compile_context *ccontext, + uint32_t directive); +
++This function controls which performance optimizations will be applied +by pcre2_compile(). It can be called multiple times with the same compile +context; the effects are cumulative, with the effects of later calls taking +precedence over earlier ones. +
++The result is zero for success, PCRE2_ERROR_NULL if ccontext is NULL, +or PCRE2_ERROR_BADOPTION if directive is unknown. The latter could be +useful to detect if a certain optimization is available. +
++The list of possible values for the directive parameter are: +
+ PCRE2_OPTIMIZATION_FULL Enable all optimizations (default) + PCRE2_OPTIMIZATION_NONE Disable all optimizations + PCRE2_AUTO_POSSESS Enable auto-possessification + PCRE2_AUTO_POSSESS_OFF Disable auto-possessification + PCRE2_DOTSTAR_ANCHOR Enable implicit dotstar anchoring + PCRE2_DOTSTAR_ANCHOR_OFF Disable implicit dotstar anchoring + PCRE2_START_OPTIMIZE Enable start-up optimizations at match time + PCRE2_START_OPTIMIZE_OFF Disable start-up optimizations at match time ++There is a complete description of the PCRE2 native API, including detailed +descriptions directive parameter values in the +pcre2api +page. +
+Return to the PCRE2 index page. +
diff --git a/mingw32/share/doc/pcre2/html/pcre2_set_substitute_callout.html b/mingw32/share/doc/pcre2/html/pcre2_set_substitute_callout.html index 7ae3a398d79..8640728fdc4 100644 --- a/mingw32/share/doc/pcre2/html/pcre2_set_substitute_callout.html +++ b/mingw32/share/doc/pcre2/html/pcre2_set_substitute_callout.html @@ -20,7 +20,7 @@int pcre2_set_substitute_callout(pcre2_match_context *mcontext, - int (*callout_function)(pcre2_substitute_callout_block *), + int (*callout_function)(pcre2_substitute_callout_block *, void *), void *callout_data);
+Return to the PCRE2 index page. +
+
+This page is part of the PCRE2 HTML documentation. It was generated
+automatically from the original man page. If there is any nonsense in it,
+please consult the man page, in case the conversion went wrong.
+
+
+SYNOPSIS
+
+
+#include <pcre2.h> +
++int pcre2_set_substitute_case_callout(pcre2_match_context *mcontext, + PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE, + PCRE2_UCHAR *, PCRE2_SIZE, + int, void *), + void *callout_data); +
++This function sets the substitute case callout fields in a match context (the +first argument). The second argument specifies a callout function, and the third +argument is an opaque data item that is passed to it. The result of this +function is always zero. +
++There is a complete description of the PCRE2 native API in the +pcre2api +page and a description of the POSIX API in the +pcre2posix +page. +
+Return to the PCRE2 index page. +
diff --git a/mingw32/share/doc/pcre2/html/pcre2api.html b/mingw32/share/doc/pcre2/html/pcre2api.html index 6b60ee9fa7a..079cf176daa 100644 --- a/mingw32/share/doc/pcre2/html/pcre2api.html +++ b/mingw32/share/doc/pcre2/html/pcre2api.html @@ -179,6 +179,10 @@@@ -203,6 +207,13 @@
+The permitted values of directive are as follows: +
+ PCRE2_OPTIMIZATION_FULL ++Enable all optional performance optimizations. This is the default value. +
+ PCRE2_OPTIMIZATION_NONE ++Disable all optional performance optimizations. +
+ PCRE2_AUTO_POSSESS + PCRE2_AUTO_POSSESS_OFF ++Enable/disable "auto-possessification" of variable quantifiers such as * and +. +This optimization, for example, turns a+b into a++b in order to avoid +backtracks into a+ that can never be successful. However, if callouts are in +use, auto-possessification means that some callouts are never taken. You can +disable this optimization if you want the matching functions to do a full, +unoptimized search and run all the callouts. +
+ PCRE2_DOTSTAR_ANCHOR + PCRE2_DOTSTAR_ANCHOR_OFF ++Enable/disable an optimization that is applied when .* is the first significant +item in a top-level branch of a pattern, and all the other branches also start +with .* or with \A or \G or ^. Such a pattern is automatically anchored if +PCRE2_DOTALL is set for all the .* items and PCRE2_MULTILINE is not set for any +^ items. Otherwise, the fact that any match must start either at the start of +the subject or following a newline is remembered. Like other optimizations, +this can cause callouts to be skipped. + +
+Dotstar anchor optimization is automatically disabled for .* if it is inside an +atomic group or a capture group that is the subject of a backreference, or if +the pattern contains (*PRUNE) or (*SKIP). +
+ PCRE2_START_OPTIMIZE + PCRE2_START_OPTIMIZE_OFF ++Enable/disable optimizations which cause matching functions to scan the subject +string for specific code unit values before attempting a match. For example, if +it is known that an unanchored match must start with a specific value, the +matching code searches the subject for that value, and fails immediately if it +cannot find it, without actually running the main matching function. This means +that a special item such as (*COMMIT) at the start of a pattern is not +considered until after a suitable starting point for the match has been found. +Also, when callouts or (*MARK) items are in use, these "start-up" optimizations +can cause them to be skipped if the pattern is never actually used. The start-up +optimizations are in effect a pre-scan of the subject that takes place before +the pattern is run. + +
+Disabling start-up optimizations ensures that in cases where the result is "no +match", the callouts do occur, and that items such as (*COMMIT) and (*MARK) are +considered at every possible starting position in the subject string. +
++Disabling start-up optimizations may change the outcome of a matching operation. +Consider the pattern +
+ (*COMMIT)ABC ++When this is compiled, PCRE2 records the fact that a match must start with the +character "A". Suppose the subject string is "DEFABC". The start-up +optimization scans along the subject, finds "A" and runs the first match +attempt from there. The (*COMMIT) item means that the pattern must match the +current starting position, which in this case, it does. However, if the same +match is run without start-up optimizations, the initial scan along the subject +string does not happen. The first match attempt is run starting from "D" and +when this fails, (*COMMIT) prevents any further matches being tried, so the +overall result is "no match". + +
+Another start-up optimization makes use of a minimum length for a matching +subject, which is recorded when possible. Consider the pattern +
+ (*MARK:1)B(*MARK:2)(X|Y) ++The minimum length for a match is two characters. If the subject is "XXBB", the +"starting character" optimization skips "XX", then tries to match "BB", which +is long enough. In the process, (*MARK:2) is encountered and remembered. When +the match attempt fails, the next "B" is found, but there is only one character +left, so there are no more attempts, and "no match" is returned with the "last +mark seen" set to "2". Without start-up optimizations, however, matches are +tried at every possible starting position, including at the end of the subject, +where (*MARK:1) is encountered, but there is no "B", so the "last mark seen" +that is returned is "1". In this case, the optimizations do not affect the +overall match result, which is still "no match", but they do affect the +auxiliary information that is returned.
@@ -1431,7 +1563,7 @@For patterns that are auto-anchored, the PCRE2_ANCHORED bit is set in the options returned for PCRE2_INFO_ALLOPTIONS. @@ -3646,9 +3812,10 @@pcre2api man page
error has occurred.-There are nearly 100 positive error codes that pcre2_compile() may return +There are over 100 positive error codes that pcre2_compile() may return if it finds an error in the pattern. There are also some negative error codes that are used for invalid UTF strings when validity checking is in force. These are the same as given by pcre2_match() and pcre2_dfa_match(), and @@ -1539,6 +1671,16 @@
pcre2api man page
end of the subject, for compatibility with Perl. If you want a multiline circumflex also to match after a terminating newline, you must set PCRE2_ALT_CIRCUMFLEX. ++ PCRE2_ALT_EXTENDED_CLASS ++Alters the parsing of character classes to follow the extended syntax +described by Unicode UTS#18. The PCRE2_ALT_EXTENDED_CLASS option has no impact +on the behaviour of the Perl-specific "(?[...])" syntax for extended classes, +but instead enables the alternative syntax of extended class behaviour inside +ordinary "[...]" character classes. See the +pcre2pattern +documentation for details of the character classes supported.PCRE2_ALT_VERBNAMES@@ -1569,16 +1711,31 @@pcre2api man page
changed within a pattern by a (?i) option setting. If either PCRE2_UTF or PCRE2_UCP is set, Unicode properties are used for all characters with more than one other case, and for all characters whose code points are greater than -U+007F. Note that there are two ASCII characters, K and S, that, in addition to +U+007F. + ++Note that there are two ASCII characters, K and S, that, in addition to their lower case ASCII equivalents, are case-equivalent with U+212A (Kelvin sign) and U+017F (long S) respectively. If you do not want this case equivalence, you can suppress it by setting PCRE2_EXTRA_CASELESS_RESTRICT.
+One language family, Turkish and Azeri, has its own case-insensitivity rules, +which can be selected by setting PCRE2_EXTRA_TURKISH_CASING. This alters the +behaviour of the 'i', 'I', U+0130 (capital I with dot above), and U+0131 +(small dotless i) characters. +
+For lower valued characters with only one other case, a lookup table is used for speed. When neither PCRE2_UTF nor PCRE2_UCP is set, a lookup table is used for all code points less than 256, and higher code points (available only in 16-bit or 32-bit mode) are treated as not having another case. +
++From release 10.45 PCRE2_CASELESS also affects what some of the letter-related +Unicode property escapes (\p and \P) match. The properties Lu (upper case +letter), Ll (lower case letter), and Lt (title case letter) are all treated as +LC (cased letter) when PCRE2_CASELESS is set.
PCRE2_DOLLAR_ENDONLY@@ -1775,7 +1932,7 @@pcre2api man page
for the PCRE2_UCP option below. In particular, it prevents the creator of the pattern from enabling this facility by starting the pattern with (*UCP). This option may be useful in applications that process patterns from external -sources. The option combination PCRE_UCP and PCRE_NEVER_UCP causes an error. +sources. The option combination PCRE2_UCP and PCRE2_NEVER_UCP causes an error.PCRE2_NEVER_UTF@@ -1798,85 +1955,57 @@pcre2api man page
PCRE2_NO_AUTO_POSSESS-If this option is set, it disables "auto-possessification", which is an -optimization that, for example, turns a+b into a++b in order to avoid +If this (deprecated) option is set, it disables "auto-possessification", which +is an optimization that, for example, turns a+b into a++b in order to avoid backtracks into a+ that can never be successful. However, if callouts are in use, auto-possessification means that some callouts are never taken. You can set this option if you want the matching functions to do a full unoptimized search and run all the callouts, but it is mainly provided for testing purposes. + ++If a compile context is available, it is recommended to use +pcre2_set_optimize() with the directive PCRE2_AUTO_POSSESS_OFF rather +than the compile option PCRE2_NO_AUTO_POSSESS. Note that PCRE2_NO_AUTO_POSSESS +takes precedence over the pcre2_set_optimize() optimization directives +PCRE2_AUTO_POSSESS and PCRE2_AUTO_POSSESS_OFF.
PCRE2_NO_DOTSTAR_ANCHOR-If this option is set, it disables an optimization that is applied when .* is -the first significant item in a top-level branch of a pattern, and all the -other branches also start with .* or with \A or \G or ^. The optimization is -automatically disabled for .* if it is inside an atomic group or a capture -group that is the subject of a backreference, or if the pattern contains -(*PRUNE) or (*SKIP). When the optimization is not disabled, such a pattern is -automatically anchored if PCRE2_DOTALL is set for all the .* items and -PCRE2_MULTILINE is not set for any ^ items. Otherwise, the fact that any match -must start either at the start of the subject or following a newline is +If this (deprecated) option is set, it disables an optimization that is applied +when .* is the first significant item in a top-level branch of a pattern, and +all the other branches also start with .* or with \A or \G or ^. The +optimization is automatically disabled for .* if it is inside an atomic group +or a capture group that is the subject of a backreference, or if the pattern +contains (*PRUNE) or (*SKIP). When the optimization is not disabled, such a +pattern is automatically anchored if PCRE2_DOTALL is set for all the .* items +and PCRE2_MULTILINE is not set for any ^ items. Otherwise, the fact that any +match must start either at the start of the subject or following a newline is remembered. Like other optimizations, this can cause callouts to be skipped. +(If a compile context is available, it is recommended to use +pcre2_set_optimize() with the directive PCRE2_DOTSTAR_ANCHOR_OFF +instead.)PCRE2_NO_START_OPTIMIZEThis is an option whose main effect is at matching time. It does not change what pcre2_compile() generates, but it does affect the output of the JIT -compiler. +compiler. Setting this option is equivalent to calling pcre2_set_optimize() +with the directive parameter set to PCRE2_START_OPTIMIZE_OFF.There are a number of optimizations that may occur at the start of a match, in order to speed up the process. For example, if it is known that an unanchored match must start with a specific code unit value, the matching code searches the subject for that value, and fails immediately if it cannot find it, without -actually running the main matching function. This means that a special item -such as (*COMMIT) at the start of a pattern is not considered until after a -suitable starting point for the match has been found. Also, when callouts or -(*MARK) items are in use, these "start-up" optimizations can cause them to be -skipped if the pattern is never actually used. The start-up optimizations are +actually running the main matching function. The start-up optimizations are in effect a pre-scan of the subject that takes place before the pattern is run.
-The PCRE2_NO_START_OPTIMIZE option disables the start-up optimizations, -possibly causing performance to suffer, but ensuring that in cases where the -result is "no match", the callouts do occur, and that items such as (*COMMIT) -and (*MARK) are considered at every possible starting position in the subject -string. -
--Setting PCRE2_NO_START_OPTIMIZE may change the outcome of a matching operation. -Consider the pattern -
- (*COMMIT)ABC --When this is compiled, PCRE2 records the fact that a match must start with the -character "A". Suppose the subject string is "DEFABC". The start-up -optimization scans along the subject, finds "A" and runs the first match -attempt from there. The (*COMMIT) item means that the pattern must match the -current starting position, which in this case, it does. However, if the same -match is run with PCRE2_NO_START_OPTIMIZE set, the initial scan along the -subject string does not happen. The first match attempt is run starting from -"D" and when this fails, (*COMMIT) prevents any further matches being tried, so -the overall result is "no match". - --As another start-up optimization makes use of a minimum length for a matching -subject, which is recorded when possible. Consider the pattern -
- (*MARK:1)B(*MARK:2)(X|Y) --The minimum length for a match is two characters. If the subject is "XXBB", the -"starting character" optimization skips "XX", then tries to match "BB", which -is long enough. In the process, (*MARK:2) is encountered and remembered. When -the match attempt fails, the next "B" is found, but there is only one character -left, so there are no more attempts, and "no match" is returned with the "last -mark seen" set to "2". If NO_START_OPTIMIZE is set, however, matches are tried -at every possible starting position, including at the end of the subject, where -(*MARK:1) is encountered, but there is no "B", so the "last mark seen" that is -returned is "1". In this case, the optimizations do not affect the overall -match result, which is still "no match", but they do affect the auxiliary -information that is returned. +Disabling the start-up optimizations may cause performance to suffer. However, +this may be desirable for patterns which contain callouts or items such as +(*COMMIT) and (*MARK). See the above description of PCRE2_START_OPTIMIZE_OFF +for further details.PCRE2_NO_UTF_CHECK@@ -1931,9 +2060,16 @@pcre2api man page
upper/lower casing operations, even when PCRE2_UTF is not set. This makes it possible to process strings in the 16-bit UCS-2 code. This option is available only if PCRE2 has been compiled with Unicode support (which is the default). -The PCRE2_EXTRA_CASELESS_RESTRICT option (see below) restricts caseless + ++The PCRE2_EXTRA_CASELESS_RESTRICT option (see above) restricts caseless matching such that ASCII characters match only ASCII characters and non-ASCII -characters match only non-ASCII characters. +characters match only non-ASCII characters. The PCRE2_EXTRA_TURKISH_CASING option +(see above) alters the matching of the 'i' characters to follow their behaviour +in Turkish and Azeri languages. For further details on +PCRE2_EXTRA_CASELESS_RESTRICT and PCRE2_EXTRA_TURKISH_CASING, see the +pcre2unicode +page.
PCRE2_UNGREEDY@@ -2070,7 +2206,8 @@pcre2api man page
ASCII letter K is case-equivalent to U+212a (Kelvin sign). This option disables recognition of case-equivalences that cross the ASCII/non-ASCII boundary. In a caseless match, both characters must either be ASCII or non-ASCII. The option -can be changed with a pattern by the (?r) option setting. +can be changed within a pattern by the (*CASELESS_RESTRICT) or (?r) option +settings.PCRE2_EXTRA_ESCAPED_CR_IS_LF@@ -2097,6 +2234,34 @@pcre2api man page
at the start of the compiled pattern and ")\b" at the end. The option may be used with PCRE2_LITERAL. However, it is ignored if PCRE2_EXTRA_MATCH_LINE is also set. ++ PCRE2_EXTRA_NO_BS0 ++If this option is set (note that its final character is the digit 0) it locks +out the use of the sequence \0 unless at least one more octal digit follows. ++ PCRE2_EXTRA_PYTHON_OCTAL ++If this option is set, PCRE2 follows Python's rules for interpreting octal +escape sequences. The rules for handling sequences such as \14, which could +be an octal number or a back reference are different. Details are given in the +pcre2pattern +documentation. ++ PCRE2_EXTRA_NEVER_CALLOUT ++If this option is set, PCRE2 treats callouts in the pattern as a syntax error, +returning PCRE2_ERROR_CALLOUT_CALLER_DISABLED. This is useful if the application +knows that a callout will not be provided to pcre2_match(), so that +callouts in the pattern are not silently ignored. ++ PCRE2_EXTRA_TURKISH_CASING ++This option alters case-equivalence of the 'i' letters to follow the +alphabet used by Turkish and Azeri languages. The option can be changed within +a pattern by the (*TURKISH_CASING) start-of-pattern setting. Either the UTF or +UCP options must be set. In the 8-bit library, UTF must be set. This option +cannot be combined with PCRE2_EXTRA_CASELESS_RESTRICT.
JUST-IN-TIME (JIT) COMPILATION
@@ -2303,6 +2468,7 @@
pcre2api man page
PCRE2_DOTALL is in force for .* Neither (*PRUNE) nor (*SKIP) appears in the pattern PCRE2_NO_DOTSTAR_ANCHOR is not set + Dotstar anchoring has not been disabled with PCRE2_DOTSTAR_ANCHOR_OFF
Passing a buffer size of zero is a permitted way of finding out how much memory @@ -3667,18 +3834,26 @@
$$ insert a dollar character
- $<n> or ${<n>} insert the contents of group <n>
+ $n or ${n} insert the contents of group n
+ $0 or $& insert the entire matched substring
+ $` insert the substring that precedes the match
+ $' insert the substring that follows the match
+ $_ insert the entire input string
$*MARK or ${*MARK} insert a control verb name
-Either a group number or a group name can be given for <n>. Curly brackets are
-required only if the following character would be interpreted as part of the
-number or name. The number may be zero to include the entire matched string.
-For example, if the pattern a(b)c is matched with "=abc=" and the replacement
-string "+$1$0$1+", the result is "=+babcb+=".
+Either a group number or a group name can be given for n, for example $2 or
+$NAME. Curly brackets are required only if the following character would be
+interpreted as part of the number or name. The number may be zero to include
+the entire matched string. For example, if the pattern a(b)c is matched with
+"=abc=" and the replacement string "+$1$0$1+", the result is "=+babcb+=".
+
++The JavaScript form $<name>, where the angle brackets are part of the syntax, +is also recognized for group names, but not for group numbers or *MARK.
$*MARK inserts the name from the last encountered backtracking control verb on @@ -3732,28 +3907,53 @@
Firstly, backslash in a replacement string is interpreted as an escape -character. The usual forms such as \n or \x{ddd} can be used to specify -particular character codes, and backslash followed by any non-alphanumeric -character quotes that character. Extended quoting can be coded using \Q...\E, -exactly as in pattern strings. +character. The usual forms such as \x{ddd} can be used to specify particular +character codes, and backslash followed by any non-alphanumeric character +quotes that character. Extended quoting can be coded using \Q...\E, exactly +as in pattern strings. The escapes \b and \v are interpreted as the +characters backspace and vertical tab, respectively. +
++The interpretation of backslash followed by one or more digits is the same as +in a pattern, which in Perl has some ambiguities. Details are given in the +pcre2pattern +page. +
++The Python form \g<n>, where the angle brackets are part of the syntax and n +is either a group name or number, is recognized as an altertive way of +inserting the contents of a group, for example \g<3>.
There are also four escape sequences for forcing the case of inserted letters. -The insertion mechanism has three states: no case forcing, force upper case, -and force lower case. The escape sequences change the current state: \U and -\L change to upper or lower case forcing, respectively, and \E (when not -terminating a \Q quoted sequence) reverts to no case forcing. The sequences -\u and \l force the next character (if it is a letter) to upper or lower -case, respectively, and then the state automatically reverts to no case -forcing. Case forcing applies to all inserted characters, including those from -capture groups and letters within \Q...\E quoted sequences. If either -PCRE2_UTF or PCRE2_UCP was set when the pattern was compiled, Unicode +Case forcing applies to all inserted characters, including those from capture +groups and letters within \Q...\E quoted sequences. The insertion mechanism +has three states: no case forcing, force upper case, and force lower case. The +escape sequences change the current state: \U and \L change to upper or lower +case forcing, respectively, and \E (when not terminating a \Q quoted +sequence) reverts to no case forcing. The sequences \u and \l force the next +character (if it is a letter) to upper or lower case, respectively, and then +the state automatically reverts to no case forcing. +
++However, if \u is immediately followed by \L or \l is immediately followed +by \U, the next character's case is forced by the first escape sequence, and +subsequent characters by the second. This provides a "title casing" facility +that can be applied to group captures. For example, if group 1 has captured +"heLLo", the replacement string "\u\L$1" becomes "Hello". +
++If either PCRE2_UTF or PCRE2_UCP was set when the pattern was compiled, Unicode properties are used for case forcing characters whose code points are greater -than 127. +than 127. However, only simple case folding, as determined by the Unicode file +CaseFolding.txt is supported. PCRE2 does not support language-specific +special casing rules such as using different lower case Greek sigmas in the +middle and ends of words (as defined in the Unicode file +SpecialCasing.txt).
Note that case forcing sequences such as \U...\E do not nest. For example, @@ -3762,20 +3962,20 @@
-The second effect of setting PCRE2_SUBSTITUTE_EXTENDED is to add more +The final effect of setting PCRE2_SUBSTITUTE_EXTENDED is to add more flexibility to capture group substitution. The syntax is similar to that used by Bash:
- ${<n>:-<string>}
- ${<n>:+<string1>:<string2>}
+ ${n:-string}
+ ${n:+string1:string2}
-As before, <n> may be a group number or a name. The first form specifies a
-default value. If group <n> is set, its value is inserted; if not, <string> is
-expanded and the result inserted. The second form specifies strings that are
-expanded and inserted when group <n> is set or unset, respectively. The first
-form is just a convenient shorthand for
+As in the simple case, n may be a group number or a name. The first form
+specifies a default value. If group n is set, its value is inserted; if
+not, the string is expanded and the result inserted. The second form specifies
+strings that are expanded and inserted when group n is set or unset,
+respectively. The first form is just a convenient shorthand for
- ${<n>:+${<n>}:<string>}
+ ${n:+${n}:string}
Backslash can be used to escape colons and closing curly brackets in the
replacement strings. A change of the case forcing state within a replacement
@@ -3852,9 +4052,18 @@ +The callout function is not called for simulated substitutions that happen as a +result of the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH option. In this mode, when +substitution processing exceeds the buffer space provided by the caller, +processing continues by counting code units. The simulation is unable to +populate the callout block, and so the simulation is pessimistic about the +required buffer size. Whichever is larger of accepted or rejected substitution +is reported as the required size. Therefore, the returned buffer length may be +an overestimate (without a substitution callout, it is normally an exact +measurement).
The first argument of the callout function is a pointer to a substitute callout @@ -3903,6 +4112,107 @@
+int pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,
+ PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE,
+ PCRE2_UCHAR *, PCRE2_SIZE,
+ int, void *),
+ void *callout_data);
+
+
+The pcre2_set_substitution_case_callout() function can be used to specify
+a callout function for pcre2_substitute() to use when performing case
+transformations. This does not affect any case insensitivity behaviour when
+performing a match, but only the user-visible transformations performed when
+processing a substitution such as:
+
+ pcre2_substitute(..., "\\U$1", ...) ++ +
+The default case transformations applied by PCRE2 are reasonably complete, and, +in UTF or UCP mode, perform the simple locale-invariant case transformations as +specified by Unicode. This is suitable for the internal (invisible) +case-equivalence procedures used during pattern matching, but an application +may wish to use more sophisticated locale-aware processing for the user-visible +substitution transformations. +
+
+One example implementation of the callout_function using the ICU
+library would be:
+
+
+
+ PCRE2_SIZE
+ icu_case_callout(
+ PCRE2_SPTR input, PCRE2_SIZE input_len,
+ PCRE2_UCHAR *output, PCRE2_SIZE output_cap,
+ int to_case, void *data_ptr)
+ {
+ UErrorCode err = U_ZERO_ERROR;
+ int32_t r = to_case == PCRE2_SUBSTITUTE_CASE_LOWER
+ ? u_strToLower(output, output_cap, input, input_len, NULL, &err)
+ : to_case == PCRE2_SUBSTITUTE_CASE_UPPER
+ ? u_strToUpper(output, output_cap, input, input_len, NULL, &err)
+ : u_strToTitle(output, output_cap, input, input_len, &first_char_only,
+ NULL, &err);
+ if (U_FAILURE(err)) return (~(PCRE2_SIZE)0);
+ return r;
+ }
+
+
++The first and second arguments of the case callout function are the Unicode +string to transform. +
++The third and fourth arguments are the output buffer and its capacity. +
++The fifth is one of the constants PCRE2_SUBSTITUTE_CASE_LOWER, +PCRE2_SUBSTITUTE_CASE_UPPER, or PCRE2_SUBSTITUTE_CASE_TITLE_FIRST. +PCRE2_SUBSTITUTE_CASE_LOWER and PCRE2_SUBSTITUTE_CASE_UPPER are passed to the +callout to indicate that the case of the entire callout input should be +case-transformed. PCRE2_SUBSTITUTE_CASE_TITLE_FIRST is passed to indicate that +only the first character or glyph should be transformed to Unicode titlecase +and the rest to Unicode lowercase (note that titlecasing sometimes uses Unicode +properties to titlecase each word in a string; but PCRE2 is requesting that only +the single leading character is to be titlecased). +
++The sixth argument is the callout_data supplied to +pcre2_set_substitute_case_callout(). +
++The resulting string in the destination buffer may be larger or smaller than the +input, if the casing rules merge or split characters. The return value is the +length required for the output string. If a buffer of sufficient size was +provided to the callout, then the result must be written to the buffer and the +number of code units returned. If the result does not fit in the provided +buffer, then the required capacity must be returned and PCRE2 will not make use +of the output buffer. PCRE2 provides input and output buffers which overlap, so +the callout must support this by suitable internal buffering. +
++Alternatively, if the callout wishes to indicate an error, then it may return +(~(PCRE2_SIZE)0). In this case pcre2_substitute() will immediately fail with +error PCRE2_ERROR_REPLACECASE. +
++When a case callout is combined with the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH +option, there are situations when pcre2_substitute() will return an +underestimate of the required buffer size. If you call pcre2_substitute() once +with PCRE2_SUBSTITUTE_OVERFLOW_LENGTH, and the input buffer is too small for +the replacement string to be constructed, then instead of calling the case +callout, pcre2_substitute() will make an estimate of the required buffer size. +The second call should also pass PCRE2_SUBSTITUTE_OVERFLOW_LENGTH, because that +second call is not guaranteed to succeed either, if the case callout requires +more buffer space than expected. The caller must make repeated attempts in a +loop. +
int pcre2_substring_nametable_scan(const pcre2_code *code, @@ -4177,7 +4487,7 @@
-Last updated: 24 April 2024
+Last updated: 26 December 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2build.html b/mingw32/share/doc/pcre2/html/pcre2build.html
index d4b0d336b08..f4e127f14ca 100644
--- a/mingw32/share/doc/pcre2/html/pcre2build.html
+++ b/mingw32/share/doc/pcre2/html/pcre2build.html
@@ -643,7 +643,7 @@
-Last updated: 15 April 2024
+Last updated: 16 April 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2compat.html b/mingw32/share/doc/pcre2/html/pcre2compat.html
index d60182ed48a..5f7e280d34f 100644
--- a/mingw32/share/doc/pcre2/html/pcre2compat.html
+++ b/mingw32/share/doc/pcre2/html/pcre2compat.html
@@ -71,7 +71,7 @@
9. Fairly obviously, PCRE2 does not support the (?{code}) and (??{code}) @@ -120,7 +125,9 @@
12. If a pattern contains more than one backtracking control verb, the first @@ -159,11 +166,11 @@
-17. In PCRE2, the upper/lower case character properties Lu and Ll are not -affected when case-independent matching is specified. For example, \p{Lu} -always matches an upper case letter. I think Perl has changed in this respect; -in the release at the time of writing (5.38), \p{Lu} and \p{Ll} match all -letters, regardless of case, when case independence is specified. +17. In PCRE2, until release 10.45, the upper/lower case character properties Lu +and Ll were not affected when case-independent matching was specified. Perl has +changed in this respect, and PCRE2 has now changed to match. When caseless +matching is in force, Lu, Ll, and Lt (title case) are all treated as Lc (cased +letter).
18. From release 5.32.0, Perl locks out the use of \K in lookaround @@ -231,6 +238,10 @@
20. Perl has different limits than PCRE2. See the @@ -252,6 +263,18 @@
+23. Both PCRE2 and Perl error when \x{ escapes are invalid, but Perl tries to +recover and prints a warning if the problem was that an invalid hexadecimal +digit was found, since PCRE2 doesn't have warnings it returns an error instead. +Additionally, Perl accepts \x{} and generates NUL unlike PCRE2. +
++24. From release 10.45, PCRE2 gives an error if \x is not followed by a +hexadecimal digit or a curly bracket. It used to interpret this as the NUL +character. Perl still generates NUL, but warns when in warning mode in most +cases. +
-Last updated: 30 November 2023
+Last updated: 02 October 2024
-Copyright © 1997-2023 University of Cambridge.
+Copyright © 1997-2024 University of Cambridge.
Return to the PCRE2 index page. diff --git a/mingw32/share/doc/pcre2/html/pcre2convert.html b/mingw32/share/doc/pcre2/html/pcre2convert.html index 6b9fea5575e..57e8989fb4a 100644 --- a/mingw32/share/doc/pcre2/html/pcre2convert.html +++ b/mingw32/share/doc/pcre2/html/pcre2convert.html @@ -182,7 +182,7 @@
-Last updated: 28 June 2018
+Last updated: 14 November 2023
Copyright © 1997-2018 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2grep.html b/mingw32/share/doc/pcre2/html/pcre2grep.html
index bd12246ae99..66c56029698 100644
--- a/mingw32/share/doc/pcre2/html/pcre2grep.html
+++ b/mingw32/share/doc/pcre2/html/pcre2grep.html
@@ -391,9 +391,10 @@
+--posix-pattern-file +When patterns are provided with the -f option, do not trim trailing +spaces or ignore empty lines in a similar way than other grep tools. To keep +the behaviour consistent with older versions, if the pattern read was +terminated with CRLF (as character literals) then both characters won't be +included as part of it, so if you really need to have pattern ending in '\r', +use a escape sequence or provide it by a different method. +
+-q, --quiet Work quietly, that is, display nothing except error messages. The exit status indicates whether or not any matches were found. @@ -993,7 +1003,7 @@
echo -e "abcde\n12345" | pcre2grep \ @@ -1116,7 +1126,7 @@pcre2grep man page
REVISION
-Last updated: 22 December 2023 +Last updated: 04 February 2025
Copyright © 1997-2023 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2jit.html b/mingw32/share/doc/pcre2/html/pcre2jit.html index d97d8003ccb..6835cd8898a 100644 --- a/mingw32/share/doc/pcre2/html/pcre2jit.html +++ b/mingw32/share/doc/pcre2/html/pcre2jit.html @@ -64,7 +64,7 @@pcre2jit man page
If --enable-jit is set on an unsupported platform, compilation fails.-A client program can tell if JIT support is available by calling +A client program can tell if JIT support has been compiled by calling pcre2_config() with the PCRE2_CONFIG_JIT option. The result is one if PCRE2 was built with JIT support, and zero otherwise. However, having the JIT code available does not guarantee that it will be used for any particular @@ -72,11 +72,19 @@
pcre2jit man page
items that are not supported by JIT (see below). Another reason is that in some environments JIT is unable to get -memory in which to build its compiled code. The only guarantee from +executable memory in which to build its compiled code. The only guarantee from pcre2_config() is that if it returns zero, JIT will definitely not be used.+As of release 10.45 there is a more informative way to test for JIT support. If +pcre2_compile_jit() is called with the single option PCRE2_JIT_TEST_ALLOC +it returns zero if JIT is available and has a working allocator. Otherwise it +returns PCRE2_ERROR_NOMEMORY if JIT is available but cannot allocate executable +memory, or PCRE2_ERROR_JIT_UNSUPPORTED if JIT support is not compiled. The +code argument is ignored, so it can be a NULL value. +
+A simple program does not need to check availability in order to use JIT when possible. The API is implemented in a way that falls back to the interpretive code if JIT is not available or cannot be used for a given match. For programs @@ -126,7 +134,8 @@
pcre2jit man page
PCRE2_JIT_COMPLETE and PCRE2_JIT_PARTIAL_HARD. This time it will ignore PCRE2_JIT_COMPLETE and just compile code for partial matching. If pcre2_jit_compile() is called with no option bits set, it immediately -returns zero. This is an alternative way of testing whether JIT is available. +returns zero. This is an alternative way of testing whether JIT support has +been compiled.At present, it is not possible to free JIT compiled code except when the entire @@ -487,7 +496,7 @@
pcre2jit man page
REVISION
-Last updated: 21 February 2024 +Last updated: 22 August 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2limits.html b/mingw32/share/doc/pcre2/html/pcre2limits.html index 8152ed22d71..514c50b2396 100644 --- a/mingw32/share/doc/pcre2/html/pcre2limits.html +++ b/mingw32/share/doc/pcre2/html/pcre2limits.html @@ -96,7 +96,7 @@pcre2limits man page
REVISION
-Last updated: August 2023 +Last updated: 16 August 2023
Copyright © 1997-2023 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2matching.html b/mingw32/share/doc/pcre2/html/pcre2matching.html index 3b8b629380c..4d0232507b6 100644 --- a/mingw32/share/doc/pcre2/html/pcre2matching.html +++ b/mingw32/share/doc/pcre2/html/pcre2matching.html @@ -27,7 +27,7 @@pcre2matching man page
This document describes the two different algorithms that are available in PCRE2 for matching a compiled regular expression against a given subject string. The "standard" algorithm is the one provided by the pcre2_match() -function. This works in the same as Perl's matching function, and provide a +function. This works in the same as Perl's matching function, and provides a Perl-compatible matching operation. The just-in-time (JIT) optimization that is described in the pcre2jit @@ -42,7 +42,7 @@pcre2matching man page
When there is only one possible way in which a given subject string can match a pattern, the two algorithms give the same answer. A difference arises, however, -when there are multiple possibilities. For example, if the pattern +when there are multiple possibilities. For example, if the anchored pattern
^<.*>@@ -115,9 +115,9 @@pcre2matching man page
Note that the size of vector needed to contain all the results depends on the -number of simultaneous matches, not on the number of parentheses in the -pattern. Using pcre2_match_data_create_from_pattern() to create the match -data block is therefore not advisable when doing DFA matching. +number of simultaneous matches, not on the number of capturing parentheses in +the pattern. Using pcre2_match_data_create_from_pattern() to create the +match data block is therefore not advisable when doing DFA matching.
Note also that all the matches that are found start at the same point in the @@ -166,37 +166,43 @@
pcre2matching man page
do this. This means that no captured substrings are available.-3. Because no substrings are captured, backreferences within the pattern are -not supported. -
--4. For the same reason, conditional expressions that use a backreference as the -condition or test for a specific group recursion are not supported. -
--5. Again for the same reason, script runs are not supported. +3. Because no substrings are captured, a number of related features are not +available: +
+
+(a) Backreferences; +
+
+(b) Conditional expressions that use a backreference as the condition or test +for a specific group recursion; +
+
+(c) Script runs; +
+
+(d) Scan substring assertions.-6. Because many paths through the tree may be active, the \K escape sequence, +4. Because many paths through the tree may be active, the \K escape sequence, which resets the start of the match when encountered (but may be on some paths and not on others), is not supported.
-7. Callouts are supported, but the value of the capture_top field is +5. Callouts are supported, but the value of the capture_top field is always 1, and the value of the capture_last field is always 0.
-8. The \C escape sequence, which (in the standard algorithm) always matches a -single code unit, even in a UTF mode, is not supported in these modes, because +6. The \C escape sequence, which (in the standard algorithm) always matches a +single code unit, even in a UTF mode, is not supported in UTF modes because the alternative algorithm moves through the subject string one character (not code unit) at a time, for all active paths through the tree.
-9. Except for (*FAIL), the backtracking control verbs such as (*PRUNE) are not +7. Except for (*FAIL), the backtracking control verbs such as (*PRUNE) are not supported. (*FAIL) is supported, and behaves like a failing negative assertion.
-10. The PCRE2_MATCH_INVALID_UTF option for pcre2_compile() is not +8. The PCRE2_MATCH_INVALID_UTF option for pcre2_compile() is not supported by pcre2_dfa_match().
ADVANTAGES OF THE ALTERNATIVE ALGORITHM
@@ -223,15 +229,18 @@pcre2matching man page
less susceptible to optimization.-2. Capturing parentheses, backreferences, script runs, and matching within -invalid UTF string are not supported. +2. Capturing parentheses and other features such as backreferences that rely on +them are not supported. +
++3. Matching within invalid UTF strings is not supported.
-3. Although atomic groups are supported, their use does not provide the +4. Although atomic groups are supported, their use does not provide the performance advantage that it does for the standard algorithm.
-4. JIT optimization is not supported. +5. JIT optimization is not supported.
AUTHOR
@@ -244,7 +253,7 @@
pcre2matching man page
REVISION
-Last updated: 19 January 2024 +Last updated: 30 August 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2partial.html b/mingw32/share/doc/pcre2/html/pcre2partial.html index 64116c4f20f..067064d90a1 100644 --- a/mingw32/share/doc/pcre2/html/pcre2partial.html +++ b/mingw32/share/doc/pcre2/html/pcre2partial.html @@ -399,7 +399,7 @@pcre2partial man page
REVISION
-Last updated: 04 September 2019 +Last updated: 27 November 2024
Copyright © 1997-2019 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2pattern.html b/mingw32/share/doc/pcre2/html/pcre2pattern.html index cf50c1a1095..84eb0aa17c5 100644 --- a/mingw32/share/doc/pcre2/html/pcre2pattern.html +++ b/mingw32/share/doc/pcre2/html/pcre2pattern.html @@ -14,37 +14,41 @@pcre2pattern man page
@@ -52,9 +56,11 @@
Perl's regular expressions are described in its own documentation, and regular @@ -74,7 +80,19 @@
+Most computers use ASCII or Unicode for encoding characters, and PCRE2 assumes +this by default. However, it can be compiled to run in an environment that uses +the EBCDIC code, which is the case for some IBM mainframe operating systems. In +the sections below, character code values are ASCII or Unicode; in an EBCDIC +environment these characters may have different code values, and there are no +code points greater than 255. Differences in behaviour when PCRE2 is running in +an EBCDIC environment are described in the section +"EBCDIC environments" +below, which you can ignore unless you really are in an EBCDIC environment. +
+A number of options that can be passed to pcre2_compile() can also be set by special items at the start of a pattern. These are not Perl-compatible, but @@ -141,7 +159,8 @@
If a pattern starts with (*NO_AUTO_POSSESS), it has the same effect as setting -the PCRE2_NO_AUTO_POSSESS option. This stops PCRE2 from making quantifiers +the PCRE2_NO_AUTO_POSSESS option, or calling pcre2_set_optimize() with +a PCRE2_AUTO_POSSESS_OFF directive. This stops PCRE2 from making quantifiers possessive when what follows cannot match the repeated item. For example, by default a+b is treated as a++b. For more details, see the pcre2api @@ -152,8 +171,9 @@
If a pattern starts with (*NO_START_OPT), it has the same effect as setting the -PCRE2_NO_START_OPTIMIZE option. This disables several optimizations for quickly -reaching "no match" results. For more details, see the +PCRE2_NO_START_OPTIMIZE option, or calling pcre2_set_optimize() with +a PCRE2_START_OPTIMIZE_OFF directive. This disables several optimizations for +quickly reaching "no match" results. For more details, see the pcre2api documentation.
@@ -162,7 +182,8 @@If a pattern starts with (*NO_DOTSTAR_ANCHOR), it has the same effect as -setting the PCRE2_NO_DOTSTAR_ANCHOR option. This disables optimizations that +setting the PCRE2_NO_DOTSTAR_ANCHOR option, or calling pcre2_set_optimize() +with a PCRE2_DOTSTAR_ANCHOR_OFF directive. This disables optimizations that apply to patterns whose top-level branches all start with .* (match any number of arbitrary characters). For more details, see the pcre2api @@ -275,14 +296,6 @@
-PCRE2 can be compiled to run in an environment that uses EBCDIC as its -character code instead of ASCII or Unicode (typically a mainframe system). In -the sections below, character code values are ASCII or Unicode; in an EBCDIC -environment these characters may have different code values, and there are no -code points greater than 255. -
A regular expression is a pattern that is matched against a subject string from @@ -298,7 +311,10 @@
The power of regular expressions comes from the ability to include wild cards, @@ -346,7 +362,7 @@
+Another difference from Perl is that any appearance of \Q or \E inside what +might otherwise be a quantifier causes PCRE2 not to recognize the sequence as a +quantifier. Perl recognizes a quantifier if (redundantly) either of the numbers +is inside \Q...\E, but not if the separating comma is. When not recognized as +a quantifier a sequence such as {\Q1\E,2} is treated as the literal string +"{1,2}".
+By default, after \x that is not followed by {, one or two hexadecimal +digits are read (letters can be in upper or lower case). If the character that +follows \x is neither { nor a hexadecimal digit, an error occurs. This is +different from Perl's default behaviour, which generates a NUL character, but +is in line with the behaviour of Perl's 'strict' mode in re. +
++Any number of hexadecimal digits may appear between \x{ and }. If a character +other than a hexadecimal digit appears between \x{ and }, or if there is no +terminating }, an error occurs.
Characters whose code points are less than 256 can be defined by either of the @@ -481,69 +516,54 @@
-When PCRE2 is compiled in EBCDIC mode, \N{U+hhh..} is not supported. \a, \e, -\f, \n, \r, and \t generate the appropriate EBCDIC code values. The \c -escape is processed as specified for Perl in the perlebcdic document. The -only characters that are allowed after \c are A-Z, a-z, or one of @, [, \, ], -^, _, or ?. Any other character provokes a compile-time error. The sequence -\c@ encodes character code 0; after \c the letters (in either case) encode -characters 1-26 (hex 01 to hex 1A); [, \, ], ^, and _ encode characters 27-31 -(hex 1B to hex 1F), and \c? becomes either 255 (hex FF) or 95 (hex 5F). +For differences in the way some escapes behave in EBCDIC environments, +see section +"EBCDIC environments" +below.
+-Thus, apart from \c?, these escapes generate the same character code values as -they do in an ASCII environment, though the meanings of the values mostly -differ. For example, \cG always generates code value 7, which is BEL in ASCII -but DEL in EBCDIC. +The escape \o must be followed by a sequence of octal digits, enclosed in +braces. An error occurs if this is not the case. This escape provides a way of +specifying character code points as octal numbers greater than 0777, and it +also allows octal numbers and backreferences to be unambiguously distinguished.
-The sequence \c? generates DEL (127, hex 7F) in an ASCII environment, but -because 127 is not a control character in EBCDIC, Perl makes it generate the -APC character. Unfortunately, there are several variants of EBCDIC. In most of -them the APC character has the value 255 (hex FF), but in the one Perl calls -POSIX-BC its value is 95 (hex 5F). If certain other characters have POSIX-BC -values, PCRE2 makes \c? generate 95; otherwise it generates 255. +If braces are not used, after \0 up to two further octal digits are read. +However, if the PCRE2_EXTRA_NO_BS0 option is set, at least one more octal digit +must follow \0 (use \00 to generate a NUL character). Make sure you supply +two digits after the initial zero if the pattern character that follows is +itself an octal digit.
-After \0 up to two further octal digits are read. If there are fewer than two -digits, just those that are present are used. Thus the sequence \0\x\015 -specifies two binary zeros followed by a CR character (code value 13). Make -sure you supply two digits after the initial zero if the pattern character that -follows is itself an octal digit. +Inside a character class, when a backslash is followed by any octal digit, up +to three octal digits are read to generate a code point. Any subsequent digits +stand for themselves. The sequences \8 and \9 are treated as the literal +characters "8" and "9".
-The escape \o must be followed by a sequence of octal digits, enclosed in -braces. An error occurs if this is not the case. This escape is a recent -addition to Perl; it provides way of specifying character code points as octal -numbers greater than 0777, and it also allows octal numbers and backreferences -to be unambiguously specified. +Outside a character class, Perl's handling of a backslash followed by a digit +other than 0 is complicated by ambiguity, and Perl has changed over time, +causing PCRE2 also to change. From PCRE2 release 10.45 there is an option +called PCRE2_EXTRA_PYTHON_OCTAL that causes PCRE2 to use Python's unambiguous +rules. The next two subsections describe the two sets of rules.
For greater clarity and unambiguity, it is best to avoid following \ by a digit greater than zero. Instead, use \o{...} or \x{...} to specify numerical -character code points, and \g{...} to specify backreferences. The following -paragraphs describe the old, ambiguous syntax. -
--The handling of a backslash followed by a digit other than 0 is complicated, -and Perl has changed over time, causing PCRE2 also to change. -
--Outside a character class, PCRE2 reads the digit and any following digits as a -decimal number. If the number is less than 10, begins with the digit 8 or 9, or -if there are at least that many previous capture groups in the expression, the -entire sequence is taken as a backreference. A description of how this -works is given -later, -following the discussion of -parenthesized groups. -Otherwise, up to three octal digits are read to form a character code. +character code points, and \g{...} to specify backreferences.
+-Inside a character class, PCRE2 handles \8 and \9 as the literal characters -"8" and "9", and otherwise reads up to three octal digits following the -backslash, using them to generate a data character. Any subsequent digits stand -for themselves. For example, outside a character class: +All the digits that follow the backslash are read as a decimal number. If the +number is less than 10, begins with the digit 8 or 9, or if there are at least +that many previous capture groups in the expression, the entire sequence is +taken as a back reference. Otherwise, up to three octal digits are read to form +a character code. For example:
\040 is another way of writing an ASCII space \40 is the same, provided there are fewer than 40 previous capture groups @@ -560,6 +580,19 @@-The property names represented by xx above are not case-sensitive, and in -accordance with Unicode's "loose matching" rules, spaces, hyphens, and -underscores are ignored. There is support for Unicode script names, Unicode -general category properties, "Any", which matches any character (including -newline), Bidi_Class, a number of binary (yes/no) properties, and some special -PCRE2 properties (described +For compatibility with Perl, negation can be specified by including a +circumflex between the opening brace and the property. For example, \p{^Lu} is +the same as \P{Lu}. + +pcre2pattern man page
digits are ever read.
+Python rules for non_class backslash 1-9 +
++If there are at least three octal digits after the backslash, exactly three are +read as an octal code point number, but the value must be no greater than +\377, even in modes where higher code point values are supported. Any +subsequent digits stand for themselves. If there are fewer than three octal +digits, the sequence is taken as a decimal back reference. Thus, for example, +\12 is always a back reference, independent of how many captures there are in +the pattern. An error is generated for a reference to a non-existent capturing +group. +
+
Constraints on character values
@@ -805,7 +838,7 @@
pcre2pattern man page
sequences that match characters with specific properties are available. They can be used in any mode, though in 8-bit and 16-bit non-UTF modes these sequences are of course limited to testing characters whose code points are -less than U+0100 and U+10000, respectively. In 32-bit non-UTF mode, code points +less than U+0100 or U+10000, respectively. In 32-bit non-UTF mode, code points greater than 0x10ffff (the Unicode limit) may be encountered. These are all treated as being in the Unknown script and with an unassigned type. @@ -823,12 +856,33 @@pcre2pattern man page
\P{xx} a character without the xx property \X a Unicode extended grapheme cluster
+In accordance with Unicode's "loose matching" rules, ASCII white space +characters, hyphens, and underscores are ignored in the properties represented +by xx above. As well as the space character, ASCII white space can be +tab, linefeed, vertical tab, formfeed, or carriage return. +
++Some properties are specified as a name only; others as a name and a value, +separated by a colon or an equals sign. The names and values consist of ASCII +letters and digits (with one Perl-specific exception, see below). They are not +case sensitive. Note, however, that the escapes themselves, \p and \P, +are case sensitive. There are abbreviations for many names. The following +examples are all equivalent: +
+ \p{bidiclass=al}
+ \p{BC=al}
+ \p{ Bidi_Class : AL }
+ \p{ Bi-di class = Al }
+ \P{ ^ Bi-di class = Al }
+
+There is support for Unicode script names, Unicode general category properties,
+"Any", which matches any character (including newline), Bidi_Class, a number of
+binary (yes/no) properties, and some special PCRE2 properties (described
below).
Certain other Perl properties such as "InMusicalSymbols" are not supported by
PCRE2. Note that \P{Any} does not match any characters, so always causes a
@@ -844,10 +898,11 @@ Unassigned characters (and in non-UTF 32-bit mode, characters with code points @@ -865,15 +920,10 @@
Each character has exactly one Unicode general category property, specified by -a two-letter abbreviation. For compatibility with Perl, negation can be -specified by including a circumflex between the opening brace and the property -name. For example, \p{^Lu} is the same as \P{Lu}. -
--If only one letter is specified with \p or \P, it includes all the general -category properties that start with that letter. In this case, in the absence -of negation, the curly brackets in the escape sequence are optional; these two -examples have the same effect: +a two-letter abbreviation. If only one letter is specified with \p or \P, it +includes all the general category properties that start with that letter. In +this case, in the absence of negation, the curly brackets in the escape +sequence are optional; these two examples have the same effect:
\p{L}
\pL
@@ -888,6 +938,7 @@ pcre2pattern man page
Cs Surrogate
L Letter
+ Lc Cased letter
Ll Lower case letter
Lm Modifier letter
Lo Other letter
@@ -924,9 +975,13 @@ pcre2pattern man page
Zp Paragraph separator
Zs Space separator
-The special property LC, which has the synonym L&, is also supported: it
-matches a character that has the Lu, Ll, or Lt property, in other words, a
-letter that is not classified as a modifier or "other".
+Perl originally used the name L& for the Lc property. This is still supported
+by Perl, but discouraged. PCRE2 also still supports it. This property matches
+any character that has the Lu, Ll, or Lt property, in other words, any letter
+that is not classified as a modifier or "other". From release 10.45 of PCRE2
+the properties Lu, Ll, and Lt are all treated as Lc when case-independent
+matching is set by the PCRE2_CASELESS option or (?i) within the pattern. The
+other properties are not affected by caseless matching.
The Cs (Surrogate) property applies only to characters whose code points are in @@ -948,11 +1003,6 @@
-Specifying caseless matching does not affect these escape sequences. For -example, \p{Lu} always matches only upper case letters. This is different from -the behaviour of current versions of Perl. -
There is another non-standard property, Xuc, which matches any character that @@ -1389,13 +1440,12 @@
-For example, the character class [aeiou] matches any lower case vowel, while -[^aeiou] matches any character that is not a lower case vowel. Note that a -circumflex is just a convenient notation for specifying the characters that -are in the class by enumerating those that are not. A class that starts with a -circumflex is not an assertion; it still consumes a character from the subject -string, and therefore it fails if the current pointer is at the end of the -string. +For example, the character class [aeiou] matches any lower case English vowel, +whereas [^aeiou] matches all other characters. Note that a circumflex is just a +convenient notation for specifying the characters that are in the class by +enumerating those that are not. A class that starts with a circumflex is not an +assertion; it still consumes a character from the subject string, and therefore +it fails to match if the current pointer is at the end of the string.
Characters in a class may be specified by their code points using \o, \x, or @@ -1405,7 +1455,10 @@
Characters that might indicate line breaks are never treated in any special way @@ -1437,6 +1490,12 @@
+There is some special treatment for alphabetic ranges in EBCDIC environments; +see the section +"EBCDIC environments" +below. +
+Perl treats a hyphen as a literal if it appears before or after a POSIX class (see below) or before or after a character type escape such as \d or \H. However, unless the hyphen is the last character in the class, Perl outputs a @@ -1448,9 +1507,9 @@
Ranges normally include all code points between the start and end characters, @@ -1463,15 +1522,6 @@
-There is a special case in EBCDIC environments for ranges whose end points are -both specified as literal letters in the same case. For compatibility with -Perl, EBCDIC code points within the range that are not letters are omitted. For -example, [h-k] matches only four characters, even though the codes for h and k -are 0x88 and 0x92, a range of 11 code points. However, if the range is -specified numerically, for example, [\x88-\x92] or [h-\x92], all code points -are included. -
-If a range that includes letters is used when caseless matching is set, it matches the letters in either case. For example, [W-c] is equivalent to [][\\^_`wxyzabc], matched caselessly, and in a non-UTF mode, if character @@ -1487,18 +1537,132 @@
-The only metacharacters that are recognized in character classes are backslash, -hyphen (only where it can be interpreted as specifying a range), circumflex -(only at the start), opening square bracket (only when it can be interpreted as -introducing a POSIX class name, or for a special compatibility feature - see -the next two sections), and the terminating closing square bracket. However, -escaping other non-alphanumeric characters does no harm. +The metacharacters that are recognized in character classes are backslash, +hyphen (when it can be interpreted as specifying a range), circumflex +(only at the start), and the terminating closing square bracket. An opening +square bracket is also special when it can be interpreted as introducing a +POSIX class (see +"Posix character classes" +below), or a special compatibility feature (see +"Compatibility feature for word boundaries" +below. Escaping any non-alphanumeric character in a class turns it into a +literal, whether or not it would otherwise be a metacharacter. +
++From release 10.45 PCRE2 supports Perl's (?[...]) extended character class +syntax. This can be used to perform set operations such as intersection on +character classes. +
++The syntax permitted within (?[...]) is quite different to ordinary character +classes. Inside the extended class, there is an expression syntax consisting of +"atoms", operators, and ordinary parentheses "()" used for grouping. Such +classes always have the Perl /xx modifier (PCRE2 option PCRE2_EXTENDED_MORE) +turned on within them. This means that literal space and tab characters are +ignored everywhere in the class. +
++The allowed atoms are individual characters specified by escape sequences such +as \n or \x{123}, character types such as \d, POSIX classes such as +[:alpha:], and nested ordinary (non-extended) character classes. For example, +in (?[\d & [...]]) the nested class [...] follows the usual rules for ordinary +character classes, in which parentheses are not metacharacters, and character +literals and ranges are permitted. +
++Character literals and ranges may not appear outside a nested ordinary +character class because they are not atoms in the extended syntax. The extended +syntax does not introduce any additional escape sequences, so (?[\y]) is an +unknown escape, as it would be in [\y]. +
++In the extended syntax, ^ does not negate a class (except within an +ordinary class nested inside an extended class); it is instead a binary +operator. +
++The binary operators are "&" (intersection), "|" or "+" (union), "-" +(subtraction) and "^" (symmetric difference). These are left-associative and +"&" has higher (tighter) precedence, while the others have equal lower +precedence. The one prefix unary operator is "!" (complement), with highest +precedence. +
++The PCRE2_ALT_EXTENDED_CLASS option enables an alternative to Perl's (?[...]) +syntax, allowing instead extended class behaviour inside ordinary [...] +character classes. This altered syntax for [...] classes is loosely described +by the Unicode standard UTS#18. The PCRE2_ALT_EXTENDED_CLASS option does not +prevent use of (?[...]) classes; it just changes the meaning of all +[...] classes that are not nested inside a Perl (?[...]) class. +
++Firstly, in ordinary Perl [...] syntax, an expression such as "[a[]" is a +character class with two literal characters "a" and "[", but in UTS#18 extended +classes the "[" character becomes an additional metacharacter within classes, +denoting the start of a nested class, so a literal "[" must be escaped as "\[". +
++Secondly, within the UTS#18 extended syntax, there are operators "||", "&&", +"--" and "~~" which denote character class union, intersection, subtraction, +and symmetric difference respectively. In standard Perl syntax, these would +simply be needlessly-repeated literals (except for "--" which could be the +start or end of a range). In UTS#18 extended classes these operators can be used +in constructs such as [\p{L}--[QW]] for "Unicode letters, other than Q and W". +A literal "-" at the start or end of a range must be escaped, so while "[--1]" +in Perl syntax is the range from hyphen to "1", it must be escaped as "[\--1]" +in UTS#18 extended classes. +
++Unlike Perl's (?[...]) extended classes, the PCRE2_EXTENDED_MORE option to +ignore space and tab characters is not automatically enabled for UTS#18 +extended classes, but it is honoured if set. +
++Extended UTS#18 classes can be nested, and nested classes are themselves +extended classes (unlike Perl, where nested classes must be simple classes). +For example, [\p{L}&&[\p{Thai}||\p{Greek}]] matches any letter that is in +the Thai or Greek scripts. Note that this means that no special grouping +characters (such as the parentheses used in Perl's (?[...]) class syntax) are +needed. +
++Individual class items (literal characters, literal ranges, properties such as +\d or \p{...}, and nested classes) can be combined by juxtaposition or by an +operator. Juxtaposition is the implicit union operator, and binds more tightly +than any explicit operator. Thus a sequence of literals and/or ranges behaves +as if it is enclosed in square brackets. For example, [A-Z0-9&&[^E8]] is the +same as [[A-Z0-9]&&[^E8]], which matches any upper case alphanumeric character +except "E" or "8". +
++Precedence between the explicit operators is not defined, so mixing operators +is a syntax error. For example, [A&&B--C] is an error, but [A&&[B--C]] is +valid.
-+This is an emerging syntax which is being adopted gradually across the regex +ecosystem: for example JavaScript adopted the "/v" flag in ECMAScript 2024; +Python's "re" module reserves the syntax for future use with a FutureWarning +for unescaped use of "[" as a literal within character classes. Due to UTS#18 +providing insufficient guidance, engines interpret the syntax differently. +Rust's "regex" crate and Python's "regex" PyPi module both implement UTS#18 +extended classes, but with slight incompatibilities ([A||B&&C] is parsed as +[A||[B&&C]] in Python's "regex" but as [[A||B]&&C] in Rust's "regex"). +
++PCRE2's syntax adds syntax restrictions similar to ECMASCript's /v flag, so +that all the UTS#18 extended classes accepted as valid by PCRE2 have the +property that they are interpreted either with the same behaviour, or as +invalid, by all other major engines. Please file an issue if you are aware of +cross-engine differences in behaviour between PCRE2 and another major engine. +
+Perl supports the POSIX notation for character classes. This uses names enclosed by [: and :] within the enclosing square brackets. PCRE2 also supports -this notation. For example, +this notation, in both ordinary and extended classes. For example,
[01[:alpha:]%]@@ -1584,7 +1748,7 @@
The other POSIX classes are unchanged by PCRE2_UCP, and match only characters @@ -1597,8 +1761,8 @@
In the POSIX.2 compliant library that was included in 4.4BSD Unix, the ugly syntax [[:<:]] and [[:>:]] is used for matching "start of word" and "end of @@ -1619,7 +1783,7 @@
Vertical bar characters are used to separate alternative patterns. For example, the pattern @@ -1634,7 +1798,7 @@
The settings of several options can be changed within a pattern by a sequence of letters enclosed between "(?" and ")". The following are Perl-compatible, @@ -1732,7 +1896,7 @@
Groups are delimited by parentheses (round brackets), which can be nested. Turning part of a pattern into a group does two things: @@ -1788,7 +1952,7 @@
Perl 5.10 introduced a feature whereby each alternative in a group uses the same numbers for its capturing parentheses. Such a group starts with (?| and is @@ -1834,7 +1998,7 @@
Identifying capture groups by number is simple, but it can be very hard to keep track of the numbers in complicated patterns. Furthermore, if an expression is @@ -1954,7 +2118,7 @@
Repetition is specified by quantifiers, which may follow any one of these items: @@ -2118,8 +2282,9 @@
When a capture group is repeated, the value captured is the substring that @@ -2135,7 +2300,7 @@
With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy") repetition, failure of what follows normally causes the repeated item to be @@ -2216,8 +2381,9 @@
When a pattern contains an unlimited repeat inside a group that can itself be @@ -2245,7 +2411,7 @@
Outside a character class, a backslash followed by a digit greater than 0 (and possibly further digits) is a backreference to a capture group earlier (that @@ -2383,23 +2549,32 @@
-An assertion is a test on the characters following or preceding the current -matching point that does not consume any characters. The simple assertions -coded as \b, \B, \A, \G, \Z, \z, ^ and $ are described +An assertion is a test that does not consume any characters. The test must +succeed for the match to continue. The simple assertions coded as \b, \B, +\A, \G, \Z, \z, ^ and $ are described above.
-More complicated assertions are coded as parenthesized groups. There are two -kinds: those that look ahead of the current position in the subject string, and -those that look behind it, and in each case an assertion may be positive (must -match for the assertion to be true) or negative (must not match for the -assertion to be true). An assertion group is matched in the normal way, -and if it is true, matching continues after it, but with the matching position +More complicated assertions are coded as parenthesized groups. If matching such +a group succeeds, matching continues after it, but with the matching position in the subject string reset to what it was before the assertion was processed.
+A special kind of assertion, called a "scan substring" assertion, matches a +subpattern against a previously captured substring. This is described in the +section entitled +"Scan substring assertions" +below. It is a PCRE2 extension, not compatible with Perl. +
++The other goup-based assertions are of two kinds: those that look ahead of the +current position in the subject string, and those that look behind it, and in +each case an assertion may be positive (must match for the assertion to be +true) or negative (must not match for the assertion to be true). +
+The Perl-compatible lookaround assertions are atomic. If an assertion is true, but there is a subsequent matching failure, there is no backtracking into the assertion. However, there are some cases where non-atomic assertions can be @@ -2624,7 +2799,7 @@
Traditional lookaround assertions are atomic. That is, if an assertion is true, but there is a subsequent matching failure, there is no backtracking into the @@ -2683,8 +2858,67 @@
+A special kind of assertion, not compatible with Perl, makes it possible to +check the contents of a captured substring by matching it with a subpattern. +Because this involves capturing, this feature is not supported by +pcre2_dfa_match(). +
++A scan substring assertion starts with the sequence (*scan_substring: or +(*scs: which is followed by a list of substring numbers (absolute or relative) +and/or substring names enclosed in single quotes or angle brackets, all within +parentheses. The rest of the item is the subpattern that is applied to the +substring, as shown in these examples: +
+ (*scan_substring:(1)...)
+ (*scs:(-2)...)
+ (*scs:('AB')...)
+ (*scs:(1,'AB',-2)...)
+
+The list of groups is checked in the order they are given, and it is the
+contents of the first one that is found to be set that are scanned. When
+PCRE2_DUPNAMES is set and there are ambiguous group names, all groups with the
+same name are checked in numerical order. A scan substring assertion fails if
+none of the groups it references have been set.
-+The pattern match on the substring is always anchored, that is, it must match +from the start of the substring. There is no "bumpalong" if it does not match +at the start. The end of the subject is temporarily reset to be the end of the +substring, so \Z, \z, and $ will match there. However, the start of the +subject is not reset. This means that ^ matches only if the substring is +actually at the start of the main subject, but it also means that lookbehind +assertions into what precedes the substring are possible. +
++Here is a very simple example: find a word that contains the rare (in English) +sequence of letters "rh" not at the start: +
+ \b(\w++)(*scs:(1).+rh) ++The first group captures a word which is then scanned by the second group. +This example does not actually need this heavyweight feature; the same match +can be achieved with: +
+ \b\w+?rh\w*\b ++When things are more complicated, however, scanning a captured substring can be +a useful way to describe the required match. For exmple, there is a rather +complicated pattern in the PCRE2 test data that checks an entire subject string +for a palindrome, that is, the sequence of letters is the same in both +directions. Suppose you want to search for individual words of two or more +characters such as "level" that are palindromes: +
+ (\b\w{2,}+\b)(*scs:(1)...palindrome-matching-pattern...)
+
+Within a substring scanning subpattern, references to other groups work as
+normal. Capturing groups may appear, and will retain their values during
+ongoing matching if the assertion succeeds.
+
+In concept, a script run is a sequence of characters that are all from the same Unicode script such as Latin or Greek. However, because some scripts are @@ -2746,7 +2980,7 @@
It is possible to cause the matching process to obey a pattern fragment conditionally or to choose between two alternative fragments, depending on @@ -2947,13 +3181,13 @@
There are two ways of including comments in patterns that are processed by PCRE2. In both cases, the start of the comment must not be in a character class, nor in the middle of any other sequence of related characters such as -(?: or a group name or number. The characters that make up a comment play -no part in the pattern matching. +(?: or a group name or number or a Unicode property name. The characters that +make up a comment play no part in the pattern matching.
The sequence (?# marks the start of a comment that continues up to the next @@ -2977,7 +3211,7 @@
Consider the problem of matching a string in parentheses, allowing for unlimited nested parentheses. Without the use of recursion, the best that can @@ -3165,7 +3399,7 @@
If the syntax for a recursive group call (either by number or by name) is used outside the parentheses to which it refers, it operates a bit like a subroutine @@ -3213,7 +3447,7 @@
For compatibility with Oniguruma, the non-Perl syntax \g followed by a name or a number enclosed either in angle brackets or single quotes, is an alternative @@ -3231,7 +3465,7 @@
Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl code to be obeyed in the middle of matching a regular expression. This makes it @@ -3244,7 +3478,9 @@
Within a regular expression, (?C<arg>) indicates a point at which the external @@ -3307,7 +3543,7 @@
There are a number of special "Backtracking Control Verbs" (to use Perl's terminology) that modify the behaviour of backtracking during matching. They @@ -3347,8 +3583,8 @@
Since these verbs are specifically related to backtracking, most of them can be used only when the pattern is to be matched using the traditional matching -function, because that uses a backtracking algorithm. With the exception of -(*FAIL), which behaves like a failing negative assertion, the backtracking +function or JIT, because they use backtracking algorithms. With the exception +of (*FAIL), which behaves like a failing negative assertion, the backtracking control verbs cause an error if encountered by the DFA matching function.
@@ -3369,7 +3605,8 @@
If you are interested in (*MARK) values after failed matches, you should -probably set the PCRE2_NO_START_OPTIMIZE option +probably either set the PCRE2_NO_START_OPTIMIZE option or call +pcre2_set_optimize() with a PCRE2_START_OPTIMIZE_OFF directive (see above) to ensure that the match is always attempted.
@@ -3514,9 +3752,9 @@@@ -3782,9 +4020,11 @@
-PCRE2 now supports non-atomic positive assertions, as described in the section -entitled +PCRE2 now supports non-atomic positive assertions and also "scan substring" +assertions, as described in the sections entitled "Non-atomic assertions" +and +"Scan substring assertions" above. These assertions must be standalone (not used as conditions). They are not Perl-compatible. For these assertions, a later backtrack does jump back into the assertion, and therefore verbs such as (*COMMIT) can be triggered by @@ -3793,7 +4033,8 @@
The effect of (*THEN) is not allowed to escape beyond an assertion. If there are no more branches to try, (*THEN) causes a positive assertion to be false, -and a negative assertion to be true. +and a negative assertion to be true. This behaviour differs from Perl when the +assertion has only one branch.
The other backtracking verbs are not treated specially if they appear in a @@ -3829,13 +4070,57 @@
+Differences in the way PCRE behaves when it is running in an EBCDIC environment +are covered in this section. +
++When PCRE2 is compiled in EBCDIC mode, \N{U+hhh..} is not supported. \a, \e, +\f, \n, \r, and \t generate the appropriate EBCDIC code values. The \c +escape is processed as specified for Perl in the perlebcdic document. The +only characters that are allowed after \c are A-Z, a-z, or one of @, [, \, ], +^, _, or ?. Any other character provokes a compile-time error. The sequence +\c@ encodes character code 0; after \c the letters (in either case) encode +characters 1-26 (hex 01 to hex 1A); [, \, ], ^, and _ encode characters 27-31 +(hex 1B to hex 1F), and \c? becomes either 255 (hex FF) or 95 (hex 5F). +
++Thus, apart from \c?, these escapes generate the same character code values as +they do in an ASCII or Unicode environment, though the meanings of the values +mostly differ. For example, \cG always generates code value 7, which is BEL in +ASCII but DEL in EBCDIC. +
++The sequence \c? generates DEL (127, hex 7F) in an ASCII environment, but +because 127 is not a control character in EBCDIC, Perl makes it generate the +APC character. Unfortunately, there are several variants of EBCDIC. In most of +them the APC character has the value 255 (hex FF), but in the one Perl calls +POSIX-BC its value is 95 (hex 5F). If certain other characters have POSIX-BC +values, PCRE2 makes \c? generate 95; otherwise it generates 255. +
++In character classes there is a special case in EBCDIC environments for ranges +whose end points are both specified as literal letters in the same case. For +compatibility with Perl, EBCDIC code points within the range that are not +letters are omitted. For example, [h-k] matches only four characters, even +though the EBCDIC codes for h and k are 0x88 and 0x92, a range of 11 code +points. However, if the range is specified numerically, for example, +[\x88-\x92] or [h-\x92], all code points are included.
-pcre2api(3), pcre2callout(3), pcre2matching(3), pcre2syntax(3), pcre2(3).
-
Philip Hazel
@@ -3844,9 +4129,9 @@
-Last updated: 04 June 2024
+Last updated: 27 November 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2perform.html b/mingw32/share/doc/pcre2/html/pcre2perform.html
index 55fdf202fc4..b595119ba88 100644
--- a/mingw32/share/doc/pcre2/html/pcre2perform.html
+++ b/mingw32/share/doc/pcre2/html/pcre2perform.html
@@ -271,7 +271,7 @@
-Last updated: 27 July 2022
+Last updated: 06 December 2022
Copyright © 1997-2022 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2posix.html b/mingw32/share/doc/pcre2/html/pcre2posix.html
index 6e7abd932ab..bc60c3b798c 100644
--- a/mingw32/share/doc/pcre2/html/pcre2posix.html
+++ b/mingw32/share/doc/pcre2/html/pcre2posix.html
@@ -171,7 +171,7 @@
@@ -370,7 +370,7 @@pcre2posix man page
REVISION
-Last updated: 19 January 2024 +Last updated: 27 November 2024
Copyright © 1997-2024 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2sample.html b/mingw32/share/doc/pcre2/html/pcre2sample.html index 345df031131..0903f04f99b 100644 --- a/mingw32/share/doc/pcre2/html/pcre2sample.html +++ b/mingw32/share/doc/pcre2/html/pcre2sample.html @@ -101,7 +101,7 @@pcre2sample man page
REVISION
-Last updated: 02 February 2016 +Last updated: 14 November 2023
Copyright © 1997-2016 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2serialize.html b/mingw32/share/doc/pcre2/html/pcre2serialize.html index 19418a83b21..d189bde2b63 100644 --- a/mingw32/share/doc/pcre2/html/pcre2serialize.html +++ b/mingw32/share/doc/pcre2/html/pcre2serialize.html @@ -203,7 +203,7 @@pcre2serialize man page
REVISION
-Last updated: 27 June 2018 +Last updated: 19 January 2024
Copyright © 1997-2018 University of Cambridge.
diff --git a/mingw32/share/doc/pcre2/html/pcre2syntax.html b/mingw32/share/doc/pcre2/html/pcre2syntax.html index 1c0ccb003e2..46da3d71fcc 100644 --- a/mingw32/share/doc/pcre2/html/pcre2syntax.html +++ b/mingw32/share/doc/pcre2/html/pcre2syntax.html @@ -24,34 +24,41 @@pcre2syntax man page
-The full syntax and semantics of the regular expressions that are supported by -PCRE2 are described in the +The full syntax and semantics of the regular expression patterns that are +supported by PCRE2 are described in the pcre2pattern -documentation. This document contains a quick-reference summary of the syntax. +documentation. This document contains a quick-reference summary of the pattern +syntax followed by the syntax of replacement strings in substitution function. +The full description of the latter is in the +pcre2api +documentation.
@@ -60,7 +67,10 @@
@@ -91,6 +101,11 @@
If PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set ("ALT_BSUX mode"), the following are also recognized:
@@ -98,7 +113,7 @@-When \x is not followed by {, from zero to two hexadecimal digits are read, +When \x is not followed by {, one or two hexadecimal digits are read, but in ALT_BSUX mode \x must be followed by two hexadecimal digits to be recognized as a hexadecimal escape; otherwise it matches a literal "x". Likewise, if \u (in ALT_BSUX mode) is not followed by four hexadecimal digits @@ -112,9 +127,7 @@pcre2syntax man page
\uhhhh character with hex code hhhh \u{hh..} character with hex code hh.. but only for EXTRA_ALT_BSUX
@@ -154,8 +167,9 @@
Property descriptions in \p and \P are matched caselessly; hyphens, -underscores, and white space are ignored, in accordance with Unicode's "loose -matching" rules. +underscores, and ASCII white space characters are ignored, in accordance with +Unicode's "loose matching" rules. For example, \p{Bidi_Class=al} is the same +as \p{ bidi class = AL }.
@@ -168,13 +182,13 @@
@@ -268,7 +284,7 @@
+When PCRE2_ALT_EXTENDED_CLASS is set, UTS#18 extended character classes may be +used, allowing nested character classes, combined using set operators. +
+ [x&&[^y]] UTS#18 extended character class + + x||y set union (OR) + x&&y set intersection (AND) + x--y set difference (AND NOT) + x~~y set symmetric difference (XOR) + ++ +
+
+ (?[...]) Perl extended character class
+ (?[\p{Thai} & \p{Nd}]) operators; whitespace ignored
+ (?[(x - y) & z]) parentheses for grouping
+
+ (?[ [^3] & \p{Nd} ]) [...] is a nested ordinary class
+ (?[ [:alpha:] - [z] ]) POSIX set is allowed outside [...]
+ (?[ \d - [3] ]) backslash-escaped set is allowed outside [...]
+ (?[ !\n & [:ascii:] ]) backslash-escaped character is allowed outside [...]
+ all other characters or ranges must be enclosed in [...]
+
+ x|y, x+y set union (OR)
+ x&y set intersection (AND)
+ x-y set difference (AND NOT)
+ x^y set symmetric difference (XOR)
+ !x set complement (NOT)
+
+Inside a Perl extended character class, [...] switches mode to be interpreted
+as an ordinary character class. Outside of a nested [...], the only items
+permitted are backslash-escapes, POSIX sets, operators, and parentheses. Inside
+a nested ordinary class, ^ has its usual meaning (inverts the class when used
+as the first character); outside of a nested class, ^ is the XOR operator.
+
+
? 0 or 1, greedy @@ -323,7 +377,7 @@-pcre2syntax man page
{,m}? zero up to m, lazy
\b word boundary @@ -341,7 +395,7 @@-pcre2syntax man page
\G first matching position in subject
\K set reported start of match @@ -351,13 +405,13 @@-pcre2syntax man page
option is set, the previous behaviour is re-enabled. When this option is set, \K is honoured in positive assertions, but ignored in negative ones. -
ALTERNATION
+
ALTERNATION
expr|expr|expr...-
CAPTURING
+
CAPTURING
(...) capture group @@ -372,20 +426,20 @@(?aP) implies (?aT) as well, though this has no additional effect. However, it -means that (?-aP) is really (?-PT) which disables all ASCII restrictions for +means that (?-aP) also implies (?-aT) and disables all ASCII restrictions for POSIX classes.pcre2syntax man page
in UTF modes, any Unicode letters and Unicode decimal digits are permitted. In both cases, a name must not start with a digit. -
ATOMIC GROUPS
+
ATOMIC GROUPS
(?>...) atomic non-capture group (*atomic:...) atomic non-capture group-
COMMENT
+
COMMENT
(?#....) comment (not nestable)-
OPTION SETTING
+
OPTION SETTING
Changes of these options within a group are automatically cancelled at the end of the group. @@ -409,7 +463,7 @@
pcre2syntax man page
(?^) unset imnrsx options@@ -421,20 +475,22 @@
pcre2syntax man page
The following are recognized only at the very start of a pattern or after one -of the newline or \R options with similar syntax. More than one of them may -appear. For the first three, d is a decimal number. -
- (*LIMIT_DEPTH=d) set the backtracking limit to d - (*LIMIT_HEAP=d) set the heap size limit to d * 1024 bytes - (*LIMIT_MATCH=d) set the match limit to d - (*NOTEMPTY) set PCRE2_NOTEMPTY when matching - (*NOTEMPTY_ATSTART) set PCRE2_NOTEMPTY_ATSTART when matching - (*NO_AUTO_POSSESS) no auto-possessification (PCRE2_NO_AUTO_POSSESS) +of the newline or \R sequences or options with similar syntax. More than one +of them may appear. For the first three, d is a decimal number. +-+ (*LIMIT_DEPTH=d) set the backtracking limit to d + (*LIMIT_HEAP=d) set the heap size limit to d * 1024 bytes + (*LIMIT_MATCH=d) set the match limit to d + (*CASELESS_RESTRICT) set PCRE2_EXTRA_CASELESS_RESTRICT when matching + (*NOTEMPTY) set PCRE2_NOTEMPTY when matching + (*NOTEMPTY_ATSTART) set PCRE2_NOTEMPTY_ATSTART when matching + (*NO_AUTO_POSSESS) no auto-possessification (PCRE2_NO_AUTO_POSSESS) (*NO_DOTSTAR_ANCHOR) no .* anchoring (PCRE2_NO_DOTSTAR_ANCHOR) - (*NO_JIT) disable JIT optimization - (*NO_START_OPT) no start-match optimization (PCRE2_NO_START_OPTIMIZE) - (*UTF) set appropriate UTF mode for the library in use - (*UCP) set PCRE2_UCP (use Unicode properties for \d etc) + (*NO_JIT) disable JIT optimization + (*NO_START_OPT) no start-match optimization (PCRE2_NO_START_OPTIMIZE) + (*TURKISH_CASING) set PCRE2_EXTRA_TURKISH_CASING when matching + (*UTF) set appropriate UTF mode for the library in use + (*UCP) set PCRE2_UCP (use Unicode properties for \d etc)Note that LIMIT_DEPTH, LIMIT_HEAP, and LIMIT_MATCH can only reduce the value of the limits set by the caller of pcre2_match() or pcre2_dfa_match(), @@ -442,7 +498,7 @@pcre2syntax man page
application can lock out the use of (*UTF) and (*UCP) by setting the PCRE2_NEVER_UTF or PCRE2_NEVER_UCP options, respectively, at compile time. -
NEWLINE CONVENTION
+
NEWLINE CONVENTION
These are recognized only at the very start of the pattern or after option settings with a similar syntax. @@ -455,7 +511,7 @@
pcre2syntax man page
(*NUL) the NUL character (binary zero)
WHAT \R MATCHES
+
WHAT \R MATCHES
These are recognized only at the very start of the pattern or after option setting with a similar syntax. @@ -464,7 +520,7 @@
pcre2syntax man page
(*BSR_UNICODE) any Unicode newline sequence