diff --git a/CMakeLists.txt b/CMakeLists.txt index 9b89a9c..93326cd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,6 +78,7 @@ # fix by David Gaussmann # 2016-10-07 PH added PCREGREP_MAX_BUFSIZE # 2017-03-11 PH turned HEAP_MATCH_RECURSE into a NO-OP for 10.30 +# 2017-04-08 PH added HEAP_LIMIT PROJECT(PCRE2 C) @@ -143,6 +144,9 @@ SET(PCRE2_LINK_SIZE "2" CACHE STRING SET(PCRE2_PARENS_NEST_LIMIT "250" CACHE STRING "Default nested parentheses limit. See PARENS_NEST_LIMIT in config.h.in for details.") +SET(PCRE2_HEAP_LIMIT "20000000" CACHE STRING + "Default limit on heap memory (kilobytes). See HEAP_LIMIT in config.h.in for details.") + SET(PCRE2_MATCH_LIMIT "10000000" CACHE STRING "Default limit on internal looping. See MATCH_LIMIT in config.h.in for details.") @@ -765,6 +769,7 @@ IF(PCRE2_SHOW_REPORT) MESSAGE(STATUS " Rebuild char tables ............. : ${PCRE2_REBUILD_CHARTABLES}") MESSAGE(STATUS " Internal link size .............. : ${PCRE2_LINK_SIZE}") MESSAGE(STATUS " Parentheses nest limit .......... : ${PCRE2_PARENS_NEST_LIMIT}") + MESSAGE(STATUS " Heap limit ...................... : ${PCRE2_HEAP_LIMIT}") MESSAGE(STATUS " Match limit ..................... : ${PCRE2_MATCH_LIMIT}") MESSAGE(STATUS " Match depth limit ............... : ${PCRE2_MATCH_LIMIT_DEPTH}") MESSAGE(STATUS " Build shared libs ............... : ${BUILD_SHARED_LIBS}") diff --git a/ChangeLog b/ChangeLog index 486ee88..177c3ef 100644 --- a/ChangeLog +++ b/ChangeLog @@ -121,6 +121,11 @@ single-branch conditions with a false condition (e.g. DEFINE) at the start of a branch. For example, /(?(DEFINE)...)^A/ and /(...){0}^B/ are now flagged as anchored. +22. Added an explicit limit on the amount of heap used by pcre2_match(), set by +pcre2_set_heap_limit() or (*LIMIT_HEAP=xxx). Upgraded pcre2test to show the +heap limit along with other pattern information, and to find the minimum when +the find_limits modifier is set. + Version 10.23 14-February-2017 ------------------------------ diff --git a/Makefile.am b/Makefile.am index fa57eeb..dd98f01 100644 --- a/Makefile.am +++ b/Makefile.am @@ -69,6 +69,7 @@ dist_html_DATA = \ doc/html/pcre2_set_character_tables.html \ doc/html/pcre2_set_compile_recursion_guard.html \ doc/html/pcre2_set_depth_limit.html \ + doc/html/pcre2_set_heap_limit.html \ doc/html/pcre2_set_match_limit.html \ doc/html/pcre2_set_max_pattern_length.html \ doc/html/pcre2_set_offset_limit.html \ @@ -152,6 +153,7 @@ dist_man_MANS = \ doc/pcre2_set_character_tables.3 \ doc/pcre2_set_compile_recursion_guard.3 \ doc/pcre2_set_depth_limit.3 \ + doc/pcre2_set_heap_limit.3 \ doc/pcre2_set_match_limit.3 \ doc/pcre2_set_max_pattern_length.3 \ doc/pcre2_set_offset_limit.3 \ diff --git a/README b/README index cf5dd7e..336f5d9 100644 --- a/README +++ b/README @@ -223,10 +223,10 @@ library. They are also documented in the pcre2build man page. --with-parens-nest-limit=500 -. PCRE2 has a counter that can be set to limit the amount of resources it uses - when matching a pattern. If the limit is exceeded during a match, the match - fails. The default is ten million. You can change the default by setting, for - example, +. PCRE2 has a counter that can be set to limit the amount of computing resource + it uses when matching a pattern with the Perl-compatible matching function. + If the limit is exceeded during a match, the match fails. The default is ten + million. You can change the default by setting, for example, --with-match-limit=500000 @@ -235,14 +235,23 @@ library. They are also documented in the pcre2build man page. pcre2api man page (search for pcre2_set_match_limit). . There is a separate counter that limits the depth of nested backtracking - during a matching process, which in turn limits the amount of memory that is - used. This also has a default of ten million, which is essentially + during a matching process, which indirectly limits the amount of heap memory + that is used. This also has a default of ten million, which is essentially "unlimited". You can change the default by setting, for example, --with-match-limit-depth=5000 There is more discussion in the pcre2api man page (search for pcre2_set_depth_limit). + +. You can also set an explicit limit on the amount of heap memory used by + the pcre2_match() interpreter: + + --with-heap-limit=500 + + The units are kilobytes. This limit does not apply when the JIT optimization + (which has its own memory control features) is used. There is more discussion + on the pcre2api man page (search for pcre2_set_heap_limit). . In the 8-bit library, the default maximum compiled pattern size is around 64K bytes. You can increase this by adding --with-link-size=3 to the @@ -865,4 +874,4 @@ The distribution should contain the files listed below. Philip Hazel Email local part: ph10 Email domain: cam.ac.uk -Last updated: 17 March 2017 +Last updated: 11 April 2017 diff --git a/RunTest b/RunTest index 88c6e85..59f2836 100755 --- a/RunTest +++ b/RunTest @@ -489,7 +489,7 @@ for bmode in "$test8" "$test16" "$test32"; do for opt in "" $jitopt; do $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput2 testtry if [ $? = 0 ] ; then - $sim $valgrind ${opt:+$vjs} ./pcre2test -q $bmode $opt -error -63,-62,-2,-1,0,100,188,189,190,191 >>testtry + $sim $valgrind ${opt:+$vjs} ./pcre2test -q $bmode $opt -error -64,-62,-2,-1,0,100,188,189,190,191 >>testtry checkresult $? 2 "$opt" fi done diff --git a/config-cmake.h.in b/config-cmake.h.in index 95ee75a..d34cc33 100644 --- a/config-cmake.h.in +++ b/config-cmake.h.in @@ -36,6 +36,7 @@ #cmakedefine NEVER_BACKSLASH_C 1 #define LINK_SIZE @PCRE2_LINK_SIZE@ +#define HEAP_LIMIT @PCRE2_HEAP_LIMIT@ #define MATCH_LIMIT @PCRE2_MATCH_LIMIT@ #define MATCH_LIMIT_DEPTH @PCRE2_MATCH_LIMIT_DEPTH@ #define NEWLINE_DEFAULT @NEWLINE_DEFAULT@ diff --git a/configure.ac b/configure.ac index bebf6d3..821a246 100644 --- a/configure.ac +++ b/configure.ac @@ -263,6 +263,12 @@ AC_ARG_WITH(parens-nest-limit, [nested parentheses limit (default=250)]), , with_parens_nest_limit=250) +# Handle --with-heap-limit +AC_ARG_WITH(heap-limit, + AS_HELP_STRING([--with-heap-limit=N], + [default limit on heap memory (kilobytes, default=20000000)]), + , with_heap_limit=20000000) + # Handle --with-match-limit=N AC_ARG_WITH(match-limit, AS_HELP_STRING([--with-match-limit=N], @@ -285,7 +291,7 @@ AC_ARG_WITH(match-limit-depth, AC_ARG_WITH(match-limit-recursion,, , with_match_limit_recursion=UNSET) - + # Handle --enable-valgrind AC_ARG_ENABLE(valgrind, AS_HELP_STRING([--enable-valgrind], @@ -680,12 +686,12 @@ AC_DEFINE_UNQUOTED([PARENS_NEST_LIMIT], [$with_parens_nest_limit], [ stack that is used while compiling a pattern.]) AC_DEFINE_UNQUOTED([MATCH_LIMIT], [$with_match_limit], [ - The value of MATCH_LIMIT determines the default number of times the internal - match() function can record a backtrack position during a single matching - attempt. There is a runtime interface for setting a different limit. The - limit exists in order to catch runaway regular expressions that take for ever - to determine that they do not match. The default is set very large so that it - does not accidentally catch legitimate cases.]) + The value of MATCH_LIMIT determines the default number of times the + pcre2_match() function can record a backtrack position during a single + matching attempt. There is a runtime interface for setting a different limit. + The limit exists in order to catch runaway regular expressions that take for + ever to determine that they do not match. The default is set very large so + that it does not accidentally catch legitimate cases.]) # --with-match-limit-recursion is an obsolete synonym for --with-match-limit-depth @@ -694,7 +700,7 @@ cat <pcre2_set_depth_limit   Set the match backtracking depth limit +pcre2_set_heap_limit +   Set the match backtracking heap limit + pcre2_set_match_limit   Set the match limit diff --git a/doc/html/pcre2_config.html b/doc/html/pcre2_config.html index 6792da2..0edce66 100644 --- a/doc/html/pcre2_config.html +++ b/doc/html/pcre2_config.html @@ -45,6 +45,7 @@ point to a uint32_t integer variable. The available codes are: PCRE2_CONFIG_BSR Indicates what \R matches by default: PCRE2_BSR_UNICODE PCRE2_BSR_ANYCRLF + PCRE2_CONFIG_HEAPLIMIT Default heap memory limit PCRE2_CONFIG_DEPTHLIMIT Default backtracking depth limit PCRE2_CONFIG_JIT Availability of just-in-time compiler support (1=yes 0=no) PCRE2_CONFIG_JITTARGET Information (a string) about the target architecture for the JIT compiler diff --git a/doc/html/pcre2_match.html b/doc/html/pcre2_match.html index 5b0d70f..724a39f 100644 --- a/doc/html/pcre2_match.html +++ b/doc/html/pcre2_match.html @@ -44,6 +44,7 @@ A match context is needed only if you want to: 
   Set up a callout function
   Set a matching offset limit 
+  Change the heap memory limit 
   Change the backtracking match limit 
   Change the backtracking depth limit
   Set custom memory management specifically for the match
diff --git a/doc/html/pcre2_pattern_info.html b/doc/html/pcre2_pattern_info.html
index fdda26b..f59e999 100644
--- a/doc/html/pcre2_pattern_info.html
+++ b/doc/html/pcre2_pattern_info.html
@@ -51,6 +51,7 @@ request are as follows:
   PCRE2_INFO_FRAMESIZE       Size of backtracking frame 
   PCRE2_INFO_HASBACKSLASHC   Return 1 if pattern contains \C
   PCRE2_INFO_HASCRORLF       Return 1 if explicit CR or LF matches exist in the pattern
+  PCRE2_INFO_HEAPLIMIT       Heap memory limit if set, otherwise PCRE2_ERROR_UNSET
   PCRE2_INFO_JCHANGED        Return 1 if (?J) or (?-J) was used
   PCRE2_INFO_JITSIZE         Size of JIT compiled code, or 0
   PCRE2_INFO_LASTCODETYPE    Type of must-be-present information
diff --git a/doc/html/pcre2api.html b/doc/html/pcre2api.html
index 7f424c9..d04e343 100644
--- a/doc/html/pcre2api.html
+++ b/doc/html/pcre2api.html
@@ -182,6 +182,10 @@ document for an overview of all the PCRE2 documentation.
   PCRE2_SIZE value);
 

 

+int pcre2_set_heap_limit(pcre2_match_context *mcontext,
+  uint32_t value);
+

+

 int pcre2_set_match_limit(pcre2_match_context *mcontext,
   uint32_t value);
 

@@ -793,6 +797,7 @@ A match context is required if you want to:
 
   Set up a callout function
   Set an offset limit for matching an unanchored pattern
+  Change the limit on the amount of heap used when matching 
   Change the backtracking match limit
   Change the backtracking depth limit
   Set custom memory management specifically for the match
@@ -851,14 +856,47 @@ subject strings. See also the PCRE2_FIRSTLINE option, which requires a match to
 start within the first line of the subject. If this is set with an offset
 limit, a match must occur in the first line and also within the offset limit.
 In other words, whichever limit comes first is used.
+int pcre2_set_heap_limit(pcre2_match_context *mcontext,
+  uint32_t value);
+

+

+The heap_limit parameter specifies, in units of kilobytes, the maximum 
+amount of heap memory that pcre2_match() may use to hold backtracking
+information when running an interpretive match. This limit does not apply to
+matching with the JIT optimization, which has its own memory control
+arrangements (see the
+pcre2jit
+documentation for more details), nor does it apply to pcre2_dfa_match().
+If the limit is reached, the negative error code PCRE2_ERROR_HEAPLIMIT is 
+returned. The default limit is set when PCRE2 is built; the default default is 
+very large and is essentially "unlimited".
+

+

+A value for the heap limit may also be supplied by an item at the start of a
+pattern of the form
+
+  (*LIMIT_HEAP=ddd)
+

+where ddd is a decimal number. However, such a setting is ignored unless ddd is
+less than the limit set by the caller of pcre2_match() or, if no such
+limit is set, less than the default.
+

+

+The pcre2_match() function starts out using a 20K vector on the system
+stack for recording backtracking points. The more nested backtracking points
+there are (that is, the deeper the search tree), the more memory is needed. 
+Heap memory is used only if the initial vector is too small. If the heap limit 
+is set to a value less than 21 (in particular, zero) no heap memory will be 
+used. In this case, only patterns that do not have a lot of nested backtracking 
+can be successfully processed. 
 int pcre2_set_match_limit(pcre2_match_context *mcontext,
   uint32_t value);
 

 

 The match_limit parameter provides a means of preventing PCRE2 from using
-up too many resources when processing patterns that are not going to match, but
-which have a very large number of possibilities in their search trees. The
-classic example is a pattern that uses nested unlimited repeats.
+up too many computing resources when processing patterns that are not going to
+match, but which have a very large number of possibilities in their search
+trees. The classic example is a pattern that uses nested unlimited repeats.
 

 

 There is an internal counter in pcre2_match() that is incremented each
@@ -895,16 +933,20 @@ limit is set, less than the default.
 This parameter limits the depth of nested backtracking in pcre2_match().
 Each time a nested backtracking point is passed, a new memory "frame" is used 
 to remember the state of matching at that point. Thus, this parameter
-indirectly limits the amount of memory that is used in a match.
+indirectly limits the amount of memory that is used in a match. However,
+because the size of each memory "frame" depends on the number of capturing
+parentheses, the actual memory limit varies from pattern to pattern. This limit
+was more useful in versions before 10.30, where function recursion was used for
+backtracking.
 

 

-This limit is not relevant, and is ignored, when matching is done using JIT
-compiled code. However, it is supported by pcre2_dfa_match(), which uses
-it to limit the depth of internal recursive function calls that implement
-lookaround assertions and pattern recursions. This is, therefore, an indirect
-limit on the amount of system stack that is used. A recursive pattern such as
-/(.)(?1)/, when matched to a very long string using pcre2_dfa_match(),
-can use a great deal of stack.
+The depth limit is not relevant, and is ignored, when matching is done using
+JIT compiled code. However, it is supported by pcre2_dfa_match(), which
+uses it to limit the depth of internal recursive function calls that implement
+atomic groups, lookaround assertions, and pattern recursions. This is,
+therefore, an indirect limit on the amount of system stack that is used. A
+recursive pattern such as /(.)(?1)/, when matched to a very long string using
+pcre2_dfa_match(), can use a great deal of stack.
 

 

 The default value for the depth limit can be set when PCRE2 is built; the
@@ -958,6 +1000,12 @@ The output is a uint32_t integer that gives the default limit for the depth of
 nested backtracking in pcre2_match() or the depth of nested recursions
 and lookarounds in pcre2_dfa_match(). Further details are given with
 pcre2_set_depth_limit() above.
+
+  PCRE2_CONFIG_HEAPLIMIT
+

+The output is a uint32_t integer that gives, in kilobytes, the default limit
+for the amount of heap memory used by pcre2_match(). Further details are
+given with pcre2_set_heap_limit() above.
 
   PCRE2_CONFIG_JIT
 

@@ -1786,6 +1834,13 @@ Return 1 if the pattern contains any explicit matches for CR or LF characters,
 otherwise 0. The third argument should point to an uint32_t variable. An
 explicit match is either a literal CR or LF character, or \r or \n or one of
 the equivalent hexadecimal or octal escape sequences.
+
+  PCRE2_INFO_HEAPLIMIT
+

+If the pattern set a heap memory limit by including an item of the form
+(*LIMIT_HEAP=nnnn) at the start, the value is returned. The third argument
+should point to an unsigned 32-bit integer. If no such value has been set, the
+call to pcre2_pattern_info() returns the error PCRE2_ERROR_UNSET.
 
   PCRE2_INFO_JCHANGED
 

@@ -2554,7 +2609,8 @@ The backtracking match limit was reached.
 

 If a pattern contains many nested backtracking points, heap memory is used to 
 remember them. This error is given when the memory allocation function (default 
-or custom) fails.
+or custom) fails. Note that a different error, PCRE2_ERROR_HEAPLIMIT, is given 
+if the amount of memory needed exceeds the heap limit.
 
   PCRE2_ERROR_NULL
 

@@ -3271,7 +3327,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 04 April 2017
+Last updated: 11 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/html/pcre2build.html b/doc/html/pcre2build.html
index 333e4f8..1cef522 100644
--- a/doc/html/pcre2build.html
+++ b/doc/html/pcre2build.html
@@ -265,17 +265,41 @@ to the configure command. This setting has no effect on the
 (though the counting is done differently).
 

 

-In some environments it is desirable to limit the depth of nested backtracking
-in order to restrict the maximum amount of heap memory that is used. A second
-limit controls this; it defaults to the value that is set for
---with-match-limit. You can set a lower default limit by adding, for example,
+The pcre2_match() function starts out using a 20K vector on the system
+stack to record backtracking points. The more nested backtracking points there
+are (that is, the deeper the search tree), the more memory is needed. If the
+initial vector is not large enough, heap memory is used, up to a certain limit,
+which is specified in kilobytes. The limit can be changed at run time, as
+described in the
+pcre2api
+documentation. The default limit (in effect unlimited) is 20 million. You can
+change this by a setting such as
+
+  --with-heap-limit=500
+

+which limits the amount of heap to 500 kilobytes. This limit applies only to
+interpretive matching in pcre2_match(). It does not apply when JIT (which has
+its own memory arrangements) is used, nor does it apply to
+pcre2_dfa_match().
+

+

+You can also explicitly limit the depth of nested backtracking in the
+pcre2_match() interpreter. This limit defaults to the value that is set
+for --with-match-limit. You can set a lower default limit by adding, for
+example,
 
   --with-match-limit_depth=10000
 

-to the configure command. This value can also be overridden at run time.
-As well as applying to pcre2_match(), this limit also controls the depth 
-of recursive function calls in pcre2_dfa_match(). These are used for 
-lookaround assertions, atomic groups, and recursion within patterns.
+to the configure command. This value can be overridden at run time. This
+depth limit indirectly limits the amount of heap memory that is used, but
+because the size of each backtracking "frame" depends on the number of
+capturing parentheses in a pattern, the amount of heap that is used before the
+limit is reached varies from pattern to pattern. This limit was more useful in
+versions before 10.30, where function recursion was used for backtracking.
+However, as well as applying to pcre2_match(), this limit also controls
+the depth of recursive function calls in pcre2_dfa_match(). These are
+used for lookaround assertions, atomic groups, and recursion within patterns.
+The limit does not apply to JIT matching.
 

 
CREATING CHARACTER TABLES AT BUILD TIME

 

@@ -530,7 +554,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 31 March 2017
+Last updated: 10 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/html/pcre2grep.html b/doc/html/pcre2grep.html
index 0212b5c..499b2d1 100644
--- a/doc/html/pcre2grep.html
+++ b/doc/html/pcre2grep.html
@@ -404,6 +404,10 @@ file name is followed by a colon; for context lines, a hyphen separator is used.
 If a line number is also being output, it follows the file name.
 

 

+--heap-limit=number
+See --match-limit below.
+

+

 --help
 Output a help message, giving brief details of the command options and file
 type support, and then exit. Anything else on the command line is
@@ -505,7 +509,7 @@ used. There is no short form for this option.
 --match-limit=number
 Processing some regular expression patterns may take a very long time to search
 for all possible matching strings. Others may require a very large amount of
-memory. There are two options that set resource limits for matching.
+memory. There are three options that set resource limits for matching.
 

 

 The --match-limit option provides a means of limiting computing resource
@@ -516,13 +520,24 @@ counter that is incremented each time around its main processing loop. If the
 value set by --match-limit is reached, an error occurs.
 

 

+The --heap-limit option specifies, as a number of kilobytes, the amount
+of heap memory that may be used for matching. Heap memory is needed only if
+matching the pattern requires a significant number of nested backtracking
+points to be remembered. This parameter can be set to zero to forbid the use of 
+heap memory altogether.
+

+

 The --depth-limit option limits the depth of nested backtracking points,
-which in turn limits the amount of memory that is used. This limit is of use
-only if it is set smaller than --match-limit.
+which indirectly limits the amount of memory that is used. The amount of memory 
+needed for each backtracking point depends on the number of capturing
+parentheses in the pattern, so the amount of memory that is used before this
+limit acts varies from pattern to pattern. This limit is of use only if it is
+set smaller than --match-limit.
 

 

 There are no short forms for these options. The default settings are specified
-when the PCRE2 library is compiled, with the default default being 10 million.
+when the PCRE2 library is compiled, with the default defaults being very large 
+and so effectively unlimited.
 

 

 \fB--max-buffer-size=number
@@ -764,11 +779,12 @@ Many of the short and long forms of pcre2grep's options are the same
 as in the GNU grep program. Any long option of the form
 --xxx-regexp (GNU terminology) is also available as --xxx-regex
 (PCRE2 terminology). However, the --depth-limit, --file-list,
---file-offsets, --include-dir, --line-offsets,
---locale, --match-limit, -M, --multiline, -N,
---newline, --om-separator, --output, -u, and
---utf-8 options are specific to pcre2grep, as is the use of the
---only-matching option with a capturing parentheses number.
+--file-offsets, --heap-limit, --include-dir,
+--line-offsets, --locale, --match-limit, -M,
+--multiline, -N, --newline, --om-separator,
+--output, -u, and --utf-8 options are specific to
+pcre2grep, as is the use of the --only-matching option with a
+capturing parentheses number.
 

 

 Although most of the common options work the same way, a few are different in
@@ -891,9 +907,9 @@ there are more than 20 such errors, pcre2grep gives up.
 

 

 The --match-limit option of pcre2grep can be used to set the
-overall resource limit; there is a second option called --depth-limit
-that sets a limit on the amount of memory that is used (see the discussion of
-these options above).
+overall resource limit. There are also other limits that affect the amount of 
+memory used during matching; see the discussion of --heap-limit and 
+--depth-limit above.
 

 
DIAGNOSTICS

 

@@ -918,7 +934,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 06 April 2017
+Last updated: 11 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/html/pcre2pattern.html b/doc/html/pcre2pattern.html
index 87258fb..66500c1 100644
--- a/doc/html/pcre2pattern.html
+++ b/doc/html/pcre2pattern.html
@@ -170,14 +170,15 @@ the application to apply the JIT optimization by calling
 pcre2_jit_compile() is ignored.
 

 

-Setting match and backtracking depth limits
+Setting match resource limits
 

 

 The pcre2_match() function contains a counter that is incremented every time it
 goes round its main loop. The caller of pcre2_match() can set a limit on
 this counter, which therefore limits the amount of computing resource used for
-a match. The maximum depth of nested backtracking can also be limited, and this
-restricts the amount of heap memory that is used.
+a match. The maximum depth of nested backtracking can also be limited; this
+indirectly restricts the amount of heap memory that is used, but there is also 
+an explicit memory limit that can be set.
 

 

 These facilities are provided to catch runaway matches that are provoked by
@@ -186,6 +187,7 @@ unlimited repeats applied to a long string that does not match). When one of
 these limits is reached, pcre2_match() gives an error return. The limits
 can also be set by items at the start of the pattern of the form
 
+  (*LIMIT_HEAP=d)
   (*LIMIT_MATCH=d)
   (*LIMIT_DEPTH=d)
 

@@ -200,11 +202,13 @@ Prior to release 10.30, LIMIT_DEPTH was called LIMIT_RECURSION. This name is
 still recognized for backwards compatibility.
 

 

-The match limit is used (but in a different way) when JIT is being used, but it
-is not relevant, and is ignored, when matching with pcre2_dfa_match().
-However, the depth limit is relevant for DFA matching, which uses function
-recursion for recursions within the pattern. In this case, the depth limit 
-controls the amount of system stack that is used.
+The heap limit applies only when the pcre2_match() interpreter is used
+for matching. It does not apply to JIT or DFA matching. The match limit is used
+(but in a different way) when JIT is being used, but it is not relevant, and is
+ignored, when matching with pcre2_dfa_match(). The depth limit is ignored 
+by JIT but is relevant for DFA matching, which uses function recursion for
+recursions within the pattern. In this case, the depth limit controls the
+amount of system stack that is used.
 

 

 Newline conventions
@@ -3434,7 +3438,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 03 April 2017
+Last updated: 11 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/html/pcre2perform.html b/doc/html/pcre2perform.html
index ad5d065..1a53493 100644
--- a/doc/html/pcre2perform.html
+++ b/doc/html/pcre2perform.html
@@ -83,11 +83,12 @@ From release 10.30, the interpretive (non-JIT) version of pcre2_match()
 uses very little system stack at run time. In earlier releases recursive
 function calls could use a great deal of stack, and this could cause problems,
 but this usage has been eliminated. Backtracking positions are now explicitly
-remembered in memory frames controlled by the code. An initial 10K vector of
-frames is allocated on the system stack (enough for about 50 frames for small
-patterns), but if this is insufficient, heap memory is used. Rewriting patterns 
-to be time-efficient, as described below, may also reduce the memory 
-requirements.
+remembered in memory frames controlled by the code. An initial 20K vector of
+frames is allocated on the system stack (enough for about 100 frames for small
+patterns), but if this is insufficient, heap memory is used. The amount of heap
+memory can be limited; if the limit is set to zero, only the initial stack
+vector is used. Rewriting patterns to be time-efficient, as described below,
+may also reduce the memory requirements.
 

 

 In contrast to pcre2_match(), pcre2_dfa_match() does use recursive 
@@ -243,7 +244,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 31 March 2017
+Last updated: 08 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/html/pcre2test.html b/doc/html/pcre2test.html
index 20b2dce..2e8a0b8 100644
--- a/doc/html/pcre2test.html
+++ b/doc/html/pcre2test.html
@@ -235,6 +235,12 @@ Behave as if each pattern line has the jit modifier; after successful
 compilation, each pattern is passed to the just-in-time compiler, if available.
 

 

+-jitverify
+Behave as if each pattern line has the jitverify modifier; after
+successful compilation, each pattern is passed to the just-in-time compiler, if
+available, and the use of JIT is verified.
+

+

 \fB-pattern\fB modifier-list
 Behave as if each pattern line contains the given modifiers.
 

@@ -1088,6 +1094,7 @@ pattern.
       get=<number or name>       extract captured substring
       getall                     extract all captured substrings
   /g  global                     global matching
+      heap_limit=<n>             set a limit on heap memory
       jitstack=<n>               set size of JIT stack
       mark                       show mark values
       match_limit=<n>            set a match limit
@@ -1330,11 +1337,11 @@ stack that is larger than the default 32K is necessary only for very
 complicated patterns.
 

 

-Setting match and depth limits
+Setting heap, match, and depth limits
 

 

-The match_limit and depth_limit modifiers set the appropriate
-limits in the match context. These values are ignored when the
+The heap_limit, match_limit, and depth_limit modifiers set
+the appropriate limits in the match context. These values are ignored when the
 find_limits modifier is specified.
 

 

@@ -1343,8 +1350,8 @@ Finding minimum limits
 

 If the find_limits modifier is present on a subject line, pcre2test
 calls the relevant matching function several times, setting different values in
-the match context via pcre2_set_match_limit() or
-pcre2_set_depth_limit() until it finds the minimum values for each
+the match context via pcre2_set_heap_limit(), \fBpcre2_set_match_limit(),
+or pcre2_set_depth_limit() until it finds the minimum values for each
 parameter that allows the match to complete without error.
 

 

@@ -1360,9 +1367,9 @@ increasing length of subject string.
 

 

 For non-DFA matching, the minimum depth_limit number is a measure of how
-much memory for recording backtracking points is needed to complete the match
-attempt. In the case of DFA matching, depth_limit controls the depth of 
-recursive calls of the internal function that is used for handling pattern 
+much nested backtracking happens (that is, how deeply the pattern's tree is
+searched). In the case of DFA matching, depth_limit controls the depth of
+recursive calls of the internal function that is used for handling pattern
 recursion, lookaround assertions, and atomic groups.
 

 

@@ -1800,7 +1807,7 @@ Cambridge, England.
 

 
REVISION

 

-Last updated: 04 April 2017
+Last updated: 11 April 2017
 

 Copyright © 1997-2017 University of Cambridge.
 

diff --git a/doc/index.html.src b/doc/index.html.src
index 3517671..9b0a7ff 100644
--- a/doc/index.html.src
+++ b/doc/index.html.src
@@ -213,6 +213,9 @@ in the library.
 pcre2_set_depth_limit
       Set the match backtracking depth limit
 
+pcre2_set_heap_limit
+      Set the match backtracking heap limit
+
 pcre2_set_match_limit
       Set the match limit
 
diff --git a/doc/pcre2.txt b/doc/pcre2.txt
index 92b17c7..5114ba9 100644
--- a/doc/pcre2.txt
+++ b/doc/pcre2.txt
@@ -283,6 +283,9 @@ PCRE2 NATIVE API MATCH CONTEXT FUNCTIONS
        int pcre2_set_offset_limit(pcre2_match_context *mcontext,
          PCRE2_SIZE value);
 
+       int pcre2_set_heap_limit(pcre2_match_context *mcontext,
+         uint32_t value);
+
        int pcre2_set_match_limit(pcre2_match_context *mcontext,
          uint32_t value);
 
@@ -840,6 +843,7 @@ PCRE2 CONTEXTS
 
          Set up a callout function
          Set an offset limit for matching an unanchored pattern
+         Change the limit on the amount of heap used when matching
          Change the backtracking match limit
          Change the backtracking depth limit
          Set custom memory management specifically for the match
@@ -896,67 +900,101 @@ PCRE2 CONTEXTS
        also  within  the  offset limit.  In other words, whichever limit comes
        first is used.
 
+       int pcre2_set_heap_limit(pcre2_match_context *mcontext,
+         uint32_t value);
+
+       The heap_limit parameter specifies, in units of kilobytes, the  maximum
+       amount  of  heap memory that pcre2_match() may use to hold backtracking
+       information when running an interpretive match.  This  limit  does  not
+       apply  to  matching with the JIT optimization, which has its own memory
+       control arrangements (see the pcre2jit documentation for more details),
+       nor  does  it apply to pcre2_dfa_match().  If the limit is reached, the
+       negative error code  PCRE2_ERROR_HEAPLIMIT  is  returned.  The  default
+       limit is set when PCRE2 is built; the default default is very large and
+       is essentially "unlimited".
+
+       A value for the heap limit may also be supplied by an item at the start
+       of a pattern of the form
+
+         (*LIMIT_HEAP=ddd)
+
+       where  ddd  is  a  decimal  number.  However, such a setting is ignored
+       unless ddd is less than the limit set by the  caller  of  pcre2_match()
+       or, if no such limit is set, less than the default.
+
+       The  pcre2_match() function starts out using a 20K vector on the system
+       stack for recording backtracking points. The more  nested  backtracking
+       points there are (that is, the deeper the search tree), the more memory
+       is needed.  Heap memory is used only  if  the  initial  vector  is  too
+       small. If the heap limit is set to a value less than 21 (in particular,
+       zero) no heap memory will be used. In this case, only patterns that  do
+       not have a lot of nested backtracking can be successfully processed.
+
        int pcre2_set_match_limit(pcre2_match_context *mcontext,
          uint32_t value);
 
-       The match_limit parameter provides a means  of  preventing  PCRE2  from
-       using up too many resources when processing patterns that are not going
-       to match, but which have a very large number of possibilities in  their
-       search  trees. The classic example is a pattern that uses nested unlim-
-       ited repeats.
+       The  match_limit  parameter  provides  a means of preventing PCRE2 from
+       using up too many computing resources when processing patterns that are
+       not going to match, but which have a very large number of possibilities
+       in their search trees. The classic  example  is  a  pattern  that  uses
+       nested unlimited repeats.
 
-       There is an internal counter in pcre2_match() that is incremented  each
-       time  round  its  main  matching  loop. If this value reaches the match
+       There  is an internal counter in pcre2_match() that is incremented each
+       time round its main matching loop. If  this  value  reaches  the  match
        limit, pcre2_match() returns the negative value PCRE2_ERROR_MATCHLIMIT.
-       This  has  the  effect  of limiting the amount of backtracking that can
+       This has the effect of limiting the amount  of  backtracking  that  can
        take place. For patterns that are not anchored, the count restarts from
-       zero  for  each position in the subject string. This limit is not rele-
+       zero for each position in the subject string. This limit is  not  rele-
        vant to pcre2_dfa_match(), which ignores it.
 
-       When pcre2_match() is called with a pattern that was successfully  pro-
+       When  pcre2_match() is called with a pattern that was successfully pro-
        cessed by pcre2_jit_compile(), the way in which matching is executed is
-       entirely different. However, there is still the possibility of  runaway
-       matching  that  goes  on  for  a very long time, and so the match_limit
-       value is also used in this case (but in a different way) to  limit  how
+       entirely  different. However, there is still the possibility of runaway
+       matching that goes on for a very long  time,  and  so  the  match_limit
+       value  is  also used in this case (but in a different way) to limit how
        long the matching can continue.
 
-       The  default  value  for  the limit can be set when PCRE2 is built; the
-       default default is 10 million, which handles all but the  most  extreme
-       cases.  A  value for the match limit may also be supplied by an item at
+       The default value for the limit can be set when  PCRE2  is  built;  the
+       default  default  is 10 million, which handles all but the most extreme
+       cases. A value for the match limit may also be supplied by an  item  at
        the start of a pattern of the form
 
          (*LIMIT_MATCH=ddd)
 
-       where ddd is a decimal number.  However,  such  a  setting  is  ignored
-       unless  ddd  is  less than the limit set by the caller of pcre2_match()
+       where  ddd  is  a  decimal  number.  However, such a setting is ignored
+       unless ddd is less than the limit set by the  caller  of  pcre2_match()
        or, if no such limit is set, less than the default.
 
        int pcre2_set_depth_limit(pcre2_match_context *mcontext,
          uint32_t value);
 
-       This  parameter  limits   the   depth   of   nested   backtracking   in
-       pcre2_match().   Each time a nested backtracking point is passed, a new
+       This   parameter   limits   the   depth   of   nested  backtracking  in
+       pcre2_match().  Each time a nested backtracking point is passed, a  new
        memory "frame" is used to remember the state of matching at that point.
-       Thus,  this  parameter  indirectly  limits the amount of memory that is
-       used in a match.
+       Thus, this parameter indirectly limits the amount  of  memory  that  is
+       used  in  a  match.  However,  because  the size of each memory "frame"
+       depends on the number of capturing parentheses, the actual memory limit
+       varies  from pattern to pattern. This limit was more useful in versions
+       before 10.30, where function recursion was used for backtracking.
 
-       This limit is not relevant, and is ignored, when matching is done using
-       JIT compiled code. However, it is supported by pcre2_dfa_match(), which
-       uses it to limit the depth of internal recursive  function  calls  that
-       implement lookaround assertions and pattern recursions. This is, there-
-       fore, an indirect limit on the amount of system stack that is  used.  A
-       recursive pattern such as /(.)(?1)/, when matched to a very long string
-       using pcre2_dfa_match(), can use a great deal of stack.
+       The depth limit is not relevant, and is ignored, when matching is  done
+       using JIT compiled code. However, it is supported by pcre2_dfa_match(),
+       which uses it to limit the depth of internal recursive  function  calls
+       that implement atomic groups, lookaround assertions, and pattern recur-
+       sions. This is, therefore, an indirect limit on the  amount  of  system
+       stack that is used. A recursive pattern such as /(.)(?1)/, when matched
+       to a very long string using pcre2_dfa_match(), can use a great deal  of
+       stack.
 
-       The default value for the depth limit can be set when PCRE2  is  built;
-       the  default  default  is  the  same value as the default for the match
-       limit. If the limit is  exceeded,  pcre2_match()  or  pcre2_dfa_match()
+       The  default  value for the depth limit can be set when PCRE2 is built;
+       the default default is the same value as  the  default  for  the  match
+       limit.  If  the  limit  is exceeded, pcre2_match() or pcre2_dfa_match()
        returns PCRE2_ERROR_DEPTHLIMIT. A value for the depth limit may also be
        supplied by an item at the start of a pattern of the form
 
          (*LIMIT_DEPTH=ddd)
 
-       where ddd is a decimal number.  However,  such  a  setting  is  ignored
+       where  ddd  is  a  decimal  number.  However, such a setting is ignored
        unless ddd is less than the limit set by the caller of pcre2_match() or
        pcre2_dfa_match() or, if no such limit is set, less than the default.
 
@@ -965,82 +1003,88 @@ CHECKING BUILD-TIME OPTIONS
 
        int pcre2_config(uint32_t what, void *where);
 
-       The function pcre2_config() makes it possible for  a  PCRE2  client  to
-       discover  which  optional  features  have  been compiled into the PCRE2
-       library. The pcre2build documentation  has  more  details  about  these
+       The  function  pcre2_config()  makes  it possible for a PCRE2 client to
+       discover which optional features have  been  compiled  into  the  PCRE2
+       library.  The  pcre2build  documentation  has  more details about these
        optional features.
 
-       The  first  argument  for pcre2_config() specifies which information is
-       required. The second argument is a pointer to  memory  into  which  the
-       information  is  placed.  If  NULL  is passed, the function returns the
-       amount of memory that is needed  for  the  requested  information.  For
-       calls  that  return  numerical  values,  the  value  is  in bytes; when
-       requesting these values, where should point  to  appropriately  aligned
-       memory.  For calls that return strings, the required length is given in
+       The first argument for pcre2_config() specifies  which  information  is
+       required.  The  second  argument  is a pointer to memory into which the
+       information is placed. If NULL is  passed,  the  function  returns  the
+       amount  of  memory  that  is  needed for the requested information. For
+       calls that return  numerical  values,  the  value  is  in  bytes;  when
+       requesting  these  values,  where should point to appropriately aligned
+       memory. For calls that return strings, the required length is given  in
        code units, not counting the terminating zero.
 
-       When requesting information, the returned value from pcre2_config()  is
-       non-negative  on success, or the negative error code PCRE2_ERROR_BADOP-
-       TION if the value in the first argument is not recognized. The  follow-
+       When  requesting information, the returned value from pcre2_config() is
+       non-negative on success, or the negative error code  PCRE2_ERROR_BADOP-
+       TION  if the value in the first argument is not recognized. The follow-
        ing information is available:
 
          PCRE2_CONFIG_BSR
 
-       The  output  is a uint32_t integer whose value indicates what character
-       sequences the \R  escape  sequence  matches  by  default.  A  value  of
+       The output is a uint32_t integer whose value indicates  what  character
+       sequences  the  \R  escape  sequence  matches  by  default.  A value of
        PCRE2_BSR_UNICODE  means  that  \R  matches  any  Unicode  line  ending
-       sequence; a value of PCRE2_BSR_ANYCRLF means that \R matches  only  CR,
+       sequence;  a  value of PCRE2_BSR_ANYCRLF means that \R matches only CR,
        LF, or CRLF. The default can be overridden when a pattern is compiled.
 
          PCRE2_CONFIG_DEPTHLIMIT
 
-       The  output  is a uint32_t integer that gives the default limit for the
-       depth of nested backtracking in pcre2_match() or the  depth  of  nested
-       recursions  and  lookarounds  in pcre2_dfa_match(). Further details are
+       The output is a uint32_t integer that gives the default limit  for  the
+       depth  of  nested  backtracking in pcre2_match() or the depth of nested
+       recursions and lookarounds in pcre2_dfa_match().  Further  details  are
        given with pcre2_set_depth_limit() above.
 
+         PCRE2_CONFIG_HEAPLIMIT
+
+       The  output is a uint32_t integer that gives, in kilobytes, the default
+       limit for the amount of heap  memory  used  by  pcre2_match().  Further
+       details are given with pcre2_set_heap_limit() above.
+
          PCRE2_CONFIG_JIT
 
-       The output is a uint32_t integer that is set  to  one  if  support  for
+       The  output  is  a  uint32_t  integer that is set to one if support for
        just-in-time compiling is available; otherwise it is set to zero.
 
          PCRE2_CONFIG_JITTARGET
 
-       The  where  argument  should point to a buffer that is at least 48 code
-       units long.  (The  exact  length  required  can  be  found  by  calling
-       pcre2_config()  with  where  set  to NULL.) The buffer is filled with a
-       string that contains the name of the architecture  for  which  the  JIT
-       compiler  is  configured,  for  example  "x86  32bit  (little  endian +
-       unaligned)". If JIT support is not available, PCRE2_ERROR_BADOPTION  is
-       returned,  otherwise the number of code units used is returned. This is
+       The where argument should point to a buffer that is at  least  48  code
+       units  long.  (The  exact  length  required  can  be  found  by calling
+       pcre2_config() with where set to NULL.) The buffer  is  filled  with  a
+       string  that  contains  the  name of the architecture for which the JIT
+       compiler is  configured,  for  example  "x86  32bit  (little  endian  +
+       unaligned)".  If JIT support is not available, PCRE2_ERROR_BADOPTION is
+       returned, otherwise the number of code units used is returned. This  is
        the length of the string, plus one unit for the terminating zero.
 
          PCRE2_CONFIG_LINKSIZE
 
        The output is a uint32_t integer that contains the number of bytes used
-       for  internal  linkage  in  compiled regular expressions. When PCRE2 is
-       configured, the value can be set to 2, 3, or 4, with the default  being
-       2.  This is the value that is returned by pcre2_config(). However, when
-       the 16-bit library is compiled, a value of 3 is rounded up  to  4,  and
-       when  the  32-bit  library  is compiled, internal linkages always use 4
+       for internal linkage in compiled regular  expressions.  When  PCRE2  is
+       configured,  the value can be set to 2, 3, or 4, with the default being
+       2. This is the value that is returned by pcre2_config(). However,  when
+       the  16-bit  library  is compiled, a value of 3 is rounded up to 4, and
+       when the 32-bit library is compiled, internal  linkages  always  use  4
        bytes, so the configured value is not relevant.
 
        The default value of 2 for the 8-bit and 16-bit libraries is sufficient
-       for  all but the most massive patterns, since it allows the size of the
+       for all but the most massive patterns, since it allows the size of  the
        compiled pattern to be up to 64K code units. Larger values allow larger
-       regular  expressions  to be compiled by those two libraries, but at the
+       regular expressions to be compiled by those two libraries, but  at  the
        expense of slower matching.
 
          PCRE2_CONFIG_MATCHLIMIT
 
        The output is a uint32_t integer that gives the default match limit for
-       pcre2_match().  Further  details are given with pcre2_set_match_limit()
+       pcre2_match(). Further details are given  with  pcre2_set_match_limit()
        above.
 
          PCRE2_CONFIG_NEWLINE
 
-       The output is a uint32_t integer  whose  value  specifies  the  default
-       character  sequence that is recognized as meaning "newline". The values
+       The  output  is  a  uint32_t  integer whose value specifies the default
+       character sequence that is recognized as meaning "newline". The  values
        are:
 
          PCRE2_NEWLINE_CR       Carriage return (CR)
@@ -1049,17 +1093,17 @@ CHECKING BUILD-TIME OPTIONS
          PCRE2_NEWLINE_ANY      Any Unicode line ending
          PCRE2_NEWLINE_ANYCRLF  Any of CR, LF, or CRLF
 
-       The default should normally correspond to  the  standard  sequence  for
+       The  default  should  normally  correspond to the standard sequence for
        your operating system.
 
          PCRE2_CONFIG_PARENSLIMIT
 
-       The  output is a uint32_t integer that gives the maximum depth of nest-
+       The output is a uint32_t integer that gives the maximum depth of  nest-
        ing of parentheses (of any kind) in a pattern. This limit is imposed to
-       cap  the  amount of system stack used when a pattern is compiled. It is
-       specified when PCRE2 is built; the default is 250. This limit does  not
-       take  into  account  the  stack that may already be used by the calling
-       application. For  finer  control  over  compilation  stack  usage,  see
+       cap the amount of system stack used when a pattern is compiled.  It  is
+       specified  when PCRE2 is built; the default is 250. This limit does not
+       take into account the stack that may already be  used  by  the  calling
+       application.  For  finer  control  over  compilation  stack  usage, see
        pcre2_set_compile_recursion_guard().
 
          PCRE2_CONFIG_STACKRECURSE
@@ -1069,25 +1113,25 @@ CHECKING BUILD-TIME OPTIONS
 
          PCRE2_CONFIG_UNICODE_VERSION
 
-       The where argument should point to a buffer that is at  least  24  code
-       units  long.  (The  exact  length  required  can  be  found  by calling
-       pcre2_config() with where set to NULL.)  If  PCRE2  has  been  compiled
-       without  Unicode  support,  the buffer is filled with the text "Unicode
-       not supported". Otherwise, the Unicode  version  string  (for  example,
-       "8.0.0")  is  inserted. The number of code units used is returned. This
+       The  where  argument  should point to a buffer that is at least 24 code
+       units long.  (The  exact  length  required  can  be  found  by  calling
+       pcre2_config()  with  where  set  to  NULL.) If PCRE2 has been compiled
+       without Unicode support, the buffer is filled with  the  text  "Unicode
+       not  supported".  Otherwise,  the  Unicode version string (for example,
+       "8.0.0") is inserted. The number of code units used is  returned.  This
        is the length of the string plus one unit for the terminating zero.
 
          PCRE2_CONFIG_UNICODE
 
-       The output is a uint32_t integer that is set to one if Unicode  support
-       is  available; otherwise it is set to zero. Unicode support implies UTF
+       The  output is a uint32_t integer that is set to one if Unicode support
+       is available; otherwise it is set to zero. Unicode support implies  UTF
        support.
 
          PCRE2_CONFIG_VERSION
 
-       The where argument should point to a buffer that is at  least  24  code
-       units  long.  (The  exact  length  required  can  be  found  by calling
-       pcre2_config() with where set to NULL.) The buffer is filled  with  the
+       The  where  argument  should point to a buffer that is at least 24 code
+       units long.  (The  exact  length  required  can  be  found  by  calling
+       pcre2_config()  with  where set to NULL.) The buffer is filled with the
        PCRE2 version string, zero-terminated. The number of code units used is
        returned. This is the length of the string plus one unit for the termi-
        nating zero.
@@ -1105,90 +1149,90 @@ COMPILING A PATTERN
 
        pcre2_code *pcre2_code_copy_with_tables(const pcre2_code *code);
 
-       The  pcre2_compile() function compiles a pattern into an internal form.
-       The pattern is defined by a pointer to a string of  code  units  and  a
-       length.  If the pattern is zero-terminated, the length can be specified
-       as PCRE2_ZERO_TERMINATED. The function returns a pointer to a block  of
-       memory  that contains the compiled pattern and related data, or NULL if
+       The pcre2_compile() function compiles a pattern into an internal  form.
+       The  pattern  is  defined  by a pointer to a string of code units and a
+       length. If the pattern is zero-terminated, the length can be  specified
+       as  PCRE2_ZERO_TERMINATED. The function returns a pointer to a block of
+       memory that contains the compiled pattern and related data, or NULL  if
        an error occurred.
 
-       If the compile context argument ccontext is NULL, memory for  the  com-
-       piled  pattern  is  obtained  by  calling  malloc().  Otherwise,  it is
-       obtained from the same memory function that was used  for  the  compile
-       context.  The  caller must free the memory by calling pcre2_code_free()
+       If  the  compile context argument ccontext is NULL, memory for the com-
+       piled pattern  is  obtained  by  calling  malloc().  Otherwise,  it  is
+       obtained  from  the  same memory function that was used for the compile
+       context. The caller must free the memory by  calling  pcre2_code_free()
        when it is no longer needed.
 
        The function pcre2_code_copy() makes a copy of the compiled code in new
-       memory,  using  the same memory allocator as was used for the original.
-       However, if the code has  been  processed  by  the  JIT  compiler  (see
-       below),  the  JIT information cannot be copied (because it is position-
+       memory, using the same memory allocator as was used for  the  original.
+       However,  if  the  code  has  been  processed  by the JIT compiler (see
+       below), the JIT information cannot be copied (because it  is  position-
        dependent).  The new copy can initially be used only for non-JIT match-
        ing, though it can be passed to pcre2_jit_compile() if required.
 
        The pcre2_code_copy() function provides a way for individual threads in
-       a multithreaded application to acquire a private copy  of  shared  com-
-       piled  code.   However, it does not make a copy of the character tables
-       used by the compiled pattern; the new pattern code points to  the  same
-       tables  as  the original code.  (See "Locale Support" below for details
-       of these character tables.) In many applications the  same  tables  are
-       used  throughout, so this behaviour is appropriate. Nevertheless, there
+       a  multithreaded  application  to acquire a private copy of shared com-
+       piled code.  However, it does not make a copy of the  character  tables
+       used  by  the compiled pattern; the new pattern code points to the same
+       tables as the original code.  (See "Locale Support" below  for  details
+       of  these  character  tables.) In many applications the same tables are
+       used throughout, so this behaviour is appropriate. Nevertheless,  there
        are occasions when a copy of a compiled pattern and the relevant tables
-       are  needed.  The pcre2_code_copy_with_tables() provides this facility.
-       Copies of both the code and the tables are  made,  with  the  new  code
-       pointing  to the new tables. The memory for the new tables is automati-
-       cally freed when pcre2_code_free() is called for the new  copy  of  the
+       are needed. The pcre2_code_copy_with_tables() provides  this  facility.
+       Copies  of  both  the  code  and the tables are made, with the new code
+       pointing to the new tables. The memory for the new tables is  automati-
+       cally  freed  when  pcre2_code_free() is called for the new copy of the
        compiled code.
 
-       NOTE:  When  one  of  the matching functions is called, pointers to the
+       NOTE: When one of the matching functions is  called,  pointers  to  the
        compiled pattern and the subject string are set in the match data block
-       so  that  they can be referenced by the substring extraction functions.
-       After running a match, you must not free a compiled pattern (or a  sub-
-       ject  string)  until  after all operations on the match data block have
+       so that they can be referenced by the substring  extraction  functions.
+       After  running a match, you must not free a compiled pattern (or a sub-
+       ject string) until after all operations on the match  data  block  have
        taken place.
 
-       The options argument for pcre2_compile() contains various bit  settings
-       that  affect  the  compilation.  It  should  be  zero if no options are
-       required. The available options are described below. Some of  them  (in
-       particular,  those  that  are  compatible with Perl, but some others as
-       well) can also be set and  unset  from  within  the  pattern  (see  the
+       The  options argument for pcre2_compile() contains various bit settings
+       that affect the compilation. It  should  be  zero  if  no  options  are
+       required.  The  available options are described below. Some of them (in
+       particular, those that are compatible with Perl,  but  some  others  as
+       well)  can  also  be  set  and  unset  from within the pattern (see the
        detailed description in the pcre2pattern documentation).
 
-       For  those options that can be different in different parts of the pat-
-       tern, the contents of the options argument specifies their settings  at
-       the  start  of  compilation. The PCRE2_ANCHORED, PCRE2_ENDANCHORED, and
-       PCRE2_NO_UTF_CHECK options can be set at the time of matching  as  well
+       For those options that can be different in different parts of the  pat-
+       tern,  the contents of the options argument specifies their settings at
+       the start of compilation. The  PCRE2_ANCHORED,  PCRE2_ENDANCHORED,  and
+       PCRE2_NO_UTF_CHECK  options  can be set at the time of matching as well
        as at compile time.
 
-       Other,  less  frequently required compile-time parameters (for example,
+       Other, less frequently required compile-time parameters  (for  example,
        the newline setting) can be provided in a compile context (as described
        above).
 
        If errorcode or erroroffset is NULL, pcre2_compile() returns NULL imme-
-       diately. Otherwise, the variables to which these point are  set  to  an
-       error  code  and  an  offset (number of code units) within the pattern,
-       respectively, when pcre2_compile() returns NULL because  a  compilation
+       diately.  Otherwise,  the  variables to which these point are set to an
+       error code and an offset (number of code  units)  within  the  pattern,
+       respectively,  when  pcre2_compile() returns NULL because a compilation
        error has occurred. The values are not defined when compilation is suc-
        cessful and pcre2_compile() returns a non-NULL value.
 
        The value returned in erroroffset is an indication of where in the pat-
-       tern  the  error  occurred. It is not necessarily the furthest point in
-       the pattern that was read. For example,  after  the  error  "lookbehind
+       tern the error occurred. It is not necessarily the  furthest  point  in
+       the  pattern  that  was  read. For example, after the error "lookbehind
        assertion is not fixed length", the error offset points to the start of
        the failing assertion.
 
-       The pcre2_get_error_message() function (see "Obtaining a textual  error
-       message"  below) provides a textual message for each error code. Compi-
+       The  pcre2_get_error_message() function (see "Obtaining a textual error
+       message" below) provides a textual message for each error code.  Compi-
        lation errors have positive error codes; UTF formatting error codes are
-       negative.  For an invalid UTF-8 or UTF-16 string, the offset is that of
+       negative. For an invalid UTF-8 or UTF-16 string, the offset is that  of
        the first code unit of the failing character.
 
-       Some errors are not detected until the whole pattern has been  scanned;
-       in  these  cases,  the offset passed back is the length of the pattern.
-       Note that the offset is in code units, not characters, even  in  a  UTF
+       Some  errors are not detected until the whole pattern has been scanned;
+       in these cases, the offset passed back is the length  of  the  pattern.
+       Note  that  the  offset is in code units, not characters, even in a UTF
        mode. It may sometimes point into the middle of a UTF-8 or UTF-16 char-
        acter.
 
-       This code fragment shows a typical straightforward call  to  pcre2_com-
+       This  code  fragment shows a typical straightforward call to pcre2_com-
        pile():
 
          pcre2_code *re;
@@ -1202,359 +1246,359 @@ COMPILING A PATTERN
            &erroffset,             /* for error offset */
            NULL);                  /* no compile context */
 
-       The  following  names for option bits are defined in the pcre2.h header
+       The following names for option bits are defined in the  pcre2.h  header
        file:
 
          PCRE2_ANCHORED
 
        If this bit is set, the pattern is forced to be "anchored", that is, it
-       is  constrained to match only at the first matching point in the string
-       that is being searched (the "subject string"). This effect can also  be
-       achieved  by appropriate constructs in the pattern itself, which is the
+       is constrained to match only at the first matching point in the  string
+       that  is being searched (the "subject string"). This effect can also be
+       achieved by appropriate constructs in the pattern itself, which is  the
        only way to do it in Perl.
 
          PCRE2_ALLOW_EMPTY_CLASS
 
-       By default, for compatibility with Perl, a closing square bracket  that
-       immediately  follows  an opening one is treated as a data character for
-       the class. When  PCRE2_ALLOW_EMPTY_CLASS  is  set,  it  terminates  the
+       By  default, for compatibility with Perl, a closing square bracket that
+       immediately follows an opening one is treated as a data  character  for
+       the  class.  When  PCRE2_ALLOW_EMPTY_CLASS  is  set,  it terminates the
        class, which therefore contains no characters and so can never match.
 
          PCRE2_ALT_BSUX
 
-       This  option  request  alternative  handling of three escape sequences,
-       which makes PCRE2's behaviour more like  ECMAscript  (aka  JavaScript).
+       This option request alternative handling  of  three  escape  sequences,
+       which  makes  PCRE2's  behaviour more like ECMAscript (aka JavaScript).
        When it is set:
 
        (1) \U matches an upper case "U" character; by default \U causes a com-
        pile time error (Perl uses \U to upper case subsequent characters).
 
        (2) \u matches a lower case "u" character unless it is followed by four
-       hexadecimal  digits,  in  which case the hexadecimal number defines the
-       code point to match. By default, \u causes a compile time  error  (Perl
+       hexadecimal digits, in which case the hexadecimal  number  defines  the
+       code  point  to match. By default, \u causes a compile time error (Perl
        uses it to upper case the following character).
 
-       (3)  \x matches a lower case "x" character unless it is followed by two
-       hexadecimal digits, in which case the hexadecimal  number  defines  the
-       code  point  to  match. By default, as in Perl, a hexadecimal number is
+       (3) \x matches a lower case "x" character unless it is followed by  two
+       hexadecimal  digits,  in  which case the hexadecimal number defines the
+       code point to match. By default, as in Perl, a  hexadecimal  number  is
        always expected after \x, but it may have zero, one, or two digits (so,
        for example, \xz matches a binary zero character followed by z).
 
          PCRE2_ALT_CIRCUMFLEX
 
        In  multiline  mode  (when  PCRE2_MULTILINE  is  set),  the  circumflex
-       metacharacter matches at the start of the subject (unless  PCRE2_NOTBOL
-       is  set),  and  also  after  any internal newline. However, it does not
+       metacharacter  matches at the start of the subject (unless PCRE2_NOTBOL
+       is set), and also after any internal  newline.  However,  it  does  not
        match after a newline at the end of the subject, for compatibility with
-       Perl.  If  you want a multiline circumflex also to match after a termi-
+       Perl. If you want a multiline circumflex also to match after  a  termi-
        nating newline, you must set PCRE2_ALT_CIRCUMFLEX.
 
          PCRE2_ALT_VERBNAMES
 
-       By default, for compatibility with Perl, the name in any verb  sequence
-       such  as  (*MARK:NAME)  is  any  sequence  of  characters that does not
-       include a closing parenthesis. The name is not processed  in  any  way,
-       and  it  is  not possible to include a closing parenthesis in the name.
-       However, if the PCRE2_ALT_VERBNAMES option  is  set,  normal  backslash
-       processing  is  applied  to  verb  names  and only an unescaped closing
-       parenthesis terminates the name. A closing parenthesis can be  included
-       in  a  name  either  as  \) or between \Q and \E. If the PCRE2_EXTENDED
+       By  default, for compatibility with Perl, the name in any verb sequence
+       such as (*MARK:NAME) is  any  sequence  of  characters  that  does  not
+       include  a  closing  parenthesis. The name is not processed in any way,
+       and it is not possible to include a closing parenthesis  in  the  name.
+       However,  if  the  PCRE2_ALT_VERBNAMES  option is set, normal backslash
+       processing is applied to verb  names  and  only  an  unescaped  closing
+       parenthesis  terminates the name. A closing parenthesis can be included
+       in a name either as \) or between \Q  and  \E.  If  the  PCRE2_EXTENDED
        option is set, unescaped whitespace in verb names is skipped and #-com-
-       ments  are  recognized in this mode, exactly as in the rest of the pat-
+       ments are recognized in this mode, exactly as in the rest of  the  pat-
        tern.
 
          PCRE2_AUTO_CALLOUT
 
-       If this bit  is  set,  pcre2_compile()  automatically  inserts  callout
-       items,  all  with  number 255, before each pattern item, except immedi-
-       ately before or after an explicit callout in the pattern.  For  discus-
+       If  this  bit  is  set,  pcre2_compile()  automatically inserts callout
+       items, all with number 255, before each pattern  item,  except  immedi-
+       ately  before  or after an explicit callout in the pattern. For discus-
        sion of the callout facility, see the pcre2callout documentation.
 
          PCRE2_CASELESS
 
-       If  this  bit is set, letters in the pattern match both upper and lower
-       case letters in the subject. It is equivalent to Perl's /i option,  and
+       If this bit is set, letters in the pattern match both upper  and  lower
+       case  letters in the subject. It is equivalent to Perl's /i option, and
        it can be changed within a pattern by a (?i) option setting.
 
          PCRE2_DOLLAR_ENDONLY
 
-       If  this bit is set, a dollar metacharacter in the pattern matches only
-       at the end of the subject string. Without this option,  a  dollar  also
-       matches  immediately before a newline at the end of the string (but not
-       before any other newlines). The PCRE2_DOLLAR_ENDONLY option is  ignored
-       if  PCRE2_MULTILINE  is  set.  There is no equivalent to this option in
+       If this bit is set, a dollar metacharacter in the pattern matches  only
+       at  the  end  of the subject string. Without this option, a dollar also
+       matches immediately before a newline at the end of the string (but  not
+       before  any other newlines). The PCRE2_DOLLAR_ENDONLY option is ignored
+       if PCRE2_MULTILINE is set. There is no equivalent  to  this  option  in
        Perl, and no way to set it within a pattern.
 
          PCRE2_DOTALL
 
-       If this bit is set, a dot metacharacter  in  the  pattern  matches  any
-       character,  including  one  that  indicates a newline. However, it only
+       If  this  bit  is  set,  a dot metacharacter in the pattern matches any
+       character, including one that indicates a  newline.  However,  it  only
        ever matches one character, even if newlines are coded as CRLF. Without
        this option, a dot does not match when the current position in the sub-
-       ject is at a newline. This option is equivalent to  Perl's  /s  option,
+       ject  is  at  a newline. This option is equivalent to Perl's /s option,
        and it can be changed within a pattern by a (?s) option setting. A neg-
        ative class such as [^a] always matches newline characters, independent
        of the setting of this option.
 
          PCRE2_DUPNAMES
 
-       If  this  bit is set, names used to identify capturing subpatterns need
+       If this bit is set, names used to identify capturing  subpatterns  need
        not be unique. This can be helpful for certain types of pattern when it
-       is  known  that  only  one instance of the named subpattern can ever be
-       matched. There are more details of named subpatterns  below;  see  also
+       is known that only one instance of the named  subpattern  can  ever  be
+       matched.  There  are  more details of named subpatterns below; see also
        the pcre2pattern documentation.
 
          PCRE2_ENDANCHORED
 
-       If  this  bit is set, the end of any pattern match must be right at the
-       end of the string being searched (the "subject  string").  This  effect
-       can  also  be achieved by appropriate constructs in the pattern itself,
+       If this bit is set, the end of any pattern match must be right  at  the
+       end  of  the  string being searched (the "subject string"). This effect
+       can also be achieved by appropriate constructs in the  pattern  itself,
        which is the only way to do it in Perl.
 
          PCRE2_EXTENDED
 
-       If this bit is set, most white space  characters  in  the  pattern  are
-       totally  ignored  except when escaped or inside a character class. How-
-       ever, white space is not allowed within  sequences  such  as  (?>  that
+       If  this  bit  is  set,  most white space characters in the pattern are
+       totally ignored except when escaped or inside a character  class.  How-
+       ever,  white  space  is  not  allowed within sequences such as (?> that
        introduce various parenthesized subpatterns, nor within numerical quan-
-       tifiers such as {1,3}.  Ignorable white space is permitted  between  an
-       item  and a following quantifier and between a quantifier and a follow-
+       tifiers  such  as {1,3}.  Ignorable white space is permitted between an
+       item and a following quantifier and between a quantifier and a  follow-
        ing + that indicates possessiveness.
 
-       PCRE2_EXTENDED also causes characters between an unescaped # outside  a
-       character  class  and the next newline, inclusive, to be ignored, which
+       PCRE2_EXTENDED  also causes characters between an unescaped # outside a
+       character class and the next newline, inclusive, to be  ignored,  which
        makes it possible to include comments inside complicated patterns. Note
-       that  the  end of this type of comment is a literal newline sequence in
+       that the end of this type of comment is a literal newline  sequence  in
        the pattern; escape sequences that happen to represent a newline do not
-       count.  PCRE2_EXTENDED is equivalent to Perl's /x option, and it can be
+       count. PCRE2_EXTENDED is equivalent to Perl's /x option, and it can  be
        changed within a pattern by a (?x) option setting.
 
        Which characters are interpreted as newlines can be specified by a set-
-       ting  in  the compile context that is passed to pcre2_compile() or by a
-       special sequence at the start of the pattern, as described in the  sec-
-       tion  entitled "Newline conventions" in the pcre2pattern documentation.
+       ting in the compile context that is passed to pcre2_compile() or  by  a
+       special  sequence at the start of the pattern, as described in the sec-
+       tion entitled "Newline conventions" in the pcre2pattern  documentation.
        A default is defined when PCRE2 is built.
 
          PCRE2_FIRSTLINE
 
-       If this option is set, an  unanchored  pattern  is  required  to  match
-       before  or  at  the  first  newline  in  the subject string, though the
-       matched text may continue over the  newline.  See  also  PCRE2_USE_OFF-
-       SET_LIMIT,   which  provides  a  more  general  limiting  facility.  If
-       PCRE2_FIRSTLINE is set with an offset limit, a match must occur in  the
-       first  line and also within the offset limit. In other words, whichever
+       If  this  option  is  set,  an  unanchored pattern is required to match
+       before or at the first  newline  in  the  subject  string,  though  the
+       matched  text  may  continue  over the newline. See also PCRE2_USE_OFF-
+       SET_LIMIT,  which  provides  a  more  general  limiting  facility.   If
+       PCRE2_FIRSTLINE  is set with an offset limit, a match must occur in the
+       first line and also within the offset limit. In other words,  whichever
        limit comes first is used.
 
          PCRE2_MATCH_UNSET_BACKREF
 
-       If this option is set, a back reference to an  unset  subpattern  group
-       matches  an  empty  string (by default this causes the current matching
-       alternative to fail).  A pattern such as  (\1)(a)  succeeds  when  this
-       option  is set (assuming it can find an "a" in the subject), whereas it
-       fails by default, for Perl compatibility.  Setting  this  option  makes
+       If  this  option  is set, a back reference to an unset subpattern group
+       matches an empty string (by default this causes  the  current  matching
+       alternative  to  fail).   A  pattern such as (\1)(a) succeeds when this
+       option is set (assuming it can find an "a" in the subject), whereas  it
+       fails  by  default,  for  Perl compatibility. Setting this option makes
        PCRE2 behave more like ECMAscript (aka JavaScript).
 
          PCRE2_MULTILINE
 
-       By  default,  for  the purposes of matching "start of line" and "end of
-       line", PCRE2 treats the subject string as consisting of a  single  line
-       of  characters,  even  if  it actually contains newlines. The "start of
-       line" metacharacter (^) matches only at the start of  the  string,  and
-       the  "end  of  line"  metacharacter  ($) matches only at the end of the
+       By default, for the purposes of matching "start of line"  and  "end  of
+       line",  PCRE2  treats the subject string as consisting of a single line
+       of characters, even if it actually contains  newlines.  The  "start  of
+       line"  metacharacter  (^)  matches only at the start of the string, and
+       the "end of line" metacharacter ($) matches only  at  the  end  of  the
        string,  or  before  a  terminating  newline  (except  when  PCRE2_DOL-
-       LAR_ENDONLY  is  set).  Note, however, that unless PCRE2_DOTALL is set,
+       LAR_ENDONLY is set). Note, however, that unless  PCRE2_DOTALL  is  set,
        the "any character" metacharacter (.) does not match at a newline. This
        behaviour (for ^, $, and dot) is the same as Perl.
 
-       When  PCRE2_MULTILINE  it is set, the "start of line" and "end of line"
-       constructs match immediately following or immediately  before  internal
-       newlines  in  the  subject string, respectively, as well as at the very
-       start and end. This is equivalent to Perl's /m option, and  it  can  be
+       When PCRE2_MULTILINE it is set, the "start of line" and "end  of  line"
+       constructs  match  immediately following or immediately before internal
+       newlines in the subject string, respectively, as well as  at  the  very
+       start  and  end.  This is equivalent to Perl's /m option, and it can be
        changed within a pattern by a (?m) option setting. Note that the "start
        of line" metacharacter does not match after a newline at the end of the
-       subject,  for compatibility with Perl.  However, you can change this by
-       setting the PCRE2_ALT_CIRCUMFLEX option. If there are no newlines in  a
-       subject  string,  or  no  occurrences  of  ^ or $ in a pattern, setting
+       subject, for compatibility with Perl.  However, you can change this  by
+       setting  the PCRE2_ALT_CIRCUMFLEX option. If there are no newlines in a
+       subject string, or no occurrences of ^  or  $  in  a  pattern,  setting
        PCRE2_MULTILINE has no effect.
 
          PCRE2_NEVER_BACKSLASH_C
 
-       This option locks out the use of \C in the pattern that is  being  com-
-       piled.   This  escape  can  cause  unpredictable  behaviour in UTF-8 or
-       UTF-16 modes, because it may leave the current matching  point  in  the
-       middle  of  a  multi-code-unit  character. This option may be useful in
-       applications that process patterns from  external  sources.  Note  that
+       This  option  locks out the use of \C in the pattern that is being com-
+       piled.  This escape can  cause  unpredictable  behaviour  in  UTF-8  or
+       UTF-16  modes,  because  it may leave the current matching point in the
+       middle of a multi-code-unit character. This option  may  be  useful  in
+       applications  that  process  patterns  from external sources. Note that
        there is also a build-time option that permanently locks out the use of
        \C.
 
          PCRE2_NEVER_UCP
 
-       This option locks out the use of Unicode properties  for  handling  \B,
+       This  option  locks  out the use of Unicode properties for handling \B,
        \b, \D, \d, \S, \s, \W, \w, and some of the POSIX character classes, as
-       described 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
+       described  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.
 
          PCRE2_NEVER_UTF
 
-       This option locks out interpretation of the pattern as  UTF-8,  UTF-16,
+       This  option  locks out interpretation of the pattern as UTF-8, UTF-16,
        or UTF-32, depending on which library is in use. In particular, it pre-
-       vents the creator of the pattern from switching to  UTF  interpretation
-       by  starting  the  pattern  with  (*UTF).  This option may be useful in
-       applications that process patterns from external sources. The  combina-
+       vents  the  creator of the pattern from switching to UTF interpretation
+       by starting the pattern with (*UTF).  This  option  may  be  useful  in
+       applications  that process patterns from external sources. The combina-
        tion of PCRE2_UTF and PCRE2_NEVER_UTF causes an error.
 
          PCRE2_NO_AUTO_CAPTURE
 
        If this option is set, it disables the use of numbered capturing paren-
-       theses in the pattern. Any opening parenthesis that is not followed  by
-       ?  behaves as if it were followed by ?: but named parentheses can still
-       be used for capturing (and they acquire  numbers  in  the  usual  way).
-       There  is  no  equivalent  of  this  option in Perl. Note that, if this
-       option is set, references  to  capturing  groups  (back  references  or
-       recursion/subroutine  calls) may only refer to named groups, though the
+       theses  in the pattern. Any opening parenthesis that is not followed by
+       ? behaves as if it were followed by ?: but named parentheses can  still
+       be  used  for  capturing  (and  they acquire numbers in the usual way).
+       There is no equivalent of this option  in  Perl.  Note  that,  if  this
+       option  is  set,  references  to  capturing  groups (back references or
+       recursion/subroutine calls) may only refer to named groups, though  the
        reference can be by name or by number.
 
          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
-       backtracks into a+ that can never be successful. However,  if  callouts
-       are  in  use,  auto-possessification means that some callouts are never
+       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
+       a full unoptimized search and run all the callouts, but  it  is  mainly
        provided for testing purposes.
 
          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 capturing group that is the subject of a back  refer-
-       ence,  or  if  the pattern contains (*PRUNE) or (*SKIP). When the opti-
-       mization is not disabled, such a pattern is automatically  anchored  if
+       .* 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 capturing group that is the subject of a back refer-
+       ence, or if the pattern contains (*PRUNE) or (*SKIP).  When  the  opti-
+       mization  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
+       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.
 
          PCRE2_NO_START_OPTIMIZE
 
-       This is an option whose main effect is at matching time.  It  does  not
+       This  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.
 
-       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  character,  the
-       matching  code searches the subject for that character, and fails imme-
-       diately if it cannot find it, without actually running the main  match-
-       ing  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 optimiza-
-       tions are in effect a pre-scan of the subject that takes  place  before
+       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 character, the
+       matching code searches the subject for that character, and fails  imme-
+       diately  if it cannot find it, without actually running the main match-
+       ing 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  optimiza-
+       tions  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
+       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
+       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 pat-
-       tern 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
+       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  pat-
+       tern  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". There are also other start-up optimizations.  For
        example, a minimum length for the subject may be recorded. Consider the
        pattern
 
          (*MARK:A)(X|Y)
 
-       The  minimum  length  for  a  match is one character. If the subject is
+       The minimum length for a match is one  character.  If  the  subject  is
        "ABC", there will be attempts to match "ABC", "BC", and "C". An attempt
        to match an empty string at the end of the subject does not take place,
-       because PCRE2 knows that the subject is  now  too  short,  and  so  the
-       (*MARK)  is  never encountered. In this case, the optimization does not
+       because  PCRE2  knows  that  the  subject  is now too short, and so the
+       (*MARK) is never encountered. In this case, the optimization  does  not
        affect the overall match result, which is still "no match", but it does
        affect the auxiliary information that is returned.
 
          PCRE2_NO_UTF_CHECK
 
-       When  PCRE2_UTF  is set, the validity of the pattern as a UTF string is
-       automatically checked. There are  discussions  about  the  validity  of
-       UTF-8  strings,  UTF-16 strings, and UTF-32 strings in the pcre2unicode
-       document. If an invalid UTF sequence is found, pcre2_compile()  returns
+       When PCRE2_UTF is set, the validity of the pattern as a UTF  string  is
+       automatically  checked.  There  are  discussions  about the validity of
+       UTF-8 strings, UTF-16 strings, and UTF-32 strings in  the  pcre2unicode
+       document.  If an invalid UTF sequence is found, pcre2_compile() returns
        a negative error code.
 
        If you know that your pattern is valid, and you want to skip this check
-       for performance reasons, you can  set  the  PCRE2_NO_UTF_CHECK  option.
-       When  it  is set, the effect of passing an invalid UTF string as a pat-
-       tern is undefined. It may cause your program to  crash  or  loop.  Note
-       that   this   option   can   also   be   passed  to  pcre2_match()  and
+       for  performance  reasons,  you  can set the PCRE2_NO_UTF_CHECK option.
+       When it is set, the effect of passing an invalid UTF string as  a  pat-
+       tern  is  undefined.  It  may cause your program to crash or loop. Note
+       that  this  option  can   also   be   passed   to   pcre2_match()   and
        pcre_dfa_match(), to suppress validity checking of the subject string.
 
          PCRE2_UCP
 
        This option changes the way PCRE2 processes \B, \b, \D, \d, \S, \s, \W,
-       \w,  and  some  of  the POSIX character classes. By default, only ASCII
-       characters are recognized, but if PCRE2_UCP is set, Unicode  properties
-       are  used instead to classify characters. More details are given in the
+       \w, and some of the POSIX character classes.  By  default,  only  ASCII
+       characters  are recognized, but if PCRE2_UCP is set, Unicode properties
+       are used instead to classify characters. More details are given in  the
        section on generic character types in the pcre2pattern page. If you set
-       PCRE2_UCP,  matching one of the items it affects takes much longer. The
-       option is available only if PCRE2 has been compiled with  Unicode  sup-
+       PCRE2_UCP, matching one of the items it affects takes much longer.  The
+       option  is  available only if PCRE2 has been compiled with Unicode sup-
        port (which is the default).
 
          PCRE2_UNGREEDY
 
-       This  option  inverts  the "greediness" of the quantifiers so that they
-       are not greedy by default, but become greedy if followed by "?". It  is
-       not  compatible  with Perl. It can also be set by a (?U) option setting
+       This option inverts the "greediness" of the quantifiers  so  that  they
+       are  not greedy by default, but become greedy if followed by "?". It is
+       not compatible with Perl. It can also be set by a (?U)  option  setting
        within the pattern.
 
          PCRE2_USE_OFFSET_LIMIT
 
        This option must be set for pcre2_compile() if pcre2_set_offset_limit()
-       is  going  to be used to set a non-default offset limit in a match con-
-       text for matches that use this pattern. An error  is  generated  if  an
-       offset  limit  is  set  without  this option. For more details, see the
-       description of pcre2_set_offset_limit() in the section  that  describes
+       is going to be used to set a non-default offset limit in a  match  con-
+       text  for  matches  that  use this pattern. An error is generated if an
+       offset limit is set without this option.  For  more  details,  see  the
+       description  of  pcre2_set_offset_limit() in the section that describes
        match contexts. See also the PCRE2_FIRSTLINE option above.
 
          PCRE2_UTF
 
-       This  option  causes  PCRE2  to regard both the pattern and the subject
-       strings that are subsequently processed as strings  of  UTF  characters
-       instead  of  single-code-unit  strings.  It  is available when PCRE2 is
-       built to include Unicode support (which is  the  default).  If  Unicode
-       support  is  not  available,  the use of this option provokes an error.
-       Details of how this option changes the behaviour of PCRE2 are given  in
+       This option causes PCRE2 to regard both the  pattern  and  the  subject
+       strings  that  are  subsequently processed as strings of UTF characters
+       instead of single-code-unit strings. It  is  available  when  PCRE2  is
+       built  to  include  Unicode  support (which is the default). If Unicode
+       support is not available, the use of this  option  provokes  an  error.
+       Details  of how this option changes the behaviour of PCRE2 are given in
        the pcre2unicode page.
 
 
 COMPILATION ERROR CODES
 
-       There  are  nearly  100  positive  error codes that pcre2_compile() may
-       return (via errorcode) if it finds an error in the pattern.  There  are
-       also  some  negative error codes that are used for invalid UTF strings.
+       There are nearly 100 positive  error  codes  that  pcre2_compile()  may
+       return  (via  errorcode) if it finds an error in the pattern. There are
+       also some negative error codes that are used for invalid  UTF  strings.
        These are the same as given by pcre2_match() and pcre2_dfa_match(), and
-       are  described  in the pcre2unicode page. The pcre2_get_error_message()
-       function (see "Obtaining a textual error message" below) can be  called
+       are described in the pcre2unicode page.  The  pcre2_get_error_message()
+       function  (see "Obtaining a textual error message" below) can be called
        to obtain a textual error message from any error code.
 
 
@@ -1577,53 +1621,53 @@ JUST-IN-TIME (JIT) COMPILATION
 
        void pcre2_jit_stack_free(pcre2_jit_stack *jit_stack);
 
-       These  functions  provide  support  for  JIT compilation, which, if the
-       just-in-time compiler is available, further processes a  compiled  pat-
+       These functions provide support for  JIT  compilation,  which,  if  the
+       just-in-time  compiler  is available, further processes a compiled pat-
        tern into machine code that executes much faster than the pcre2_match()
-       interpretive matching function. Full details are given in the  pcre2jit
+       interpretive  matching function. Full details are given in the pcre2jit
        documentation.
 
-       JIT  compilation  is  a heavyweight optimization. It can take some time
-       for patterns to be analyzed, and for one-off matches  and  simple  pat-
-       terns  the benefit of faster execution might be offset by a much slower
-       compilation time.  Most (but not all) patterns can be optimized by  the
+       JIT compilation is a heavyweight optimization. It can  take  some  time
+       for  patterns  to  be analyzed, and for one-off matches and simple pat-
+       terns the benefit of faster execution might be offset by a much  slower
+       compilation  time.  Most (but not all) patterns can be optimized by the
        JIT compiler.
 
 
 LOCALE SUPPORT
 
-       PCRE2  handles caseless matching, and determines whether characters are
-       letters, digits, or whatever, by reference to a set of tables,  indexed
-       by  character  code  point.  This applies only to characters whose code
-       points are less than 256. By default, higher-valued code  points  never
-       match  escapes  such as \w or \d.  However, if PCRE2 is built with Uni-
+       PCRE2 handles caseless matching, and determines whether characters  are
+       letters,  digits, or whatever, by reference to a set of tables, indexed
+       by character code point. This applies only  to  characters  whose  code
+       points  are  less than 256. By default, higher-valued code points never
+       match escapes such as \w or \d.  However, if PCRE2 is built  with  Uni-
        code support, all characters can be tested with \p and \P, or, alterna-
-       tively,  the  PCRE2_UCP  option  can be set when a pattern is compiled;
-       this causes \w and friends to use Unicode property support  instead  of
+       tively, the PCRE2_UCP option can be set when  a  pattern  is  compiled;
+       this  causes  \w and friends to use Unicode property support instead of
        the built-in tables.
 
-       The  use  of  locales  with Unicode is discouraged. If you are handling
-       characters with code points greater than 128,  you  should  either  use
+       The use of locales with Unicode is discouraged.  If  you  are  handling
+       characters  with  code  points  greater than 128, you should either use
        Unicode support, or use locales, but not try to mix the two.
 
-       PCRE2  contains  an  internal  set of character tables that are used by
-       default.  These are sufficient for  many  applications.  Normally,  the
+       PCRE2 contains an internal set of character tables  that  are  used  by
+       default.   These  are  sufficient  for many applications. Normally, the
        internal tables recognize only ASCII characters. However, when PCRE2 is
        built, it is possible to cause the internal tables to be rebuilt in the
        default "C" locale of the local system, which may cause them to be dif-
        ferent.
 
-       The internal tables can be overridden by tables supplied by the  appli-
-       cation  that  calls  PCRE2.  These may be created in a different locale
-       from the default.  As more and more applications change to  using  Uni-
+       The  internal tables can be overridden by tables supplied by the appli-
+       cation that calls PCRE2. These may be created  in  a  different  locale
+       from  the  default.  As more and more applications change to using Uni-
        code, the need for this locale support is expected to die away.
 
-       External  tables  are built by calling the pcre2_maketables() function,
-       in the relevant locale. The result can be passed to pcre2_compile()  as
-       often   as  necessary,  by  creating  a  compile  context  and  calling
-       pcre2_set_character_tables() to set the  tables  pointer  therein.  For
-       example,  to  build  and use tables that are appropriate for the French
-       locale (where accented characters with  values  greater  than  128  are
+       External tables are built by calling the  pcre2_maketables()  function,
+       in  the relevant locale. The result can be passed to pcre2_compile() as
+       often  as  necessary,  by  creating  a  compile  context  and   calling
+       pcre2_set_character_tables()  to  set  the  tables pointer therein. For
+       example, to build and use tables that are appropriate  for  the  French
+       locale  (where  accented  characters  with  values greater than 128 are
        treated as letters), the following code could be used:
 
          setlocale(LC_CTYPE, "fr_FR");
@@ -1632,15 +1676,15 @@ LOCALE SUPPORT
          pcre2_set_character_tables(ccontext, tables);
          re = pcre2_compile(..., ccontext);
 
-       The  locale  name "fr_FR" is used on Linux and other Unix-like systems;
-       if you are using Windows, the name for the French locale  is  "french".
-       It  is the caller's responsibility to ensure that the memory containing
+       The locale name "fr_FR" is used on Linux and other  Unix-like  systems;
+       if  you  are using Windows, the name for the French locale is "french".
+       It is the caller's responsibility to ensure that the memory  containing
        the tables remains available for as long as it is needed.
 
        The pointer that is passed (via the compile context) to pcre2_compile()
-       is  saved  with  the  compiled pattern, and the same tables are used by
-       pcre2_match() and pcre_dfa_match(). Thus, for any single pattern,  com-
-       pilation  and  matching  both  happen in the same locale, but different
+       is saved with the compiled pattern, and the same  tables  are  used  by
+       pcre2_match()  and pcre_dfa_match(). Thus, for any single pattern, com-
+       pilation and matching both happen in the  same  locale,  but  different
        patterns can be processed in different locales.
 
 
@@ -1648,13 +1692,13 @@ INFORMATION ABOUT A COMPILED PATTERN
 
        int pcre2_pattern_info(const pcre2 *code, uint32_t what, void *where);
 
-       The pcre2_pattern_info() function returns general information  about  a
+       The  pcre2_pattern_info()  function returns general information about a
        compiled pattern. For information about callouts, see the next section.
-       The first argument for pcre2_pattern_info() is a pointer  to  the  com-
+       The  first  argument  for pcre2_pattern_info() is a pointer to the com-
        piled pattern. The second argument specifies which piece of information
-       is required, and the third argument is  a  pointer  to  a  variable  to
-       receive  the data. If the third argument is NULL, the first argument is
-       ignored, and the function returns the size in  bytes  of  the  variable
+       is  required,  and  the  third  argument  is a pointer to a variable to
+       receive the data. If the third argument is NULL, the first argument  is
+       ignored,  and  the  function  returns the size in bytes of the variable
        that is required for the information requested. Otherwise, the yield of
        the function is zero for success, or one of the following negative num-
        bers:
@@ -1664,9 +1708,9 @@ INFORMATION ABOUT A COMPILED PATTERN
          PCRE2_ERROR_BADOPTION      the value of what was invalid
          PCRE2_ERROR_UNSET          the requested field is not set
 
-       The  "magic  number" is placed at the start of each compiled pattern as
-       an simple check against passing an arbitrary memory pointer. Here is  a
-       typical  call of pcre2_pattern_info(), to obtain the length of the com-
+       The "magic number" is placed at the start of each compiled  pattern  as
+       an  simple check against passing an arbitrary memory pointer. Here is a
+       typical call of pcre2_pattern_info(), to obtain the length of the  com-
        piled pattern:
 
          int rc;
@@ -1683,19 +1727,19 @@ INFORMATION ABOUT A COMPILED PATTERN
          PCRE2_INFO_ARGOPTIONS
 
        Return a copy of the pattern's options. The third argument should point
-       to a  uint32_t  variable.  PCRE2_INFO_ARGOPTIONS  returns  exactly  the
-       options  that were passed to pcre2_compile(), whereas PCRE2_INFO_ALLOP-
-       TIONS returns the compile options as modified by any  top-level  (*XXX)
+       to  a  uint32_t  variable.  PCRE2_INFO_ARGOPTIONS  returns  exactly the
+       options that were passed to pcre2_compile(), whereas  PCRE2_INFO_ALLOP-
+       TIONS  returns  the compile options as modified by any top-level (*XXX)
        option settings such as (*UTF) at the start of the pattern itself.
 
-       For   example,   if  the  pattern  /(*UTF)abc/  is  compiled  with  the
-       PCRE2_EXTENDED  option,  the  result   for   PCRE2_INFO_ALLOPTIONS   is
-       PCRE2_EXTENDED  and  PCRE2_UTF.   Option settings such as (?i) that can
-       change within a pattern do not affect the result  of  PCRE2_INFO_ALLOP-
+       For  example,  if  the  pattern  /(*UTF)abc/  is  compiled   with   the
+       PCRE2_EXTENDED   option,   the   result  for  PCRE2_INFO_ALLOPTIONS  is
+       PCRE2_EXTENDED and PCRE2_UTF.  Option settings such as  (?i)  that  can
+       change  within  a pattern do not affect the result of PCRE2_INFO_ALLOP-
        TIONS, even if they appear right at the start of the pattern. (This was
        different in some earlier releases.)
 
-       A pattern compiled without PCRE2_ANCHORED is automatically anchored  by
+       A  pattern compiled without PCRE2_ANCHORED is automatically anchored by
        PCRE2 if the first significant item in every top-level branch is one of
        the following:
 
@@ -1704,7 +1748,7 @@ INFORMATION ABOUT A COMPILED PATTERN
          \G    always
          .*    sometimes - see below
 
-       When .* is the first significant item, anchoring is possible only  when
+       When  .* is the first significant item, anchoring is possible only when
        all the following are true:
 
          .* is not in an atomic group
@@ -1714,164 +1758,172 @@ INFORMATION ABOUT A COMPILED PATTERN
          Neither (*PRUNE) nor (*SKIP) appears in the pattern
          PCRE2_NO_DOTSTAR_ANCHOR is not set
 
-       For  patterns  that are auto-anchored, the PCRE2_ANCHORED bit is set in
+       For patterns that are auto-anchored, the PCRE2_ANCHORED bit is  set  in
        the options returned for PCRE2_INFO_ALLOPTIONS.
 
          PCRE2_INFO_BACKREFMAX
 
-       Return the number of the highest back reference  in  the  pattern.  The
-       third  argument should point to an uint32_t variable. Named subpatterns
-       acquire numbers as well as names, and these count towards  the  highest
-       back  reference.   Back  references such as \4 or \g{12} match the cap-
-       tured characters of the given group, but in addition, the check that  a
+       Return  the  number  of  the highest back reference in the pattern. The
+       third argument should point to an uint32_t variable. Named  subpatterns
+       acquire  numbers  as well as names, and these count towards the highest
+       back reference.  Back references such as \4 or \g{12}  match  the  cap-
+       tured  characters of the given group, but in addition, the check that a
        capturing group is set in a conditional subpattern such as (?(3)a|b) is
-       also a back reference. Zero is returned if there  are  no  back  refer-
+       also  a  back  reference.  Zero is returned if there are no back refer-
        ences.
 
          PCRE2_INFO_BSR
 
        The output is a uint32_t whose value indicates what character sequences
        the \R escape sequence matches. A value of PCRE2_BSR_UNICODE means that
-       \R  matches any Unicode line ending sequence; a value of PCRE2_BSR_ANY-
+       \R matches any Unicode line ending sequence; a value of  PCRE2_BSR_ANY-
        CRLF means that \R matches only CR, LF, or CRLF.
 
          PCRE2_INFO_CAPTURECOUNT
 
-       Return the highest capturing subpattern number in the pattern. In  pat-
+       Return  the highest capturing subpattern number in the pattern. In pat-
        terns where (?| is not used, this is also the total number of capturing
        subpatterns.  The third argument should point to an uint32_t variable.
 
          PCRE2_INFO_DEPTHLIMIT
 
-       If the pattern set a backtracking depth limit by including an  item  of
-       the  form  (*LIMIT_DEPTH=nnnn) at the start, the value is returned. The
-       third argument should point to an unsigned 32-bit integer. If  no  such
-       value  has been set, the call to pcre2_pattern_info() returns the error
+       If  the  pattern set a backtracking depth limit by including an item of
+       the form (*LIMIT_DEPTH=nnnn) at the start, the value is  returned.  The
+       third  argument  should point to an unsigned 32-bit integer. If no such
+       value has been set, the call to pcre2_pattern_info() returns the  error
        PCRE2_ERROR_UNSET.
 
          PCRE2_INFO_FIRSTBITMAP
 
-       In the absence of a single first code unit for a non-anchored  pattern,
-       pcre2_compile()  may construct a 256-bit table that defines a fixed set
-       of values for the first code unit in any match. For example, a  pattern
-       that  starts  with  [abc]  results in a table with three bits set. When
-       code unit values greater than 255 are supported, the flag bit  for  255
-       means  "any  code unit of value 255 or above". If such a table was con-
-       structed, a pointer to it is returned. Otherwise NULL is returned.  The
+       In  the absence of a single first code unit for a non-anchored pattern,
+       pcre2_compile() may construct a 256-bit table that defines a fixed  set
+       of  values for the first code unit in any match. For example, a pattern
+       that starts with [abc] results in a table with  three  bits  set.  When
+       code  unit  values greater than 255 are supported, the flag bit for 255
+       means "any code unit of value 255 or above". If such a table  was  con-
+       structed,  a pointer to it is returned. Otherwise NULL is returned. The
        third argument should point to an const uint8_t * variable.
 
          PCRE2_INFO_FIRSTCODETYPE
 
        Return information about the first code unit of any matched string, for
-       a non-anchored pattern. The third argument should point to an  uint32_t
-       variable.  If there is a fixed first value, for example, the letter "c"
+       a  non-anchored pattern. The third argument should point to an uint32_t
+       variable. If there is a fixed first value, for example, the letter  "c"
        from a pattern such as (cat|cow|coyote), 1 is returned, and the charac-
-       ter  value can be retrieved using PCRE2_INFO_FIRSTCODEUNIT. If there is
-       no fixed first value, but it is known that a match can  occur  only  at
-       the  start  of  the subject or following a newline in the subject, 2 is
+       ter value can be retrieved using PCRE2_INFO_FIRSTCODEUNIT. If there  is
+       no  fixed  first  value, but it is known that a match can occur only at
+       the start of the subject or following a newline in the  subject,  2  is
        returned. Otherwise, and for anchored patterns, 0 is returned.
 
          PCRE2_INFO_FIRSTCODEUNIT
 
-       Return the value of the first code unit of any matched  string  in  the
+       Return  the  value  of the first code unit of any matched string in the
        situation where PCRE2_INFO_FIRSTCODETYPE returns 1; otherwise return 0.
-       The third argument should point to an uint32_t variable. In  the  8-bit
-       library,  the  value is always less than 256. In the 16-bit library the
-       value can be up to 0xffff. In the 32-bit library  in  UTF-32  mode  the
+       The  third  argument should point to an uint32_t variable. In the 8-bit
+       library, the value is always less than 256. In the 16-bit  library  the
+       value  can  be  up  to 0xffff. In the 32-bit library in UTF-32 mode the
        value can be up to 0x10ffff, and up to 0xffffffff when not using UTF-32
        mode.
 
          PCRE2_INFO_FRAMESIZE
 
        Return the size (in bytes) of the data frames that are used to remember
-       backtracking  positions  when the pattern is processed by pcre2_match()
-       without the use of JIT. The third argument should point  to  an  size_t
+       backtracking positions when the pattern is processed  by  pcre2_match()
+       without  the  use  of JIT. The third argument should point to an size_t
        variable. The frame size depends on the number of capturing parentheses
-       in the pattern. Each additional capturing  group  adds  two  PCRE2_SIZE
+       in  the  pattern.  Each  additional capturing group adds two PCRE2_SIZE
        variables.
 
          PCRE2_INFO_HASBACKSLASHC
 
-       Return  1 if the pattern contains any instances of \C, otherwise 0. The
+       Return 1 if the pattern contains any instances of \C, otherwise 0.  The
        third argument should point to an uint32_t variable.
 
          PCRE2_INFO_HASCRORLF
 
-       Return 1 if the pattern contains any explicit  matches  for  CR  or  LF
+       Return  1  if  the  pattern  contains any explicit matches for CR or LF
        characters, otherwise 0. The third argument should point to an uint32_t
-       variable. An explicit match is either a literal CR or LF character,  or
-       \r  or  \n  or  one  of  the  equivalent  hexadecimal  or  octal escape
+       variable.  An explicit match is either a literal CR or LF character, or
+       \r or  \n  or  one  of  the  equivalent  hexadecimal  or  octal  escape
        sequences.
 
+         PCRE2_INFO_HEAPLIMIT
+
+       If the pattern set a heap memory limit by including an item of the form
+       (*LIMIT_HEAP=nnnn) at the start, the value is returned. The third argu-
+       ment  should  point to an unsigned 32-bit integer. If no such value has
+       been  set,  the  call  to  pcre2_pattern_info()   returns   the   error
+       PCRE2_ERROR_UNSET.
+
          PCRE2_INFO_JCHANGED
 
-       Return 1 if the (?J) or (?-J) option setting is used  in  the  pattern,
-       otherwise  0.  The third argument should point to an uint32_t variable.
-       (?J) and (?-J) set and unset the local PCRE2_DUPNAMES  option,  respec-
+       Return  1  if  the (?J) or (?-J) option setting is used in the pattern,
+       otherwise 0. The third argument should point to an  uint32_t  variable.
+       (?J)  and  (?-J) set and unset the local PCRE2_DUPNAMES option, respec-
        tively.
 
          PCRE2_INFO_JITSIZE
 
-       If  the  compiled  pattern was successfully processed by pcre2_jit_com-
-       pile(), return the size of the  JIT  compiled  code,  otherwise  return
+       If the compiled pattern was successfully  processed  by  pcre2_jit_com-
+       pile(),  return  the  size  of  the JIT compiled code, otherwise return
        zero. The third argument should point to a size_t variable.
 
          PCRE2_INFO_LASTCODETYPE
 
-       Returns  1 if there is a rightmost literal code unit that must exist in
-       any matched string, other than at its start. The third argument  should
-       point  to  an  uint32_t  variable.  If  there  is  no  such value, 0 is
-       returned. When 1 is  returned,  the  code  unit  value  itself  can  be
-       retrieved  using PCRE2_INFO_LASTCODEUNIT. For anchored patterns, a last
-       literal value is recorded only if  it  follows  something  of  variable
-       length.  For example, for the pattern /^a\d+z\d+/ the returned value is
-       1 (with "z" returned from PCRE2_INFO_LASTCODEUNIT), but  for  /^a\dz\d/
+       Returns 1 if there is a rightmost literal code unit that must exist  in
+       any  matched string, other than at its start. The third argument should
+       point to an uint32_t  variable.  If  there  is  no  such  value,  0  is
+       returned.  When  1  is  returned,  the  code  unit  value itself can be
+       retrieved using PCRE2_INFO_LASTCODEUNIT. For anchored patterns, a  last
+       literal  value  is  recorded  only  if it follows something of variable
+       length. For example, for the pattern /^a\d+z\d+/ the returned value  is
+       1  (with  "z" returned from PCRE2_INFO_LASTCODEUNIT), but for /^a\dz\d/
        the returned value is 0.
 
          PCRE2_INFO_LASTCODEUNIT
 
-       Return  the value of the rightmost literal data unit that must exist in
-       any matched string, other than at its start, if such a value  has  been
-       recorded.  The  third argument should point to an uint32_t variable. If
+       Return the value of the rightmost literal data unit that must exist  in
+       any  matched  string, other than at its start, if such a value has been
+       recorded. The third argument should point to an uint32_t  variable.  If
        there is no such value, 0 is returned.
 
          PCRE2_INFO_MATCHEMPTY
 
-       Return 1 if the pattern might match an empty string, otherwise  0.  The
-       third  argument  should  point  to an uint32_t variable. When a pattern
+       Return  1  if the pattern might match an empty string, otherwise 0. The
+       third argument should point to an uint32_t  variable.  When  a  pattern
        contains recursive subroutine calls it is not always possible to deter-
-       mine  whether  or  not it can match an empty string. PCRE2 takes a cau-
+       mine whether or not it can match an empty string. PCRE2  takes  a  cau-
        tious approach and returns 1 in such cases.
 
          PCRE2_INFO_MATCHLIMIT
 
-       If the pattern set a match limit by  including  an  item  of  the  form
-       (*LIMIT_MATCH=nnnn)  at  the  start,  the  value is returned. The third
-       argument should point to an unsigned 32-bit integer. If no  such  value
-       has  been  set,  the  call  to  pcre2_pattern_info()  returns the error
+       If  the  pattern  set  a  match  limit by including an item of the form
+       (*LIMIT_MATCH=nnnn) at the start, the  value  is  returned.  The  third
+       argument  should  point to an unsigned 32-bit integer. If no such value
+       has been set,  the  call  to  pcre2_pattern_info()  returns  the  error
        PCRE2_ERROR_UNSET.
 
          PCRE2_INFO_MAXLOOKBEHIND
 
        Return the number of characters (not code units) in the longest lookbe-
-       hind  assertion  in  the pattern. The third argument should point to an
-       unsigned 32-bit integer. This information is useful when  doing  multi-
-       segment  matching  using the partial matching facilities. Note that the
+       hind assertion in the pattern. The third argument should  point  to  an
+       unsigned  32-bit  integer. This information is useful when doing multi-
+       segment matching using the partial matching facilities. Note  that  the
        simple assertions \b and \B require a one-character lookbehind. \A also
-       registers  a  one-character  lookbehind,  though  it  does not actually
-       inspect the previous character. This is to ensure  that  at  least  one
-       character  from  the old segment is retained when a new segment is pro-
+       registers a one-character  lookbehind,  though  it  does  not  actually
+       inspect  the  previous  character.  This is to ensure that at least one
+       character from the old segment is retained when a new segment  is  pro-
        cessed. Otherwise, if there are no lookbehinds in the pattern, \A might
        match incorrectly at the start of a new segment.
 
          PCRE2_INFO_MINLENGTH
 
-       If  a  minimum  length  for  matching subject strings was computed, its
-       value is returned. Otherwise the returned value is 0. The  value  is  a
-       number  of characters, which in UTF mode may be different from the num-
-       ber of code units.  The third argument  should  point  to  an  uint32_t
-       variable.  The  value  is  a  lower bound to the length of any matching
-       string. There may not be any strings of that length  that  do  actually
+       If a minimum length for matching  subject  strings  was  computed,  its
+       value  is  returned.  Otherwise the returned value is 0. The value is a
+       number of characters, which in UTF mode may be different from the  num-
+       ber  of  code  units.   The  third argument should point to an uint32_t
+       variable. The value is a lower bound to  the  length  of  any  matching
+       string.  There  may  not be any strings of that length that do actually
        match, but every string that does match is at least that long.
 
          PCRE2_INFO_NAMECOUNT
@@ -1879,50 +1931,50 @@ INFORMATION ABOUT A COMPILED PATTERN
          PCRE2_INFO_NAMETABLE
 
        PCRE2 supports the use of named as well as numbered capturing parenthe-
-       ses. The names are just an additional way of identifying the  parenthe-
+       ses.  The names are just an additional way of identifying the parenthe-
        ses, which still acquire numbers. Several convenience functions such as
-       pcre2_substring_get_byname() are provided for extracting captured  sub-
-       strings  by  name. It is also possible to extract the data directly, by
-       first converting the name to a number in order to  access  the  correct
-       pointers  in the output vector (described with pcre2_match() below). To
-       do the conversion, you need to use the  name-to-number  map,  which  is
+       pcre2_substring_get_byname()  are provided for extracting captured sub-
+       strings by name. It is also possible to extract the data  directly,  by
+       first  converting  the  name to a number in order to access the correct
+       pointers in the output vector (described with pcre2_match() below).  To
+       do  the  conversion,  you  need to use the name-to-number map, which is
        described by these three values.
 
-       The  map  consists  of a number of fixed-size entries. PCRE2_INFO_NAME-
-       COUNT gives the number of entries, and  PCRE2_INFO_NAMEENTRYSIZE  gives
-       the  size  of each entry in code units; both of these return a uint32_t
+       The map consists of a number of  fixed-size  entries.  PCRE2_INFO_NAME-
+       COUNT  gives  the number of entries, and PCRE2_INFO_NAMEENTRYSIZE gives
+       the size of each entry in code units; both of these return  a  uint32_t
        value. The entry size depends on the length of the longest name.
 
        PCRE2_INFO_NAMETABLE returns a pointer to the first entry of the table.
-       This  is  a  PCRE2_SPTR  pointer to a block of code units. In the 8-bit
-       library, the first two bytes of each entry are the number of  the  cap-
+       This is a PCRE2_SPTR pointer to a block of code  units.  In  the  8-bit
+       library,  the  first two bytes of each entry are the number of the cap-
        turing parenthesis, most significant byte first. In the 16-bit library,
-       the pointer points to 16-bit code units, the first  of  which  contains
-       the  parenthesis  number.  In the 32-bit library, the pointer points to
-       32-bit code units, the first of which contains the parenthesis  number.
+       the  pointer  points  to 16-bit code units, the first of which contains
+       the parenthesis number. In the 32-bit library, the  pointer  points  to
+       32-bit  code units, the first of which contains the parenthesis number.
        The rest of the entry is the corresponding name, zero terminated.
 
-       The  names are in alphabetical order. If (?| is used to create multiple
-       groups with the same number, as described in the section  on  duplicate
-       subpattern  numbers  in  the pcre2pattern page, the groups may be given
-       the same name, but there is only one  entry  in  the  table.  Different
+       The names are in alphabetical order. If (?| is used to create  multiple
+       groups  with  the same number, as described in the section on duplicate
+       subpattern numbers in the pcre2pattern page, the groups  may  be  given
+       the  same  name,  but  there  is only one entry in the table. Different
        names for groups of the same number are not permitted.
 
-       Duplicate  names  for subpatterns with different numbers are permitted,
-       but only if PCRE2_DUPNAMES is set. They appear  in  the  table  in  the
-       order  in  which  they were found in the pattern. In the absence of (?|
-       this is the order of increasing number; when (?| is used  this  is  not
+       Duplicate names for subpatterns with different numbers  are  permitted,
+       but  only  if  PCRE2_DUPNAMES  is  set. They appear in the table in the
+       order in which they were found in the pattern. In the  absence  of  (?|
+       this  is  the  order of increasing number; when (?| is used this is not
        necessarily the case because later subpatterns may have lower numbers.
 
-       As  a  simple  example of the name/number table, consider the following
-       pattern after compilation by the 8-bit library  (assume  PCRE2_EXTENDED
+       As a simple example of the name/number table,  consider  the  following
+       pattern  after  compilation by the 8-bit library (assume PCRE2_EXTENDED
        is set, so white space - including newlines - is ignored):
 
          (? (?(\d\d)?\d\d) -
          (?\d\d) - (?\d\d) )
 
-       There  are  four  named subpatterns, so the table has four entries, and
-       each entry in the table is eight bytes long. The table is  as  follows,
+       There are four named subpatterns, so the table has  four  entries,  and
+       each  entry  in the table is eight bytes long. The table is as follows,
        with non-printing bytes shows in hexadecimal, and undefined bytes shown
        as ??:
 
@@ -1931,8 +1983,8 @@ INFORMATION ABOUT A COMPILED PATTERN
          00 04 m  o  n  t  h  00
          00 02 y  e  a  r  00 ??
 
-       When writing code to extract data  from  named  subpatterns  using  the
-       name-to-number  map,  remember that the length of the entries is likely
+       When  writing  code  to  extract  data from named subpatterns using the
+       name-to-number map, remember that the length of the entries  is  likely
        to be different for each compiled pattern.
 
          PCRE2_INFO_NEWLINE
@@ -1950,14 +2002,14 @@ INFORMATION ABOUT A COMPILED PATTERN
 
          PCRE2_INFO_SIZE
 
-       Return  the  size  of  the  compiled  pattern  in  bytes (for all three
-       libraries). The third argument should point to a size_t variable.  This
-       value  includes  the  size  of the general data block that precedes the
-       code units of the compiled pattern itself. The value that is used  when
-       pcre2_compile()  is  getting memory in which to place the compiled pat-
-       tern may be slightly larger than the value  returned  by  this  option,
-       because  there are cases where the code that calculates the size has to
-       over-estimate. Processing a pattern with  the  JIT  compiler  does  not
+       Return the size of  the  compiled  pattern  in  bytes  (for  all  three
+       libraries).  The third argument should point to a size_t variable. This
+       value includes the size of the general data  block  that  precedes  the
+       code  units of the compiled pattern itself. The value that is used when
+       pcre2_compile() is getting memory in which to place the  compiled  pat-
+       tern  may  be  slightly  larger than the value returned by this option,
+       because there are cases where the code that calculates the size has  to
+       over-estimate.  Processing  a  pattern  with  the JIT compiler does not
        alter the value returned by this option.
 
 
@@ -1968,22 +2020,22 @@ INFORMATION ABOUT A PATTERN'S CALLOUTS
          void *user_data);
 
        A script language that supports the use of string arguments in callouts
-       might like to scan all the callouts in a  pattern  before  running  the
+       might  like  to  scan  all the callouts in a pattern before running the
        match. This can be done by calling pcre2_callout_enumerate(). The first
-       argument is a pointer to a compiled pattern, the  second  points  to  a
-       callback  function,  and the third is arbitrary user data. The callback
-       function is called for every callout in the pattern  in  the  order  in
+       argument  is  a  pointer  to a compiled pattern, the second points to a
+       callback function, and the third is arbitrary user data.  The  callback
+       function  is  called  for  every callout in the pattern in the order in
        which they appear. Its first argument is a pointer to a callout enumer-
-       ation block, and its second argument is the user_data  value  that  was
-       passed  to  pcre2_callout_enumerate(). The contents of the callout enu-
-       meration block are described in the pcre2callout  documentation,  which
+       ation  block,  and  its second argument is the user_data value that was
+       passed to pcre2_callout_enumerate(). The contents of the  callout  enu-
+       meration  block  are described in the pcre2callout documentation, which
        also gives further details about callouts.
 
 
 SERIALIZATION AND PRECOMPILING
 
-       It  is  possible  to  save  compiled patterns on disc or elsewhere, and
-       reload them later, subject to a number of restrictions.  The  functions
+       It is possible to save compiled patterns  on  disc  or  elsewhere,  and
+       reload  them  later, subject to a number of restrictions. The functions
        whose names begin with pcre2_serialize_ are used for this purpose. They
        are described in the pcre2serialize documentation.
 
@@ -1998,56 +2050,56 @@ THE MATCH DATA BLOCK
 
        void pcre2_match_data_free(pcre2_match_data *match_data);
 
-       Information about a successful or unsuccessful match  is  placed  in  a
-       match  data  block,  which  is  an opaque structure that is accessed by
-       function calls. In particular, the match data block contains  a  vector
-       of  offsets into the subject string that define the matched part of the
-       subject and any substrings that were captured. This  is  known  as  the
+       Information  about  a  successful  or unsuccessful match is placed in a
+       match data block, which is an opaque  structure  that  is  accessed  by
+       function  calls.  In particular, the match data block contains a vector
+       of offsets into the subject string that define the matched part of  the
+       subject  and  any  substrings  that were captured. This is known as the
        ovector.
 
-       Before  calling  pcre2_match(), pcre2_dfa_match(), or pcre2_jit_match()
+       Before calling pcre2_match(), pcre2_dfa_match(),  or  pcre2_jit_match()
        you must create a match data block by calling one of the creation func-
-       tions  above.  For pcre2_match_data_create(), the first argument is the
-       number of pairs of offsets in the  ovector.  One  pair  of  offsets  is
+       tions above. For pcre2_match_data_create(), the first argument  is  the
+       number  of  pairs  of  offsets  in  the ovector. One pair of offsets is
        required to identify the string that matched the whole pattern, with an
-       additional pair for each captured substring. For example, a value of  4
-       creates  enough space to record the matched portion of the subject plus
-       three captured substrings. A minimum of at least 1 pair is  imposed  by
+       additional  pair for each captured substring. For example, a value of 4
+       creates enough space to record the matched portion of the subject  plus
+       three  captured  substrings. A minimum of at least 1 pair is imposed by
        pcre2_match_data_create(), so it is always possible to return the over-
        all matched string.
 
        The second argument of pcre2_match_data_create() is a pointer to a gen-
-       eral  context, which can specify custom memory management for obtaining
+       eral context, which can specify custom memory management for  obtaining
        the memory for the match data block. If you are not using custom memory
        management, pass NULL, which causes malloc() to be used.
 
-       For  pcre2_match_data_create_from_pattern(),  the  first  argument is a
+       For pcre2_match_data_create_from_pattern(), the  first  argument  is  a
        pointer to a compiled pattern. The ovector is created to be exactly the
        right size to hold all the substrings a pattern might capture. The sec-
-       ond argument is again a pointer to a general context, but in this  case
+       ond  argument is again a pointer to a general context, but in this case
        if NULL is passed, the memory is obtained using the same allocator that
        was used for the compiled pattern (custom or default).
 
-       A match data block can be used many times, with the same  or  different
-       compiled  patterns. You can extract information from a match data block
+       A  match  data block can be used many times, with the same or different
+       compiled patterns. You can extract information from a match data  block
        after  a  match  operation  has  finished,  using  functions  that  are
-       described  in  the  sections  on  matched  strings and other match data
+       described in the sections on  matched  strings  and  other  match  data
        below.
 
-       When a call of pcre2_match() fails, valid  data  is  available  in  the
-       match    block    only   when   the   error   is   PCRE2_ERROR_NOMATCH,
-       PCRE2_ERROR_PARTIAL, or one of the  error  codes  for  an  invalid  UTF
+       When  a  call  of  pcre2_match()  fails, valid data is available in the
+       match   block   only   when   the   error    is    PCRE2_ERROR_NOMATCH,
+       PCRE2_ERROR_PARTIAL,  or  one  of  the  error  codes for an invalid UTF
        string. Exactly what is available depends on the error, and is detailed
        below.
 
-       When one of the matching functions is called, pointers to the  compiled
-       pattern  and the subject string are set in the match data block so that
-       they can be referenced by the extraction  functions.  After  running  a
-       match,  you  must not free a compiled pattern or a subject string until
-       after all operations on the match data  block  (for  that  match)  have
+       When  one of the matching functions is called, pointers to the compiled
+       pattern and the subject string are set in the match data block so  that
+       they  can  be  referenced  by the extraction functions. After running a
+       match, you must not free a compiled pattern or a subject  string  until
+       after  all  operations  on  the  match data block (for that match) have
        taken place.
 
-       When  a match data block itself is no longer needed, it should be freed
+       When a match data block itself is no longer needed, it should be  freed
        by calling pcre2_match_data_free().
 
 
@@ -2058,15 +2110,15 @@ MATCHING A PATTERN: THE TRADITIONAL FUNCTION
          uint32_t options, pcre2_match_data *match_data,
          pcre2_match_context *mcontext);
 
-       The function pcre2_match() is called to match a subject string  against
-       a  compiled pattern, which is passed in the code argument. You can call
+       The  function pcre2_match() is called to match a subject string against
+       a compiled pattern, which is passed in the code argument. You can  call
        pcre2_match() with the same code argument as many times as you like, in
-       order  to  find multiple matches in the subject string or to match dif-
+       order to find multiple matches in the subject string or to  match  dif-
        ferent subject strings with the same pattern.
 
-       This function is the main matching facility  of  the  library,  and  it
-       operates  in  a  Perl-like  manner. For specialist use there is also an
-       alternative matching function, which is described below in the  section
+       This  function  is  the  main  matching facility of the library, and it
+       operates in a Perl-like manner. For specialist use  there  is  also  an
+       alternative  matching function, which is described below in the section
        about the pcre2_dfa_match() function.
 
        Here is an example of a simple call to pcre2_match():
@@ -2081,187 +2133,187 @@ MATCHING A PATTERN: THE TRADITIONAL FUNCTION
            match_data,     /* the match data block */
            NULL);          /* a match context; NULL means use defaults */
 
-       If  the  subject  string is zero-terminated, the length can be given as
+       If the subject string is zero-terminated, the length can  be  given  as
        PCRE2_ZERO_TERMINATED. A match context must be provided if certain less
        common matching parameters are to be changed. For details, see the sec-
        tion on the match context above.
 
    The string to be matched by pcre2_match()
 
-       The subject string is passed to pcre2_match() as a pointer in  subject,
-       a  length  in  length, and a starting offset in startoffset. The length
-       and offset are in code units, not characters.  That  is,  they  are  in
-       bytes  for the 8-bit library, 16-bit code units for the 16-bit library,
-       and 32-bit code units for the 32-bit library, whether or not  UTF  pro-
+       The  subject string is passed to pcre2_match() as a pointer in subject,
+       a length in length, and a starting offset in  startoffset.  The  length
+       and  offset  are  in  code units, not characters.  That is, they are in
+       bytes for the 8-bit library, 16-bit code units for the 16-bit  library,
+       and  32-bit  code units for the 32-bit library, whether or not UTF pro-
        cessing is enabled.
 
        If startoffset is greater than the length of the subject, pcre2_match()
-       returns PCRE2_ERROR_BADOFFSET. When the starting offset  is  zero,  the
-       search  for a match starts at the beginning of the subject, and this is
+       returns  PCRE2_ERROR_BADOFFSET.  When  the starting offset is zero, the
+       search for a match starts at the beginning of the subject, and this  is
        by far the most common case. In UTF-8 or UTF-16 mode, the starting off-
-       set  must  point to the start of a character, or to the end of the sub-
-       ject (in UTF-32 mode, one code unit equals one character, so  all  off-
-       sets  are  valid).  Like  the  pattern  string, the subject may contain
+       set must point to the start of a character, or to the end of  the  sub-
+       ject  (in  UTF-32 mode, one code unit equals one character, so all off-
+       sets are valid). Like the  pattern  string,  the  subject  may  contain
        binary zeroes.
 
-       A non-zero starting offset is useful when searching for  another  match
-       in  the  same  subject  by calling pcre2_match() again after a previous
-       success.  Setting startoffset differs from  passing  over  a  shortened
-       string  and  setting  PCRE2_NOTBOL in the case of a pattern that begins
+       A  non-zero  starting offset is useful when searching for another match
+       in the same subject by calling pcre2_match()  again  after  a  previous
+       success.   Setting  startoffset  differs  from passing over a shortened
+       string and setting PCRE2_NOTBOL in the case of a  pattern  that  begins
        with any kind of lookbehind. For example, consider the pattern
 
          \Biss\B
 
-       which finds occurrences of "iss" in the middle of  words.  (\B  matches
-       only  if  the  current position in the subject is not a word boundary.)
+       which  finds  occurrences  of "iss" in the middle of words. (\B matches
+       only if the current position in the subject is not  a  word  boundary.)
        When applied to the string "Mississipi" the first call to pcre2_match()
-       finds  the first occurrence. If pcre2_match() is called again with just
-       the remainder of the subject,  namely  "issipi",  it  does  not  match,
+       finds the first occurrence. If pcre2_match() is called again with  just
+       the  remainder  of  the  subject,  namely  "issipi", it does not match,
        because \B is always false at the start of the subject, which is deemed
-       to be a word boundary. However, if pcre2_match() is passed  the  entire
+       to  be  a word boundary. However, if pcre2_match() is passed the entire
        string again, but with startoffset set to 4, it finds the second occur-
-       rence of "iss" because it is able to look behind the starting point  to
+       rence  of "iss" because it is able to look behind the starting point to
        discover that it is preceded by a letter.
 
-       Finding  all  the  matches  in a subject is tricky when the pattern can
+       Finding all the matches in a subject is tricky  when  the  pattern  can
        match an empty string. It is possible to emulate Perl's /g behaviour by
-       first   trying   the   match   again  at  the  same  offset,  with  the
-       PCRE2_NOTEMPTY_ATSTART and PCRE2_ANCHORED options,  and  then  if  that
-       fails,  advancing  the  starting  offset  and  trying an ordinary match
-       again. There is some code that demonstrates  how  to  do  this  in  the
-       pcre2demo  sample  program. In the most general case, you have to check
-       to see if the newline convention recognizes CRLF as a newline,  and  if
-       so,  and the current character is CR followed by LF, advance the start-
+       first  trying  the  match  again  at  the   same   offset,   with   the
+       PCRE2_NOTEMPTY_ATSTART  and  PCRE2_ANCHORED  options,  and then if that
+       fails, advancing the starting  offset  and  trying  an  ordinary  match
+       again.  There  is  some  code  that  demonstrates how to do this in the
+       pcre2demo sample program. In the most general case, you have  to  check
+       to  see  if the newline convention recognizes CRLF as a newline, and if
+       so, and the current character is CR followed by LF, advance the  start-
        ing offset by two characters instead of one.
 
-       If a non-zero starting offset is passed when the pattern  is  anchored,
-       an  single  attempt to match at the given offset is made. This can only
+       If  a  non-zero starting offset is passed when the pattern is anchored,
+       an single attempt to match at the given offset is made. This  can  only
        succeed if the pattern does not require the match to be at the start of
-       the  subject.  In other words, the anchoring must be the result of set-
-       ting the PCRE2_ANCHORED option or the use of .* with PCRE2_DOTALL,  not
+       the subject. In other words, the anchoring must be the result  of  set-
+       ting  the PCRE2_ANCHORED option or the use of .* with PCRE2_DOTALL, not
        by starting the pattern with ^ or \A.
 
    Option bits for pcre2_match()
 
        The unused bits of the options argument for pcre2_match() must be zero.
-       The only bits that may be set  are  PCRE2_ANCHORED,  PCRE2_ENDANCHORED,
-       PCRE2_NOTBOL,   PCRE2_NOTEOL,  PCRE2_NOTEMPTY,  PCRE2_NOTEMPTY_ATSTART,
-       PCRE2_NO_JIT, PCRE2_NO_UTF_CHECK,  PCRE2_PARTIAL_HARD,  and  PCRE2_PAR-
+       The  only  bits  that may be set are PCRE2_ANCHORED, PCRE2_ENDANCHORED,
+       PCRE2_NOTBOL,  PCRE2_NOTEOL,  PCRE2_NOTEMPTY,   PCRE2_NOTEMPTY_ATSTART,
+       PCRE2_NO_JIT,  PCRE2_NO_UTF_CHECK,  PCRE2_PARTIAL_HARD,  and PCRE2_PAR-
        TIAL_SOFT.  Their action is described below.
 
-       Setting  PCRE2_ANCHORED  or PCRE2_ENDANCHORED at match time is not sup-
-       ported by the just-in-time (JIT) compiler. If it is set,  JIT  matching
-       is  disabled  and  the interpretive code in pcre2_match() is run. Apart
-       from PCRE2_NO_JIT (obviously), the remaining options are supported  for
+       Setting PCRE2_ANCHORED or PCRE2_ENDANCHORED at match time is  not  sup-
+       ported  by  the just-in-time (JIT) compiler. If it is set, JIT matching
+       is disabled and the interpretive code in pcre2_match()  is  run.  Apart
+       from  PCRE2_NO_JIT (obviously), the remaining options are supported for
        JIT matching.
 
          PCRE2_ANCHORED
 
        The PCRE2_ANCHORED option limits pcre2_match() to matching at the first
-       matching position. If a pattern was compiled  with  PCRE2_ANCHORED,  or
-       turned  out to be anchored by virtue of its contents, it cannot be made
-       unachored at matching time. Note that setting the option at match  time
+       matching  position.  If  a pattern was compiled with PCRE2_ANCHORED, or
+       turned out to be anchored by virtue of its contents, it cannot be  made
+       unachored  at matching time. Note that setting the option at match time
        disables JIT matching.
 
          PCRE2_ENDANCHORED
 
-       If  the  PCRE2_ENDANCHORED option is set, any string that pcre2_match()
-       matches must be right at the end of the subject string. Note that  set-
+       If the PCRE2_ENDANCHORED option is set, any string  that  pcre2_match()
+       matches  must be right at the end of the subject string. Note that set-
        ting the option at match time disables JIT matching.
 
          PCRE2_NOTBOL
 
        This option specifies that first character of the subject string is not
-       the beginning of a line, so the  circumflex  metacharacter  should  not
-       match  before  it.  Setting  this without having set PCRE2_MULTILINE at
+       the  beginning  of  a  line, so the circumflex metacharacter should not
+       match before it. Setting this without  having  set  PCRE2_MULTILINE  at
        compile time causes circumflex never to match. This option affects only
        the behaviour of the circumflex metacharacter. It does not affect \A.
 
          PCRE2_NOTEOL
 
        This option specifies that the end of the subject string is not the end
-       of a line, so the dollar metacharacter should not match it nor  (except
-       in  multiline mode) a newline immediately before it. Setting this with-
-       out having set PCRE2_MULTILINE at compile time causes dollar  never  to
+       of  a line, so the dollar metacharacter should not match it nor (except
+       in multiline mode) a newline immediately before it. Setting this  with-
+       out  having  set PCRE2_MULTILINE at compile time causes dollar never to
        match. This option affects only the behaviour of the dollar metacharac-
        ter. It does not affect \Z or \z.
 
          PCRE2_NOTEMPTY
 
        An empty string is not considered to be a valid match if this option is
-       set.  If  there are alternatives in the pattern, they are tried. If all
-       the alternatives match the empty string, the entire  match  fails.  For
+       set. If there are alternatives in the pattern, they are tried.  If  all
+       the  alternatives  match  the empty string, the entire match fails. For
        example, if the pattern
 
          a?b?
 
-       is  applied  to  a  string not beginning with "a" or "b", it matches an
+       is applied to a string not beginning with "a" or  "b",  it  matches  an
        empty string at the start of the subject. With PCRE2_NOTEMPTY set, this
-       match  is  not valid, so pcre2_match() searches further into the string
+       match is not valid, so pcre2_match() searches further into  the  string
        for occurrences of "a" or "b".
 
          PCRE2_NOTEMPTY_ATSTART
 
-       This is like PCRE2_NOTEMPTY, except that it locks out an  empty  string
+       This  is  like PCRE2_NOTEMPTY, except that it locks out an empty string
        match only at the first matching position, that is, at the start of the
-       subject plus the starting offset. An empty string match  later  in  the
-       subject  is  permitted.   If  the pattern is anchored, such a match can
+       subject  plus  the  starting offset. An empty string match later in the
+       subject is permitted.  If the pattern is anchored,  such  a  match  can
        occur only if the pattern contains \K.
 
          PCRE2_NO_JIT
 
-       By  default,  if  a  pattern  has  been   successfully   processed   by
-       pcre2_jit_compile(),  JIT  is  automatically used when pcre2_match() is
-       called with options that JIT supports.  Setting  PCRE2_NO_JIT  disables
+       By   default,   if   a  pattern  has  been  successfully  processed  by
+       pcre2_jit_compile(), JIT is automatically used  when  pcre2_match()  is
+       called  with  options  that JIT supports. Setting PCRE2_NO_JIT disables
        the use of JIT; it forces matching to be done by the interpreter.
 
          PCRE2_NO_UTF_CHECK
 
        When PCRE2_UTF is set at compile time, the validity of the subject as a
-       UTF string is checked by default  when  pcre2_match()  is  subsequently
-       called.   If  a non-zero starting offset is given, the check is applied
-       only to that part of the subject that could be inspected during  match-
-       ing,  and there is a check that the starting offset points to the first
-       code unit of a character or to the end of the subject. If there are  no
-       lookbehind  assertions in the pattern, the check starts at the starting
-       offset. Otherwise, it starts at the length of  the  longest  lookbehind
+       UTF  string  is  checked  by default when pcre2_match() is subsequently
+       called.  If a non-zero starting offset is given, the check  is  applied
+       only  to that part of the subject that could be inspected during match-
+       ing, and there is a check that the starting offset points to the  first
+       code  unit of a character or to the end of the subject. If there are no
+       lookbehind assertions in the pattern, the check starts at the  starting
+       offset.  Otherwise,  it  starts at the length of the longest lookbehind
        before the starting offset, or at the start of the subject if there are
-       not that many characters before the  starting  offset.  Note  that  the
+       not  that  many  characters  before  the starting offset. Note that the
        sequences \b and \B are one-character lookbehinds.
 
        The check is carried out before any other processing takes place, and a
-       negative error code is returned if the check fails. There  are  several
-       UTF  error  codes  for each code unit width, corresponding to different
-       problems with the code unit sequence. There are discussions  about  the
-       validity  of  UTF-8  strings, UTF-16 strings, and UTF-32 strings in the
+       negative  error  code is returned if the check fails. There are several
+       UTF error codes for each code unit width,  corresponding  to  different
+       problems  with  the code unit sequence. There are discussions about the
+       validity of UTF-8 strings, UTF-16 strings, and UTF-32  strings  in  the
        pcre2unicode page.
 
-       If you know that your subject is valid, and  you  want  to  skip  these
-       checks  for  performance  reasons,  you  can set the PCRE2_NO_UTF_CHECK
-       option when calling pcre2_match(). You might want to do  this  for  the
+       If  you  know  that  your  subject is valid, and you want to skip these
+       checks for performance reasons,  you  can  set  the  PCRE2_NO_UTF_CHECK
+       option  when  calling  pcre2_match(). You might want to do this for the
        second and subsequent calls to pcre2_match() if you are making repeated
        calls to find other matches in the same subject string.
 
-       WARNING: When PCRE2_NO_UTF_CHECK is  set,  the  effect  of  passing  an
-       invalid  string  as  a  subject, or an invalid value of startoffset, is
+       WARNING:  When  PCRE2_NO_UTF_CHECK  is  set,  the  effect of passing an
+       invalid string as a subject, or an invalid  value  of  startoffset,  is
        undefined.  Your program may crash or loop indefinitely.
 
          PCRE2_PARTIAL_HARD
          PCRE2_PARTIAL_SOFT
 
-       These options turn on the partial matching  feature.  A  partial  match
-       occurs  if  the  end of the subject string is reached successfully, but
-       there are not enough subject characters to complete the match. If  this
-       happens  when  PCRE2_PARTIAL_SOFT  (but not PCRE2_PARTIAL_HARD) is set,
-       matching continues by testing any remaining alternatives.  Only  if  no
-       complete  match can be found is PCRE2_ERROR_PARTIAL returned instead of
-       PCRE2_ERROR_NOMATCH. In other words, PCRE2_PARTIAL_SOFT specifies  that
-       the  caller  is prepared to handle a partial match, but only if no com-
+       These  options  turn  on  the partial matching feature. A partial match
+       occurs if the end of the subject string is  reached  successfully,  but
+       there  are not enough subject characters to complete the match. If this
+       happens when PCRE2_PARTIAL_SOFT (but not  PCRE2_PARTIAL_HARD)  is  set,
+       matching  continues  by  testing any remaining alternatives. Only if no
+       complete match can be found is PCRE2_ERROR_PARTIAL returned instead  of
+       PCRE2_ERROR_NOMATCH.  In other words, PCRE2_PARTIAL_SOFT specifies that
+       the caller is prepared to handle a partial match, but only if  no  com-
        plete match can be found.
 
-       If PCRE2_PARTIAL_HARD is set, it overrides PCRE2_PARTIAL_SOFT. In  this
-       case,  if  a  partial match is found, pcre2_match() immediately returns
-       PCRE2_ERROR_PARTIAL, without considering  any  other  alternatives.  In
+       If  PCRE2_PARTIAL_HARD is set, it overrides PCRE2_PARTIAL_SOFT. In this
+       case, if a partial match is found,  pcre2_match()  immediately  returns
+       PCRE2_ERROR_PARTIAL,  without  considering  any  other alternatives. In
        other words, when PCRE2_PARTIAL_HARD is set, a partial match is consid-
        ered to be more important that an alternative complete match.
 
@@ -2271,38 +2323,38 @@ MATCHING A PATTERN: THE TRADITIONAL FUNCTION
 
 NEWLINE HANDLING WHEN MATCHING
 
-       When  PCRE2 is built, a default newline convention is set; this is usu-
-       ally the standard convention for the operating system. The default  can
-       be  overridden  in a compile context by calling pcre2_set_newline(). It
-       can also be overridden by starting a pattern string with, for  example,
-       (*CRLF),  as  described  in  the  section on newline conventions in the
-       pcre2pattern page. During matching, the newline choice affects the  be-
-       haviour  of the dot, circumflex, and dollar metacharacters. It may also
-       alter the way the match starting position is  advanced  after  a  match
+       When PCRE2 is built, a default newline convention is set; this is  usu-
+       ally  the standard convention for the operating system. The default can
+       be overridden in a compile context by calling  pcre2_set_newline().  It
+       can  also be overridden by starting a pattern string with, for example,
+       (*CRLF), as described in the section  on  newline  conventions  in  the
+       pcre2pattern  page. During matching, the newline choice affects the be-
+       haviour of the dot, circumflex, and dollar metacharacters. It may  also
+       alter  the  way  the  match starting position is advanced after a match
        failure for an unanchored pattern.
 
        When PCRE2_NEWLINE_CRLF, PCRE2_NEWLINE_ANYCRLF, or PCRE2_NEWLINE_ANY is
-       set as the newline convention, and a match attempt  for  an  unanchored
+       set  as  the  newline convention, and a match attempt for an unanchored
        pattern fails when the current starting position is at a CRLF sequence,
-       and the pattern contains no explicit matches for CR or  LF  characters,
-       the  match  position  is  advanced by two characters instead of one, in
+       and  the  pattern contains no explicit matches for CR or LF characters,
+       the match position is advanced by two characters  instead  of  one,  in
        other words, to after the CRLF.
 
        The above rule is a compromise that makes the most common cases work as
-       expected.  For  example,  if  the  pattern is .+A (and the PCRE2_DOTALL
+       expected. For example, if the pattern  is  .+A  (and  the  PCRE2_DOTALL
        option is not set), it does not match the string "\r\nA" because, after
-       failing  at the start, it skips both the CR and the LF before retrying.
-       However, the pattern [\r\n]A does match that string,  because  it  con-
+       failing at the start, it skips both the CR and the LF before  retrying.
+       However,  the  pattern  [\r\n]A does match that string, because it con-
        tains an explicit CR or LF reference, and so advances only by one char-
        acter after the first failure.
 
        An explicit match for CR of LF is either a literal appearance of one of
-       those  characters  in the pattern, or one of the \r or \n or equivalent
+       those characters in the pattern, or one of the \r or \n  or  equivalent
        octal or hexadecimal escape sequences. Implicit matches such as [^X] do
-       not  count, nor does \s, even though it includes CR and LF in the char-
+       not count, nor does \s, even though it includes CR and LF in the  char-
        acters that it matches.
 
-       Notwithstanding the above, anomalous effects may still occur when  CRLF
+       Notwithstanding  the above, anomalous effects may still occur when CRLF
        is a valid newline sequence and explicit \r or \n escapes appear in the
        pattern.
 
@@ -2313,81 +2365,81 @@ HOW PCRE2_MATCH() RETURNS A STRING AND CAPTURED SUBSTRINGS
 
        PCRE2_SIZE *pcre2_get_ovector_pointer(pcre2_match_data *match_data);
 
-       In general, a pattern matches a certain portion of the subject, and  in
-       addition,  further  substrings  from  the  subject may be picked out by
-       parenthesized parts of the pattern.  Following  the  usage  in  Jeffrey
-       Friedl's  book,  this  is  called  "capturing" in what follows, and the
-       phrase "capturing subpattern" or "capturing group" is used for a  frag-
-       ment  of  a  pattern that picks out a substring. PCRE2 supports several
+       In  general, a pattern matches a certain portion of the subject, and in
+       addition, further substrings from the subject  may  be  picked  out  by
+       parenthesized  parts  of  the  pattern.  Following the usage in Jeffrey
+       Friedl's book, this is called "capturing"  in  what  follows,  and  the
+       phrase  "capturing subpattern" or "capturing group" is used for a frag-
+       ment of a pattern that picks out a substring.  PCRE2  supports  several
        other kinds of parenthesized subpattern that do not cause substrings to
-       be  captured. The pcre2_pattern_info() function can be used to find out
+       be captured. The pcre2_pattern_info() function can be used to find  out
        how many capturing subpatterns there are in a compiled pattern.
 
-       You can use auxiliary functions for accessing  captured  substrings  by
+       You  can  use  auxiliary functions for accessing captured substrings by
        number or by name, as described in sections below.
 
        Alternatively, you can make direct use of the vector of PCRE2_SIZE val-
-       ues, called  the  ovector,  which  contains  the  offsets  of  captured
-       strings.   It   is   part  of  the  match  data  block.   The  function
-       pcre2_get_ovector_pointer() returns the address  of  the  ovector,  and
+       ues,  called  the  ovector,  which  contains  the  offsets  of captured
+       strings.  It  is  part  of  the  match  data   block.    The   function
+       pcre2_get_ovector_pointer()  returns  the  address  of the ovector, and
        pcre2_get_ovector_count() returns the number of pairs of values it con-
        tains.
 
        Within the ovector, the first in each pair of values is set to the off-
        set of the first code unit of a substring, and the second is set to the
-       offset of the first code unit after the end of a substring. These  val-
-       ues  are always code unit offsets, not character offsets. That is, they
-       are byte offsets in the 8-bit library, 16-bit  offsets  in  the  16-bit
+       offset  of the first code unit after the end of a substring. These val-
+       ues are always code unit offsets, not character offsets. That is,  they
+       are  byte  offsets  in  the 8-bit library, 16-bit offsets in the 16-bit
        library, and 32-bit offsets in the 32-bit library.
 
-       After  a  partial  match  (error  return PCRE2_ERROR_PARTIAL), only the
-       first pair of offsets (that is, ovector[0]  and  ovector[1])  are  set.
-       They  identify  the part of the subject that was partially matched. See
+       After a partial match  (error  return  PCRE2_ERROR_PARTIAL),  only  the
+       first  pair  of  offsets  (that is, ovector[0] and ovector[1]) are set.
+       They identify the part of the subject that was partially  matched.  See
        the pcre2partial documentation for details of partial matching.
 
-       After a fully successful match, the first pair  of  offsets  identifies
-       the  portion  of the subject string that was matched by the entire pat-
-       tern. The next pair is used for the first captured  substring,  and  so
-       on.  The  value  returned by pcre2_match() is one more than the highest
-       numbered pair that has been set. For example, if  two  substrings  have
-       been  captured,  the returned value is 3. If there are no captured sub-
+       After  a  fully  successful match, the first pair of offsets identifies
+       the portion of the subject string that was matched by the  entire  pat-
+       tern.  The  next  pair is used for the first captured substring, and so
+       on. The value returned by pcre2_match() is one more  than  the  highest
+       numbered  pair  that  has been set. For example, if two substrings have
+       been captured, the returned value is 3. If there are no  captured  sub-
        strings, the return value from a successful match is 1, indicating that
        just the first pair of offsets has been set.
 
-       If  a  pattern uses the \K escape sequence within a positive assertion,
+       If a pattern uses the \K escape sequence within a  positive  assertion,
        the reported start of a successful match can be greater than the end of
-       the  match.   For  example,  if the pattern (?=ab\K) is matched against
+       the match.  For example, if the pattern  (?=ab\K)  is  matched  against
        "ab", the start and end offset values for the match are 2 and 0.
 
-       If a capturing subpattern group is matched repeatedly within  a  single
-       match  operation, it is the last portion of the subject that it matched
+       If  a  capturing subpattern group is matched repeatedly within a single
+       match operation, it is the last portion of the subject that it  matched
        that is returned.
 
        If the ovector is too small to hold all the captured substring offsets,
-       as  much  as possible is filled in, and the function returns a value of
-       zero. If captured substrings are not of interest, pcre2_match() may  be
+       as much as possible is filled in, and the function returns a  value  of
+       zero.  If captured substrings are not of interest, pcre2_match() may be
        called with a match data block whose ovector is of minimum length (that
        is, one pair).
 
-       It is possible for capturing subpattern number n+1 to match  some  part
+       It  is  possible for capturing subpattern number n+1 to match some part
        of the subject when subpattern n has not been used at all. For example,
-       if the string "abc" is matched  against  the  pattern  (a|(z))(bc)  the
+       if  the  string  "abc"  is  matched against the pattern (a|(z))(bc) the
        return from the function is 4, and subpatterns 1 and 3 are matched, but
-       2 is not. When this happens, both values in  the  offset  pairs  corre-
+       2  is  not.  When  this happens, both values in the offset pairs corre-
        sponding to unused subpatterns are set to PCRE2_UNSET.
 
-       Offset  values  that correspond to unused subpatterns at the end of the
-       expression are also set to PCRE2_UNSET.  For  example,  if  the  string
+       Offset values that correspond to unused subpatterns at the end  of  the
+       expression  are  also  set  to  PCRE2_UNSET. For example, if the string
        "abc" is matched against the pattern (abc)(x(yz)?)? subpatterns 2 and 3
-       are not matched.  The return from the function is 2, because the  high-
+       are  not matched.  The return from the function is 2, because the high-
        est used capturing subpattern number is 1. The offsets for for the sec-
-       ond and third capturing  subpatterns  (assuming  the  vector  is  large
+       ond  and  third  capturing  subpatterns  (assuming  the vector is large
        enough, of course) are set to PCRE2_UNSET.
 
        Elements in the ovector that do not correspond to capturing parentheses
        in the pattern are never changed. That is, if a pattern contains n cap-
        turing parentheses, no more than ovector[0] to ovector[2n+1] are set by
-       pcre2_match(). The other elements retain whatever  values  they  previ-
+       pcre2_match().  The  other  elements retain whatever values they previ-
        ously had.
 
 
@@ -2397,56 +2449,56 @@ OTHER INFORMATION ABOUT A MATCH
 
        PCRE2_SIZE pcre2_get_startchar(pcre2_match_data *match_data);
 
-       As  well as the offsets in the ovector, other information about a match
-       is retained in the match data block and can be retrieved by  the  above
-       functions  in  appropriate  circumstances.  If they are called at other
+       As well as the offsets in the ovector, other information about a  match
+       is  retained  in the match data block and can be retrieved by the above
+       functions in appropriate circumstances. If they  are  called  at  other
        times, the result is undefined.
 
-       After a successful match, a partial match (PCRE2_ERROR_PARTIAL),  or  a
-       failure  to  match  (PCRE2_ERROR_NOMATCH), a (*MARK) name may be avail-
-       able, and pcre2_get_mark() can be called. It returns a pointer  to  the
-       zero-terminated  name,  which is within the compiled pattern. Otherwise
-       NULL is returned. The length of the (*MARK) name (excluding the  termi-
-       nating  zero)  is  stored  in the code unit that preceeds the name. You
-       should use this instead of relying  on  the  terminating  zero  if  the
+       After  a  successful match, a partial match (PCRE2_ERROR_PARTIAL), or a
+       failure to match (PCRE2_ERROR_NOMATCH), a (*MARK) name  may  be  avail-
+       able,  and  pcre2_get_mark() can be called. It returns a pointer to the
+       zero-terminated name, which is within the compiled  pattern.  Otherwise
+       NULL  is returned. The length of the (*MARK) name (excluding the termi-
+       nating zero) is stored in the code unit that  preceeds  the  name.  You
+       should  use  this  instead  of  relying  on the terminating zero if the
        (*MARK) name might contain a binary zero.
 
        After a successful match, the (*MARK) name that is returned is the last
-       one encountered on the matching path through the pattern. After  a  "no
-       match"  or  a  partial  match,  the  last  encountered  (*MARK) name is
+       one  encountered  on the matching path through the pattern. After a "no
+       match" or a  partial  match,  the  last  encountered  (*MARK)  name  is
        returned. For example, consider this pattern:
 
          ^(*MARK:A)((*MARK:B)a|b)c
 
-       When it matches "bc", the returned mark is A. The B mark is  "seen"  in
-       the  first  branch of the group, but it is not on the matching path. On
-       the other hand, when this pattern fails to  match  "bx",  the  returned
+       When  it  matches "bc", the returned mark is A. The B mark is "seen" in
+       the first branch of the group, but it is not on the matching  path.  On
+       the  other  hand,  when  this pattern fails to match "bx", the returned
        mark is B.
 
-       After  a  successful  match, a partial match, or one of the invalid UTF
-       errors (for example, PCRE2_ERROR_UTF8_ERR5), pcre2_get_startchar()  can
+       After a successful match, a partial match, or one of  the  invalid  UTF
+       errors  (for example, PCRE2_ERROR_UTF8_ERR5), pcre2_get_startchar() can
        be called. After a successful or partial match it returns the code unit
-       offset of the character at which the match started. For  a  non-partial
-       match,  this can be different to the value of ovector[0] if the pattern
-       contains the \K escape sequence. After a partial match,  however,  this
-       value  is  always the same as ovector[0] because \K does not affect the
+       offset  of  the character at which the match started. For a non-partial
+       match, this can be different to the value of ovector[0] if the  pattern
+       contains  the  \K escape sequence. After a partial match, however, this
+       value is always the same as ovector[0] because \K does not  affect  the
        result of a partial match.
 
-       After a UTF check failure, pcre2_get_startchar() can be used to  obtain
+       After  a UTF check failure, pcre2_get_startchar() can be used to obtain
        the code unit offset of the invalid UTF character. Details are given in
        the pcre2unicode page.
 
 
 ERROR RETURNS FROM pcre2_match()
 
-       If pcre2_match() fails, it returns a negative number. This can be  con-
-       verted  to a text string by calling the pcre2_get_error_message() func-
-       tion (see "Obtaining a textual error message" below).   Negative  error
-       codes  are  also  returned  by other functions, and are documented with
-       them. The codes are given names in the header file. If UTF checking  is
+       If  pcre2_match() fails, it returns a negative number. This can be con-
+       verted to a text string by calling the pcre2_get_error_message()  func-
+       tion  (see  "Obtaining a textual error message" below).  Negative error
+       codes are also returned by other functions,  and  are  documented  with
+       them.  The codes are given names in the header file. If UTF checking is
        in force and an invalid UTF subject string is detected, one of a number
-       of UTF-specific negative error codes is returned. Details are given  in
-       the  pcre2unicode  page. The following are the other errors that may be
+       of  UTF-specific negative error codes is returned. Details are given in
+       the pcre2unicode page. The following are the other errors that  may  be
        returned by pcre2_match():
 
          PCRE2_ERROR_NOMATCH
@@ -2455,20 +2507,20 @@ ERROR RETURNS FROM pcre2_match()
 
          PCRE2_ERROR_PARTIAL
 
-       The subject string did not match, but it did match partially.  See  the
+       The  subject  string did not match, but it did match partially. See the
        pcre2partial documentation for details of partial matching.
 
          PCRE2_ERROR_BADMAGIC
 
        PCRE2 stores a 4-byte "magic number" at the start of the compiled code,
-       to catch the case when it is passed a junk pointer. This is  the  error
+       to  catch  the case when it is passed a junk pointer. This is the error
        that is returned when the magic number is not present.
 
          PCRE2_ERROR_BADMODE
 
-       This  error is given when a compiled pattern is passed to a function in
-       a library of a different code unit width, for example, a  pattern  com-
-       piled  by  the  8-bit  library  is passed to a 16-bit or 32-bit library
+       This error is given when a compiled pattern is passed to a function  in
+       a  library  of a different code unit width, for example, a pattern com-
+       piled by the 8-bit library is passed to  a  16-bit  or  32-bit  library
        function.
 
          PCRE2_ERROR_BADOFFSET
@@ -2482,15 +2534,15 @@ ERROR RETURNS FROM pcre2_match()
          PCRE2_ERROR_BADUTFOFFSET
 
        The UTF code unit sequence that was passed as a subject was checked and
-       found  to be valid (the PCRE2_NO_UTF_CHECK option was not set), but the
-       value of startoffset did not point to the beginning of a UTF  character
+       found to be valid (the PCRE2_NO_UTF_CHECK option was not set), but  the
+       value  of startoffset did not point to the beginning of a UTF character
        or the end of the subject.
 
          PCRE2_ERROR_CALLOUT
 
-       This  error  is never generated by pcre2_match() itself. It is provided
-       for use by callout  functions  that  want  to  cause  pcre2_match()  or
-       pcre2_callout_enumerate()  to  return a distinctive error code. See the
+       This error is never generated by pcre2_match() itself. It  is  provided
+       for  use  by  callout  functions  that  want  to cause pcre2_match() or
+       pcre2_callout_enumerate() to return a distinctive error code.  See  the
        pcre2callout documentation for details.
 
          PCRE2_ERROR_DEPTHLIMIT
@@ -2499,14 +2551,14 @@ ERROR RETURNS FROM pcre2_match()
 
          PCRE2_ERROR_INTERNAL
 
-       An unexpected internal error has occurred. This error could  be  caused
+       An  unexpected  internal error has occurred. This error could be caused
        by a bug in PCRE2 or by overwriting of the compiled pattern.
 
          PCRE2_ERROR_JIT_STACKLIMIT
 
-       This  error  is  returned  when a pattern that was successfully studied
-       using JIT is being matched, but the memory available for  the  just-in-
-       time  processing stack is not large enough. See the pcre2jit documenta-
+       This error is returned when a pattern  that  was  successfully  studied
+       using  JIT  is being matched, but the memory available for the just-in-
+       time processing stack is not large enough. See the pcre2jit  documenta-
        tion for more details.
 
          PCRE2_ERROR_MATCHLIMIT
@@ -2515,9 +2567,11 @@ ERROR RETURNS FROM pcre2_match()
 
          PCRE2_ERROR_NOMEMORY
 
-       If a pattern contains many nested backtracking points, heap  memory  is
-       used  to  remember them. This error is given when the memory allocation
-       function (default or custom) fails.
+       If  a  pattern contains many nested backtracking points, heap memory is
+       used to remember them. This error is given when the  memory  allocation
+       function  (default  or  custom)  fails.  Note  that  a different error,
+       PCRE2_ERROR_HEAPLIMIT, is given if the amount of memory needed  exceeds
+       the heap limit.
 
          PCRE2_ERROR_NULL
 
@@ -2525,12 +2579,12 @@ ERROR RETURNS FROM pcre2_match()
 
          PCRE2_ERROR_RECURSELOOP
 
-       This error is returned when  pcre2_match()  detects  a  recursion  loop
-       within  the  pattern. Specifically, it means that either the whole pat-
+       This  error  is  returned  when  pcre2_match() detects a recursion loop
+       within the pattern. Specifically, it means that either the  whole  pat-
        tern or a subpattern has been called recursively for the second time at
-       the  same  position  in  the  subject string. Some simple patterns that
-       might do this are detected and faulted at compile time, but  more  com-
-       plicated  cases,  in particular mutual recursions between two different
+       the same position in the subject  string.  Some  simple  patterns  that
+       might  do  this are detected and faulted at compile time, but more com-
+       plicated cases, in particular mutual recursions between  two  different
        subpatterns, cannot be detected until matching is attempted.
 
 
@@ -2539,20 +2593,20 @@ OBTAINING A TEXTUAL ERROR MESSAGE
        int pcre2_get_error_message(int errorcode, PCRE2_UCHAR *buffer,
          PCRE2_SIZE bufflen);
 
-       A text message for an error code  from  any  PCRE2  function  (compile,
-       match,  or  auxiliary)  can be obtained by calling pcre2_get_error_mes-
-       sage(). The code is passed as the first argument,  with  the  remaining
-       two  arguments  specifying  a  code  unit buffer and its length in code
-       units, into which the text message is placed. The message  is  returned
-       in  code  units  of the appropriate width for the library that is being
+       A  text  message  for  an  error code from any PCRE2 function (compile,
+       match, or auxiliary) can be obtained  by  calling  pcre2_get_error_mes-
+       sage().  The  code  is passed as the first argument, with the remaining
+       two arguments specifying a code unit buffer  and  its  length  in  code
+       units,  into  which the text message is placed. The message is returned
+       in code units of the appropriate width for the library  that  is  being
        used.
 
-       The returned message is terminated with a trailing zero, and the  func-
-       tion  returns  the  number  of  code units used, excluding the trailing
+       The  returned message is terminated with a trailing zero, and the func-
+       tion returns the number of code  units  used,  excluding  the  trailing
        zero.  If  the  error  number  is  unknown,  the  negative  error  code
-       PCRE2_ERROR_BADDATA  is  returned. If the buffer is too small, the mes-
-       sage is truncated (but still with a trailing zero),  and  the  negative
-       error  code PCRE2_ERROR_NOMEMORY is returned.  None of the messages are
+       PCRE2_ERROR_BADDATA is returned. If the buffer is too small,  the  mes-
+       sage  is  truncated  (but still with a trailing zero), and the negative
+       error code PCRE2_ERROR_NOMEMORY is returned.  None of the messages  are
        very long; a buffer size of 120 code units is ample.
 
 
@@ -2571,39 +2625,39 @@ EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
 
        void pcre2_substring_free(PCRE2_UCHAR *buffer);
 
-       Captured substrings can be accessed directly by using  the  ovector  as
+       Captured  substrings  can  be accessed directly by using the ovector as
        described above.  For convenience, auxiliary functions are provided for
-       extracting  captured  substrings  as  new,  separate,   zero-terminated
+       extracting   captured  substrings  as  new,  separate,  zero-terminated
        strings. A substring that contains a binary zero is correctly extracted
-       and has a further zero added on the end, but  the  result  is  not,  of
+       and  has  a  further  zero  added on the end, but the result is not, of
        course, a C string.
 
        The functions in this section identify substrings by number. The number
        zero refers to the entire matched substring, with higher numbers refer-
-       ring  to  substrings  captured by parenthesized groups. After a partial
-       match, only substring zero is available.  An  attempt  to  extract  any
-       other  substring  gives the error PCRE2_ERROR_PARTIAL. The next section
+       ring to substrings captured by parenthesized groups.  After  a  partial
+       match,  only  substring  zero  is  available. An attempt to extract any
+       other substring gives the error PCRE2_ERROR_PARTIAL. The  next  section
        describes similar functions for extracting captured substrings by name.
 
-       If a pattern uses the \K escape sequence within a  positive  assertion,
+       If  a  pattern uses the \K escape sequence within a positive assertion,
        the reported start of a successful match can be greater than the end of
-       the match.  For example, if the pattern  (?=ab\K)  is  matched  against
-       "ab",  the  start  and  end offset values for the match are 2 and 0. In
-       this situation, calling these functions with a  zero  substring  number
+       the  match.   For  example,  if the pattern (?=ab\K) is matched against
+       "ab", the start and end offset values for the match are  2  and  0.  In
+       this  situation,  calling  these functions with a zero substring number
        extracts a zero-length empty string.
 
-       You  can  find the length in code units of a captured substring without
-       extracting it by calling pcre2_substring_length_bynumber().  The  first
-       argument  is a pointer to the match data block, the second is the group
-       number, and the third is a pointer to a variable into which the  length
-       is  placed.  If  you just want to know whether or not the substring has
+       You can find the length in code units of a captured  substring  without
+       extracting  it  by calling pcre2_substring_length_bynumber(). The first
+       argument is a pointer to the match data block, the second is the  group
+       number,  and the third is a pointer to a variable into which the length
+       is placed. If you just want to know whether or not  the  substring  has
        been captured, you can pass the third argument as NULL.
 
-       The pcre2_substring_copy_bynumber() function  copies  a  captured  sub-
-       string  into  a supplied buffer, whereas pcre2_substring_get_bynumber()
-       copies it into new memory, obtained using the  same  memory  allocation
-       function  that  was  used for the match data block. The first two argu-
-       ments of these functions are a pointer to the match data  block  and  a
+       The  pcre2_substring_copy_bynumber()  function  copies  a captured sub-
+       string into a supplied buffer,  whereas  pcre2_substring_get_bynumber()
+       copies  it  into  new memory, obtained using the same memory allocation
+       function that was used for the match data block. The  first  two  argu-
+       ments  of  these  functions are a pointer to the match data block and a
        capturing group number.
 
        The final arguments of pcre2_substring_copy_bynumber() are a pointer to
@@ -2612,25 +2666,25 @@ EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
        for the extracted substring, excluding the terminating zero.
 
        For pcre2_substring_get_bynumber() the third and fourth arguments point
-       to  variables that are updated with a pointer to the new memory and the
-       number of code units that comprise the substring, again  excluding  the
-       terminating  zero.  When  the substring is no longer needed, the memory
+       to variables that are updated with a pointer to the new memory and  the
+       number  of  code units that comprise the substring, again excluding the
+       terminating zero. When the substring is no longer  needed,  the  memory
        should be freed by calling pcre2_substring_free().
 
-       The return value from all these functions is zero  for  success,  or  a
-       negative  error  code.  If  the pattern match failed, the match failure
-       code is returned.  If a substring number  greater  than  zero  is  used
-       after  a partial match, PCRE2_ERROR_PARTIAL is returned. Other possible
+       The  return  value  from  all these functions is zero for success, or a
+       negative error code. If the pattern match  failed,  the  match  failure
+       code  is  returned.   If  a  substring number greater than zero is used
+       after a partial match, PCRE2_ERROR_PARTIAL is returned. Other  possible
        error codes are:
 
          PCRE2_ERROR_NOMEMORY
 
-       The buffer was too small for  pcre2_substring_copy_bynumber(),  or  the
+       The  buffer  was  too small for pcre2_substring_copy_bynumber(), or the
        attempt to get memory failed for pcre2_substring_get_bynumber().
 
          PCRE2_ERROR_NOSUBSTRING
 
-       There  is  no  substring  with that number in the pattern, that is, the
+       There is no substring with that number in the  pattern,  that  is,  the
        number is greater than the number of capturing parentheses.
 
          PCRE2_ERROR_UNAVAILABLE
@@ -2641,8 +2695,8 @@ EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
 
          PCRE2_ERROR_UNSET
 
-       The substring did not participate in the match.  For  example,  if  the
-       pattern  is  (abc)|(def) and the subject is "def", and the ovector con-
+       The  substring  did  not  participate in the match. For example, if the
+       pattern is (abc)|(def) and the subject is "def", and the  ovector  con-
        tains at least two capturing slots, substring number 1 is unset.
 
 
@@ -2653,32 +2707,32 @@ EXTRACTING A LIST OF ALL CAPTURED SUBSTRINGS
 
        void pcre2_substring_list_free(PCRE2_SPTR *list);
 
-       The pcre2_substring_list_get() function  extracts  all  available  sub-
-       strings  and  builds  a  list of pointers to them. It also (optionally)
-       builds a second list that  contains  their  lengths  (in  code  units),
+       The  pcre2_substring_list_get()  function  extracts  all available sub-
+       strings and builds a list of pointers to  them.  It  also  (optionally)
+       builds  a  second  list  that  contains  their lengths (in code units),
        excluding a terminating zero that is added to each of them. All this is
        done in a single block of memory that is obtained using the same memory
        allocation function that was used to get the match data block.
 
-       This  function  must be called only after a successful match. If called
+       This function must be called only after a successful match.  If  called
        after a partial match, the error code PCRE2_ERROR_PARTIAL is returned.
 
-       The address of the memory block is returned via listptr, which is  also
+       The  address of the memory block is returned via listptr, which is also
        the start of the list of string pointers. The end of the list is marked
-       by a NULL pointer. The address of the list of lengths is  returned  via
-       lengthsptr.  If your strings do not contain binary zeros and you do not
+       by  a  NULL pointer. The address of the list of lengths is returned via
+       lengthsptr. If your strings do not contain binary zeros and you do  not
        therefore need the lengths, you may supply NULL as the lengthsptr argu-
-       ment  to  disable  the  creation of a list of lengths. The yield of the
-       function is zero if all went well, or PCRE2_ERROR_NOMEMORY if the  mem-
-       ory  block could not be obtained. When the list is no longer needed, it
+       ment to disable the creation of a list of lengths.  The  yield  of  the
+       function  is zero if all went well, or PCRE2_ERROR_NOMEMORY if the mem-
+       ory block could not be obtained. When the list is no longer needed,  it
        should be freed by calling pcre2_substring_list_free().
 
        If this function encounters a substring that is unset, which can happen
-       when  capturing subpattern number n+1 matches some part of the subject,
-       but subpattern n has not been used at all, it returns an empty  string.
-       This  can  be  distinguished  from  a  genuine zero-length substring by
+       when capturing subpattern number n+1 matches some part of the  subject,
+       but  subpattern n has not been used at all, it returns an empty string.
+       This can be distinguished  from  a  genuine  zero-length  substring  by
        inspecting  the  appropriate  offset  in  the  ovector,  which  contain
-       PCRE2_UNSET   for   unset   substrings,   or   by   calling  pcre2_sub-
+       PCRE2_UNSET  for   unset   substrings,   or   by   calling   pcre2_sub-
        string_length_bynumber().
 
 
@@ -2698,39 +2752,39 @@ EXTRACTING CAPTURED SUBSTRINGS BY NAME
 
        void pcre2_substring_free(PCRE2_UCHAR *buffer);
 
-       To extract a substring by name, you first have to find associated  num-
+       To  extract a substring by name, you first have to find associated num-
        ber.  For example, for this pattern:
 
          (a+)b(?\d+)...
 
        the number of the subpattern called "xxx" is 2. If the name is known to
-       be unique (PCRE2_DUPNAMES was not set), you can find  the  number  from
+       be  unique  (PCRE2_DUPNAMES  was not set), you can find the number from
        the name by calling pcre2_substring_number_from_name(). The first argu-
-       ment is the compiled pattern, and the second is the name. The yield  of
+       ment  is the compiled pattern, and the second is the name. The yield of
        the function is the subpattern number, PCRE2_ERROR_NOSUBSTRING if there
-       is no subpattern of  that  name,  or  PCRE2_ERROR_NOUNIQUESUBSTRING  if
-       there  is  more than one subpattern of that name. Given the number, you
-       can extract the substring directly from the ovector, or use one of  the
+       is  no  subpattern  of  that  name, or PCRE2_ERROR_NOUNIQUESUBSTRING if
+       there is more than one subpattern of that name. Given the  number,  you
+       can  extract the substring directly from the ovector, or use one of the
        "bynumber" functions described above.
 
-       For  convenience,  there are also "byname" functions that correspond to
-       the "bynumber" functions, the only difference  being  that  the  second
-       argument  is  a  name instead of a number. If PCRE2_DUPNAMES is set and
+       For convenience, there are also "byname" functions that  correspond  to
+       the  "bynumber"  functions,  the  only difference being that the second
+       argument is a name instead of a number. If PCRE2_DUPNAMES  is  set  and
        there are duplicate names, these functions scan all the groups with the
        given name, and return the first named string that is set.
 
-       If  there are no groups with the given name, PCRE2_ERROR_NOSUBSTRING is
-       returned. If all groups with the name have  numbers  that  are  greater
-       than  the  number  of  slots in the ovector, PCRE2_ERROR_UNAVAILABLE is
-       returned. If there is at least one group with a slot  in  the  ovector,
+       If there are no groups with the given name, PCRE2_ERROR_NOSUBSTRING  is
+       returned.  If  all  groups  with the name have numbers that are greater
+       than the number of slots in  the  ovector,  PCRE2_ERROR_UNAVAILABLE  is
+       returned.  If  there  is at least one group with a slot in the ovector,
        but no group is found to be set, PCRE2_ERROR_UNSET is returned.
 
        Warning: If the pattern uses the (?| feature to set up multiple subpat-
-       terns with the same number, as described in the  section  on  duplicate
-       subpattern  numbers  in  the pcre2pattern page, you cannot use names to
-       distinguish the different subpatterns, because names are  not  included
-       in  the compiled code. The matching process uses only numbers. For this
-       reason, the use of different names for subpatterns of the  same  number
+       terns  with  the  same number, as described in the section on duplicate
+       subpattern numbers in the pcre2pattern page, you cannot  use  names  to
+       distinguish  the  different subpatterns, because names are not included
+       in the compiled code. The matching process uses only numbers. For  this
+       reason,  the  use of different names for subpatterns of the same number
        causes an error at compile time.
 
 
@@ -2743,52 +2797,52 @@ CREATING A NEW STRING WITH SUBSTITUTIONS
          PCRE2_SIZE rlength, PCRE2_UCHAR *outputbufferP,
          PCRE2_SIZE *outlengthptr);
 
-       This  function calls pcre2_match() and then makes a copy of the subject
-       string in outputbuffer, replacing the part that was  matched  with  the
-       replacement  string,  whose  length is supplied in rlength. This can be
+       This function calls pcre2_match() and then makes a copy of the  subject
+       string  in  outputbuffer,  replacing the part that was matched with the
+       replacement string, whose length is supplied in rlength.  This  can  be
        given as PCRE2_ZERO_TERMINATED for a zero-terminated string. Matches in
-       which  a  \K item in a lookahead in the pattern causes the match to end
+       which a \K item in a lookahead in the pattern causes the match  to  end
        before it starts are not supported, and give rise to an error return.
 
-       The first seven arguments of pcre2_substitute() are  the  same  as  for
+       The  first  seven  arguments  of pcre2_substitute() are the same as for
        pcre2_match(), except that the partial matching options are not permit-
-       ted, and match_data may be passed as NULL, in which case a  match  data
-       block  is obtained and freed within this function, using memory manage-
-       ment functions from the match context, if provided, or else those  that
+       ted,  and  match_data may be passed as NULL, in which case a match data
+       block is obtained and freed within this function, using memory  manage-
+       ment  functions from the match context, if provided, or else those that
        were used to allocate memory for the compiled code.
 
-       The  outlengthptr  argument  must point to a variable that contains the
-       length, in code units, of the output buffer. If the  function  is  suc-
-       cessful,  the value is updated to contain the length of the new string,
+       The outlengthptr argument must point to a variable  that  contains  the
+       length,  in  code  units, of the output buffer. If the function is suc-
+       cessful, the value is updated to contain the length of the new  string,
        excluding the trailing zero that is automatically added.
 
-       If the function is not  successful,  the  value  set  via  outlengthptr
-       depends  on  the  type  of  error. For syntax errors in the replacement
-       string, the value is the offset in the  replacement  string  where  the
-       error  was  detected.  For  other  errors,  the value is PCRE2_UNSET by
-       default. This includes the case of the output buffer being  too  small,
-       unless  PCRE2_SUBSTITUTE_OVERFLOW_LENGTH  is  set (see below), in which
-       case the value is the minimum length needed, including  space  for  the
-       trailing  zero.  Note  that  in  order  to compute the required length,
-       pcre2_substitute() has  to  simulate  all  the  matching  and  copying,
+       If  the  function  is  not  successful,  the value set via outlengthptr
+       depends on the type of error. For  syntax  errors  in  the  replacement
+       string,  the  value  is  the offset in the replacement string where the
+       error was detected. For other  errors,  the  value  is  PCRE2_UNSET  by
+       default.  This  includes the case of the output buffer being too small,
+       unless PCRE2_SUBSTITUTE_OVERFLOW_LENGTH is set (see  below),  in  which
+       case  the  value  is the minimum length needed, including space for the
+       trailing zero. Note that in  order  to  compute  the  required  length,
+       pcre2_substitute()  has  to  simulate  all  the  matching  and copying,
        instead of giving an error return as soon as the buffer overflows. Note
        also that the length is in code units, not bytes.
 
-       In the replacement string, which is interpreted as a UTF string in  UTF
-       mode,  and  is  checked  for UTF validity unless the PCRE2_NO_UTF_CHECK
+       In  the replacement string, which is interpreted as a UTF string in UTF
+       mode, and is checked for UTF  validity  unless  the  PCRE2_NO_UTF_CHECK
        option is set, a dollar character is an escape character that can spec-
-       ify  the insertion of characters from capturing groups or (*MARK) items
+       ify the insertion of characters from capturing groups or (*MARK)  items
        in the pattern. The following forms are always recognized:
 
          $$                  insert a dollar character
          $ or ${}      insert the contents of group 
          $*MARK or ${*MARK}  insert the name of the last (*MARK) encountered
 
-       Either a group number or a group name  can  be  given  for  .  Curly
-       brackets  are  required only if the following character would be inter-
+       Either  a  group  number  or  a  group name can be given for . Curly
+       brackets are required only if the following character would  be  inter-
        preted 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
+       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 facility for inserting a (*MARK) name can be used to perform simple
@@ -2798,92 +2852,92 @@ CREATING A NEW STRING WITH SUBSTITUTIONS
              apple lemon
           2: pear orange
 
-       As well as the usual options for pcre2_match(), a number of  additional
+       As  well as the usual options for pcre2_match(), a number of additional
        options can be set in the options argument.
 
        PCRE2_SUBSTITUTE_GLOBAL causes the function to iterate over the subject
-       string, replacing every matching substring. If this is  not  set,  only
-       the  first matching substring is replaced. If any matched substring has
-       zero length, after the substitution has happened, an attempt to find  a
-       non-empty  match at the same position is performed. If this is not suc-
-       cessful, the current position is advanced by one character except  when
-       CRLF  is  a  valid newline sequence and the next two characters are CR,
+       string,  replacing  every  matching substring. If this is not set, only
+       the first matching substring is replaced. If any matched substring  has
+       zero  length, after the substitution has happened, an attempt to find a
+       non-empty match at the same position is performed. If this is not  suc-
+       cessful,  the current position is advanced by one character except when
+       CRLF is a valid newline sequence and the next two  characters  are  CR,
        LF. In this case, the current position is advanced by two characters.
 
-       PCRE2_SUBSTITUTE_OVERFLOW_LENGTH changes what happens when  the  output
+       PCRE2_SUBSTITUTE_OVERFLOW_LENGTH  changes  what happens when the output
        buffer is too small. The default action is to return PCRE2_ERROR_NOMEM-
-       ORY immediately. If this option  is  set,  however,  pcre2_substitute()
+       ORY  immediately.  If  this  option is set, however, pcre2_substitute()
        continues to go through the motions of matching and substituting (with-
-       out, of course, writing anything) in order to compute the size of  buf-
-       fer  that  is  needed.  This  value is passed back via the outlengthptr
-       variable,   with   the   result   of   the   function    still    being
+       out,  of course, writing anything) in order to compute the size of buf-
+       fer that is needed. This value is  passed  back  via  the  outlengthptr
+       variable,    with    the   result   of   the   function   still   being
        PCRE2_ERROR_NOMEMORY.
 
-       Passing  a  buffer  size  of zero is a permitted way of finding out how
-       much memory is needed for given substitution. However, this  does  mean
+       Passing a buffer size of zero is a permitted way  of  finding  out  how
+       much  memory  is needed for given substitution. However, this does mean
        that the entire operation is carried out twice. Depending on the appli-
-       cation, it may be more efficient to allocate a large  buffer  and  free
-       the   excess   afterwards,   instead  of  using  PCRE2_SUBSTITUTE_OVER-
+       cation,  it  may  be more efficient to allocate a large buffer and free
+       the  excess  afterwards,  instead   of   using   PCRE2_SUBSTITUTE_OVER-
        FLOW_LENGTH.
 
-       PCRE2_SUBSTITUTE_UNKNOWN_UNSET causes references  to  capturing  groups
-       that  do  not appear in the pattern to be treated as unset groups. This
-       option should be used with care, because it means  that  a  typo  in  a
-       group  name  or  number  no  longer  causes the PCRE2_ERROR_NOSUBSTRING
+       PCRE2_SUBSTITUTE_UNKNOWN_UNSET  causes  references  to capturing groups
+       that do not appear in the pattern to be treated as unset  groups.  This
+       option  should  be  used  with  care, because it means that a typo in a
+       group name or  number  no  longer  causes  the  PCRE2_ERROR_NOSUBSTRING
        error.
 
-       PCRE2_SUBSTITUTE_UNSET_EMPTY causes unset capturing  groups  (including
+       PCRE2_SUBSTITUTE_UNSET_EMPTY  causes  unset capturing groups (including
        unknown  groups  when  PCRE2_SUBSTITUTE_UNKNOWN_UNSET  is  set)  to  be
-       treated as empty strings when inserted  as  described  above.  If  this
-       option  is  not  set,  an  attempt  to insert an unset group causes the
-       PCRE2_ERROR_UNSET error. This option does not  influence  the  extended
+       treated  as  empty  strings  when  inserted as described above. If this
+       option is not set, an attempt to  insert  an  unset  group  causes  the
+       PCRE2_ERROR_UNSET  error.  This  option does not influence the extended
        substitution syntax described below.
 
-       PCRE2_SUBSTITUTE_EXTENDED  causes extra processing to be applied to the
-       replacement string. Without this option, only the dollar  character  is
-       special,  and  only  the  group insertion forms listed above are valid.
+       PCRE2_SUBSTITUTE_EXTENDED causes extra processing to be applied to  the
+       replacement  string.  Without this option, only the dollar character is
+       special, and only the group insertion forms  listed  above  are  valid.
        When PCRE2_SUBSTITUTE_EXTENDED is set, two things change:
 
-       Firstly, backslash in a replacement string is interpreted as an  escape
+       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-alphanu-
-       meric  character  quotes  that character. Extended quoting can be coded
+       particular  character codes, and backslash followed by any non-alphanu-
+       meric character quotes that character. Extended quoting  can  be  coded
        using \Q...\E, exactly as in pattern strings.
 
-       There are also four escape sequences for forcing the case  of  inserted
-       letters.   The  insertion  mechanism has three states: no case forcing,
+       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, respec-
-       tively, 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
+       tively,  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 captured groups and let-
        ters within \Q...\E quoted sequences.
 
        Note that case forcing sequences such as \U...\E do not nest. For exam-
-       ple, the result of processing "\Uaa\LBB\Ecc\E" is "AAbbcc";  the  final
+       ple,  the  result of processing "\Uaa\LBB\Ecc\E" is "AAbbcc"; the final
        \E has no effect.
 
-       The  second  effect of setting PCRE2_SUBSTITUTE_EXTENDED is to add more
-       flexibility to group substitution. The syntax is similar to  that  used
+       The second effect of setting PCRE2_SUBSTITUTE_EXTENDED is to  add  more
+       flexibility  to  group substitution. The syntax is similar to that used
        by Bash:
 
          ${:-}
          ${:+:}
 
-       As  before,   may be a group number or a name. The first form speci-
-       fies a default value. If group  is set, its value  is  inserted;  if
-       not,    is  expanded  and  the result inserted. The second form
-       specifies strings that are expanded and inserted when group  is  set
-       or  unset,  respectively. The first form is just a convenient shorthand
+       As before,  may be a group number or a name. The first  form  speci-
+       fies  a  default  value. If group  is set, its value is inserted; if
+       not,  is expanded and the  result  inserted.  The  second  form
+       specifies  strings that are expanded and inserted when group  is set
+       or unset, respectively. The first form is just a  convenient  shorthand
        for
 
          ${:+${}:}
 
-       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 string remains  in  force  afterwards,  as  shown  in  this
+       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  string  remains  in  force  afterwards,  as  shown in this
        pcre2test example:
 
          /(some)?(body)/substitute_extended,replace=${1:+\U:\L}HeLLo
@@ -2892,41 +2946,41 @@ CREATING A NEW STRING WITH SUBSTITUTIONS
              somebody
           1: HELLO
 
-       The  PCRE2_SUBSTITUTE_UNSET_EMPTY option does not affect these extended
-       substitutions.  However,  PCRE2_SUBSTITUTE_UNKNOWN_UNSET   does   cause
+       The PCRE2_SUBSTITUTE_UNSET_EMPTY option does not affect these  extended
+       substitutions.   However,   PCRE2_SUBSTITUTE_UNKNOWN_UNSET  does  cause
        unknown groups in the extended syntax forms to be treated as unset.
 
-       If  successful,  pcre2_substitute()  returns the number of replacements
+       If successful, pcre2_substitute() returns the  number  of  replacements
        that were made. This may be zero if no matches were found, and is never
        greater than 1 unless PCRE2_SUBSTITUTE_GLOBAL is set.
 
        In the event of an error, a negative error code is returned. Except for
-       PCRE2_ERROR_NOMATCH   (which   is   never   returned),   errors    from
+       PCRE2_ERROR_NOMATCH    (which   is   never   returned),   errors   from
        pcre2_match() are passed straight back.
 
        PCRE2_ERROR_NOSUBSTRING is returned for a non-existent substring inser-
        tion, unless PCRE2_SUBSTITUTE_UNKNOWN_UNSET is set.
 
        PCRE2_ERROR_UNSET is returned for an unset substring insertion (includ-
-       ing  an  unknown  substring when PCRE2_SUBSTITUTE_UNKNOWN_UNSET is set)
+       ing an unknown substring when  PCRE2_SUBSTITUTE_UNKNOWN_UNSET  is  set)
        when  the  simple  (non-extended)  syntax  is  used  and  PCRE2_SUBSTI-
        TUTE_UNSET_EMPTY is not set.
 
-       PCRE2_ERROR_NOMEMORY  is  returned  if  the  output  buffer  is not big
+       PCRE2_ERROR_NOMEMORY is returned  if  the  output  buffer  is  not  big
        enough. If the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH option is set, the size
-       of  buffer  that is needed is returned via outlengthptr. Note that this
+       of buffer that is needed is returned via outlengthptr. Note  that  this
        does not happen by default.
 
-       PCRE2_ERROR_BADREPLACEMENT is used for miscellaneous syntax  errors  in
+       PCRE2_ERROR_BADREPLACEMENT  is  used for miscellaneous syntax errors in
        the   replacement   string,   with   more   particular   errors   being
-       PCRE2_ERROR_BADREPESCAPE (invalid  escape  sequence),  PCRE2_ERROR_REP-
-       MISSING_BRACE  (closing curly bracket not found), PCRE2_BADSUBSTITUTION
-       (syntax error in extended group substitution), and  PCRE2_BADSUBPATTERN
-       (the  pattern  match ended before it started, which can happen if \K is
+       PCRE2_ERROR_BADREPESCAPE  (invalid  escape  sequence), PCRE2_ERROR_REP-
+       MISSING_BRACE (closing curly bracket not found),  PCRE2_BADSUBSTITUTION
+       (syntax  error in extended group substitution), and PCRE2_BADSUBPATTERN
+       (the pattern match ended before it started, which can happen if  \K  is
        used in an assertion).
 
        As for all PCRE2 errors, a text message that describes the error can be
-       obtained   by   calling  the  pcre2_get_error_message()  function  (see
+       obtained  by  calling  the  pcre2_get_error_message()   function   (see
        "Obtaining a textual error message" above).
 
 
@@ -2935,56 +2989,56 @@ DUPLICATE SUBPATTERN NAMES
        int pcre2_substring_nametable_scan(const pcre2_code *code,
          PCRE2_SPTR name, PCRE2_SPTR *first, PCRE2_SPTR *last);
 
-       When a pattern is compiled with the PCRE2_DUPNAMES  option,  names  for
-       subpatterns  are  not required to be unique. Duplicate names are always
-       allowed for subpatterns with the same number, created by using the  (?|
-       feature.  Indeed,  if  such subpatterns are named, they are required to
+       When  a  pattern  is compiled with the PCRE2_DUPNAMES option, names for
+       subpatterns are not required to be unique. Duplicate names  are  always
+       allowed  for subpatterns with the same number, created by using the (?|
+       feature. Indeed, if such subpatterns are named, they  are  required  to
        use the same names.
 
        Normally, patterns with duplicate names are such that in any one match,
-       only  one of the named subpatterns participates. An example is shown in
+       only one of the named subpatterns participates. An example is shown  in
        the pcre2pattern documentation.
 
-       When  duplicates   are   present,   pcre2_substring_copy_byname()   and
-       pcre2_substring_get_byname()  return  the first substring corresponding
-       to  the  given  name  that  is  set.  Only   if   none   are   set   is
-       PCRE2_ERROR_UNSET  is  returned. The pcre2_substring_number_from_name()
+       When   duplicates   are   present,   pcre2_substring_copy_byname()  and
+       pcre2_substring_get_byname() return the first  substring  corresponding
+       to   the   given   name   that   is  set.  Only  if  none  are  set  is
+       PCRE2_ERROR_UNSET is returned.  The  pcre2_substring_number_from_name()
        function returns the error PCRE2_ERROR_NOUNIQUESUBSTRING when there are
        duplicate names.
 
-       If  you want to get full details of all captured substrings for a given
-       name, you must use the pcre2_substring_nametable_scan()  function.  The
-       first  argument is the compiled pattern, and the second is the name. If
-       the third and fourth arguments are NULL, the function returns  a  group
+       If you want to get full details of all captured substrings for a  given
+       name,  you  must use the pcre2_substring_nametable_scan() function. The
+       first argument is the compiled pattern, and the second is the name.  If
+       the  third  and fourth arguments are NULL, the function returns a group
        number for a unique name, or PCRE2_ERROR_NOUNIQUESUBSTRING otherwise.
 
        When the third and fourth arguments are not NULL, they must be pointers
-       to variables that are updated by the function. After it has  run,  they
+       to  variables  that are updated by the function. After it has run, they
        point to the first and last entries in the name-to-number table for the
-       given name, and the function returns the length of each entry  in  code
-       units.  In both cases, PCRE2_ERROR_NOSUBSTRING is returned if there are
+       given  name,  and the function returns the length of each entry in code
+       units. In both cases, PCRE2_ERROR_NOSUBSTRING is returned if there  are
        no entries for the given name.
 
        The format of the name table is described above in the section entitled
-       Information  about  a  pattern.  Given all the relevant entries for the
-       name, you can extract each of their numbers,  and  hence  the  captured
+       Information about a pattern. Given all the  relevant  entries  for  the
+       name,  you  can  extract  each of their numbers, and hence the captured
        data.
 
 
 FINDING ALL POSSIBLE MATCHES AT ONE POSITION
 
-       The  traditional  matching  function  uses a similar algorithm to Perl,
-       which stops when it finds the first match at a given point in the  sub-
+       The traditional matching function uses a  similar  algorithm  to  Perl,
+       which  stops when it finds the first match at a given point in the sub-
        ject. If you want to find all possible matches, or the longest possible
-       match at a given position,  consider  using  the  alternative  matching
-       function  (see  below) instead. If you cannot use the alternative func-
+       match  at  a  given  position,  consider using the alternative matching
+       function (see below) instead. If you cannot use the  alternative  func-
        tion, you can kludge it up by making use of the callout facility, which
        is described in the pcre2callout documentation.
 
        What you have to do is to insert a callout right at the end of the pat-
-       tern.  When your callout function is called, extract and save the  cur-
-       rent  matched  substring.  Then return 1, which forces pcre2_match() to
-       backtrack and try other alternatives. Ultimately, when it runs  out  of
+       tern.   When your callout function is called, extract and save the cur-
+       rent matched substring. Then return 1, which  forces  pcre2_match()  to
+       backtrack  and  try other alternatives. Ultimately, when it runs out of
        matches, pcre2_match() will yield PCRE2_ERROR_NOMATCH.
 
 
@@ -2996,26 +3050,26 @@ MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
          pcre2_match_context *mcontext,
          int *workspace, PCRE2_SIZE wscount);
 
-       The  function  pcre2_dfa_match()  is  called  to match a subject string
-       against a compiled pattern, using a matching algorithm that  scans  the
+       The function pcre2_dfa_match() is called  to  match  a  subject  string
+       against  a  compiled pattern, using a matching algorithm that scans the
        subject string just once (not counting lookaround assertions), and does
-       not backtrack.  This has different characteristics to the normal  algo-
-       rithm,  and  is not compatible with Perl. Some of the features of PCRE2
-       patterns are not supported.  Nevertheless, there are  times  when  this
-       kind  of  matching  can be useful. For a discussion of the two matching
+       not  backtrack.  This has different characteristics to the normal algo-
+       rithm, and is not compatible with Perl. Some of the features  of  PCRE2
+       patterns  are  not  supported.  Nevertheless, there are times when this
+       kind of matching can be useful. For a discussion of  the  two  matching
        algorithms, and a list of features that pcre2_dfa_match() does not sup-
        port, see the pcre2matching documentation.
 
-       The  arguments  for  the pcre2_dfa_match() function are the same as for
+       The arguments for the pcre2_dfa_match() function are the  same  as  for
        pcre2_match(), plus two extras. The ovector within the match data block
        is used in a different way, and this is described below. The other com-
-       mon arguments are used in the same way as for pcre2_match(),  so  their
+       mon  arguments  are used in the same way as for pcre2_match(), so their
        description is not repeated here.
 
-       The  two  additional  arguments provide workspace for the function. The
-       workspace vector should contain at least 20 elements. It  is  used  for
+       The two additional arguments provide workspace for  the  function.  The
+       workspace  vector  should  contain at least 20 elements. It is used for
        keeping  track  of  multiple  paths  through  the  pattern  tree.  More
-       workspace is needed for patterns and subjects where there are a lot  of
+       workspace  is needed for patterns and subjects where there are a lot of
        potential matches.
 
        Here is an example of a simple call to pcre2_dfa_match():
@@ -3035,45 +3089,45 @@ MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
 
    Option bits for pcre_dfa_match()
 
-       The  unused  bits of the options argument for pcre2_dfa_match() must be
-       zero. The only bits that may be set  are  PCRE2_ANCHORED,  PCRE2_ENDAN-
-       CHORED,        PCRE2_NOTBOL,        PCRE2_NOTEOL,       PCRE2_NOTEMPTY,
+       The unused bits of the options argument for pcre2_dfa_match()  must  be
+       zero.  The  only  bits that may be set are PCRE2_ANCHORED, PCRE2_ENDAN-
+       CHORED,       PCRE2_NOTBOL,        PCRE2_NOTEOL,        PCRE2_NOTEMPTY,
        PCRE2_NOTEMPTY_ATSTART,     PCRE2_NO_UTF_CHECK,     PCRE2_PARTIAL_HARD,
-       PCRE2_PARTIAL_SOFT,  PCRE2_DFA_SHORTEST, and PCRE2_DFA_RESTART. All but
-       the last four of these are exactly the same as  for  pcre2_match(),  so
+       PCRE2_PARTIAL_SOFT, PCRE2_DFA_SHORTEST, and PCRE2_DFA_RESTART. All  but
+       the  last  four  of these are exactly the same as for pcre2_match(), so
        their description is not repeated here.
 
          PCRE2_PARTIAL_HARD
          PCRE2_PARTIAL_SOFT
 
-       These  have  the  same general effect as they do for pcre2_match(), but
-       the details are slightly different. When PCRE2_PARTIAL_HARD is set  for
-       pcre2_dfa_match(),  it  returns  PCRE2_ERROR_PARTIAL  if the end of the
+       These have the same general effect as they do  for  pcre2_match(),  but
+       the  details are slightly different. When PCRE2_PARTIAL_HARD is set for
+       pcre2_dfa_match(), it returns PCRE2_ERROR_PARTIAL if  the  end  of  the
        subject is reached and there is still at least one matching possibility
        that requires additional characters. This happens even if some complete
-       matches have already been found. When PCRE2_PARTIAL_SOFT  is  set,  the
-       return  code  PCRE2_ERROR_NOMATCH is converted into PCRE2_ERROR_PARTIAL
-       if the end of the subject is  reached,  there  have  been  no  complete
+       matches  have  already  been found. When PCRE2_PARTIAL_SOFT is set, the
+       return code PCRE2_ERROR_NOMATCH is converted  into  PCRE2_ERROR_PARTIAL
+       if  the  end  of  the  subject  is reached, there have been no complete
        matches, but there is still at least one matching possibility. The por-
-       tion of the string that was inspected when the  longest  partial  match
+       tion  of  the  string that was inspected when the longest partial match
        was found is set as the first matching string in both cases. There is a
-       more detailed discussion of partial and  multi-segment  matching,  with
+       more  detailed  discussion  of partial and multi-segment matching, with
        examples, in the pcre2partial documentation.
 
          PCRE2_DFA_SHORTEST
 
-       Setting  the PCRE2_DFA_SHORTEST option causes the matching algorithm to
+       Setting the PCRE2_DFA_SHORTEST option causes the matching algorithm  to
        stop as soon as it has found one match. Because of the way the alterna-
-       tive  algorithm  works, this is necessarily the shortest possible match
+       tive algorithm works, this is necessarily the shortest  possible  match
        at the first possible matching point in the subject string.
 
          PCRE2_DFA_RESTART
 
-       When pcre2_dfa_match() returns a partial match, it is possible to  call
+       When  pcre2_dfa_match() returns a partial match, it is possible to call
        it again, with additional subject characters, and have it continue with
        the same match. The PCRE2_DFA_RESTART option requests this action; when
-       it  is  set,  the workspace and wscount options must reference the same
-       vector as before because data about the match so far is  left  in  them
+       it is set, the workspace and wscount options must  reference  the  same
+       vector  as  before  because data about the match so far is left in them
        after a partial match. There is more discussion of this facility in the
        pcre2partial documentation.
 
@@ -3081,8 +3135,8 @@ MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
 
        When pcre2_dfa_match() succeeds, it may have matched more than one sub-
        string in the subject. Note, however, that all the matches from one run
-       of the function start at the same point in  the  subject.  The  shorter
-       matches  are all initial substrings of the longer matches. For example,
+       of  the  function  start  at the same point in the subject. The shorter
+       matches are all initial substrings of the longer matches. For  example,
        if the pattern
 
          <.*>
@@ -3097,17 +3151,17 @@ MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
           
          
 
-       On success, the yield of the function is a number  greater  than  zero,
-       which  is  the  number  of  matched substrings. The offsets of the sub-
-       strings are returned in the ovector, and can be extracted by number  in
-       the  same way as for pcre2_match(), but the numbers bear no relation to
-       any capturing groups that may exist in the pattern, because DFA  match-
+       On  success,  the  yield of the function is a number greater than zero,
+       which is the number of matched substrings.  The  offsets  of  the  sub-
+       strings  are returned in the ovector, and can be extracted by number in
+       the same way as for pcre2_match(), but the numbers bear no relation  to
+       any  capturing groups that may exist in the pattern, because DFA match-
        ing does not support group capture.
 
-       Calls  to  the  convenience  functions  that extract substrings by name
-       return the error PCRE2_ERROR_DFA_UFUNC (unsupported function)  if  used
+       Calls to the convenience functions  that  extract  substrings  by  name
+       return  the  error PCRE2_ERROR_DFA_UFUNC (unsupported function) if used
        after a DFA match. The convenience functions that extract substrings by
-       number never return PCRE2_ERROR_NOSUBSTRING, and the meanings  of  some
+       number  never  return PCRE2_ERROR_NOSUBSTRING, and the meanings of some
        other errors are slightly different:
 
          PCRE2_ERROR_UNAVAILABLE
@@ -3117,64 +3171,64 @@ MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
 
          PCRE2_ERROR_UNSET
 
-       There is a slot in the ovector  for  this  substring,  but  there  were
+       There  is  a  slot  in  the  ovector for this substring, but there were
        insufficient matches to fill it.
 
-       The  matched  strings  are  stored  in  the ovector in reverse order of
-       length; that is, the longest matching string is first.  If  there  were
-       too  many matches to fit into the ovector, the yield of the function is
+       The matched strings are stored in  the  ovector  in  reverse  order  of
+       length;  that  is,  the longest matching string is first. If there were
+       too many matches to fit into the ovector, the yield of the function  is
        zero, and the vector is filled with the longest matches.
 
-       NOTE: PCRE2's "auto-possessification" optimization usually  applies  to
-       character  repeats at the end of a pattern (as well as internally). For
-       example, the pattern "a\d+" is compiled as if it were "a\d++". For  DFA
-       matching,  this  means  that  only  one possible match is found. If you
-       really do want multiple matches in such cases, either use  an  ungreedy
-       repeat  auch  as  "a\d+?"  or set the PCRE2_NO_AUTO_POSSESS option when
+       NOTE:  PCRE2's  "auto-possessification" optimization usually applies to
+       character repeats at the end of a pattern (as well as internally).  For
+       example,  the pattern "a\d+" is compiled as if it were "a\d++". For DFA
+       matching, this means that only one possible  match  is  found.  If  you
+       really  do  want multiple matches in such cases, either use an ungreedy
+       repeat auch as "a\d+?" or set  the  PCRE2_NO_AUTO_POSSESS  option  when
        compiling.
 
    Error returns from pcre2_dfa_match()
 
        The pcre2_dfa_match() function returns a negative number when it fails.
-       Many  of  the  errors  are  the same as for pcre2_match(), as described
+       Many of the errors are the same  as  for  pcre2_match(),  as  described
        above.  There are in addition the following errors that are specific to
        pcre2_dfa_match():
 
          PCRE2_ERROR_DFA_UITEM
 
-       This  return  is  given  if pcre2_dfa_match() encounters an item in the
-       pattern that it does not support, for instance, the use of \C in a  UTF
+       This return is given if pcre2_dfa_match() encounters  an  item  in  the
+       pattern  that it does not support, for instance, the use of \C in a UTF
        mode or a back reference.
 
          PCRE2_ERROR_DFA_UCOND
 
-       This  return  is given if pcre2_dfa_match() encounters a condition item
-       that uses a back reference for the condition, or a test  for  recursion
+       This return is given if pcre2_dfa_match() encounters a  condition  item
+       that  uses  a back reference for the condition, or a test for recursion
        in a specific group. These are not supported.
 
          PCRE2_ERROR_DFA_WSSIZE
 
-       This  return  is  given  if  pcre2_dfa_match() runs out of space in the
+       This return is given if pcre2_dfa_match() runs  out  of  space  in  the
        workspace vector.
 
          PCRE2_ERROR_DFA_RECURSE
 
-       When a recursive subpattern is processed, the matching  function  calls
+       When  a  recursive subpattern is processed, the matching function calls
        itself recursively, using private memory for the ovector and workspace.
-       This error is given if the internal ovector is not large  enough.  This
+       This  error  is given if the internal ovector is not large enough. This
        should be extremely rare, as a vector of size 1000 is used.
 
          PCRE2_ERROR_DFA_BADRESTART
 
-       When  pcre2_dfa_match()  is  called  with the PCRE2_DFA_RESTART option,
-       some plausibility checks are made on the  contents  of  the  workspace,
-       which  should  contain data about the previous partial match. If any of
+       When pcre2_dfa_match() is called  with  the  PCRE2_DFA_RESTART  option,
+       some  plausibility  checks  are  made on the contents of the workspace,
+       which should contain data about the previous partial match. If  any  of
        these checks fail, this error is given.
 
 
 SEE ALSO
 
-       pcre2build(3),   pcre2callout(3),    pcre2demo(3),    pcre2matching(3),
+       pcre2build(3),    pcre2callout(3),    pcre2demo(3),   pcre2matching(3),
        pcre2partial(3), pcre2posix(3), pcre2sample(3), pcre2unicode(3).
 
 
@@ -3187,7 +3241,7 @@ AUTHOR
 
 REVISION
 
-       Last updated: 04 April 2017
+       Last updated: 11 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
 ------------------------------------------------------------------------------
  
@@ -3427,64 +3481,85 @@ LIMITING PCRE2 RESOURCE USAGE
        pcre2_dfa_match() matching function, but it does also limit JIT  match-
        ing (though the counting is done differently).
 
-       In some environments it is desirable to limit the depth of nested back-
-       tracking in order to restrict the maximum amount of heap memory that is
-       used.  A  second  limit controls this; it defaults to the value that is
-       set for --with-match-limit. You  can  set  a  lower  default  limit  by
-       adding, for example,
+       The  pcre2_match() function starts out using a 20K vector on the system
+       stack to record  backtracking  points.  The  more  nested  backtracking
+       points there are (that is, the deeper the search tree), the more memory
+       is needed. If the initial vector is not large enough,  heap  memory  is
+       used, up to a certain limit, which is specified in kilobytes. The limit
+       can be changed at run time, as described in the pcre2api documentation.
+       The  default  limit (in effect unlimited) is 20 million. You can change
+       this by a setting such as
+
+         --with-heap-limit=500
+
+       which limits the amount of heap to 500 kilobytes.  This  limit  applies
+       only  to interpretive matching in pcre2_match(). It does not apply when
+       JIT (which has its own memory arrangements) is used, nor does it  apply
+       to pcre2_dfa_match().
+
+       You  can  also explicitly limit the depth of nested backtracking in the
+       pcre2_match() interpreter. This limit defaults to the value that is set
+       for  --with-match-limit.  You  can set a lower default limit by adding,
+       for example,
 
          --with-match-limit_depth=10000
 
-       to  the  configure  command.  This  value can also be overridden at run
-       time.  As well as applying to pcre2_match(), this limit  also  controls
-       the  depth  of recursive function calls in pcre2_dfa_match(). These are
-       used for lookaround assertions, atomic  groups,  and  recursion  within
-       patterns.
+       to the configure command. This value can be  overridden  at  run  time.
+       This  depth  limit  indirectly limits the amount of heap memory that is
+       used, but because the size of each backtracking "frame" depends on  the
+       number  of  capturing parentheses in a pattern, the amount of heap that
+       is used before the limit is reached varies  from  pattern  to  pattern.
+       This  limit  was  more  useful in versions before 10.30, where function
+       recursion was used for backtracking.  However, as well as  applying  to
+       pcre2_match(), this limit also controls the depth of recursive function
+       calls in pcre2_dfa_match(). These are used for  lookaround  assertions,
+       atomic groups, and recursion within patterns.  The limit does not apply
+       to JIT matching.
 
 
 CREATING CHARACTER TABLES AT BUILD TIME
 
        PCRE2 uses fixed tables for processing characters whose code points are
        less than 256. By default, PCRE2 is built with a set of tables that are
-       distributed  in  the file src/pcre2_chartables.c.dist. These tables are
+       distributed in the file src/pcre2_chartables.c.dist. These  tables  are
        for ASCII codes only. If you add
 
          --enable-rebuild-chartables
 
-       to the configure command, the distributed tables are  no  longer  used.
-       Instead,  a  program  called dftables is compiled and run. This outputs
+       to  the  configure  command, the distributed tables are no longer used.
+       Instead, a program called dftables is compiled and  run.  This  outputs
        the source for new set of tables, created in the default locale of your
        C run-time system. This method of replacing the tables does not work if
-       you are cross compiling, because dftables is run on the local host.  If
-       you  need  to  create alternative tables when cross compiling, you will
+       you  are cross compiling, because dftables is run on the local host. If
+       you need to create alternative tables when cross  compiling,  you  will
        have to do so "by hand".
 
 
 USING EBCDIC CODE
 
-       PCRE2 assumes by default that it will run in an environment  where  the
-       character  code is ASCII or Unicode, which is a superset of ASCII. This
+       PCRE2  assumes  by default that it will run in an environment where the
+       character code is ASCII or Unicode, which is a superset of ASCII.  This
        is the case for most computer operating systems. PCRE2 can, however, be
        compiled to run in an 8-bit EBCDIC environment by adding
 
          --enable-ebcdic --disable-unicode
 
        to the configure command. This setting implies --enable-rebuild-charta-
-       bles. You should only use it if you know that  you  are  in  an  EBCDIC
+       bles.  You  should  only  use  it if you know that you are in an EBCDIC
        environment (for example, an IBM mainframe operating system).
 
-       It  is  not possible to support both EBCDIC and UTF-8 codes in the same
-       version of the library. Consequently,  --enable-unicode  and  --enable-
+       It is not possible to support both EBCDIC and UTF-8 codes in  the  same
+       version  of  the  library. Consequently, --enable-unicode and --enable-
        ebcdic are mutually exclusive.
 
        The EBCDIC character that corresponds to an ASCII LF is assumed to have
-       the value 0x15 by default. However, in some EBCDIC  environments,  0x25
+       the  value  0x15 by default. However, in some EBCDIC environments, 0x25
        is used. In such an environment you should use
 
          --enable-ebcdic-nl25
 
        as well as, or instead of, --enable-ebcdic. The EBCDIC character for CR
-       has the same value as in ASCII, namely, 0x0d.  Whichever  of  0x15  and
+       has  the  same  value  as in ASCII, namely, 0x0d. Whichever of 0x15 and
        0x25 is not chosen as LF is made to correspond to the Unicode NEL char-
        acter (which, in Unicode, is 0x85).
 
@@ -3497,34 +3572,34 @@ PCRE2GREP SUPPORT FOR EXTERNAL SCRIPTS
 
        By default, on non-Windows systems, pcre2grep supports the use of call-
        outs with string arguments within the patterns it is matching, in order
-       to run external scripts. For details, see the pcre2grep  documentation.
-       This  support  can be disabled by adding --disable-pcre2grep-callout to
+       to  run external scripts. For details, see the pcre2grep documentation.
+       This support can be disabled by adding  --disable-pcre2grep-callout  to
        the configure command.
 
 
 PCRE2GREP OPTIONS FOR COMPRESSED FILE SUPPORT
 
-       By default, pcre2grep reads all files as plain text. You can  build  it
-       so  that  it recognizes files whose names end in .gz or .bz2, and reads
+       By  default,  pcre2grep reads all files as plain text. You can build it
+       so that it recognizes files whose names end in .gz or .bz2,  and  reads
        them with libz or libbz2, respectively, by adding one or both of
 
          --enable-pcre2grep-libz
          --enable-pcre2grep-libbz2
 
        to the configure command. These options naturally require that the rel-
-       evant  libraries  are installed on your system. Configuration will fail
+       evant libraries are installed on your system. Configuration  will  fail
        if they are not.
 
 
 PCRE2GREP BUFFER SIZE
 
-       pcre2grep uses an internal buffer to hold a "window" on the file it  is
+       pcre2grep  uses an internal buffer to hold a "window" on the file it is
        scanning, in order to be able to output "before" and "after" lines when
-       it finds a match. The starting size of the buffer is  controlled  by  a
-       parameter  whose default value is 20K. The buffer itself is three times
-       this size, but because of the way  it  is  used  for  holding  "before"
-       lines,  the  longest  line  that is guaranteed to be processable is the
-       parameter size. If a longer line is  encountered,  pcre2grep  automati-
+       it  finds  a  match. The starting size of the buffer is controlled by a
+       parameter whose default value is 20K. The buffer itself is three  times
+       this  size,  but  because  of  the  way it is used for holding "before"
+       lines, the longest line that is guaranteed to  be  processable  is  the
+       parameter  size.  If  a longer line is encountered, pcre2grep automati-
        cally expands the buffer, up to a specified maximum size, whose default
        is 1M or the starting size, whichever is the larger. You can change the
        default parameter values by adding, for example,
@@ -3532,8 +3607,8 @@ PCRE2GREP BUFFER SIZE
          --with-pcre2grep-bufsize=51200
          --with-pcre2grep-max-bufsize=2097152
 
-       to  the  configure  command. The caller of pcre2grep can override these
-       values by using --buffer-size  and  --max-buffer-size  on  the  command
+       to the configure command. The caller of pcre2grep  can  override  these
+       values  by  using  --buffer-size  and  --max-buffer-size on the command
        line.
 
 
@@ -3544,26 +3619,26 @@ PCRE2TEST OPTION FOR LIBREADLINE SUPPORT
          --enable-pcre2test-libreadline
          --enable-pcre2test-libedit
 
-       to  the  configure  command,  pcre2test  is linked with the libreadline
+       to the configure command, pcre2test  is  linked  with  the  libreadline
        orlibedit library, respectively, and when its input is from a terminal,
-       it  reads  it using the readline() function. This provides line-editing
-       and history facilities. Note that libreadline is  GPL-licensed,  so  if
-       you  distribute  a binary of pcre2test linked in this way, there may be
+       it reads it using the readline() function. This  provides  line-editing
+       and  history  facilities.  Note that libreadline is GPL-licensed, so if
+       you distribute a binary of pcre2test linked in this way, there  may  be
        licensing issues. These can be avoided by linking instead with libedit,
        which has a BSD licence.
 
-       Setting  --enable-pcre2test-libreadline causes the -lreadline option to
-       be added to the pcre2test build. In many operating environments with  a
-       sytem-installed  readline  library this is sufficient. However, in some
+       Setting --enable-pcre2test-libreadline causes the -lreadline option  to
+       be  added to the pcre2test build. In many operating environments with a
+       sytem-installed readline library this is sufficient. However,  in  some
        environments (e.g. if an unmodified distribution version of readline is
-       in  use),  some  extra configuration may be necessary. The INSTALL file
+       in use), some extra configuration may be necessary.  The  INSTALL  file
        for libreadline says this:
 
          "Readline uses the termcap functions, but does not link with
          the termcap or curses library itself, allowing applications
          which link with readline the to choose an appropriate library."
 
-       If your environment has not been set up so that an appropriate  library
+       If  your environment has not been set up so that an appropriate library
        is automatically included, you may need to add something like
 
          LIBS="-ncurses"
@@ -3577,7 +3652,7 @@ INCLUDING DEBUGGING CODE
 
          --enable-debug
 
-       to  the configure command, additional debugging code is included in the
+       to the configure command, additional debugging code is included in  the
        build. This feature is intended for use by the PCRE2 maintainers.
 
 
@@ -3587,15 +3662,15 @@ DEBUGGING WITH VALGRIND SUPPORT
 
          --enable-valgrind
 
-       to the configure command, PCRE2 will use valgrind annotations  to  mark
-       certain  memory  regions  as  unaddressable.  This  allows it to detect
-       invalid memory accesses, and  is  mostly  useful  for  debugging  PCRE2
+       to  the  configure command, PCRE2 will use valgrind annotations to mark
+       certain memory regions as  unaddressable.  This  allows  it  to  detect
+       invalid  memory  accesses,  and  is  mostly  useful for debugging PCRE2
        itself.
 
 
 CODE COVERAGE REPORTING
 
-       If  your  C  compiler is gcc, you can build a version of PCRE2 that can
+       If your C compiler is gcc, you can build a version of  PCRE2  that  can
        generate a code coverage report for its test suite. To enable this, you
        must install lcov version 1.6 or above. Then specify
 
@@ -3604,20 +3679,20 @@ CODE COVERAGE REPORTING
        to the configure command and build PCRE2 in the usual way.
 
        Note that using ccache (a caching C compiler) is incompatible with code
-       coverage reporting. If you have configured ccache to run  automatically
+       coverage  reporting. If you have configured ccache to run automatically
        on your system, you must set the environment variable
 
          CCACHE_DISABLE=1
 
        before running make to build PCRE2, so that ccache is not used.
 
-       When  --enable-coverage  is  used,  the  following addition targets are
+       When --enable-coverage is used,  the  following  addition  targets  are
        added to the Makefile:
 
          make coverage
 
-       This creates a fresh coverage report for the PCRE2 test  suite.  It  is
-       equivalent  to running "make coverage-reset", "make coverage-baseline",
+       This  creates  a  fresh coverage report for the PCRE2 test suite. It is
+       equivalent to running "make coverage-reset", "make  coverage-baseline",
        "make check", and then "make coverage-report".
 
          make coverage-reset
@@ -3634,56 +3709,56 @@ CODE COVERAGE REPORTING
 
          make coverage-clean-report
 
-       This removes the generated coverage report without cleaning the  cover-
+       This  removes the generated coverage report without cleaning the cover-
        age data itself.
 
          make coverage-clean-data
 
-       This  removes  the captured coverage data without removing the coverage
+       This removes the captured coverage data without removing  the  coverage
        files created at compile time (*.gcno).
 
          make coverage-clean
 
-       This cleans all coverage data including the generated coverage  report.
-       For  more  information about code coverage, see the gcov and lcov docu-
+       This  cleans all coverage data including the generated coverage report.
+       For more information about code coverage, see the gcov and  lcov  docu-
        mentation.
 
 
 SUPPORT FOR FUZZERS
 
-       There is a special option for use by people who  want  to  run  fuzzing
+       There  is  a  special  option for use by people who want to run fuzzing
        tests on PCRE2:
 
          --enable-fuzz-support
 
        At present this applies only to the 8-bit library. If set, it causes an
-       extra library  called  libpcre2-fuzzsupport.a  to  be  built,  but  not
-       installed.  This contains a single function called LLVMFuzzerTestOneIn-
-       put() whose arguments are a pointer to a string and the length  of  the
-       string.  When  called,  this  function tries to compile the string as a
-       pattern, and if that succeeds, to match it.  This is done both with  no
-       options  and  with some random options bits that are generated from the
+       extra  library  called  libpcre2-fuzzsupport.a  to  be  built,  but not
+       installed. This contains a single function called  LLVMFuzzerTestOneIn-
+       put()  whose  arguments are a pointer to a string and the length of the
+       string. When called, this function tries to compile  the  string  as  a
+       pattern,  and if that succeeds, to match it.  This is done both with no
+       options and with some random options bits that are generated  from  the
        string.
 
-       Setting --enable-fuzz-support also causes  a  binary  called  pcre2fuz-
-       zcheck  to be created. This is normally run under valgrind or used when
+       Setting  --enable-fuzz-support  also  causes  a binary called pcre2fuz-
+       zcheck to be created. This is normally run under valgrind or used  when
        PCRE2 is compiled with address sanitizing enabled. It calls the fuzzing
-       function  and  outputs information about it is doing. The input strings
-       are specified by arguments: if an argument starts with "=" the rest  of
-       it  is  a  literal  input string. Otherwise, it is assumed to be a file
+       function and outputs information about it is doing. The  input  strings
+       are  specified by arguments: if an argument starts with "=" the rest of
+       it is a literal input string. Otherwise, it is assumed  to  be  a  file
        name, and the contents of the file are the test string.
 
 
 OBSOLETE OPTION
 
-       In versions of PCRE2 prior to 10.30, there were two  ways  of  handling
-       backtracking  in the pcre2_match() function. The default was to use the
+       In  versions  of  PCRE2 prior to 10.30, there were two ways of handling
+       backtracking in the pcre2_match() function. The default was to use  the
        system stack, but if
 
          --disable-stack-for-recursion
 
-       was set, memory on the heap was used. From release 10.30  onwards  this
-       has  changed  (the  stack  is  no longer used) and this option now does
+       was  set,  memory on the heap was used. From release 10.30 onwards this
+       has changed (the stack is no longer used)  and  this  option  now  does
        nothing except give a warning.
 
 
@@ -3701,7 +3776,7 @@ AUTHOR
 
 REVISION
 
-       Last updated: 31 March 2017
+       Last updated: 10 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
 ------------------------------------------------------------------------------
  
@@ -5522,41 +5597,44 @@ SPECIAL START-OF-PATTERN ITEMS
        attempt by the application to apply the  JIT  optimization  by  calling
        pcre2_jit_compile() is ignored.
 
-   Setting match and backtracking depth limits
+   Setting match resource limits
 
        The pcre2_match() function contains a counter that is incremented every
        time it goes round its main loop. The caller of pcre2_match() can set a
        limit  on  this counter, which therefore limits the amount of computing
        resource used for a match. The maximum depth of nested backtracking can
-       also  be  limited, and this restricts the amount of heap memory that is
-       used.
+       also  be  limited;  this indirectly restricts the amount of heap memory
+       that is used, but there is also an explicit memory limit  that  can  be
+       set.
 
-       These facilities are provided to catch runaway matches  that  are  pro-
+       These  facilities  are  provided to catch runaway matches that are pro-
        voked by patterns with huge matching trees (a typical example is a pat-
-       tern with nested unlimited repeats applied to a long string  that  does
+       tern  with  nested unlimited repeats applied to a long string that does
        not match). When one of these limits is reached, pcre2_match() gives an
-       error return. The limits can also be set by items at the start  of  the
+       error  return.  The limits can also be set by items at the start of the
        pattern of the form
 
+         (*LIMIT_HEAP=d)
          (*LIMIT_MATCH=d)
          (*LIMIT_DEPTH=d)
 
        where d is any number of decimal digits. However, the value of the set-
-       ting must be less than the value set (or defaulted) by  the  caller  of
-       pcre2_match()  for  it  to have any effect. In other words, the pattern
-       writer can lower the limits set by the programmer, but not raise  them.
-       If  there  is  more  than one setting of one of these limits, the lower
+       ting  must  be  less than the value set (or defaulted) by the caller of
+       pcre2_match() for it to have any effect. In other  words,  the  pattern
+       writer  can lower the limits set by the programmer, but not raise them.
+       If there is more than one setting of one of  these  limits,  the  lower
        value is used.
 
-       Prior to release 10.30, LIMIT_DEPTH was  called  LIMIT_RECURSION.  This
+       Prior  to  release  10.30, LIMIT_DEPTH was called LIMIT_RECURSION. This
        name is still recognized for backwards compatibility.
 
-       The  match  limit  is  used  (but in a different way) when JIT is being
-       used, but it is not  relevant,  and  is  ignored,  when  matching  with
-       pcre2_dfa_match().  However, the depth limit is relevant for DFA match-
-       ing, which uses function recursion for recursions within  the  pattern.
-       In  this case, the depth limit controls the amount of system stack that
-       is used.
+       The heap limit applies only when the pcre2_match() interpreter is  used
+       for matching. It does not apply to JIT or DFA matching. The match limit
+       is used (but in a different way) when JIT is being used, but it is  not
+       relevant,  and  is  ignored,  when matching with pcre2_dfa_match(). The
+       depth limit is ignored by JIT but is relevant for DFA  matching,  which
+       uses  function  recursion  for  recursions  within the pattern. In this
+       case, the depth limit controls the amount of system stack that is used.
 
    Newline conventions
 
@@ -8480,7 +8558,7 @@ AUTHOR
 
 REVISION
 
-       Last updated: 03 April 2017
+       Last updated: 11 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
 ------------------------------------------------------------------------------
  
@@ -8557,10 +8635,12 @@ STACK AND HEAP USAGE AT RUN TIME
        sive  function  calls  could  use a great deal of stack, and this could
        cause problems, but this usage has been eliminated. Backtracking  posi-
        tions  are now explicitly remembered in memory frames controlled by the
-       code. An initial 10K vector of frames is allocated on the system  stack
-       (enough  for about 50 frames for small patterns), but if this is insuf-
-       ficient, heap memory is used. Rewriting patterns to be  time-efficient,
-       as described below, may also reduce the memory requirements.
+       code. An initial 20K vector of frames is allocated on the system  stack
+       (enough for about 100 frames for small patterns), but if this is insuf-
+       ficient, heap memory is used. The amount of heap memory can be limited;
+       if  the  limit  is  set to zero, only the initial stack vector is used.
+       Rewriting patterns to be time-efficient, as described below,  may  also
+       reduce the memory requirements.
 
        In  contrast  to  pcre2_match(),  pcre2_dfa_match()  does use recursive
        function calls, but  only  for  processing  atomic  groups,  lookaround
@@ -8706,7 +8786,7 @@ AUTHOR
 
 REVISION
 
-       Last updated: 31 March 2017
+       Last updated: 08 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
 ------------------------------------------------------------------------------
  
diff --git a/doc/pcre2_config.3 b/doc/pcre2_config.3
index 86be29b..40a310e 100644
--- a/doc/pcre2_config.3
+++ b/doc/pcre2_config.3
@@ -1,4 +1,4 @@
-.TH PCRE2_CONFIG 3 "24 March 2017" "PCRE2 10.30"
+.TH PCRE2_CONFIG 3 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .SH SYNOPSIS
@@ -31,6 +31,7 @@ point to a uint32_t integer variable. The available codes are:
   PCRE2_CONFIG_BSR             Indicates what \eR matches by default:
                                  PCRE2_BSR_UNICODE
                                  PCRE2_BSR_ANYCRLF
+  PCRE2_CONFIG_HEAPLIMIT       Default heap memory limit                                
   PCRE2_CONFIG_DEPTHLIMIT      Default backtracking depth limit
 .\" JOIN
   PCRE2_CONFIG_JIT             Availability of just-in-time compiler
diff --git a/doc/pcre2_match.3 b/doc/pcre2_match.3
index dc962b7..feaa470 100644
--- a/doc/pcre2_match.3
+++ b/doc/pcre2_match.3
@@ -1,4 +1,4 @@
-.TH PCRE2_MATCH 3 "04 April 2017" "PCRE2 10.30"
+.TH PCRE2_MATCH 3 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .SH SYNOPSIS
@@ -32,6 +32,7 @@ A match context is needed only if you want to:
 .sp
   Set up a callout function
   Set a matching offset limit 
+  Change the heap memory limit 
   Change the backtracking match limit 
   Change the backtracking depth limit
   Set custom memory management specifically for the match
diff --git a/doc/pcre2_pattern_info.3 b/doc/pcre2_pattern_info.3
index 8e7e2f7..13fd163 100644
--- a/doc/pcre2_pattern_info.3
+++ b/doc/pcre2_pattern_info.3
@@ -1,4 +1,4 @@
-.TH PCRE2_PATTERN_INFO 3 "25 March 2017" "PCRE2 10.30"
+.TH PCRE2_PATTERN_INFO 3 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .SH SYNOPSIS
@@ -43,6 +43,9 @@ request are as follows:
 .\" JOIN
   PCRE2_INFO_HASCRORLF       Return 1 if explicit CR or LF matches
                                exist in the pattern
+.\" JOIN
+  PCRE2_INFO_HEAPLIMIT       Heap memory limit if set,
+                               otherwise PCRE2_ERROR_UNSET
   PCRE2_INFO_JCHANGED        Return 1 if (?J) or (?-J) was used
   PCRE2_INFO_JITSIZE         Size of JIT compiled code, or 0
   PCRE2_INFO_LASTCODETYPE    Type of must-be-present information
diff --git a/doc/pcre2_set_heap_limit.3 b/doc/pcre2_set_heap_limit.3
new file mode 100644
index 0000000..a99b4ab
--- /dev/null
+++ b/doc/pcre2_set_heap_limit.3
@@ -0,0 +1,28 @@
+.TH PCRE2_SET_DEPTH_LIMIT 3 "11 April 2017" "PCRE2 10.30"
+.SH NAME
+PCRE2 - Perl-compatible regular expressions (revised API)
+.SH SYNOPSIS
+.rs
+.sp
+.B #include 
+.PP
+.nf
+.B int pcre2_set_heap_limit(pcre2_match_context *\fImcontext\fP,
+.B "  uint32_t \fIvalue\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function sets the backtracking heap limit field in a match context. The
+result is always zero.
+.P
+There is a complete description of the PCRE2 native API in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+page and a description of the POSIX API in the
+.\" HREF
+\fBpcre2posix\fP
+.\"
+page.
diff --git a/doc/pcre2api.3 b/doc/pcre2api.3
index c34ff3c..feb054f 100644
--- a/doc/pcre2api.3
+++ b/doc/pcre2api.3
@@ -1,4 +1,4 @@
-.TH PCRE2API 3 "04 April 2017" "PCRE2 10.30"
+.TH PCRE2API 3 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .sp
@@ -123,6 +123,9 @@ document for an overview of all the PCRE2 documentation.
 .B int pcre2_set_offset_limit(pcre2_match_context *\fImcontext\fP,
 .B "  PCRE2_SIZE \fIvalue\fP);"
 .sp
+.B int pcre2_set_heap_limit(pcre2_match_context *\fImcontext\fP,
+.B "  uint32_t \fIvalue\fP);"
+.sp
 .B int pcre2_set_match_limit(pcre2_match_context *\fImcontext\fP,
 .B "  uint32_t \fIvalue\fP);"
 .sp
@@ -753,6 +756,7 @@ A match context is required if you want to:
 .sp
   Set up a callout function
   Set an offset limit for matching an unanchored pattern
+  Change the limit on the amount of heap used when matching 
   Change the backtracking match limit
   Change the backtracking depth limit
   Set custom memory management specifically for the match
@@ -816,14 +820,49 @@ limit, a match must occur in the first line and also within the offset limit.
 In other words, whichever limit comes first is used.
 .sp
 .nf
+.B int pcre2_set_heap_limit(pcre2_match_context *\fImcontext\fP,
+.B "  uint32_t \fIvalue\fP);"
+.fi
+.sp
+The \fIheap_limit\fP parameter specifies, in units of kilobytes, the maximum 
+amount of heap memory that \fBpcre2_match()\fP may use to hold backtracking
+information when running an interpretive match. This limit does not apply to
+matching with the JIT optimization, which has its own memory control
+arrangements (see the
+.\" HREF
+\fBpcre2jit\fP
+.\"
+documentation for more details), nor does it apply to \fBpcre2_dfa_match()\fP.
+If the limit is reached, the negative error code PCRE2_ERROR_HEAPLIMIT is 
+returned. The default limit is set when PCRE2 is built; the default default is 
+very large and is essentially "unlimited".
+.P
+A value for the heap limit may also be supplied by an item at the start of a
+pattern of the form
+.sp
+  (*LIMIT_HEAP=ddd)
+.sp
+where ddd is a decimal number. However, such a setting is ignored unless ddd is
+less than the limit set by the caller of \fBpcre2_match()\fP or, if no such
+limit is set, less than the default.
+.P
+The \fBpcre2_match()\fP function starts out using a 20K vector on the system
+stack for recording backtracking points. The more nested backtracking points
+there are (that is, the deeper the search tree), the more memory is needed. 
+Heap memory is used only if the initial vector is too small. If the heap limit 
+is set to a value less than 21 (in particular, zero) no heap memory will be 
+used. In this case, only patterns that do not have a lot of nested backtracking 
+can be successfully processed. 
+.sp
+.nf
 .B int pcre2_set_match_limit(pcre2_match_context *\fImcontext\fP,
 .B "  uint32_t \fIvalue\fP);"
 .fi
 .sp
 The \fImatch_limit\fP parameter provides a means of preventing PCRE2 from using
-up too many resources when processing patterns that are not going to match, but
-which have a very large number of possibilities in their search trees. The
-classic example is a pattern that uses nested unlimited repeats.
+up too many computing resources when processing patterns that are not going to
+match, but which have a very large number of possibilities in their search
+trees. The classic example is a pattern that uses nested unlimited repeats.
 .P
 There is an internal counter in \fBpcre2_match()\fP that is incremented each
 time round its main matching loop. If this value reaches the match limit,
@@ -859,15 +898,19 @@ limit is set, less than the default.
 This parameter limits the depth of nested backtracking in \fBpcre2_match()\fP.
 Each time a nested backtracking point is passed, a new memory "frame" is used 
 to remember the state of matching at that point. Thus, this parameter
-indirectly limits the amount of memory that is used in a match.
+indirectly limits the amount of memory that is used in a match. However,
+because the size of each memory "frame" depends on the number of capturing
+parentheses, the actual memory limit varies from pattern to pattern. This limit
+was more useful in versions before 10.30, where function recursion was used for
+backtracking.
 .P
-This limit is not relevant, and is ignored, when matching is done using JIT
-compiled code. However, it is supported by \fBpcre2_dfa_match()\fP, which uses
-it to limit the depth of internal recursive function calls that implement
-lookaround assertions and pattern recursions. This is, therefore, an indirect
-limit on the amount of system stack that is used. A recursive pattern such as
-/(.)(?1)/, when matched to a very long string using \fBpcre2_dfa_match()\fP,
-can use a great deal of stack.
+The depth limit is not relevant, and is ignored, when matching is done using
+JIT compiled code. However, it is supported by \fBpcre2_dfa_match()\fP, which
+uses it to limit the depth of internal recursive function calls that implement
+atomic groups, lookaround assertions, and pattern recursions. This is,
+therefore, an indirect limit on the amount of system stack that is used. A
+recursive pattern such as /(.)(?1)/, when matched to a very long string using
+\fBpcre2_dfa_match()\fP, can use a great deal of stack.
 .P
 The default value for the depth limit can be set when PCRE2 is built; the
 default default is the same value as the default for the match limit. If the
@@ -921,6 +964,12 @@ The output is a uint32_t integer that gives the default limit for the depth of
 nested backtracking in \fBpcre2_match()\fP or the depth of nested recursions
 and lookarounds in \fBpcre2_dfa_match()\fP. Further details are given with
 \fBpcre2_set_depth_limit()\fP above.
+.sp
+  PCRE2_CONFIG_HEAPLIMIT
+.sp
+The output is a uint32_t integer that gives, in kilobytes, the default limit
+for the amount of heap memory used by \fBpcre2_match()\fP. Further details are
+given with \fBpcre2_set_heap_limit()\fP above.
 .sp
   PCRE2_CONFIG_JIT
 .sp
@@ -1784,6 +1833,13 @@ Return 1 if the pattern contains any explicit matches for CR or LF characters,
 otherwise 0. The third argument should point to an \fBuint32_t\fP variable. An
 explicit match is either a literal CR or LF character, or \er or \en or one of
 the equivalent hexadecimal or octal escape sequences.
+.sp
+  PCRE2_INFO_HEAPLIMIT
+.sp
+If the pattern set a heap memory limit by including an item of the form
+(*LIMIT_HEAP=nnnn) at the start, the value is returned. The third argument
+should point to an unsigned 32-bit integer. If no such value has been set, the
+call to \fBpcre2_pattern_info()\fP returns the error PCRE2_ERROR_UNSET.
 .sp
   PCRE2_INFO_JCHANGED
 .sp
@@ -2603,7 +2659,8 @@ The backtracking match limit was reached.
 .sp
 If a pattern contains many nested backtracking points, heap memory is used to 
 remember them. This error is given when the memory allocation function (default 
-or custom) fails.
+or custom) fails. Note that a different error, PCRE2_ERROR_HEAPLIMIT, is given 
+if the amount of memory needed exceeds the heap limit.
 .sp
   PCRE2_ERROR_NULL
 .sp
@@ -3322,6 +3379,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 04 April 2017
+Last updated: 11 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2build.3 b/doc/pcre2build.3
index dc0e928..7537cbb 100644
--- a/doc/pcre2build.3
+++ b/doc/pcre2build.3
@@ -1,4 +1,4 @@
-.TH PCRE2BUILD 3 "31 March 2017" "PCRE2 10.30"
+.TH PCRE2BUILD 3 "10 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .
@@ -260,17 +260,42 @@ to the \fBconfigure\fP command. This setting has no effect on the
 \fBpcre2_dfa_match()\fP matching function, but it does also limit JIT matching 
 (though the counting is done differently).
 .P
-In some environments it is desirable to limit the depth of nested backtracking
-in order to restrict the maximum amount of heap memory that is used. A second
-limit controls this; it defaults to the value that is set for
---with-match-limit. You can set a lower default limit by adding, for example,
+The \fBpcre2_match()\fP function starts out using a 20K vector on the system
+stack to record backtracking points. The more nested backtracking points there
+are (that is, the deeper the search tree), the more memory is needed. If the
+initial vector is not large enough, heap memory is used, up to a certain limit,
+which is specified in kilobytes. The limit can be changed at run time, as
+described in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation. The default limit (in effect unlimited) is 20 million. You can
+change this by a setting such as
+.sp
+  --with-heap-limit=500
+.sp   
+which limits the amount of heap to 500 kilobytes. This limit applies only to
+interpretive matching in pcre2_match(). It does not apply when JIT (which has
+its own memory arrangements) is used, nor does it apply to
+\fBpcre2_dfa_match()\fP.
+.P
+You can also explicitly limit the depth of nested backtracking in the
+\fBpcre2_match()\fP interpreter. This limit defaults to the value that is set
+for --with-match-limit. You can set a lower default limit by adding, for
+example,
 .sp
   --with-match-limit_depth=10000
 .sp
-to the \fBconfigure\fP command. This value can also be overridden at run time.
-As well as applying to \fBpcre2_match()\fP, this limit also controls the depth 
-of recursive function calls in \fBpcre2_dfa_match()\fP. These are used for 
-lookaround assertions, atomic groups, and recursion within patterns.
+to the \fBconfigure\fP command. This value can be overridden at run time. This
+depth limit indirectly limits the amount of heap memory that is used, but
+because the size of each backtracking "frame" depends on the number of
+capturing parentheses in a pattern, the amount of heap that is used before the
+limit is reached varies from pattern to pattern. This limit was more useful in
+versions before 10.30, where function recursion was used for backtracking.
+However, as well as applying to \fBpcre2_match()\fP, this limit also controls
+the depth of recursive function calls in \fBpcre2_dfa_match()\fP. These are
+used for lookaround assertions, atomic groups, and recursion within patterns.
+The limit does not apply to JIT matching.
 .
 .
 .SH "CREATING CHARACTER TABLES AT BUILD TIME"
@@ -547,6 +572,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 31 March 2017
+Last updated: 10 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2grep.1 b/doc/pcre2grep.1
index b450375..f5fd37f 100644
--- a/doc/pcre2grep.1
+++ b/doc/pcre2grep.1
@@ -1,4 +1,4 @@
-.TH PCRE2GREP 1 "06 April 2017" "PCRE2 10.30"
+.TH PCRE2GREP 1 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 pcre2grep - a grep with Perl-compatible regular expressions.
 .SH SYNOPSIS
@@ -347,6 +347,9 @@ file names are shown when multiple files are searched. For matching lines, the
 file name is followed by a colon; for context lines, a hyphen separator is used.
 If a line number is also being output, it follows the file name.
 .TP
+\fB--heap-limit\fP=\fInumber\fP
+See \fB--match-limit\fP below.
+.TP
 \fB--help\fP
 Output a help message, giving brief details of the command options and file
 type support, and then exit. Anything else on the command line is
@@ -436,7 +439,7 @@ used. There is no short form for this option.
 \fB--match-limit\fP=\fInumber\fP
 Processing some regular expression patterns may take a very long time to search
 for all possible matching strings. Others may require a very large amount of
-memory. There are two options that set resource limits for matching.
+memory. There are three options that set resource limits for matching.
 .sp
 The \fB--match-limit\fP option provides a means of limiting computing resource
 usage when processing patterns that are not going to match, but which have a
@@ -445,12 +448,22 @@ is a pattern that uses nested unlimited repeats. Internally, PCRE2 has a
 counter that is incremented each time around its main processing loop. If the 
 value set by \fB--match-limit\fP is reached, an error occurs.
 .sp
+The \fB--heap-limit\fP option specifies, as a number of kilobytes, the amount
+of heap memory that may be used for matching. Heap memory is needed only if
+matching the pattern requires a significant number of nested backtracking
+points to be remembered. This parameter can be set to zero to forbid the use of 
+heap memory altogether.
+.sp
 The \fB--depth-limit\fP option limits the depth of nested backtracking points,
-which in turn limits the amount of memory that is used. This limit is of use
-only if it is set smaller than \fB--match-limit\fP.
+which indirectly limits the amount of memory that is used. The amount of memory 
+needed for each backtracking point depends on the number of capturing
+parentheses in the pattern, so the amount of memory that is used before this
+limit acts varies from pattern to pattern. This limit is of use only if it is
+set smaller than \fB--match-limit\fP.
 .sp
 There are no short forms for these options. The default settings are specified
-when the PCRE2 library is compiled, with the default default being 10 million.
+when the PCRE2 library is compiled, with the default defaults being very large 
+and so effectively unlimited.
 .TP
 \fB--max-buffer-size=\fInumber\fP
 This limits the expansion of the processing buffer, whose initial size can be
@@ -670,11 +683,12 @@ Many of the short and long forms of \fBpcre2grep\fP's options are the same
 as in the GNU \fBgrep\fP program. Any long option of the form
 \fB--xxx-regexp\fP (GNU terminology) is also available as \fB--xxx-regex\fP
 (PCRE2 terminology). However, the \fB--depth-limit\fP, \fB--file-list\fP,
-\fB--file-offsets\fP, \fB--include-dir\fP, \fB--line-offsets\fP,
-\fB--locale\fP, \fB--match-limit\fP, \fB-M\fP, \fB--multiline\fP, \fB-N\fP,
-\fB--newline\fP, \fB--om-separator\fP, \fB--output\fP, \fB-u\fP, and
-\fB--utf-8\fP options are specific to \fBpcre2grep\fP, as is the use of the
-\fB--only-matching\fP option with a capturing parentheses number.
+\fB--file-offsets\fP, \fB--heap-limit\fP, \fB--include-dir\fP,
+\fB--line-offsets\fP, \fB--locale\fP, \fB--match-limit\fP, \fB-M\fP,
+\fB--multiline\fP, \fB-N\fP, \fB--newline\fP, \fB--om-separator\fP,
+\fB--output\fP, \fB-u\fP, and \fB--utf-8\fP options are specific to
+\fBpcre2grep\fP, as is the use of the \fB--only-matching\fP option with a
+capturing parentheses number.
 .P
 Although most of the common options work the same way, a few are different in
 \fBpcre2grep\fP. For example, the \fB--include\fP option's argument is a glob
@@ -799,9 +813,9 @@ message and the line that caused the problem to the standard error stream. If
 there are more than 20 such errors, \fBpcre2grep\fP gives up.
 .P
 The \fB--match-limit\fP option of \fBpcre2grep\fP can be used to set the
-overall resource limit; there is a second option called \fB--depth-limit\fP
-that sets a limit on the amount of memory that is used (see the discussion of
-these options above).
+overall resource limit. There are also other limits that affect the amount of 
+memory used during matching; see the discussion of \fB--heap-limit\fP and 
+\fB--depth-limit\fP above.
 .
 .
 .SH DIAGNOSTICS
@@ -834,6 +848,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 06 April 2017
+Last updated: 11 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2grep.txt b/doc/pcre2grep.txt
index 31319b9..b957e24 100644
--- a/doc/pcre2grep.txt
+++ b/doc/pcre2grep.txt
@@ -383,6 +383,9 @@ OPTIONS
                  colon;  for  context lines, a hyphen separator is used.  If a
                  line number is also being output, it follows the file name.
 
+       --heap-limit=number
+                 See --match-limit below.
+
        --help    Output a help message, giving brief details  of  the  command
                  options  and  file type support, and then exit. Anything else
                  on the command line is ignored.
@@ -482,7 +485,7 @@ OPTIONS
        --match-limit=number
                  Processing some regular expression patterns may take  a  very
                  long time to search for all possible matching strings. Others
-                 may require a very large amount  of  memory.  There  are  two
+                 may require a very large amount of memory.  There  are  three
                  options that set resource limits for matching.
 
                  The --match-limit option provides a means of limiting comput-
@@ -494,237 +497,248 @@ OPTIONS
                  processing  loop.  If  the  value  set  by  --match-limit  is
                  reached, an error occurs.
 
-                 The --depth-limit option limits the  depth  of  nested  back-
-                 tracking  points,  which  in turn limits the amount of memory
-                 that is used. This limit is of use only if it is set  smaller
-                 than --match-limit.
+                 The --heap-limit option specifies, as a number of  kilobytes,
+                 the amount of heap memory that may be used for matching. Heap
+                 memory is needed only if matching the pattern requires a sig-
+                 nificant  number  of  nested backtracking points to be remem-
+                 bered. This parameter can be set to zero to forbid the use of
+                 heap memory altogether.
+
+                 The  --depth-limit  option  limits  the depth of nested back-
+                 tracking points, which indirectly limits the amount of memory
+                 that is used. The amount of memory needed for each backtrack-
+                 ing point depends on the number of capturing  parentheses  in
+                 the pattern, so the amount of memory that is used before this
+                 limit acts varies from pattern to pattern. This limit  is  of
+                 use only if it is set smaller than --match-limit.
 
                  There  are no short forms for these options. The default set-
                  tings are specified when the PCRE2 library is compiled,  with
-                 the default default being 10 million.
+                 the  default  defaults  being  very  large and so effectively
+                 unlimited.
 
        --max-buffer-size=number
-                 This  limits  the  expansion  of the processing buffer, whose
-                 initial size can be set by --buffer-size. The maximum  buffer
-                 size  is  silently  forced to be no smaller than the starting
+                 This limits the expansion of  the  processing  buffer,  whose
+                 initial  size can be set by --buffer-size. The maximum buffer
+                 size is silently forced to be no smaller  than  the  starting
                  buffer size.
 
        -M, --multiline
-                 Allow patterns to match more than one line. When this  option
+                 Allow  patterns to match more than one line. When this option
                  is set, the PCRE2 library is called in "multiline" mode. This
-                 allows a matched string to extend past the end of a line  and
-                 continue  on one or more subsequent lines. Patterns used with
+                 allows  a matched string to extend past the end of a line and
+                 continue on one or more subsequent lines. Patterns used  with
                  -M may usefully contain literal newline characters and inter-
-                 nal  occurrences of ^ and $ characters. The output for a suc-
-                 cessful match may consist of more than one  line.  The  first
-                 line  is  the  line  in which the match started, and the last
-                 line is the line in which the match  ended.  If  the  matched
-                 string  ends  with a newline sequence, the output ends at the
-                 end of that line.  If -v is set,  none  of  the  lines  in  a
-                 multi-line  match  are output. Once a match has been handled,
-                 scanning restarts at the beginning of the line after the  one
+                 nal occurrences of ^ and $ characters. The output for a  suc-
+                 cessful  match  may  consist of more than one line. The first
+                 line is the line in which the match  started,  and  the  last
+                 line  is  the  line  in which the match ended. If the matched
+                 string ends with a newline sequence, the output ends  at  the
+                 end  of  that  line.   If  -v  is set, none of the lines in a
+                 multi-line match are output. Once a match has  been  handled,
+                 scanning  restarts at the beginning of the line after the one
                  in which the match ended.
 
-                 The  newline  sequence  that separates multiple lines must be
-                 matched as part of the pattern.  For  example,  to  find  the
-                 phrase  "regular  expression" in a file where "regular" might
-                 be at the end of a line and "expression" at the start of  the
+                 The newline sequence that separates multiple  lines  must  be
+                 matched  as  part  of  the  pattern. For example, to find the
+                 phrase "regular expression" in a file where  "regular"  might
+                 be  at the end of a line and "expression" at the start of the
                  next line, you could use this command:
 
                    pcre2grep -M 'regular\s+expression' 
 
-                 The  \s  escape  sequence  matches any white space character,
-                 including newlines, and is followed  by  +  so  as  to  match
-                 trailing  white  space  on the first line as well as possibly
+                 The \s escape sequence matches  any  white  space  character,
+                 including  newlines,  and  is  followed  by  + so as to match
+                 trailing white space on the first line as  well  as  possibly
                  handling a two-character newline sequence.
 
-                 There is a limit to the number of lines that can be  matched,
-                 imposed  by  the way that pcre2grep buffers the input file as
-                 it scans it. With a  sufficiently  large  processing  buffer,
+                 There  is a limit to the number of lines that can be matched,
+                 imposed by the way that pcre2grep buffers the input  file  as
+                 it  scans  it.  With  a sufficiently large processing buffer,
                  this should not be a problem, but the -M option does not work
                  when input is read line by line (see --line-buffered.)
 
        -N newline-type, --newline=newline-type
-                 The PCRE2 library supports  five  different  conventions  for
-                 indicating  the  ends of lines. They are the single-character
-                 sequences CR (carriage return) and LF  (linefeed),  the  two-
-                 character  sequence CRLF, an "anycrlf" convention, which rec-
-                 ognizes any of the preceding three types, and an  "any"  con-
+                 The  PCRE2  library  supports  five different conventions for
+                 indicating the ends of lines. They are  the  single-character
+                 sequences  CR  (carriage  return) and LF (linefeed), the two-
+                 character sequence CRLF, an "anycrlf" convention, which  rec-
+                 ognizes  any  of the preceding three types, and an "any" con-
                  vention, in which any Unicode line ending sequence is assumed
-                 to end a line. The Unicode sequences are the three just  men-
-                 tioned,  plus  VT  (vertical  tab,  U+000B),  FF  (form feed,
-                 U+000C),  NEL  (next  line,  U+0085),  LS  (line   separator,
+                 to  end a line. The Unicode sequences are the three just men-
+                 tioned, plus  VT  (vertical  tab,  U+000B),  FF  (form  feed,
+                 U+000C),   NEL  (next  line,  U+0085),  LS  (line  separator,
                  U+2028), and PS (paragraph separator, U+2029).
 
-                 When  the  PCRE2  library  is  built,  a  default line-ending
-                 sequence  is  specified.   This  is  normally  the   standard
+                 When the  PCRE2  library  is  built,  a  default  line-ending
+                 sequence   is  specified.   This  is  normally  the  standard
                  sequence for the operating system. Unless otherwise specified
-                 by this option, pcre2grep uses the  library's  default.   The
+                 by  this  option,  pcre2grep uses the library's default.  The
                  possible values for this option are CR, LF, CRLF, ANYCRLF, or
-                 ANY. This makes it possible to use pcre2grep  to  scan  files
+                 ANY.  This  makes  it possible to use pcre2grep to scan files
                  that have come from other environments without having to mod-
-                 ify their line endings. If the data  that  is  being  scanned
-                 does  not  agree  with  the  convention  set  by this option,
-                 pcre2grep may behave in strange ways. Note that  this  option
-                 does  not apply to files specified by the -f, --exclude-from,
-                 or --include-from options, which  are  expected  to  use  the
+                 ify  their  line  endings.  If the data that is being scanned
+                 does not agree  with  the  convention  set  by  this  option,
+                 pcre2grep  may  behave in strange ways. Note that this option
+                 does not apply to files specified by the -f,  --exclude-from,
+                 or  --include-from  options,  which  are  expected to use the
                  operating system's standard newline sequence.
 
        -n, --line-number
                  Precede each output line by its line number in the file, fol-
-                 lowed by a colon for matching lines or a hyphen  for  context
+                 lowed  by  a colon for matching lines or a hyphen for context
                  lines. If the file name is also being output, it precedes the
-                 line number. When the -M option causes  a  pattern  to  match
-                 more  than  one  line, only the first is preceded by its line
+                 line  number.  When  the  -M option causes a pattern to match
+                 more than one line, only the first is preceded  by  its  line
                  number. This option is forced if --line-offsets is used.
 
-       --no-jit  If the PCRE2 library is built with support  for  just-in-time
+       --no-jit  If  the  PCRE2 library is built with support for just-in-time
                  compiling (which speeds up matching), pcre2grep automatically
                  makes use of this, unless it was explicitly disabled at build
-                 time.  This  option  can be used to disable the use of JIT at
-                 run time. It is provided for testing and working round  prob-
+                 time. This option can be used to disable the use  of  JIT  at
+                 run  time. It is provided for testing and working round prob-
                  lems.  It should never be needed in normal use.
 
        -O text, --output=text
-                 When  there  is a match, instead of outputting the whole line
-                 that matched, output just the  given  text.  This  option  is
-                 mutually  exclusive with --only-matching, --file-offsets, and
+                 When there is a match, instead of outputting the  whole  line
+                 that  matched,  output  just  the  given text. This option is
+                 mutually exclusive with --only-matching, --file-offsets,  and
                  --line-offsets. Escape sequences starting with a dollar char-
-                 acter  may be used to insert the contents of the matched part
+                 acter may be used to insert the contents of the matched  part
                  of the line and/or captured substrings into the text.
 
-                 $ or ${} is replaced  by  the  captured  sub-
-                 string  of  the  given  decimal  number; zero substitutes the
+                 $  or  ${}  is  replaced by the captured sub-
+                 string of the given  decimal  number;  zero  substitutes  the
                  whole match. If the number is greater than the number of cap-
-                 turing  substrings,  or if the capture is unset, the replace-
+                 turing substrings, or if the capture is unset,  the  replace-
                  ment is empty.
 
-                 $a is replaced by bell; $b by backspace; $e by escape; $f  by
-                 form  feed;  $n by newline; $r by carriage return; $t by tab;
+                 $a  is replaced by bell; $b by backspace; $e by escape; $f by
+                 form feed; $n by newline; $r by carriage return; $t  by  tab;
                  $v by vertical tab.
 
-                 $o is replaced by the character  represented  by  the
+                 $o  is  replaced  by the character represented by the
                  given octal number; up to three digits are processed.
 
-                 $x  is  replaced  by the character represented by the
+                 $x is replaced by the character  represented  by  the
                  given hexadecimal number; up to two digits are processed.
 
-                 Any other character is substituted by itself. In  particular,
+                 Any  other character is substituted by itself. In particular,
                  $$ is replaced by a single dollar.
 
        -o, --only-matching
                  Show only the part of the line that matched a pattern instead
-                 of the whole line. In this mode, no context  is  shown.  That
-                 is,  the -A, -B, and -C options are ignored. If there is more
-                 than one match in a line, each of them is  shown  separately,
-                 on  a  separate  line  of  output.  If -o is combined with -v
-                 (invert the sense of the match to find  non-matching  lines),
-                 no  output is generated, but the return code is set appropri-
-                 ately. If the matched portion of the line is  empty,  nothing
-                 is  output  unless  the  file  name  or line number are being
-                 printed, in which case they are shown on an  otherwise  empty
+                 of  the  whole  line. In this mode, no context is shown. That
+                 is, the -A, -B, and -C options are ignored. If there is  more
+                 than  one  match in a line, each of them is shown separately,
+                 on a separate line of output.  If  -o  is  combined  with  -v
+                 (invert  the  sense of the match to find non-matching lines),
+                 no output is generated, but the return code is set  appropri-
+                 ately.  If  the matched portion of the line is empty, nothing
+                 is output unless the file  name  or  line  number  are  being
+                 printed,  in  which case they are shown on an otherwise empty
                  line.  This  option  is  mutually  exclusive  with  --output,
                  --file-offsets and --line-offsets.
 
        -onumber, --only-matching=number
-                 Show only the part of the line  that  matched  the  capturing
+                 Show  only  the  part  of the line that matched the capturing
                  parentheses of the given number. Up to 32 capturing parenthe-
                  ses are supported, and -o0 is equivalent to -o without a num-
-                 ber.  Because  these options can be given without an argument
-                 (see above), if an argument is present, it must be  given  in
-                 the  same  shell item, for example, -o3 or --only-matching=2.
+                 ber. Because these options can be given without  an  argument
+                 (see  above),  if an argument is present, it must be given in
+                 the same shell item, for example, -o3  or  --only-matching=2.
                  The comments given for the non-argument case above also apply
                  to this option. If the specified capturing parentheses do not
-                 exist in the pattern, or were not set in the  match,  nothing
-                 is  output unless the file name or line number are being out-
+                 exist  in  the pattern, or were not set in the match, nothing
+                 is output unless the file name or line number are being  out-
                  put.
 
-                 If this option is given multiple times,  multiple  substrings
-                 are  output  for  each  match,  in  the order the options are
-                 given, and all on one line. For example, -o3 -o1  -o3  causes
-                 the  substrings  matched by capturing parentheses 3 and 1 and
-                 then 3 again to be output. By default, there is no  separator
+                 If  this  option is given multiple times, multiple substrings
+                 are output for each match,  in  the  order  the  options  are
+                 given,  and  all on one line. For example, -o3 -o1 -o3 causes
+                 the substrings matched by capturing parentheses 3 and  1  and
+                 then  3 again to be output. By default, there is no separator
                  (but see the next option).
 
        --om-separator=text
-                 Specify  a  separating string for multiple occurrences of -o.
-                 The default is an empty string. Separating strings are  never
+                 Specify a separating string for multiple occurrences  of  -o.
+                 The  default is an empty string. Separating strings are never
                  coloured.
 
        -q, --quiet
                  Work quietly, that is, display nothing except error messages.
-                 The exit status indicates whether or  not  any  matches  were
+                 The  exit  status  indicates  whether or not any matches were
                  found.
 
        -r, --recursive
-                 If  any given path is a directory, recursively scan the files
-                 it contains, taking note of any --include and --exclude  set-
-                 tings.  By  default, a directory is read as a normal file; in
-                 some operating systems this gives an  immediate  end-of-file.
-                 This  option  is  a  shorthand  for  setting the -d option to
+                 If any given path is a directory, recursively scan the  files
+                 it  contains, taking note of any --include and --exclude set-
+                 tings. By default, a directory is read as a normal  file;  in
+                 some  operating  systems this gives an immediate end-of-file.
+                 This option is a shorthand  for  setting  the  -d  option  to
                  "recurse".
 
        --recursion-limit=number
                  See --match-limit above.
 
        -s, --no-messages
-                 Suppress error  messages  about  non-existent  or  unreadable
-                 files.  Such  files  are quietly skipped. However, the return
+                 Suppress  error  messages  about  non-existent  or unreadable
+                 files. Such files are quietly skipped.  However,  the  return
                  code is still 2, even if matches were found in other files.
 
        -t, --total-count
-                 This option is useful when scanning more than  one  file.  If
-                 used  on its own, -t suppresses all output except for a grand
-                 total number of matching lines (or non-matching lines  if  -v
-                 is  used)  in  all  the files. If -t is used with -c, a grand
-                 total is output except when the previous output is  just  one
-                 line.  In  other words, it is not output when just one file's
-                 count is listed. If file names are being  output,  the  grand
-                 total  is preceded by "TOTAL:". Otherwise, it appears as just
-                 another number. The -t option is ignored when  used  with  -L
-                 (list  files  without matches), because the grand total would
+                 This  option  is  useful when scanning more than one file. If
+                 used on its own, -t suppresses all output except for a  grand
+                 total  number  of matching lines (or non-matching lines if -v
+                 is used) in all the files. If -t is used  with  -c,  a  grand
+                 total  is  output except when the previous output is just one
+                 line. In other words, it is not output when just  one  file's
+                 count  is  listed.  If file names are being output, the grand
+                 total is preceded by "TOTAL:". Otherwise, it appears as  just
+                 another  number.  The  -t option is ignored when used with -L
+                 (list files without matches), because the grand  total  would
                  always be zero.
 
        -u, --utf-8
                  Operate in UTF-8 mode. This option is available only if PCRE2
                  has been compiled with UTF-8 support. All patterns (including
-                 those for any --exclude and --include options) and  all  sub-
-                 ject  lines  that  are scanned must be valid strings of UTF-8
+                 those  for  any --exclude and --include options) and all sub-
+                 ject lines that are scanned must be valid  strings  of  UTF-8
                  characters.
 
        -V, --version
-                 Write the version numbers of pcre2grep and the PCRE2  library
-                 to  the  standard  output and then exit. Anything else on the
+                 Write  the version numbers of pcre2grep and the PCRE2 library
+                 to the standard output and then exit. Anything  else  on  the
                  command line is ignored.
 
        -v, --invert-match
-                 Invert the sense of the match, so that  lines  which  do  not
+                 Invert  the  sense  of  the match, so that lines which do not
                  match any of the patterns are the ones that are found.
 
        -w, --word-regex, --word-regexp
                  Force the patterns to match only whole words. This is equiva-
-                 lent to having \b at the start and end of the  pattern.  This
-                 option  applies only to the patterns that are matched against
-                 the contents of files; it does not apply to  patterns  speci-
+                 lent  to  having \b at the start and end of the pattern. This
+                 option applies only to the patterns that are matched  against
+                 the  contents  of files; it does not apply to patterns speci-
                  fied by any of the --include or --exclude options.
 
        -x, --line-regex, --line-regexp
-                 Force  the  patterns to be anchored (each must start matching
-                 at the beginning of a line) and in addition, require them  to
-                 match  entire  lines. In multiline mode the match may be more
+                 Force the patterns to be anchored (each must  start  matching
+                 at  the beginning of a line) and in addition, require them to
+                 match entire lines. In multiline mode the match may  be  more
                  than one line. This is equivalent to having \A and \Z charac-
-                 ters  at  the  start  and  end  of each alternative top-level
+                 ters at the start  and  end  of  each  alternative  top-level
                  branch in every pattern. This option applies only to the pat-
                  terns that are matched against the contents of files; it does
-                 not apply to patterns specified by any of  the  --include  or
+                 not  apply  to  patterns specified by any of the --include or
                  --exclude options.
 
 
 ENVIRONMENT VARIABLES
 
-       The  environment  variables  LC_ALL  and LC_CTYPE are examined, in that
-       order, for a locale. The first one that is set is  used.  This  can  be
-       overridden  by  the  --locale  option.  If  no locale is set, the PCRE2
+       The environment variables LC_ALL and LC_CTYPE  are  examined,  in  that
+       order,  for  a  locale.  The first one that is set is used. This can be
+       overridden by the --locale option. If  no  locale  is  set,  the  PCRE2
        library's default (usually the "C" locale) is used.
 
 
@@ -732,99 +746,99 @@ NEWLINES
 
        The -N (--newline) option allows pcre2grep to scan files with different
        newline conventions from the default. Any parts of the input files that
-       are written to the standard output are copied identically,  with  what-
-       ever  newline sequences they have in the input. However, the setting of
-       this option does not affect the interpretation of  files  specified  by
+       are  written  to the standard output are copied identically, with what-
+       ever newline sequences they have in the input. However, the setting  of
+       this  option  does  not affect the interpretation of files specified by
        the -f, --exclude-from, or --include-from options, which are assumed to
-       use the operating system's  standard  newline  sequence,  nor  does  it
-       affect  the way in which pcre2grep writes informational messages to the
+       use  the  operating  system's  standard  newline  sequence, nor does it
+       affect the way in which pcre2grep writes informational messages to  the
        standard error and output streams. For these it uses the string "\n" to
-       indicate  newlines,  relying on the C I/O library to convert this to an
+       indicate newlines, relying on the C I/O library to convert this  to  an
        appropriate sequence.
 
 
 OPTIONS COMPATIBILITY
 
        Many of the short and long forms of pcre2grep's options are the same as
-       in  the GNU grep program. Any long option of the form --xxx-regexp (GNU
+       in the GNU grep program. Any long option of the form --xxx-regexp  (GNU
        terminology) is also available as --xxx-regex (PCRE2 terminology). How-
-       ever,  the  --depth-limit,  --file-list, --file-offsets, --include-dir,
-       --line-offsets, --locale, --match-limit, -M,  --multiline,  -N,  --new-
-       line, --om-separator, --output, -u, and --utf-8 options are specific to
-       pcre2grep, as is the use of the --only-matching option with a capturing
-       parentheses number.
+       ever, the  --depth-limit,  --file-list,  --file-offsets,  --heap-limit,
+       --include-dir,  --line-offsets,  --locale,  --match-limit, -M, --multi-
+       line, -N, --newline, --om-separator, --output, -u, and --utf-8  options
+       are  specific to pcre2grep, as is the use of the --only-matching option
+       with a capturing parentheses number.
 
-       Although  most  of the common options work the same way, a few are dif-
-       ferent in pcre2grep. For example, the --include option's argument is  a
-       glob  for GNU grep, but a regular expression for pcre2grep. If both the
-       -c and -l options are given, GNU grep lists only  file  names,  without
+       Although most of the common options work the same way, a few  are  dif-
+       ferent  in pcre2grep. For example, the --include option's argument is a
+       glob for GNU grep, but a regular expression for pcre2grep. If both  the
+       -c  and  -l  options are given, GNU grep lists only file names, without
        counts, but pcre2grep gives the counts as well.
 
 
 OPTIONS WITH DATA
 
        There are four different ways in which an option with data can be spec-
-       ified.  If a short form option is used, the  data  may  follow  immedi-
+       ified.   If  a  short  form option is used, the data may follow immedi-
        ately, or (with one exception) in the next command line item. For exam-
        ple:
 
          -f/some/file
          -f /some/file
 
-       The exception is the -o option, which may appear with or without  data.
-       Because  of this, if data is present, it must follow immediately in the
+       The  exception is the -o option, which may appear with or without data.
+       Because of this, if data is present, it must follow immediately in  the
        same item, for example -o3.
 
-       If a long form option is used, the data may appear in the same  command
-       line  item,  separated by an equals character, or (with two exceptions)
+       If  a long form option is used, the data may appear in the same command
+       line item, separated by an equals character, or (with  two  exceptions)
        it may appear in the next command line item. For example:
 
          --file=/some/file
          --file /some/file
 
-       Note, however, that if you want to supply a file name beginning with  ~
-       as  data  in  a  shell  command,  and have the shell expand ~ to a home
+       Note,  however, that if you want to supply a file name beginning with ~
+       as data in a shell command, and have the  shell  expand  ~  to  a  home
        directory, you must separate the file name from the option, because the
        shell does not treat ~ specially unless it is at the start of an item.
 
-       The  exceptions  to the above are the --colour (or --color) and --only-
-       matching options, for which the data  is  optional.  If  one  of  these
-       options  does  have  data, it must be given in the first form, using an
+       The exceptions to the above are the --colour (or --color)  and  --only-
+       matching  options,  for  which  the  data  is optional. If one of these
+       options does have data, it must be given in the first  form,  using  an
        equals character. Otherwise pcre2grep will assume that it has no data.
 
 
 USING PCRE2'S CALLOUT FACILITY
 
-       pcre2grep has, by default, support for  calling  external  programs  or
-       scripts  or  echoing  specific strings during matching by making use of
-       PCRE2's callout facility. However, this support can  be  disabled  when
-       pcre2grep  is  built.  You can find out whether your binary has support
-       for callouts by running it with the --help option. If  the  support  is
+       pcre2grep  has,  by  default,  support for calling external programs or
+       scripts or echoing specific strings during matching by  making  use  of
+       PCRE2's  callout  facility.  However, this support can be disabled when
+       pcre2grep is built. You can find out whether your  binary  has  support
+       for  callouts  by  running it with the --help option. If the support is
        not enabled, all callouts in patterns are ignored by pcre2grep.
 
-       A  callout  in a PCRE2 pattern is of the form (?C) where the argu-
-       ment is either a number or a quoted string (see the pcre2callout  docu-
-       mentation  for  details).  Numbered  callouts are ignored by pcre2grep;
+       A callout in a PCRE2 pattern is of the form (?C) where  the  argu-
+       ment  is either a number or a quoted string (see the pcre2callout docu-
+       mentation for details). Numbered callouts  are  ignored  by  pcre2grep;
        only callouts with string arguments are useful.
 
    Calling external programs or scripts
 
        If the callout string does not start with a pipe (vertical bar) charac-
-       ter,  it  is parsed into a list of substrings separated by pipe charac-
-       ters. The first substring must be an executable name, with the  follow-
+       ter, it is parsed into a list of substrings separated by  pipe  charac-
+       ters.  The first substring must be an executable name, with the follow-
        ing substrings specifying arguments:
 
          executable_name|arg1|arg2|...
 
-       Any  substring  (including  the  executable  name)  may  contain escape
-       sequences started by a dollar character: $  or  ${}  is
-       replaced  by  the captured substring of the given decimal number, which
-       must be greater than zero. If the number is greater than the number  of
-       capturing  substrings,  or  if the capture is unset, the replacement is
+       Any substring  (including  the  executable  name)  may  contain  escape
+       sequences  started  by  a dollar character: $ or ${} is
+       replaced by the captured substring of the given decimal  number,  which
+       must  be greater than zero. If the number is greater than the number of
+       capturing substrings, or if the capture is unset,  the  replacement  is
        empty.
 
-       Any other character is substituted by  itself.  In  particular,  $$  is
-       replaced  by  a  single  dollar and $| is replaced by a pipe character.
+       Any  other  character  is  substituted  by itself. In particular, $$ is
+       replaced by a single dollar and $| is replaced  by  a  pipe  character.
        Here is an example:
 
          echo -e "abcde\n12345" | pcre2grep \
@@ -840,49 +854,49 @@ USING PCRE2'S CALLOUT FACILITY
 
        The parameters for the execv() system call that is used to run the pro-
        gram or script are zero-terminated strings. This means that binary zero
-       characters in the callout argument will cause premature termination  of
-       their  substrings,  and  therefore  should  not  be present. Any syntax
-       errors in the string (for example, a dollar  not  followed  by  another
-       character)  cause  the  callout  to  be ignored. If running the program
+       characters  in the callout argument will cause premature termination of
+       their substrings, and therefore  should  not  be  present.  Any  syntax
+       errors  in  the  string  (for example, a dollar not followed by another
+       character) cause the callout to be  ignored.  If  running  the  program
        fails for any reason (including the non-existence of the executable), a
-       local  matching failure occurs and the matcher backtracks in the normal
+       local matching failure occurs and the matcher backtracks in the  normal
        way.
 
    Echoing a specific string
 
-       If the callout string starts with a pipe (vertical bar) character,  the
+       If  the callout string starts with a pipe (vertical bar) character, the
        rest of the string is written to the output, having been passed through
-       the same escape processing as text from the --output option. This  pro-
+       the  same escape processing as text from the --output option. This pro-
        vides a simple echoing facility that avoids calling an external program
-       or script. No terminator is added to the string, so if you want a  new-
-       line,  you  must  include  it  explicitly.  Matching continues normally
-       after the string is output. If you want to see only the callout  output
-       but  not  any  output from an actual match, you should end the relevant
+       or  script. No terminator is added to the string, so if you want a new-
+       line, you must include  it  explicitly.   Matching  continues  normally
+       after  the string is output. If you want to see only the callout output
+       but not any output from an actual match, you should  end  the  relevant
        pattern with (*FAIL).
 
 
 MATCHING ERRORS
 
-       It is possible to supply a regular expression that takes  a  very  long
-       time  to  fail  to  match certain lines. Such patterns normally involve
-       nested indefinite repeats, for example: (a+)*\d when matched against  a
-       line  of  a's  with  no  final digit. The PCRE2 matching function has a
-       resource limit that causes it to abort in these circumstances. If  this
-       happens,  pcre2grep  outputs  an error message and the line that caused
-       the problem to the standard error stream. If there  are  more  than  20
+       It  is  possible  to supply a regular expression that takes a very long
+       time to fail to match certain lines.  Such  patterns  normally  involve
+       nested  indefinite repeats, for example: (a+)*\d when matched against a
+       line of a's with no final digit. The  PCRE2  matching  function  has  a
+       resource  limit that causes it to abort in these circumstances. If this
+       happens, pcre2grep outputs an error message and the  line  that  caused
+       the  problem  to  the  standard error stream. If there are more than 20
        such errors, pcre2grep gives up.
 
-       The  --match-limit  option  of pcre2grep can be used to set the overall
-       resource limit; there is a second option called --depth-limit that sets
-       a  limit  on  the  amount of memory that is used (see the discussion of
-       these options above).
+       The --match-limit option of pcre2grep can be used to  set  the  overall
+       resource  limit.  There are also other limits that affect the amount of
+       memory used during matching; see the  discussion  of  --heap-limit  and
+       --depth-limit above.
 
 
 DIAGNOSTICS
 
        Exit status is 0 if any matches were found, 1 if no matches were found,
-       and  2  for syntax errors, overlong lines, non-existent or inaccessible
-       files (even if matches were found in other files) or too many  matching
+       and 2 for syntax errors, overlong lines, non-existent  or  inaccessible
+       files  (even if matches were found in other files) or too many matching
        errors. Using the -s option to suppress error messages about inaccessi-
        ble files does not affect the return code.
 
@@ -901,5 +915,5 @@ AUTHOR
 
 REVISION
 
-       Last updated: 06 April 2017
+       Last updated: 11 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
diff --git a/doc/pcre2pattern.3 b/doc/pcre2pattern.3
index a622cd2..9a3257f 100644
--- a/doc/pcre2pattern.3
+++ b/doc/pcre2pattern.3
@@ -1,4 +1,4 @@
-.TH PCRE2PATTERN 3 "03 April 2017" "PCRE2 10.30"
+.TH PCRE2PATTERN 3 "11 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .SH "PCRE2 REGULAR EXPRESSION DETAILS"
@@ -138,14 +138,15 @@ the application to apply the JIT optimization by calling
 \fBpcre2_jit_compile()\fP is ignored.
 .
 .
-.SS "Setting match and backtracking depth limits"
+.SS "Setting match resource limits"
 .rs
 .sp
 The pcre2_match() function contains a counter that is incremented every time it
 goes round its main loop. The caller of \fBpcre2_match()\fP can set a limit on
 this counter, which therefore limits the amount of computing resource used for
-a match. The maximum depth of nested backtracking can also be limited, and this
-restricts the amount of heap memory that is used.
+a match. The maximum depth of nested backtracking can also be limited; this
+indirectly restricts the amount of heap memory that is used, but there is also 
+an explicit memory limit that can be set.
 .P
 These facilities are provided to catch runaway matches that are provoked by
 patterns with huge matching trees (a typical example is a pattern with nested
@@ -153,6 +154,7 @@ unlimited repeats applied to a long string that does not match). When one of
 these limits is reached, \fBpcre2_match()\fP gives an error return. The limits
 can also be set by items at the start of the pattern of the form
 .sp
+  (*LIMIT_HEAP=d)
   (*LIMIT_MATCH=d)
   (*LIMIT_DEPTH=d)
 .sp
@@ -165,11 +167,13 @@ setting of one of these limits, the lower value is used.
 Prior to release 10.30, LIMIT_DEPTH was called LIMIT_RECURSION. This name is 
 still recognized for backwards compatibility.
 .P
-The match limit is used (but in a different way) when JIT is being used, but it
-is not relevant, and is ignored, when matching with \fBpcre2_dfa_match()\fP.
-However, the depth limit is relevant for DFA matching, which uses function
-recursion for recursions within the pattern. In this case, the depth limit 
-controls the amount of system stack that is used.
+The heap limit applies only when the \fBpcre2_match()\fP interpreter is used
+for matching. It does not apply to JIT or DFA matching. The match limit is used
+(but in a different way) when JIT is being used, but it is not relevant, and is
+ignored, when matching with \fBpcre2_dfa_match()\fP. The depth limit is ignored 
+by JIT but is relevant for DFA matching, which uses function recursion for
+recursions within the pattern. In this case, the depth limit controls the
+amount of system stack that is used.
 .
 .
 .\" HTML 
@@ -3465,6 +3469,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 03 April 2017
+Last updated: 11 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2perform.3 b/doc/pcre2perform.3
index 878a2e5..0781102 100644
--- a/doc/pcre2perform.3
+++ b/doc/pcre2perform.3
@@ -1,4 +1,4 @@
-.TH PCRE2PERFORM 3 "31 March 2017" "PCRE2 10.30"
+.TH PCRE2PERFORM 3 "08 April 2017" "PCRE2 10.30"
 .SH NAME
 PCRE2 - Perl-compatible regular expressions (revised API)
 .SH "PCRE2 PERFORMANCE"
@@ -69,11 +69,12 @@ From release 10.30, the interpretive (non-JIT) version of \fBpcre2_match()\fP
 uses very little system stack at run time. In earlier releases recursive
 function calls could use a great deal of stack, and this could cause problems,
 but this usage has been eliminated. Backtracking positions are now explicitly
-remembered in memory frames controlled by the code. An initial 10K vector of
-frames is allocated on the system stack (enough for about 50 frames for small
-patterns), but if this is insufficient, heap memory is used. Rewriting patterns 
-to be time-efficient, as described below, may also reduce the memory 
-requirements.
+remembered in memory frames controlled by the code. An initial 20K vector of
+frames is allocated on the system stack (enough for about 100 frames for small
+patterns), but if this is insufficient, heap memory is used. The amount of heap
+memory can be limited; if the limit is set to zero, only the initial stack
+vector is used. Rewriting patterns to be time-efficient, as described below,
+may also reduce the memory requirements.
 .P
 In contrast to \fBpcre2_match()\fP, \fBpcre2_dfa_match()\fP does use recursive 
 function calls, but only for processing atomic groups, lookaround assertions,
@@ -231,6 +232,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 31 March 2017
+Last updated: 08 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2test.1 b/doc/pcre2test.1
index 85e82f2..9653241 100644
--- a/doc/pcre2test.1
+++ b/doc/pcre2test.1
@@ -1,4 +1,4 @@
-.TH PCRE2TEST 1 "08 April 2017" "PCRE 10.30"
+.TH PCRE2TEST 1 "11 April 2017" "PCRE 10.30"
 .SH NAME
 pcre2test - a program for testing Perl-compatible regular expressions.
 .SH SYNOPSIS
@@ -1063,6 +1063,7 @@ pattern.
       get=       extract captured substring
       getall                     extract all captured substrings
   /g  global                     global matching
+      heap_limit=             set a limit on heap memory
       jitstack=               set size of JIT stack
       mark                       show mark values
       match_limit=            set a match limit
@@ -1293,11 +1294,11 @@ stack that is larger than the default 32K is necessary only for very
 complicated patterns.
 .
 .
-.SS "Setting match and depth limits"
+.SS "Setting heap, match, and depth limits"
 .rs
 .sp
-The \fBmatch_limit\fP and \fBdepth_limit\fP modifiers set the appropriate
-limits in the match context. These values are ignored when the
+The \fBheap_limit\fP, \fBmatch_limit\fP, and \fBdepth_limit\fP modifiers set
+the appropriate limits in the match context. These values are ignored when the
 \fBfind_limits\fP modifier is specified.
 .
 .
@@ -1306,8 +1307,8 @@ limits in the match context. These values are ignored when the
 .sp
 If the \fBfind_limits\fP modifier is present on a subject line, \fBpcre2test\fP
 calls the relevant matching function several times, setting different values in
-the match context via \fBpcre2_set_match_limit()\fP or
-\fBpcre2_set_depth_limit()\fP until it finds the minimum values for each
+the match context via \fBpcre2_set_heap_limit(), \fBpcre2_set_match_limit()\fP,
+or \fBpcre2_set_depth_limit()\fP until it finds the minimum values for each
 parameter that allows the match to complete without error.
 .P
 If JIT is being used, only the match limit is relevant. If DFA matching is
@@ -1320,9 +1321,9 @@ numbers of matching possibilities, it can become large very quickly with
 increasing length of subject string. 
 .P
 For non-DFA matching, the minimum \fIdepth_limit\fP number is a measure of how
-much memory for recording backtracking points is needed to complete the match
-attempt. In the case of DFA matching, \fIdepth_limit\fP controls the depth of 
-recursive calls of the internal function that is used for handling pattern 
+much nested backtracking happens (that is, how deeply the pattern's tree is
+searched). In the case of DFA matching, \fIdepth_limit\fP controls the depth of
+recursive calls of the internal function that is used for handling pattern
 recursion, lookaround assertions, and atomic groups.
 .
 .
@@ -1782,6 +1783,6 @@ Cambridge, England.
 .rs
 .sp
 .nf
-Last updated: 08 April 2017
+Last updated: 11 April 2017
 Copyright (c) 1997-2017 University of Cambridge.
 .fi
diff --git a/doc/pcre2test.txt b/doc/pcre2test.txt
index 9f27861..c311d83 100644
--- a/doc/pcre2test.txt
+++ b/doc/pcre2test.txt
@@ -185,31 +185,37 @@ COMMAND LINE OPTIONS
                  successful  compilation,  each pattern is passed to the just-
                  in-time compiler, if available.
 
+       -jitverify
+                 Behave as if each pattern line has  the  jitverify  modifier;
+                 after  successful  compilation, each pattern is passed to the
+                 just-in-time compiler, if available, and the use  of  JIT  is
+                 verified.
+
        -pattern modifier-list
                  Behave as if each pattern line contains the given modifiers.
 
        -q        Do not output the version number of pcre2test at the start of
                  execution.
 
-       -S size   On  Unix-like  systems, set the size of the run-time stack to
+       -S size   On Unix-like systems, set the size of the run-time  stack  to
                  size megabytes.
 
        -subject modifier-list
                  Behave as if each subject line contains the given modifiers.
 
-       -t        Run each compile and match many times with a timer, and  out-
-                 put  the  resulting  times  per compile or match. When JIT is
-                 used, separate times are given for the  initial  compile  and
-                 the  JIT  compile.  You  can control the number of iterations
-                 that are used for timing by following -t with a number (as  a
-                 separate  item  on  the command line). For example, "-t 1000"
+       -t        Run  each compile and match many times with a timer, and out-
+                 put the resulting times per compile or  match.  When  JIT  is
+                 used,  separate  times  are given for the initial compile and
+                 the JIT compile. You can control  the  number  of  iterations
+                 that  are used for timing by following -t with a number (as a
+                 separate item on the command line). For  example,  "-t  1000"
                  iterates 1000 times. The default is to iterate 500,000 times.
 
        -tm       This is like -t except that it times only the matching phase,
                  not the compile phase.
 
-       -T -TM    These  behave like -t and -tm, but in addition, at the end of
-                 a run, the total times for all compiles and matches are  out-
+       -T -TM    These behave like -t and -tm, but in addition, at the end  of
+                 a  run, the total times for all compiles and matches are out-
                  put.
 
        -version  Output the PCRE2 version number and then exit.
@@ -217,139 +223,139 @@ COMMAND LINE OPTIONS
 
 DESCRIPTION
 
-       If  pcre2test  is given two filename arguments, it reads from the first
+       If pcre2test is given two filename arguments, it reads from  the  first
        and writes to the second. If the first name is "-", input is taken from
-       the  standard  input. If pcre2test is given only one argument, it reads
+       the standard input. If pcre2test is given only one argument,  it  reads
        from that file and writes to stdout. Otherwise, it reads from stdin and
        writes to stdout.
 
-       When  pcre2test  is  built,  a configuration option can specify that it
-       should be linked with the libreadline or libedit library. When this  is
-       done,  if the input is from a terminal, it is read using the readline()
+       When pcre2test is built, a configuration option  can  specify  that  it
+       should  be linked with the libreadline or libedit library. When this is
+       done, if the input is from a terminal, it is read using the  readline()
        function. This provides line-editing and history facilities. The output
        from the -help option states whether or not readline() will be used.
 
-       The  program  handles  any number of tests, each of which consists of a
-       set of input lines. Each set starts with a regular expression  pattern,
+       The program handles any number of tests, each of which  consists  of  a
+       set  of input lines. Each set starts with a regular expression pattern,
        followed by any number of subject lines to be matched against that pat-
        tern. In between sets of test data, command lines that begin with # may
        appear. This file format, with some restrictions, can also be processed
-       by the perltest.sh script that is distributed with PCRE2 as a means  of
+       by  the perltest.sh script that is distributed with PCRE2 as a means of
        checking that the behaviour of PCRE2 and Perl is the same.
 
        When the input is a terminal, pcre2test prompts for each line of input,
-       using "re>" to prompt for regular expression patterns, and  "data>"  to
-       prompt  for subject lines. Command lines starting with # can be entered
+       using  "re>"  to prompt for regular expression patterns, and "data>" to
+       prompt for subject lines. Command lines starting with # can be  entered
        only in response to the "re>" prompt.
 
-       Each subject line is matched separately and independently. If you  want
+       Each  subject line is matched separately and independently. If you want
        to do multi-line matches, you have to use the \n escape sequence (or \r
-       or \r\n, etc., depending on the newline setting) in a  single  line  of
-       input  to encode the newline sequences. There is no limit on the length
-       of subject lines; the input buffer is automatically extended if  it  is
-       too  small.  There  are  replication features that makes it possible to
-       generate long repetitive pattern or subject  lines  without  having  to
+       or  \r\n,  etc.,  depending on the newline setting) in a single line of
+       input to encode the newline sequences. There is no limit on the  length
+       of  subject  lines; the input buffer is automatically extended if it is
+       too small. There are replication features that  makes  it  possible  to
+       generate  long  repetitive  pattern  or subject lines without having to
        supply them explicitly.
 
-       An  empty  line  or  the end of the file signals the end of the subject
-       lines for a test, at which point a  new  pattern  or  command  line  is
+       An empty line or the end of the file signals the  end  of  the  subject
+       lines  for  a  test,  at  which  point a new pattern or command line is
        expected if there is still input to be read.
 
 
 COMMAND LINES
 
-       In  between sets of test data, a line that begins with # is interpreted
+       In between sets of test data, a line that begins with # is  interpreted
        as a command line. If the first character is followed by white space or
-       an  exclamation  mark,  the  line is treated as a comment, and ignored.
+       an exclamation mark, the line is treated as  a  comment,  and  ignored.
        Otherwise, the following commands are recognized:
 
          #forbid_utf
 
-       Subsequent  patterns  automatically  have   the   PCRE2_NEVER_UTF   and
-       PCRE2_NEVER_UCP  options  set, which locks out the use of the PCRE2_UTF
-       and PCRE2_UCP options and the use of (*UTF) and (*UCP) at the start  of
-       patterns.  This  command  also  forces an error if a subsequent pattern
-       contains any occurrences of \P, \p, or \X, which  are  still  supported
-       when  PCRE2_UTF  is not set, but which require Unicode property support
+       Subsequent   patterns   automatically   have  the  PCRE2_NEVER_UTF  and
+       PCRE2_NEVER_UCP options set, which locks out the use of  the  PCRE2_UTF
+       and  PCRE2_UCP options and the use of (*UTF) and (*UCP) at the start of
+       patterns. This command also forces an error  if  a  subsequent  pattern
+       contains  any  occurrences  of \P, \p, or \X, which are still supported
+       when PCRE2_UTF is not set, but which require Unicode  property  support
        to be included in the library.
 
-       This is a trigger guard that is used in test files to ensure  that  UTF
-       or  Unicode property tests are not accidentally added to files that are
-       used when Unicode support is  not  included  in  the  library.  Setting
-       PCRE2_NEVER_UTF  and  PCRE2_NEVER_UCP as a default can also be obtained
-       by the use of #pattern; the difference is that  #forbid_utf  cannot  be
-       unset,  and the automatic options are not displayed in pattern informa-
+       This  is  a trigger guard that is used in test files to ensure that UTF
+       or Unicode property tests are not accidentally added to files that  are
+       used  when  Unicode  support  is  not  included in the library. Setting
+       PCRE2_NEVER_UTF and PCRE2_NEVER_UCP as a default can also  be  obtained
+       by  the  use  of #pattern; the difference is that #forbid_utf cannot be
+       unset, and the automatic options are not displayed in pattern  informa-
        tion, to avoid cluttering up test output.
 
          #load 
 
        This command is used to load a set of precompiled patterns from a file,
-       as  described  in  the  section entitled "Saving and restoring compiled
+       as described in the section entitled  "Saving  and  restoring  compiled
        patterns" below.
 
          #newline_default []
 
-       When PCRE2 is built, a default newline  convention  can  be  specified.
-       This  determines which characters and/or character pairs are recognized
+       When  PCRE2  is  built,  a default newline convention can be specified.
+       This determines which characters and/or character pairs are  recognized
        as indicating a newline in a pattern or subject string. The default can
-       be  overridden when a pattern is compiled. The standard test files con-
-       tain tests of various newline conventions,  but  the  majority  of  the
-       tests  expect  a  single  linefeed  to  be  recognized  as a newline by
+       be overridden when a pattern is compiled. The standard test files  con-
+       tain  tests  of  various  newline  conventions, but the majority of the
+       tests expect a single  linefeed  to  be  recognized  as  a  newline  by
        default. Without special action the tests would fail when PCRE2 is com-
        piled with either CR or CRLF as the default newline.
 
        The #newline_default command specifies a list of newline types that are
-       acceptable as the default. The types must be one of CR, LF, CRLF,  ANY-
+       acceptable  as the default. The types must be one of CR, LF, CRLF, ANY-
        CRLF, or ANY (in upper or lower case), for example:
 
          #newline_default LF Any anyCRLF
 
        If the default newline is in the list, this command has no effect. Oth-
-       erwise, except when testing the POSIX  API,  a  newline  modifier  that
-       specifies  the  first  newline  convention in the list (LF in the above
-       example) is added to any pattern that does not already have  a  newline
+       erwise,  except  when  testing  the  POSIX API, a newline modifier that
+       specifies the first newline convention in the list  (LF  in  the  above
+       example)  is  added to any pattern that does not already have a newline
        modifier. If the newline list is empty, the feature is turned off. This
        command is present in a number of the standard test input files.
 
-       When the POSIX API is being tested there is  no  way  to  override  the
-       default  newline  convention,  though it is possible to set the newline
-       convention from within the pattern. A warning is  given  if  the  posix
+       When  the  POSIX  API  is  being tested there is no way to override the
+       default newline convention, though it is possible to  set  the  newline
+       convention  from  within  the  pattern. A warning is given if the posix
        modifier is used when #newline_default would set a default for the non-
        POSIX API.
 
          #pattern 
 
-       This command sets a default modifier list that applies  to  all  subse-
+       This  command  sets  a default modifier list that applies to all subse-
        quent patterns. Modifiers on a pattern can change these settings.
 
          #perltest
 
-       The  appearance of this line causes all subsequent modifier settings to
+       The appearance of this line causes all subsequent modifier settings  to
        be checked for compatibility with the perltest.sh script, which is used
-       to  confirm that Perl gives the same results as PCRE2. Also, apart from
-       comment lines, none of the other command lines are  permitted,  because
-       they  and  many  of the modifiers are specific to pcre2test, and should
-       not be used in test files that are also processed by  perltest.sh.  The
-       #perltest  command  helps detect tests that are accidentally put in the
+       to confirm that Perl gives the same results as PCRE2. Also, apart  from
+       comment  lines,  none of the other command lines are permitted, because
+       they and many of the modifiers are specific to  pcre2test,  and  should
+       not  be  used in test files that are also processed by perltest.sh. The
+       #perltest command helps detect tests that are accidentally put  in  the
        wrong file.
 
          #pop []
          #popcopy []
 
-       These commands are used to manipulate the stack of  compiled  patterns,
-       as  described  in  the  section entitled "Saving and restoring compiled
+       These  commands  are used to manipulate the stack of compiled patterns,
+       as described in the section entitled  "Saving  and  restoring  compiled
        patterns" below.
 
          #save 
 
-       This command is used to save a set of compiled patterns to a  file,  as
-       described  in  the section entitled "Saving and restoring compiled pat-
+       This  command  is used to save a set of compiled patterns to a file, as
+       described in the section entitled "Saving and restoring  compiled  pat-
        terns" below.
 
          #subject 
 
-       This command sets a default modifier list that applies  to  all  subse-
-       quent  subject lines. Modifiers on a subject line can change these set-
+       This  command  sets  a default modifier list that applies to all subse-
+       quent subject lines. Modifiers on a subject line can change these  set-
        tings.
 
 
@@ -357,58 +363,58 @@ MODIFIER SYNTAX
 
        Modifier lists are used with both pattern and subject lines. Items in a
        list are separated by commas followed by optional white space. Trailing
-       whitespace in a modifier list is ignored. Some modifiers may  be  given
-       for  both patterns and subject lines, whereas others are valid only for
+       whitespace  in  a modifier list is ignored. Some modifiers may be given
+       for both patterns and subject lines, whereas others are valid only  for
        one  or  the  other.  Each  modifier  has  a  long  name,  for  example
-       "anchored",  and  some of them must be followed by an equals sign and a
-       value, for example, "offset=12". Values cannot  contain  comma  charac-
-       ters,  but may contain spaces. Modifiers that do not take values may be
+       "anchored", and some of them must be followed by an equals sign  and  a
+       value,  for  example,  "offset=12". Values cannot contain comma charac-
+       ters, but may contain spaces. Modifiers that do not take values may  be
        preceded by a minus sign to turn off a previous setting.
 
        A few of the more common modifiers can also be specified as single let-
-       ters,  for  example "i" for "caseless". In documentation, following the
+       ters, for example "i" for "caseless". In documentation,  following  the
        Perl convention, these are written with a slash ("the /i modifier") for
-       clarity.  Abbreviated  modifiers  must all be concatenated in the first
-       item of a modifier list. If the first item is not recognized as a  long
-       modifier  name, it is interpreted as a sequence of these abbreviations.
+       clarity. Abbreviated modifiers must all be concatenated  in  the  first
+       item  of a modifier list. If the first item is not recognized as a long
+       modifier name, it is interpreted as a sequence of these  abbreviations.
        For example:
 
          /abc/ig,newline=cr,jit=3
 
-       This is a pattern line whose modifier list starts with  two  one-letter
-       modifiers  (/i  and  /g).  The lower-case abbreviated modifiers are the
+       This  is  a pattern line whose modifier list starts with two one-letter
+       modifiers (/i and /g). The lower-case  abbreviated  modifiers  are  the
        same as used in Perl.
 
 
 PATTERN SYNTAX
 
-       A pattern line must start with one of the following characters  (common
+       A  pattern line must start with one of the following characters (common
        symbols, excluding pattern meta-characters):
 
          / ! " ' ` - = _ : ; , % & @ ~
 
-       This  is  interpreted  as the pattern's delimiter. A regular expression
-       may be continued over several input lines, in which  case  the  newline
+       This is interpreted as the pattern's delimiter.  A  regular  expression
+       may  be  continued  over several input lines, in which case the newline
        characters are included within it. It is possible to include the delim-
        iter within the pattern by escaping it with a backslash, for example
 
          /abc\/def/
 
-       If you do this, the escape and the delimiter form part of the  pattern,
+       If  you do this, the escape and the delimiter form part of the pattern,
        but since the delimiters are all non-alphanumeric, this does not affect
-       its interpretation. If the terminating delimiter  is  immediately  fol-
+       its  interpretation.  If  the terminating delimiter is immediately fol-
        lowed by a backslash, for example,
 
          /abc/\
 
-       then  a  backslash  is added to the end of the pattern. This is done to
-       provide a way of testing the error condition that arises if  a  pattern
+       then a backslash is added to the end of the pattern. This  is  done  to
+       provide  a  way of testing the error condition that arises if a pattern
        finishes with a backslash, because
 
          /abc\/
 
-       is  interpreted as the first line of a pattern that starts with "abc/",
-       causing pcre2test to read the next line as a continuation of the  regu-
+       is interpreted as the first line of a pattern that starts with  "abc/",
+       causing  pcre2test to read the next line as a continuation of the regu-
        lar expression.
 
        A pattern can be followed by a modifier list (details below).
@@ -416,7 +422,7 @@ PATTERN SYNTAX
 
 SUBJECT LINE SYNTAX
 
-       Before    each   subject   line   is   passed   to   pcre2_match()   or
+       Before   each   subject   line   is   passed   to   pcre2_match()    or
        pcre2_dfa_match(), leading and trailing white space is removed, and the
        line is scanned for backslash escapes. The following provide a means of
        encoding non-printing characters in a visible way:
@@ -436,23 +442,23 @@ SUBJECT LINE SYNTAX
          \x{hh...}  hexadecimal character (any number of hex digits)
 
        The use of \x{hh...} is not dependent on the use of the utf modifier on
-       the  pattern. It is recognized always. There may be any number of hexa-
-       decimal digits inside the braces; invalid  values  provoke  error  mes-
+       the pattern. It is recognized always. There may be any number of  hexa-
+       decimal  digits  inside  the  braces; invalid values provoke error mes-
        sages.
 
-       Note  that  \xhh  specifies one byte rather than one character in UTF-8
-       mode; this makes it possible to construct invalid UTF-8  sequences  for
-       testing  purposes.  On the other hand, \x{hh} is interpreted as a UTF-8
-       character in UTF-8 mode, generating more than one byte if the value  is
-       greater  than  127.   When testing the 8-bit library not in UTF-8 mode,
+       Note that \xhh specifies one byte rather than one  character  in  UTF-8
+       mode;  this  makes it possible to construct invalid UTF-8 sequences for
+       testing purposes. On the other hand, \x{hh} is interpreted as  a  UTF-8
+       character  in UTF-8 mode, generating more than one byte if the value is
+       greater than 127.  When testing the 8-bit library not  in  UTF-8  mode,
        \x{hh} generates one byte for values less than 256, and causes an error
        for greater values.
 
        In UTF-16 mode, all 4-digit \x{hhhh} values are accepted. This makes it
        possible to construct invalid UTF-16 sequences for testing purposes.
 
-       In UTF-32 mode, all 4- to 8-digit \x{...}  values  are  accepted.  This
-       makes  it  possible  to  construct invalid UTF-32 sequences for testing
+       In  UTF-32  mode,  all  4- to 8-digit \x{...} values are accepted. This
+       makes it possible to construct invalid  UTF-32  sequences  for  testing
        purposes.
 
        There is a special backslash sequence that specifies replication of one
@@ -460,45 +466,45 @@ SUBJECT LINE SYNTAX
 
          \[]{}
 
-       This  makes  it possible to test long strings without having to provide
+       This makes it possible to test long strings without having  to  provide
        them as part of the file. For example:
 
          \[abc]{4}
 
-       is converted to "abcabcabcabc". This feature does not support  nesting.
+       is  converted to "abcabcabcabc". This feature does not support nesting.
        To include a closing square bracket in the characters, code it as \x5D.
 
-       A  backslash  followed  by  an equals sign marks the end of the subject
+       A backslash followed by an equals sign marks the  end  of  the  subject
        string and the start of a modifier list. For example:
 
          abc\=notbol,notempty
 
-       If the subject string is empty and \= is followed  by  whitespace,  the
-       line  is  treated  as a comment line, and is not used for matching. For
+       If  the  subject  string is empty and \= is followed by whitespace, the
+       line is treated as a comment line, and is not used  for  matching.  For
        example:
 
          \= This is a comment.
          abc\= This is an invalid modifier list.
 
-       A backslash followed  by  any  other  non-alphanumeric  character  just
+       A  backslash  followed  by  any  other  non-alphanumeric character just
        escapes that character. A backslash followed by anything else causes an
-       error. However, if the very last character in the line is  a  backslash
-       (and  there  is  no  modifier list), it is ignored. This gives a way of
-       passing an empty line as data, since a real empty line  terminates  the
+       error.  However,  if the very last character in the line is a backslash
+       (and there is no modifier list), it is ignored. This  gives  a  way  of
+       passing  an  empty line as data, since a real empty line terminates the
        data input.
 
 
 PATTERN MODIFIERS
 
-       There  are  several types of modifier that can appear in pattern lines.
+       There are several types of modifier that can appear in  pattern  lines.
        Except where noted below, they may also be used in #pattern commands. A
-       pattern's  modifier  list can add to or override default modifiers that
+       pattern's modifier list can add to or override default  modifiers  that
        were set by a previous #pattern command.
 
    Setting compilation options
 
-       The following modifiers set options for pcre2_compile(). The most  com-
-       mon  ones have single-letter abbreviations. See pcre2api for a descrip-
+       The  following modifiers set options for pcre2_compile(). The most com-
+       mon ones have single-letter abbreviations. See pcre2api for a  descrip-
        tion of their effects.
 
              allow_empty_class         set PCRE2_ALLOW_EMPTY_CLASS
@@ -530,15 +536,15 @@ PATTERN MODIFIERS
              utf                       set PCRE2_UTF
 
        As well as turning on the PCRE2_UTF option, the utf modifier causes all
-       non-printing  characters  in  output  strings  to  be printed using the
-       \x{hh...} notation. Otherwise, those less than 0x100 are output in  hex
-       without  the  curly brackets. Setting utf in 16-bit or 32-bit mode also
-       causes pattern and subject  strings  to  be  translated  to  UTF-16  or
+       non-printing characters in output  strings  to  be  printed  using  the
+       \x{hh...}  notation. Otherwise, those less than 0x100 are output in hex
+       without the curly brackets. Setting utf in 16-bit or 32-bit  mode  also
+       causes  pattern  and  subject  strings  to  be  translated to UTF-16 or
        UTF-32, respectively, before being passed to library functions.
 
    Setting compilation controls
 
-       The  following  modifiers  affect  the  compilation  process or request
+       The following modifiers  affect  the  compilation  process  or  request
        information about the pattern:
 
              bsr=[anycrlf|unicode]     specify \R handling
@@ -571,34 +577,34 @@ PATTERN MODIFIERS
 
    Newline and \R handling
 
-       The bsr modifier specifies what \R in a pattern should match. If it  is
-       set  to  "anycrlf",  \R  matches  CR, LF, or CRLF only. If it is set to
-       "unicode", \R matches any Unicode  newline  sequence.  The  default  is
+       The  bsr modifier specifies what \R in a pattern should match. If it is
+       set to "anycrlf", \R matches CR, LF, or CRLF only.  If  it  is  set  to
+       "unicode",  \R  matches  any  Unicode  newline sequence. The default is
        specified when PCRE2 is built, with the default default being Unicode.
 
-       The  newline  modifier specifies which characters are to be interpreted
+       The newline modifier specifies which characters are to  be  interpreted
        as newlines, both in the pattern and in subject lines. The type must be
        one of CR, LF, CRLF, ANYCRLF, or ANY (in upper or lower case).
 
    Information about a pattern
 
-       The  debug modifier is a shorthand for info,fullbincode, requesting all
+       The debug modifier is a shorthand for info,fullbincode, requesting  all
        available information.
 
        The bincode modifier causes a representation of the compiled code to be
-       output  after compilation. This information does not contain length and
+       output after compilation. This information does not contain length  and
        offset values, which ensures that the same output is generated for dif-
-       ferent  internal  link  sizes  and different code unit widths. By using
-       bincode, the same regression tests can be used  in  different  environ-
+       ferent internal link sizes and different code  unit  widths.  By  using
+       bincode,  the  same  regression tests can be used in different environ-
        ments.
 
-       The  fullbincode  modifier, by contrast, does include length and offset
-       values. This is used in a few special tests that run only for  specific
+       The fullbincode modifier, by contrast, does include length  and  offset
+       values.  This is used in a few special tests that run only for specific
        code unit widths and link sizes, and is also useful for one-off tests.
 
-       The  info  modifier  requests  information  about  the compiled pattern
-       (whether it is anchored, has a fixed first character, and so  on).  The
-       information  is  obtained  from the pcre2_pattern_info() function. Here
+       The info modifier  requests  information  about  the  compiled  pattern
+       (whether  it  is anchored, has a fixed first character, and so on). The
+       information is obtained from the  pcre2_pattern_info()  function.  Here
        are some typical examples:
 
            re> /(?i)(^a|^b)/m,info
@@ -616,118 +622,118 @@ PATTERN MODIFIERS
          Last code unit = 'c' (caseless)
          Subject length lower bound = 3
 
-       "Compile options" are those specified by modifiers;  "overall  options"
-       have  added options that are taken or deduced from the pattern. If both
-       sets of options are the same, just a single "options" line  is  output;
-       if  there  are  no  options,  the line is omitted. "First code unit" is
-       where any match must start; if there is more than one they  are  listed
-       as  "starting  code  units".  "Last code unit" is the last literal code
-       unit that must be present in any match. This  is  not  necessarily  the
-       last  character.  These lines are omitted if no starting or ending code
+       "Compile  options"  are those specified by modifiers; "overall options"
+       have added options that are taken or deduced from the pattern. If  both
+       sets  of  options are the same, just a single "options" line is output;
+       if there are no options, the line is  omitted.  "First  code  unit"  is
+       where  any  match must start; if there is more than one they are listed
+       as "starting code units". "Last code unit" is  the  last  literal  code
+       unit  that  must  be  present in any match. This is not necessarily the
+       last character. These lines are omitted if no starting or  ending  code
        units are recorded.
 
-       The framesize modifier shows the size, in bytes, of the storage  frames
-       used  by  pcre2_match()  for handling backtracking. The size depends on
+       The  framesize modifier shows the size, in bytes, of the storage frames
+       used by pcre2_match() for handling backtracking. The  size  depends  on
        the number of capturing parentheses in the pattern.
 
-       The callout_info modifier requests information about all  the  callouts
+       The  callout_info  modifier requests information about all the callouts
        in the pattern. A list of them is output at the end of any other infor-
        mation that is requested. For each callout, either its number or string
        is given, followed by the item that follows it in the pattern.
 
    Passing a NULL context
 
-       Normally,  pcre2test  passes a context block to pcre2_compile(). If the
-       null_context modifier is set, however, NULL  is  passed.  This  is  for
-       testing  that  pcre2_compile()  behaves correctly in this case (it uses
+       Normally, pcre2test passes a context block to pcre2_compile().  If  the
+       null_context  modifier  is  set,  however,  NULL is passed. This is for
+       testing that pcre2_compile() behaves correctly in this  case  (it  uses
        default values).
 
    Specifying the pattern's length
 
        By default, patterns are passed to the compiling functions as zero-ter-
-       minated  strings.  When  using the POSIX wrapper API, there is no other
-       option. However, when using PCRE2's native API, patterns can be  passed
-       by  length  instead  of  being zero-terminated. The use_length modifier
-       causes this to happen.  Using a length happens  automatically  (whether
-       or  not  use_length is set) when hex is set, because patterns specified
+       minated strings. When using the POSIX wrapper API, there  is  no  other
+       option.  However, when using PCRE2's native API, patterns can be passed
+       by length instead of being  zero-terminated.  The  use_length  modifier
+       causes  this  to happen.  Using a length happens automatically (whether
+       or not use_length is set) when hex is set, because  patterns  specified
        in hexadecimal may contain binary zeros.
 
    Specifying pattern characters in hexadecimal
 
-       The hex modifier specifies that the characters of the  pattern,  except
-       for  substrings  enclosed  in single or double quotes, are to be inter-
-       preted as pairs of hexadecimal digits. This feature is  provided  as  a
+       The  hex  modifier specifies that the characters of the pattern, except
+       for substrings enclosed in single or double quotes, are  to  be  inter-
+       preted  as  pairs  of hexadecimal digits. This feature is provided as a
        way of creating patterns that contain binary zeros and other non-print-
-       ing characters. White space is permitted between pairs of  digits.  For
+       ing  characters.  White space is permitted between pairs of digits. For
        example, this pattern contains three characters:
 
          /ab 32 59/hex
 
-       Parts  of  such  a  pattern are taken literally if quoted. This pattern
-       contains nine characters, only two of which are specified in  hexadeci-
+       Parts of such a pattern are taken literally  if  quoted.  This  pattern
+       contains  nine characters, only two of which are specified in hexadeci-
        mal:
 
          /ab "literal" 32/hex
 
-       Either  single or double quotes may be used. There is no way of includ-
-       ing the delimiter within a substring. The hex and expand modifiers  are
+       Either single or double quotes may be used. There is no way of  includ-
+       ing  the delimiter within a substring. The hex and expand modifiers are
        mutually exclusive.
 
-       The  POSIX  API  cannot  be used with patterns specified in hexadecimal
+       The POSIX API cannot be used with  patterns  specified  in  hexadecimal
        because they may contain binary zeros, which conflicts with regcomp()'s
-       requirement  for  a  zero-terminated  string.  Such patterns are always
+       requirement for a zero-terminated  string.  Such  patterns  are  always
        passed to pcre2_compile() as a string with a length, not as zero-termi-
        nated.
 
    Specifying wide characters in 16-bit and 32-bit modes
 
        In 16-bit and 32-bit modes, all input is automatically treated as UTF-8
-       and translated to UTF-16 or UTF-32 when the utf modifier  is  set.  For
+       and  translated  to  UTF-16 or UTF-32 when the utf modifier is set. For
        testing the 16-bit and 32-bit libraries in non-UTF mode, the utf8_input
-       modifier can be used. It is mutually exclusive with  utf.  Input  lines
+       modifier  can  be  used. It is mutually exclusive with utf. Input lines
        are interpreted as UTF-8 as a means of specifying wide characters. More
        details are given in "Input encoding" above.
 
    Generating long repetitive patterns
 
-       Some tests use long patterns that are very repetitive. Instead of  cre-
-       ating  a very long input line for such a pattern, you can use a special
-       repetition feature, similar to the  one  described  for  subject  lines
-       above.  If  the  expand  modifier is present on a pattern, parts of the
+       Some  tests use long patterns that are very repetitive. Instead of cre-
+       ating a very long input line for such a pattern, you can use a  special
+       repetition  feature,  similar  to  the  one described for subject lines
+       above. If the expand modifier is present on a  pattern,  parts  of  the
        pattern that have the form
 
          \[]{}
 
        are expanded before the pattern is passed to pcre2_compile(). For exam-
        ple, \[AB]{6000} is expanded to "ABAB..." 6000 times. This construction
-       cannot be nested. An initial "\[" sequence is recognized only  if  "]{"
-       followed  by  decimal  digits and "}" is found later in the pattern. If
+       cannot  be  nested. An initial "\[" sequence is recognized only if "]{"
+       followed by decimal digits and "}" is found later in  the  pattern.  If
        not, the characters remain in the pattern unaltered. The expand and hex
        modifiers are mutually exclusive.
 
-       If  part  of an expanded pattern looks like an expansion, but is really
+       If part of an expanded pattern looks like an expansion, but  is  really
        part of the actual pattern, unwanted expansion can be avoided by giving
        two values in the quantifier. For example, \[AB]{6000,6000} is not rec-
        ognized as an expansion item.
 
-       If the info modifier is set on an expanded pattern, the result  of  the
+       If  the  info modifier is set on an expanded pattern, the result of the
        expansion is included in the information that is output.
 
    JIT compilation
 
-       Just-in-time  (JIT)  compiling  is  a heavyweight optimization that can
-       greatly speed up pattern matching. See the pcre2jit  documentation  for
-       details.  JIT  compiling  happens, optionally, after a pattern has been
-       successfully compiled into an internal form. The JIT compiler  converts
+       Just-in-time (JIT) compiling is a  heavyweight  optimization  that  can
+       greatly  speed  up pattern matching. See the pcre2jit documentation for
+       details. JIT compiling happens, optionally, after a  pattern  has  been
+       successfully  compiled into an internal form. The JIT compiler converts
        this to optimized machine code. It needs to know whether the match-time
        options PCRE2_PARTIAL_HARD and PCRE2_PARTIAL_SOFT are going to be used,
-       because  different  code  is generated for the different cases. See the
-       partial modifier in "Subject Modifiers" below for details of how  these
+       because different code is generated for the different  cases.  See  the
+       partial  modifier in "Subject Modifiers" below for details of how these
        options are specified for each match attempt.
 
-       JIT  compilation  is  requested by the /jit pattern modifier, which may
+       JIT compilation is requested by the /jit pattern  modifier,  which  may
        optionally be followed by an equals sign and a number in the range 0 to
-       7.   The  three bits that make up the number specify which of the three
+       7.  The three bits that make up the number specify which of  the  three
        JIT operating modes are to be compiled:
 
          1  compile JIT code for non-partial matching
@@ -744,31 +750,31 @@ PATTERN MODIFIERS
          6  soft and hard partial matching only
          7  all three modes
 
-       If no number is given, 7 is  assumed.  The  phrase  "partial  matching"
+       If  no  number  is  given,  7 is assumed. The phrase "partial matching"
        means a call to pcre2_match() with either the PCRE2_PARTIAL_SOFT or the
-       PCRE2_PARTIAL_HARD option set. Note that such a call may return a  com-
+       PCRE2_PARTIAL_HARD  option set. Note that such a call may return a com-
        plete match; the options enable the possibility of a partial match, but
-       do not require it. Note also that if you request JIT  compilation  only
-       for  partial  matching (for example, /jit=2) but do not set the partial
-       modifier on a subject line, that match will not use  JIT  code  because
+       do  not  require it. Note also that if you request JIT compilation only
+       for partial matching (for example, /jit=2) but do not set  the  partial
+       modifier  on  a  subject line, that match will not use JIT code because
        none was compiled for non-partial matching.
 
-       If  JIT compilation is successful, the compiled JIT code will automati-
-       cally be used when an appropriate type of match  is  run,  except  when
-       incompatible  run-time options are specified. For more details, see the
-       pcre2jit documentation. See also the jitstack modifier below for a  way
+       If JIT compilation is successful, the compiled JIT code will  automati-
+       cally  be  used  when  an appropriate type of match is run, except when
+       incompatible run-time options are specified. For more details, see  the
+       pcre2jit  documentation. See also the jitstack modifier below for a way
        of setting the size of the JIT stack.
 
-       If  the  jitfast  modifier is specified, matching is done using the JIT
-       "fast path" interface, pcre2_jit_match(), which skips some of the  san-
-       ity  checks that are done by pcre2_match(), and of course does not work
-       when JIT is not supported. If jitfast is specified without  jit,  jit=7
+       If the jitfast modifier is specified, matching is done  using  the  JIT
+       "fast  path" interface, pcre2_jit_match(), which skips some of the san-
+       ity checks that are done by pcre2_match(), and of course does not  work
+       when  JIT  is not supported. If jitfast is specified without jit, jit=7
        is assumed.
 
-       If  the jitverify modifier is specified, information about the compiled
-       pattern shows whether JIT compilation was or  was  not  successful.  If
-       jitverify  is  specified without jit, jit=7 is assumed. If JIT compila-
-       tion is successful when jitverify is set, the text "(JIT)" is added  to
+       If the jitverify modifier is specified, information about the  compiled
+       pattern  shows  whether  JIT  compilation was or was not successful. If
+       jitverify is specified without jit, jit=7 is assumed. If  JIT  compila-
+       tion  is successful when jitverify is set, the text "(JIT)" is added to
        the first output line after a match or non match when JIT-compiled code
        was actually used in the match.
 
@@ -779,19 +785,19 @@ PATTERN MODIFIERS
          /pattern/locale=fr_FR
 
        The given locale is set, pcre2_maketables() is called to build a set of
-       character  tables for the locale, and this is then passed to pcre2_com-
-       pile() when compiling the regular expression. The same tables are  used
-       when  matching the following subject lines. The locale modifier applies
+       character tables for the locale, and this is then passed to  pcre2_com-
+       pile()  when compiling the regular expression. The same tables are used
+       when matching the following subject lines. The locale modifier  applies
        only to the pattern on which it appears, but can be given in a #pattern
-       command  if a default is needed. Setting a locale and alternate charac-
+       command if a default is needed. Setting a locale and alternate  charac-
        ter tables are mutually exclusive.
 
    Showing pattern memory
 
        The memory modifier causes the size in bytes of the memory used to hold
-       the  compiled  pattern  to be output. This does not include the size of
-       the pcre2_code block; it is just the actual compiled data. If the  pat-
-       tern  is  subsequently  passed to the JIT compiler, the size of the JIT
+       the compiled pattern to be output. This does not include  the  size  of
+       the  pcre2_code block; it is just the actual compiled data. If the pat-
+       tern is subsequently passed to the JIT compiler, the size  of  the  JIT
        compiled code is also output. Here is an example:
 
            re> /a(b)c/jit,memory
@@ -801,27 +807,27 @@ PATTERN MODIFIERS
 
    Limiting nested parentheses
 
-       The parens_nest_limit modifier sets a limit  on  the  depth  of  nested
-       parentheses  in  a  pattern.  Breaching  the limit causes a compilation
-       error.  The default for the library is set when  PCRE2  is  built,  but
-       pcre2test  sets  its  own default of 220, which is required for running
+       The  parens_nest_limit  modifier  sets  a  limit on the depth of nested
+       parentheses in a pattern. Breaching  the  limit  causes  a  compilation
+       error.   The  default  for  the library is set when PCRE2 is built, but
+       pcre2test sets its own default of 220, which is  required  for  running
        the standard test suite.
 
    Limiting the pattern length
 
-       The max_pattern_length modifier sets a limit, in  code  units,  to  the
+       The  max_pattern_length  modifier  sets  a limit, in code units, to the
        length of pattern that pcre2_compile() will accept. Breaching the limit
-       causes a compilation  error.  The  default  is  the  largest  number  a
+       causes  a  compilation  error.  The  default  is  the  largest number a
        PCRE2_SIZE variable can hold (essentially unlimited).
 
    Using the POSIX wrapper API
 
-       The  /posix and posix_nosub modifiers cause pcre2test to call PCRE2 via
-       the POSIX wrapper API rather than its native API. When  posix_nosub  is
-       used,  the  POSIX  option  REG_NOSUB  is passed to regcomp(). The POSIX
-       wrapper supports only the 8-bit library. Note that it  does  not  imply
+       The /posix and posix_nosub modifiers cause pcre2test to call PCRE2  via
+       the  POSIX  wrapper API rather than its native API. When posix_nosub is
+       used, the POSIX option REG_NOSUB is  passed  to  regcomp().  The  POSIX
+       wrapper  supports  only  the 8-bit library. Note that it does not imply
        POSIX matching semantics; for more detail see the pcre2posix documenta-
-       tion. The following pattern modifiers set  options  for  the  regcomp()
+       tion.  The  following  pattern  modifiers set options for the regcomp()
        function:
 
          caseless           REG_ICASE
@@ -831,35 +837,35 @@ PATTERN MODIFIERS
          ucp                REG_UCP        )   the POSIX standard
          utf                REG_UTF8       )
 
-       The  regerror_buffsize  modifier  specifies a size for the error buffer
-       that is passed to regerror() in the event of a compilation  error.  For
+       The regerror_buffsize modifier specifies a size for  the  error  buffer
+       that  is  passed to regerror() in the event of a compilation error. For
        example:
 
          /abc/posix,regerror_buffsize=20
 
-       This  provides  a means of testing the behaviour of regerror() when the
-       buffer is too small for the error message. If  this  modifier  has  not
+       This provides a means of testing the behaviour of regerror()  when  the
+       buffer  is  too  small  for the error message. If this modifier has not
        been set, a large buffer is used.
 
-       The  aftertext  and  allaftertext  subject  modifiers work as described
-       below. All other modifiers are either ignored, with a warning  message,
+       The aftertext and allaftertext  subject  modifiers  work  as  described
+       below.  All other modifiers are either ignored, with a warning message,
        or cause an error.
 
    Testing the stack guard feature
 
-       The  stackguard  modifier  is  used  to  test the use of pcre2_set_com-
-       pile_recursion_guard(), a function that is  provided  to  enable  stack
-       availability  to  be checked during compilation (see the pcre2api docu-
-       mentation for details). If the number  specified  by  the  modifier  is
+       The stackguard modifier is used  to  test  the  use  of  pcre2_set_com-
+       pile_recursion_guard(),  a  function  that  is provided to enable stack
+       availability to be checked during compilation (see the  pcre2api  docu-
+       mentation  for  details).  If  the  number specified by the modifier is
        greater than zero, pcre2_set_compile_recursion_guard() is called to set
-       up callback from pcre2_compile() to a local function. The  argument  it
-       receives  is  the current nesting parenthesis depth; if this is greater
+       up  callback  from pcre2_compile() to a local function. The argument it
+       receives is the current nesting parenthesis depth; if this  is  greater
        than the value given by the modifier, non-zero is returned, causing the
        compilation to be aborted.
 
    Using alternative character tables
 
-       The  value  specified for the tables modifier must be one of the digits
+       The value specified for the tables modifier must be one of  the  digits
        0, 1, or 2. It causes a specific set of built-in character tables to be
        passed to pcre2_compile(). This is used in the PCRE2 tests to check be-
        haviour with different character tables. The digit specifies the tables
@@ -870,15 +876,15 @@ PATTERN MODIFIERS
                pcre2_chartables.c.dist
          2   a set of tables defining ISO 8859 characters
 
-       In  table 2, some characters whose codes are greater than 128 are iden-
-       tified as letters, digits, spaces,  etc.  Setting  alternate  character
+       In table 2, some characters whose codes are greater than 128 are  iden-
+       tified  as  letters,  digits,  spaces, etc. Setting alternate character
        tables and a locale are mutually exclusive.
 
    Setting certain match controls
 
        The following modifiers are really subject modifiers, and are described
-       below.  However, they may be included in a pattern's modifier list,  in
-       which  case  they  are  applied to every subject line that is processed
+       below.   However, they may be included in a pattern's modifier list, in
+       which case they are applied to every subject  line  that  is  processed
        with that pattern. They may not appear in #pattern commands. These mod-
        ifiers do not affect the compilation process.
 
@@ -895,24 +901,24 @@ PATTERN MODIFIERS
              substitute_unknown_unset   use PCRE2_SUBSTITUTE_UNKNOWN_UNSET
              substitute_unset_empty     use PCRE2_SUBSTITUTE_UNSET_EMPTY
 
-       These  modifiers may not appear in a #pattern command. If you want them
+       These modifiers may not appear in a #pattern command. If you want  them
        as defaults, set them in a #subject command.
 
    Saving a compiled pattern
 
-       When a pattern with the push modifier is successfully compiled,  it  is
-       pushed  onto  a  stack  of compiled patterns, and pcre2test expects the
-       next line to contain a new pattern (or a command) instead of a  subject
+       When  a  pattern with the push modifier is successfully compiled, it is
+       pushed onto a stack of compiled patterns,  and  pcre2test  expects  the
+       next  line to contain a new pattern (or a command) instead of a subject
        line. This facility is used when saving compiled patterns to a file, as
-       described in the section entitled "Saving and restoring  compiled  pat-
-       terns"  below.  If pushcopy is used instead of push, a copy of the com-
-       piled pattern is stacked, leaving the original  as  current,  ready  to
-       match  the  following  input  lines. This provides a way of testing the
-       pcre2_code_copy() function.   The  push  and  pushcopy   modifiers  are
-       incompatible  with  compilation  modifiers  such  as global that act at
-       match time. Any that are specified are ignored (for the stacked  copy),
+       described  in  the section entitled "Saving and restoring compiled pat-
+       terns" below. If pushcopy is used instead of push, a copy of  the  com-
+       piled  pattern  is  stacked,  leaving the original as current, ready to
+       match the following input lines. This provides a  way  of  testing  the
+       pcre2_code_copy()  function.   The  push  and  pushcopy   modifiers are
+       incompatible with compilation modifiers such  as  global  that  act  at
+       match  time. Any that are specified are ignored (for the stacked copy),
        with a warning message, except for replace, which causes an error. Note
-       that jitverify, which is allowed, does not carry through to any  subse-
+       that  jitverify, which is allowed, does not carry through to any subse-
        quent matching that uses a stacked pattern.
 
 
@@ -923,7 +929,7 @@ SUBJECT MODIFIERS
 
    Setting match options
 
-       The   following   modifiers   set   options   for   pcre2_match()    or
+       The    following   modifiers   set   options   for   pcre2_match()   or
        pcre2_dfa_match(). See pcreapi for a description of their effects.
 
              anchored                  set PCRE2_ANCHORED
@@ -939,20 +945,20 @@ SUBJECT MODIFIERS
              partial_hard (or ph)      set PCRE2_PARTIAL_HARD
              partial_soft (or ps)      set PCRE2_PARTIAL_SOFT
 
-       The  partial matching modifiers are provided with abbreviations because
+       The partial matching modifiers are provided with abbreviations  because
        they appear frequently in tests.
 
-       If the posix modifier was present on the  pattern,  causing  the  POSIX
+       If  the  posix  modifier  was present on the pattern, causing the POSIX
        wrapper API to be used, the only option-setting modifiers that have any
-       effect  are  notbol,  notempty,   and   noteol,   causing   REG_NOTBOL,
-       REG_NOTEMPTY,  and REG_NOTEOL, respectively, to be passed to regexec().
+       effect   are   notbol,   notempty,   and  noteol,  causing  REG_NOTBOL,
+       REG_NOTEMPTY, and REG_NOTEOL, respectively, to be passed to  regexec().
        The other modifiers are ignored, with a warning message.
 
    Setting match controls
 
-       The following modifiers affect the matching process  or  request  addi-
-       tional  information.  Some  of  them may also be specified on a pattern
-       line (see above), in which case they apply to every subject  line  that
+       The  following  modifiers  affect the matching process or request addi-
+       tional information. Some of them may also be  specified  on  a  pattern
+       line  (see  above), in which case they apply to every subject line that
        is matched against that pattern.
 
              aftertext                  show text after match
@@ -972,6 +978,7 @@ SUBJECT MODIFIERS
              get=       extract captured substring
              getall                     extract all captured substrings
          /g  global                     global matching
+             heap_limit=             set a limit on heap memory
              jitstack=               set size of JIT stack
              mark                       show mark values
              match_limit=            set a match limit
@@ -991,29 +998,29 @@ SUBJECT MODIFIERS
              zero_terminate             pass the subject as zero-terminated
 
        The effects of these modifiers are described in the following sections.
-       When matching via the POSIX wrapper API, the  aftertext,  allaftertext,
-       and  ovector subject modifiers work as described below. All other modi-
+       When  matching  via the POSIX wrapper API, the aftertext, allaftertext,
+       and ovector subject modifiers work as described below. All other  modi-
        fiers are either ignored, with a warning message, or cause an error.
 
    Showing more text
 
-       The aftertext modifier requests that as well as outputting the part  of
+       The  aftertext modifier requests that as well as outputting the part of
        the subject string that matched the entire pattern, pcre2test should in
        addition output the remainder of the subject string. This is useful for
        tests where the subject contains multiple copies of the same substring.
-       The allaftertext modifier requests the same action  for  captured  sub-
+       The  allaftertext  modifier  requests the same action for captured sub-
        strings as well as the main matched substring. In each case the remain-
        der is output on the following line with a plus character following the
        capture number.
 
-       The  allusedtext modifier requests that all the text that was consulted
-       during a successful pattern match by the interpreter should  be  shown.
-       This  feature  is not supported for JIT matching, and if requested with
-       JIT it is ignored (with  a  warning  message).  Setting  this  modifier
+       The allusedtext modifier requests that all the text that was  consulted
+       during  a  successful pattern match by the interpreter should be shown.
+       This feature is not supported for JIT matching, and if  requested  with
+       JIT  it  is  ignored  (with  a  warning message). Setting this modifier
        affects the output if there is a lookbehind at the start of a match, or
-       a lookahead at the end, or if \K is used  in  the  pattern.  Characters
-       that  precede or follow the start and end of the actual match are indi-
-       cated in the output by '<' or '>' characters underneath them.  Here  is
+       a  lookahead  at  the  end, or if \K is used in the pattern. Characters
+       that precede or follow the start and end of the actual match are  indi-
+       cated  in  the output by '<' or '>' characters underneath them. Here is
        an example:
 
            re> /(?<=pqr)abc(?=xyz)/
@@ -1021,16 +1028,16 @@ SUBJECT MODIFIERS
           0: pqrabcxyz
              <<<   >>>
 
-       This  shows  that  the  matched string is "abc", with the preceding and
-       following strings "pqr" and "xyz"  having  been  consulted  during  the
+       This shows that the matched string is "abc",  with  the  preceding  and
+       following  strings  "pqr"  and  "xyz"  having been consulted during the
        match (when processing the assertions).
 
-       The  startchar  modifier  requests  that the starting character for the
-       match be indicated, if it is different to  the  start  of  the  matched
+       The startchar modifier requests that the  starting  character  for  the
+       match  be  indicated,  if  it  is different to the start of the matched
        string. The only time when this occurs is when \K has been processed as
        part of the match. In this situation, the output for the matched string
-       is  displayed  from  the  starting  character instead of from the match
-       point, with circumflex characters under  the  earlier  characters.  For
+       is displayed from the starting character  instead  of  from  the  match
+       point,  with  circumflex  characters  under the earlier characters. For
        example:
 
            re> /abc\Kxyz/
@@ -1038,7 +1045,7 @@ SUBJECT MODIFIERS
           0: abcxyz
              ^^^
 
-       Unlike  allusedtext, the startchar modifier can be used with JIT.  How-
+       Unlike allusedtext, the startchar modifier can be used with JIT.   How-
        ever, these two modifiers are mutually exclusive.
 
    Showing the value of all capture groups
@@ -1046,98 +1053,98 @@ SUBJECT MODIFIERS
        The allcaptures modifier requests that the values of all potential cap-
        tured parentheses be output after a match. By default, only those up to
        the highest one actually used in the match are output (corresponding to
-       the  return  code from pcre2_match()). Groups that did not take part in
-       the match are output as "". This modifier is  not  relevant  for
-       DFA  matching  (which does no capturing); it is ignored, with a warning
+       the return code from pcre2_match()). Groups that did not take  part  in
+       the  match  are  output as "". This modifier is not relevant for
+       DFA matching (which does no capturing); it is ignored, with  a  warning
        message, if present.
 
    Testing callouts
 
-       A callout function is supplied when pcre2test calls the library  match-
-       ing  functions, unless callout_none is specified. If callout_capture is
-       set, the current captured groups are output when a callout occurs.  The
+       A  callout function is supplied when pcre2test calls the library match-
+       ing functions, unless callout_none is specified. If callout_capture  is
+       set,  the current captured groups are output when a callout occurs. The
        default return from the callout function is zero, which allows matching
        to continue.
 
-       The callout_fail modifier can be given one or two numbers. If there  is
-       only  one number, 1 is returned instead of 0 (causing matching to back-
-       track) when a callout  of  that  number  is  reached.  If  two  numbers
-       (:)  are  given,  1  is  returned when callout  is reached and
-       there have been at least  callouts. The  callout_error  modifier  is
-       similar,  except  that  PCRE2_ERROR_CALLOUT  is  returned,  causing the
-       entire matching process to be aborted. If both these modifiers are  set
+       The  callout_fail modifier can be given one or two numbers. If there is
+       only one number, 1 is returned instead of 0 (causing matching to  back-
+       track)  when  a  callout  of  that  number  is  reached. If two numbers
+       (:) are given, 1 is returned when  callout    is  reached  and
+       there  have  been  at least  callouts. The callout_error modifier is
+       similar, except  that  PCRE2_ERROR_CALLOUT  is  returned,  causing  the
+       entire  matching process to be aborted. If both these modifiers are set
        for the same callout number, callout_error takes precedence.
 
-       Note  that  callouts  with string arguments are always given the number
+       Note that callouts with string arguments are always  given  the  number
        zero. See "Callouts" below for a description of the output when a call-
        out it taken.
 
-       The  callout_data  modifier can be given an unsigned or a negative num-
-       ber.  This is set as the "user data" that is  passed  to  the  matching
-       function,  and  passed  back  when the callout function is invoked. Any
-       value other than zero is used as  a  return  from  pcre2test's  callout
+       The callout_data modifier can be given an unsigned or a  negative  num-
+       ber.   This  is  set  as the "user data" that is passed to the matching
+       function, and passed back when the callout  function  is  invoked.  Any
+       value  other  than  zero  is  used as a return from pcre2test's callout
        function.
 
    Finding all matches in a string
 
        Searching for all possible matches within a subject can be requested by
-       the global or altglobal modifier. After finding a match,  the  matching
-       function  is  called  again to search the remainder of the subject. The
-       difference between global and altglobal is that  the  former  uses  the
-       start_offset  argument  to  pcre2_match() or pcre2_dfa_match() to start
-       searching at a new point within the entire string (which is  what  Perl
+       the  global  or altglobal modifier. After finding a match, the matching
+       function is called again to search the remainder of  the  subject.  The
+       difference  between  global  and  altglobal is that the former uses the
+       start_offset argument to pcre2_match() or  pcre2_dfa_match()  to  start
+       searching  at  a new point within the entire string (which is what Perl
        does), whereas the latter passes over a shortened subject. This makes a
        difference to the matching process if the pattern begins with a lookbe-
        hind assertion (including \b or \B).
 
-       If  an  empty  string  is  matched,  the  next  match  is done with the
+       If an empty string  is  matched,  the  next  match  is  done  with  the
        PCRE2_NOTEMPTY_ATSTART and PCRE2_ANCHORED flags set, in order to search
        for another, non-empty, match at the same point in the subject. If this
-       match fails, the start offset is advanced,  and  the  normal  match  is
-       retried.  This  imitates the way Perl handles such cases when using the
-       /g modifier or the split() function.  Normally,  the  start  offset  is
-       advanced  by  one  character,  but if the newline convention recognizes
-       CRLF as a newline, and the current character is CR followed by  LF,  an
+       match  fails,  the  start  offset  is advanced, and the normal match is
+       retried. This imitates the way Perl handles such cases when  using  the
+       /g  modifier  or  the  split()  function. Normally, the start offset is
+       advanced by one character, but if  the  newline  convention  recognizes
+       CRLF  as  a newline, and the current character is CR followed by LF, an
        advance of two characters occurs.
 
    Testing substring extraction functions
 
-       The  copy  and  get  modifiers  can  be  used  to  test  the pcre2_sub-
+       The copy  and  get  modifiers  can  be  used  to  test  the  pcre2_sub-
        string_copy_xxx() and pcre2_substring_get_xxx() functions.  They can be
-       given  more than once, and each can specify a group name or number, for
+       given more than once, and each can specify a group name or number,  for
        example:
 
           abcd\=copy=1,copy=3,get=G1
 
-       If the #subject command is used to set default copy and/or  get  lists,
-       these  can  be unset by specifying a negative number to cancel all num-
+       If  the  #subject command is used to set default copy and/or get lists,
+       these can be unset by specifying a negative number to cancel  all  num-
        bered groups and an empty name to cancel all named groups.
 
-       The getall modifier tests  pcre2_substring_list_get(),  which  extracts
+       The  getall  modifier  tests pcre2_substring_list_get(), which extracts
        all captured substrings.
 
-       If  the  subject line is successfully matched, the substrings extracted
-       by the convenience functions are output with  C,  G,  or  L  after  the
-       string  number  instead  of  a colon. This is in addition to the normal
-       full list. The string length (that is, the return from  the  extraction
+       If the subject line is successfully matched, the  substrings  extracted
+       by  the  convenience  functions  are  output  with C, G, or L after the
+       string number instead of a colon. This is in  addition  to  the  normal
+       full  list.  The string length (that is, the return from the extraction
        function) is given in parentheses after each substring, followed by the
        name when the extraction was by name.
 
    Testing the substitution function
 
-       If the replace modifier is  set,  the  pcre2_substitute()  function  is
-       called  instead of one of the matching functions. Note that replacement
-       strings cannot contain commas, because a comma signifies the end  of  a
+       If  the  replace  modifier  is  set, the pcre2_substitute() function is
+       called instead of one of the matching functions. Note that  replacement
+       strings  cannot  contain commas, because a comma signifies the end of a
        modifier. This is not thought to be an issue in a test program.
 
-       Unlike  subject strings, pcre2test does not process replacement strings
-       for escape sequences. In UTF mode, a replacement string is  checked  to
-       see  if it is a valid UTF-8 string. If so, it is correctly converted to
-       a UTF string of the appropriate code unit width. If it is not  a  valid
-       UTF-8  string, the individual code units are copied directly. This pro-
+       Unlike subject strings, pcre2test does not process replacement  strings
+       for  escape  sequences. In UTF mode, a replacement string is checked to
+       see if it is a valid UTF-8 string. If so, it is correctly converted  to
+       a  UTF  string of the appropriate code unit width. If it is not a valid
+       UTF-8 string, the individual code units are copied directly. This  pro-
        vides a means of passing an invalid UTF-8 string for testing purposes.
 
-       The following modifiers set options (in additional to the normal  match
+       The  following modifiers set options (in additional to the normal match
        options) for pcre2_substitute():
 
          global                      PCRE2_SUBSTITUTE_GLOBAL
@@ -1147,8 +1154,8 @@ SUBJECT MODIFIERS
          substitute_unset_empty      PCRE2_SUBSTITUTE_UNSET_EMPTY
 
 
-       After  a  successful  substitution, the modified string is output, pre-
-       ceded by the number of replacements. This may be zero if there were  no
+       After a successful substitution, the modified string  is  output,  pre-
+       ceded  by the number of replacements. This may be zero if there were no
        matches. Here is a simple example of a substitution test:
 
          /abc/replace=xxx
@@ -1157,12 +1164,12 @@ SUBJECT MODIFIERS
              =abc=abc=\=global
           2: =xxx=xxx=
 
-       Subject  and replacement strings should be kept relatively short (fewer
-       than 256 characters) for substitution tests, as fixed-size buffers  are
-       used.  To  make it easy to test for buffer overflow, if the replacement
-       string starts with a number in square brackets, that number  is  passed
-       to  pcre2_substitute()  as  the  size  of  the  output buffer, with the
-       replacement string starting at the next character. Here is  an  example
+       Subject and replacement strings should be kept relatively short  (fewer
+       than  256 characters) for substitution tests, as fixed-size buffers are
+       used. To make it easy to test for buffer overflow, if  the  replacement
+       string  starts  with a number in square brackets, that number is passed
+       to pcre2_substitute() as the  size  of  the  output  buffer,  with  the
+       replacement  string  starting at the next character. Here is an example
        that tests the edge case:
 
          /abc/
@@ -1171,11 +1178,11 @@ SUBJECT MODIFIERS
              123abc123\=replace=[9]XYZ
          Failed: error -47: no more memory
 
-       The    default    action    of    pcre2_substitute()   is   to   return
-       PCRE2_ERROR_NOMEMORY when the output buffer is too small.  However,  if
-       the  PCRE2_SUBSTITUTE_OVERFLOW_LENGTH  option is set (by using the sub-
-       stitute_overflow_length modifier), pcre2_substitute() continues  to  go
-       through  the  motions of matching and substituting, in order to compute
+       The   default   action   of    pcre2_substitute()    is    to    return
+       PCRE2_ERROR_NOMEMORY  when  the output buffer is too small. However, if
+       the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH option is set (by using  the  sub-
+       stitute_overflow_length  modifier),  pcre2_substitute() continues to go
+       through the motions of matching and substituting, in order  to  compute
        the size of buffer that is required. When this happens, pcre2test shows
        the required buffer length (which includes space for the trailing zero)
        as part of the error message. For example:
@@ -1185,30 +1192,31 @@ SUBJECT MODIFIERS
          Failed: error -47: no more memory: 10 code units are needed
 
        A replacement string is ignored with POSIX and DFA matching. Specifying
-       partial  matching  provokes  an  error return ("bad option value") from
+       partial matching provokes an error return  ("bad  option  value")  from
        pcre2_substitute().
 
    Setting the JIT stack size
 
-       The jitstack modifier provides a way of setting the maximum stack  size
-       that  is  used  by the just-in-time optimization code. It is ignored if
+       The  jitstack modifier provides a way of setting the maximum stack size
+       that is used by the just-in-time optimization code. It  is  ignored  if
        JIT optimization is not being used. The value is a number of kilobytes.
        Providing a stack that is larger than the default 32K is necessary only
        for very complicated patterns.
 
-   Setting match and depth limits
+   Setting heap, match, and depth limits
 
-       The match_limit and depth_limit modifiers set the appropriate limits in
-       the  match context. These values are ignored when the find_limits modi-
-       fier is specified.
+       The  heap_limit,  match_limit, and depth_limit modifiers set the appro-
+       priate limits in the match context. These values are ignored  when  the
+       find_limits modifier is specified.
 
    Finding minimum limits
 
-       If the find_limits modifier is present on  a  subject  line,  pcre2test
-       calls  the  relevant matching function several times, setting different
-       values  in   the   match   context   via   pcre2_set_match_limit()   or
-       pcre2_set_depth_limit()  until  it  finds  the  minimum values for each
-       parameter that allows the match to complete without error.
+       If  the  find_limits  modifier  is present on a subject line, pcre2test
+       calls the relevant matching function several times,  setting  different
+       values    in    the    match    context   via   pcre2_set_heap_limit(),
+       pcre2_set_match_limit(), or pcre2_set_depth_limit() until it finds  the
+       minimum  values  for  each  parameter that allows the match to complete
+       without error.
 
        If JIT is being used, only the match limit is relevant. If DFA matching
        is being used, only the depth limit is relevant.
@@ -1220,8 +1228,8 @@ SUBJECT MODIFIERS
        quickly with increasing length of subject string.
 
        For  non-DFA  matching,  the minimum depth_limit number is a measure of
-       how much memory for recording backtracking points is needed to complete
-       the  match  attempt.  In the case of DFA matching, depth_limit controls
+       how much nested backtracking happens (that is, how deeply the pattern's
+       tree  is  searched).  In the case of DFA matching, depth_limit controls
        the depth of recursive calls of the internal function that is used  for
        handling pattern recursion, lookaround assertions, and atomic groups.
 
@@ -1632,5 +1640,5 @@ AUTHOR
 
 REVISION
 
-       Last updated: 04 April 2017
+       Last updated: 11 April 2017
        Copyright (c) 1997-2017 University of Cambridge.
diff --git a/src/config.h.in b/src/config.h.in
index 2a45a6e..54eed73 100644
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -132,6 +132,10 @@ sure both macros are undefined; an emulation function will then be used. */
 /* Define to 1 if you have the  header file. */
 #undef HAVE_ZLIB_H
 
+/* This limits the amount of memory that pcre2_match() may use while matching
+   a pattern. The value is in kilobytes. */
+#undef HEAP_LIMIT
+
 /* The value of LINK_SIZE determines the number of bytes used to store links
    as offsets within the compiled regex. The default is 2, which allows for
    compiled patterns up to 64K long. This covers the vast majority of cases.
@@ -143,7 +147,7 @@ sure both macros are undefined; an emulation function will then be used. */
 #undef LT_OBJDIR
 
 /* The value of MATCH_LIMIT determines the default number of times the
-   internal match() function can record a backtrack position during a single
+   pcre2_match() function can record a backtrack position during a single
    matching attempt. There is a runtime interface for setting a different
    limit. The limit exists in order to catch runaway regular expressions that
    take for ever to determine that they do not match. The default is set very
diff --git a/src/pcre2.h b/src/pcre2.h
index e699b8a..e15ede4 100644
--- a/src/pcre2.h
+++ b/src/pcre2.h
@@ -268,6 +268,7 @@ numbers must not be changed. */
 #define PCRE2_ERROR_BADSUBSPATTERN    (-60)
 #define PCRE2_ERROR_TOOMANYREPLACE    (-61)
 #define PCRE2_ERROR_BADSERIALIZEDDATA (-62)
+#define PCRE2_ERROR_HEAPLIMIT         (-63)
 
 /* Request types for pcre2_pattern_info() */
 
@@ -297,6 +298,7 @@ numbers must not be changed. */
 #define PCRE2_INFO_SIZE                 22
 #define PCRE2_INFO_HASBACKSLASHC        23
 #define PCRE2_INFO_FRAMESIZE            24
+#define PCRE2_INFO_HEAPLIMIT            25
 
 /* Request types for pcre2_config(). */
 
@@ -313,6 +315,7 @@ numbers must not be changed. */
 #define PCRE2_CONFIG_UNICODE                 9
 #define PCRE2_CONFIG_UNICODE_VERSION        10
 #define PCRE2_CONFIG_VERSION                11
+#define PCRE2_CONFIG_HEAPLIMIT              12
 
 /* Types for code units in patterns and subject strings. */
 
@@ -452,6 +455,8 @@ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
     int (*)(pcre2_callout_block *, void *), void *); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
   pcre2_set_depth_limit(pcre2_match_context *, uint32_t); \
+PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
+  pcre2_set_heap_limit(pcre2_match_context *, uint32_t); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
   pcre2_set_match_limit(pcre2_match_context *, uint32_t); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
@@ -676,6 +681,7 @@ pcre2_compile are called by application code. */
 #define pcre2_set_character_tables            PCRE2_SUFFIX(pcre2_set_character_tables_)
 #define pcre2_set_compile_recursion_guard     PCRE2_SUFFIX(pcre2_set_compile_recursion_guard_)
 #define pcre2_set_depth_limit                 PCRE2_SUFFIX(pcre2_set_depth_limit_)
+#define pcre2_set_heap_limit                  PCRE2_SUFFIX(pcre2_set_heap_limit_)
 #define pcre2_set_match_limit                 PCRE2_SUFFIX(pcre2_set_match_limit_)
 #define pcre2_set_max_pattern_length          PCRE2_SUFFIX(pcre2_set_max_pattern_length_)
 #define pcre2_set_newline                     PCRE2_SUFFIX(pcre2_set_newline_)
diff --git a/src/pcre2.h.in b/src/pcre2.h.in
index 7a8eb71..fb0042b 100644
--- a/src/pcre2.h.in
+++ b/src/pcre2.h.in
@@ -268,6 +268,7 @@ numbers must not be changed. */
 #define PCRE2_ERROR_BADSUBSPATTERN    (-60)
 #define PCRE2_ERROR_TOOMANYREPLACE    (-61)
 #define PCRE2_ERROR_BADSERIALIZEDDATA (-62)
+#define PCRE2_ERROR_HEAPLIMIT         (-63)
 
 /* Request types for pcre2_pattern_info() */
 
@@ -297,6 +298,7 @@ numbers must not be changed. */
 #define PCRE2_INFO_SIZE                 22
 #define PCRE2_INFO_HASBACKSLASHC        23
 #define PCRE2_INFO_FRAMESIZE            24
+#define PCRE2_INFO_HEAPLIMIT            25
 
 /* Request types for pcre2_config(). */
 
@@ -313,6 +315,7 @@ numbers must not be changed. */
 #define PCRE2_CONFIG_UNICODE                 9
 #define PCRE2_CONFIG_UNICODE_VERSION        10
 #define PCRE2_CONFIG_VERSION                11
+#define PCRE2_CONFIG_HEAPLIMIT              12
 
 /* Types for code units in patterns and subject strings. */
 
@@ -452,6 +455,8 @@ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
     int (*)(pcre2_callout_block *, void *), void *); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
   pcre2_set_depth_limit(pcre2_match_context *, uint32_t); \
+PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
+  pcre2_set_heap_limit(pcre2_match_context *, uint32_t); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
   pcre2_set_match_limit(pcre2_match_context *, uint32_t); \
 PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
@@ -676,6 +681,7 @@ pcre2_compile are called by application code. */
 #define pcre2_set_character_tables            PCRE2_SUFFIX(pcre2_set_character_tables_)
 #define pcre2_set_compile_recursion_guard     PCRE2_SUFFIX(pcre2_set_compile_recursion_guard_)
 #define pcre2_set_depth_limit                 PCRE2_SUFFIX(pcre2_set_depth_limit_)
+#define pcre2_set_heap_limit                  PCRE2_SUFFIX(pcre2_set_heap_limit_)
 #define pcre2_set_match_limit                 PCRE2_SUFFIX(pcre2_set_match_limit_)
 #define pcre2_set_max_pattern_length          PCRE2_SUFFIX(pcre2_set_max_pattern_length_)
 #define pcre2_set_newline                     PCRE2_SUFFIX(pcre2_set_newline_)
diff --git a/src/pcre2_compile.c b/src/pcre2_compile.c
index bab1494..e823747 100644
--- a/src/pcre2_compile.c
+++ b/src/pcre2_compile.c
@@ -727,6 +727,7 @@ enum { PSO_OPT,     /* Value is an option bit */
        PSO_FLG,     /* Value is a flag bit */
        PSO_NL,      /* Value is a newline type */
        PSO_BSR,     /* Value is a \R type */
+       PSO_LIMH,    /* Read integer value for heap limit */ 
        PSO_LIMM,    /* Read integer value for match limit */
        PSO_LIMD };  /* Read integer value for depth limit */
 
@@ -749,6 +750,7 @@ static pso pso_list[] = {
   { (uint8_t *)STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR, 18, PSO_OPT, PCRE2_NO_DOTSTAR_ANCHOR },
   { (uint8_t *)STRING_NO_JIT_RIGHTPAR,             7, PSO_FLG, PCRE2_NOJIT },
   { (uint8_t *)STRING_NO_START_OPT_RIGHTPAR,      13, PSO_OPT, PCRE2_NO_START_OPTIMIZE },
+  { (uint8_t *)STRING_LIMIT_HEAP_EQ,              11, PSO_LIMH, 0 },
   { (uint8_t *)STRING_LIMIT_MATCH_EQ,             12, PSO_LIMM, 0 },
   { (uint8_t *)STRING_LIMIT_DEPTH_EQ,             12, PSO_LIMD, 0 },
   { (uint8_t *)STRING_LIMIT_RECURSION_EQ,         16, PSO_LIMD, 0 },
@@ -8853,6 +8855,7 @@ uint32_t firstcu, reqcu;              /* Value of first/req code unit */
 uint32_t setflags = 0;                /* NL and BSR set flags */
 
 uint32_t skipatstart;                 /* When checking (*UTF) etc */
+uint32_t limit_heap  = UINT32_MAX;
 uint32_t limit_match = UINT32_MAX;    /* Unset match limits */
 uint32_t limit_depth = UINT32_MAX;
 
@@ -9026,6 +9029,7 @@ while (patlen - skipatstart >= 2 &&
 
         case PSO_LIMM:
         case PSO_LIMD:
+        case PSO_LIMH: 
         c = 0;
         pp = skipatstart;
         if (!IS_DIGIT(ptr[pp]))
@@ -9045,7 +9049,8 @@ while (patlen - skipatstart >= 2 &&
           ptr += pp;
           goto HAD_EARLY_ERROR;
           }
-        if (p->type == PSO_LIMM) limit_match = c;
+        if (p->type == PSO_LIMH) limit_heap = c;
+          else if (p->type == PSO_LIMM) limit_match = c;
           else limit_depth = c;
         skipatstart += pp - skipatstart;
         break;
@@ -9288,6 +9293,7 @@ re->magic_number = MAGIC_NUMBER;
 re->compile_options = options;
 re->overall_options = cb.external_options;
 re->flags = PCRE2_CODE_UNIT_WIDTH/8 | cb.external_flags | setflags;
+re->limit_heap = limit_heap;
 re->limit_match = limit_match;
 re->limit_depth = limit_depth;
 re->first_codeunit = 0;
diff --git a/src/pcre2_config.c b/src/pcre2_config.c
index 73b21b8..a60ff69 100644
--- a/src/pcre2_config.c
+++ b/src/pcre2_config.c
@@ -84,6 +84,7 @@ if (where == NULL)  /* Requests a length */
     return PCRE2_ERROR_BADOPTION;
 
     case PCRE2_CONFIG_BSR:
+    case PCRE2_CONFIG_HEAPLIMIT: 
     case PCRE2_CONFIG_JIT:
     case PCRE2_CONFIG_LINKSIZE:
     case PCRE2_CONFIG_MATCHLIMIT:
@@ -116,6 +117,10 @@ switch (what)
 #endif
   break;
 
+  case PCRE2_CONFIG_HEAPLIMIT:
+  *((uint32_t *)where) = HEAP_LIMIT;
+  break;
+
   case PCRE2_CONFIG_JIT:
 #ifdef SUPPORT_JIT
   *((uint32_t *)where) = 1;
diff --git a/src/pcre2_context.c b/src/pcre2_context.c
index 653b2c3..5427c03 100644
--- a/src/pcre2_context.c
+++ b/src/pcre2_context.c
@@ -168,6 +168,7 @@ const pcre2_match_context PRIV(default_match_context) = {
   NULL,
   NULL,
   PCRE2_UNSET,   /* Offset limit */
+  HEAP_LIMIT, 
   MATCH_LIMIT,
   MATCH_LIMIT_DEPTH };
 
@@ -346,6 +347,13 @@ mcontext->callout_data = callout_data;
 return 0;
 }
 
+PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
+pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
+{
+mcontext->heap_limit = limit;
+return 0;
+}
+
 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
 {
diff --git a/src/pcre2_error.c b/src/pcre2_error.c
index e25c7e6..3805495 100644
--- a/src/pcre2_error.c
+++ b/src/pcre2_error.c
@@ -256,6 +256,7 @@ static const unsigned char match_error_texts[] =
   "match with end before start is not supported\0"
   "too many replacements (more than INT_MAX)\0"
   "bad serialized data\0"
+  "heap limit exceeded\0" 
   ;
 
 
diff --git a/src/pcre2_internal.h b/src/pcre2_internal.h
index e516314..377737a 100644
--- a/src/pcre2_internal.h
+++ b/src/pcre2_internal.h
@@ -240,6 +240,16 @@ not rely on this. */
 
 #define COMPILE_ERROR_BASE 100
 
+/* The initial frames vector for remembering backtracking points in 
+pcre2_match() is allocated on the system stack, of this size (bytes). The size
+must be a multiple of sizeof(PCRE2_SPTR) in all environments, so making it a
+multiple of 8 is best. Typical frame sizes are a few hundred bytes (it depends
+on the number of capturing parentheses) so 20K handles quite a few frames. A
+larger vector on the heap is obtained for patterns that need more frames. The
+maximum size of this can be limited. */
+
+#define START_FRAMES_SIZE 20480
+
 /* Define the default BSR convention. */
 
 #ifdef BSR_ANYCRLF
@@ -922,6 +932,7 @@ a positive value. */
 #define STRING_NO_START_OPT_RIGHTPAR      "NO_START_OPT)"
 #define STRING_NOTEMPTY_RIGHTPAR          "NOTEMPTY)"
 #define STRING_NOTEMPTY_ATSTART_RIGHTPAR  "NOTEMPTY_ATSTART)"
+#define STRING_LIMIT_HEAP_EQ              "LIMIT_HEAP="
 #define STRING_LIMIT_MATCH_EQ             "LIMIT_MATCH="
 #define STRING_LIMIT_DEPTH_EQ             "LIMIT_DEPTH="
 #define STRING_LIMIT_RECURSION_EQ         "LIMIT_RECURSION="
@@ -1196,6 +1207,7 @@ only. */
 #define STRING_NO_START_OPT_RIGHTPAR      STR_N STR_O STR_UNDERSCORE STR_S STR_T STR_A STR_R STR_T STR_UNDERSCORE STR_O STR_P STR_T STR_RIGHT_PARENTHESIS
 #define STRING_NOTEMPTY_RIGHTPAR          STR_N STR_O STR_T STR_E STR_M STR_P STR_T STR_Y STR_RIGHT_PARENTHESIS
 #define STRING_NOTEMPTY_ATSTART_RIGHTPAR  STR_N STR_O STR_T STR_E STR_M STR_P STR_T STR_Y STR_UNDERSCORE STR_A STR_T STR_S STR_T STR_A STR_R STR_T STR_RIGHT_PARENTHESIS
+#define STRING_LIMIT_HEAP_EQ              STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_H STR_E STR_A STR_P STR_EQUALS_SIGN
 #define STRING_LIMIT_MATCH_EQ             STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_M STR_A STR_T STR_C STR_H STR_EQUALS_SIGN
 #define STRING_LIMIT_DEPTH_EQ             STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_D STR_E STR_P STR_T STR_H STR_EQUALS_SIGN
 #define STRING_LIMIT_RECURSION_EQ         STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_R STR_E STR_C STR_U STR_R STR_S STR_I STR_O STR_N STR_EQUALS_SIGN
diff --git a/src/pcre2_intmodedep.h b/src/pcre2_intmodedep.h
index 221fcb9..b6b478f 100644
--- a/src/pcre2_intmodedep.h
+++ b/src/pcre2_intmodedep.h
@@ -585,6 +585,7 @@ typedef struct pcre2_real_match_context {
   int    (*callout)(pcre2_callout_block *, void *);
   void    *callout_data;
   PCRE2_SIZE offset_limit;
+  uint32_t heap_limit; 
   uint32_t match_limit;
   uint32_t depth_limit;
 } pcre2_real_match_context;
@@ -614,6 +615,7 @@ typedef struct pcre2_real_code {
   uint32_t compile_options;       /* Options passed to pcre2_compile() */
   uint32_t overall_options;       /* Options after processing the pattern */
   uint32_t flags;                 /* Various state flags */
+  uint32_t limit_heap;            /* Limit set in the pattern */ 
   uint32_t limit_match;           /* Limit set in the pattern */
   uint32_t limit_depth;           /* Limit set in the pattern */
   uint32_t first_codeunit;        /* Starting code unit */
@@ -808,9 +810,10 @@ typedef struct match_block {
   heapframe *match_frames;        /* Points to vector of frames */
   heapframe *match_frames_top;    /* Points after the end of the vector */
   heapframe *stack_frames;        /* The original vector on the stack */ 
-  uint32_t match_call_count;      /* Number of times a new frame is created */
+  PCRE2_SIZE heap_limit;          /* As it says */
   uint32_t match_limit;           /* As it says */
   uint32_t match_limit_depth;     /* As it says */
+  uint32_t match_call_count;      /* Number of times a new frame is created */
   BOOL hitend;                    /* Hit the end of the subject at some point */
   BOOL hasthen;                   /* Pattern contains (*THEN) */
   const uint8_t *lcc;             /* Points to lower casing table */
diff --git a/src/pcre2_match.c b/src/pcre2_match.c
index c5eede4..ed6d604 100644
--- a/src/pcre2_match.c
+++ b/src/pcre2_match.c
@@ -64,15 +64,6 @@ information, and fields within it. */
 
 #define RECURSE_UNSET 0xffffffffu  /* Bigger than max group number */
 
-/* The initial frames vector for remembering backtracking points is allocated
-on the system stack, of this size (bytes). The size must be a multiple of
-sizeof(PCRE2_SPTR) in all environments, so making it a multiple of 8 is best.
-Typical frame sizes are a few hundred bytes (it depends on the number of
-capturing parentheses) so 10K handles quite a few frames. A larger vector on
-the heap is obtained for patterns that need more frames. */
-
-#define START_FRAMES_SIZE 10240
-
 /* Masks for identifying the public options that are permitted at match time. */
 
 #define PUBLIC_MATCH_OPTIONS \
@@ -618,14 +609,22 @@ backtracking point. */
 MATCH_RECURSE:
 
 /* Set up a new backtracking frame. If the vector is full, get a new one
-on the heap, doubling the size. */
+on the heap, doubling the size, but constrained by the heap limit. */
 
 N = (heapframe *)((char *)F + frame_size);
 if (N >= mb->match_frames_top)
   {
   PCRE2_SIZE newsize = mb->frame_vector_size * 2;
-  heapframe *new = mb->memctl.malloc(newsize, mb->memctl.memory_data);
+  heapframe *new;
 
+  if ((newsize / 1024) > mb->heap_limit)
+    {
+    PCRE2_SIZE maxsize = ((mb->heap_limit * 1024)/frame_size) * frame_size;
+    if (mb->frame_vector_size == maxsize) return PCRE2_ERROR_HEAPLIMIT;
+    newsize = maxsize;
+    }
+
+  new = mb->memctl.malloc(newsize, mb->memctl.memory_data);
   if (new == NULL) return PCRE2_ERROR_NOMEMORY;
   memcpy(new, mb->match_frames, mb->frame_vector_size);
 
@@ -802,13 +801,13 @@ fprintf(stderr, "++ op=%d\n", *Fecode);
              Fstart_match == mb->start_subject + mb->start_offset)))
       RRETURN(MATCH_NOMATCH);
 
-    /* Also fail if PCRE2_ENDANCHORED is set and the end of the match is not 
+    /* Also fail if PCRE2_ENDANCHORED is set and the end of the match is not
     the end of the subject. */
-    
+
     if (Feptr < mb->end_subject &&
         ((mb->moptions | mb->poptions) & PCRE2_ENDANCHORED) != 0)
-      RRETURN(MATCH_NOMATCH);     
- 
+      RRETURN(MATCH_NOMATCH);
+
     /* We have a successful match of the whole pattern. Record the result and
     then do a direct return from the function. If there is space in the offset
     vector, set any pairs that follow the highest-numbered captured string but
@@ -6093,13 +6092,13 @@ set up later. */
 utf = (re->overall_options & PCRE2_UTF) != 0;
 mb->partial = ((options & PCRE2_PARTIAL_HARD) != 0)? 2 :
               ((options & PCRE2_PARTIAL_SOFT) != 0)? 1 : 0;
-              
-/* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same 
-time. */ 
-              
-if (mb->partial != 0 && 
+
+/* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same
+time. */
+
+if (mb->partial != 0 &&
    ((re->overall_options | options) & PCRE2_ENDANCHORED) != 0)
-  return PCRE2_ERROR_BADOPTION; 
+  return PCRE2_ERROR_BADOPTION;
 
 /* Check a UTF string for validity if required. For 8-bit and 16-bit strings,
 we must also check that a starting offset does not point into the middle of a
@@ -6266,9 +6265,22 @@ correct when calling match() more than once for non-anchored patterns. */
 
 frame_size = sizeof(heapframe) + ((re->top_bracket - 1) * 2 * sizeof(PCRE2_SIZE));
 
+/* Limits set in the pattern override the match context only if they are
+smaller. */
+
+mb->heap_limit = (mcontext->heap_limit < re->limit_heap)?
+  mcontext->heap_limit : re->limit_heap;
+
+mb->match_limit = (mcontext->match_limit < re->limit_match)?
+  mcontext->match_limit : re->limit_match;
+
+mb->match_limit_depth = (mcontext->depth_limit < re->limit_depth)?
+  mcontext->depth_limit : re->limit_depth;
+
 /* If a pattern has very many capturing parentheses, the frame size may be very
 large. Ensure that there are at least 10 available frames by getting an initial
-vector on the heap if necessary. */
+vector on the heap if necessary, except when the heap limit prevents this. Get
+fewer if possible. (The heap limit is in kilobytes.) */
 
 if (frame_size <= START_FRAMES_SIZE/10)
   {
@@ -6278,6 +6290,11 @@ if (frame_size <= START_FRAMES_SIZE/10)
 else
   {
   mb->frame_vector_size = frame_size * 10;
+  if ((mb->frame_vector_size / 1024) > mb->heap_limit)
+    {
+    if (frame_size > mb->heap_limit * 1024) return PCRE2_ERROR_HEAPLIMIT;
+    mb->frame_vector_size = ((mb->heap_limit * 1024)/frame_size) * frame_size;
+    }
   mb->match_frames = mb->memctl.malloc(mb->frame_vector_size,
     mb->memctl.memory_data);
   if (mb->match_frames == NULL) return PCRE2_ERROR_NOMEMORY;
@@ -6292,14 +6309,6 @@ to avoid uninitialized memory read errors when it is copied to a new frame. */
 memset((char *)(mb->match_frames) + offsetof(heapframe, ovector), 0xff,
   re->top_bracket * 2 * sizeof(PCRE2_SIZE));
 
-/* Limits set in the pattern override the match context only if they are
-smaller. */
-
-mb->match_limit = (mcontext->match_limit < re->limit_match)?
-  mcontext->match_limit : re->limit_match;
-mb->match_limit_depth = (mcontext->depth_limit < re->limit_depth)?
-  mcontext->depth_limit : re->limit_depth;
-
 /* Pointers to the individual character tables */
 
 mb->lcc = re->tables + lcc_offset;
diff --git a/src/pcre2_pattern_info.c b/src/pcre2_pattern_info.c
index 5dd8ac5..c4ba38d 100644
--- a/src/pcre2_pattern_info.c
+++ b/src/pcre2_pattern_info.c
@@ -80,6 +80,7 @@ if (where == NULL)   /* Requests field length */
     case PCRE2_INFO_FIRSTCODEUNIT:
     case PCRE2_INFO_HASBACKSLASHC:
     case PCRE2_INFO_HASCRORLF:
+    case PCRE2_INFO_HEAPLIMIT: 
     case PCRE2_INFO_JCHANGED:
     case PCRE2_INFO_LASTCODETYPE:
     case PCRE2_INFO_LASTCODEUNIT:
@@ -171,6 +172,11 @@ switch(what)
   *((uint32_t *)where) = (re->flags & PCRE2_HASCRORLF) != 0;
   break;
 
+  case PCRE2_INFO_HEAPLIMIT:
+  *((uint32_t *)where) = re->limit_heap;
+  if (re->limit_heap == UINT32_MAX) return PCRE2_ERROR_UNSET;
+  break;
+
   case PCRE2_INFO_JCHANGED:
   *((uint32_t *)where) = (re->flags & PCRE2_JCHANGED) != 0;
   break;
diff --git a/src/pcre2grep.c b/src/pcre2grep.c
index f282e9e..7858954 100644
--- a/src/pcre2grep.c
+++ b/src/pcre2grep.c
@@ -212,6 +212,7 @@ static const uint8_t *character_tables = NULL;
 
 static uint32_t pcre2_options = 0;
 static uint32_t process_options = 0;
+static PCRE2_SIZE heap_limit = PCRE2_UNSET;
 static uint32_t match_limit = 0;
 static uint32_t depth_limit = 0;
 
@@ -330,7 +331,7 @@ static const char *incexname[4] = { "--include", "--exclude",
 
 /* Structure for options and list of them */
 
-enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_U32NUMBER,
+enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_U32NUMBER, OP_SIZE,
        OP_OP_NUMBER, OP_OP_NUMBERS, OP_PATLIST, OP_FILELIST, OP_BINFILES };
 
 typedef struct option_item {
@@ -356,16 +357,17 @@ used to identify them. */
 #define N_LOFFSETS     (-10)
 #define N_FOFFSETS     (-11)
 #define N_LBUFFER      (-12)
-#define N_M_LIMIT      (-13)
-#define N_M_LIMIT_DEP  (-14)
-#define N_BUFSIZE      (-15)
-#define N_NOJIT        (-16)
-#define N_FILE_LIST    (-17)
-#define N_BINARY_FILES (-18)
-#define N_EXCLUDE_FROM (-19)
-#define N_INCLUDE_FROM (-20)
-#define N_OM_SEPARATOR (-21)
-#define N_MAX_BUFSIZE  (-22)
+#define N_H_LIMIT      (-13)
+#define N_M_LIMIT      (-14)
+#define N_M_LIMIT_DEP  (-15)
+#define N_BUFSIZE      (-16)
+#define N_NOJIT        (-17)
+#define N_FILE_LIST    (-18)
+#define N_BINARY_FILES (-19)
+#define N_EXCLUDE_FROM (-20)
+#define N_INCLUDE_FROM (-21)
+#define N_OM_SEPARATOR (-22)
+#define N_MAX_BUFSIZE  (-23)
 
 static option_item optionlist[] = {
   { OP_NODATA,     N_NULL,   NULL,              "",              "terminate options" },
@@ -397,6 +399,7 @@ static option_item optionlist[] = {
   { OP_NODATA,     N_LBUFFER, NULL,             "line-buffered", "use line buffering" },
   { OP_NODATA,     N_LOFFSETS, NULL,            "line-offsets",  "output line numbers and offsets, not text" },
   { OP_STRING,     N_LOCALE, &locale,           "locale=locale", "use the named locale" },
+  { OP_SIZE,       N_H_LIMIT, &heap_limit,      "heap-limit=number",  "set PCRE2 heap limit option (kilobytes)" },
   { OP_U32NUMBER,  N_M_LIMIT, &match_limit,     "match-limit=number", "set PCRE2 match limit option" },
   { OP_U32NUMBER,  N_M_LIMIT_DEP, &depth_limit, "depth-limit=number", "set PCRE2 depth limit option" },
   { OP_U32NUMBER,  N_M_LIMIT_DEP, &depth_limit, "recursion-limit=number", "obsolete synonym for depth-limit" },
@@ -525,9 +528,9 @@ pcre2grep_exit(int rc)
 {
 if (resource_error)
   {
-  fprintf(stderr, "pcre2grep: Error %d, %d or %d means that a resource limit "
-    "was exceeded.\n", PCRE2_ERROR_JIT_STACKLIMIT, PCRE2_ERROR_MATCHLIMIT,
-    PCRE2_ERROR_DEPTHLIMIT);
+  fprintf(stderr, "pcre2grep: Error %d, %d, %d or %d means that a resource "
+    "limit was exceeded.\n", PCRE2_ERROR_JIT_STACKLIMIT, PCRE2_ERROR_MATCHLIMIT,
+    PCRE2_ERROR_DEPTHLIMIT, PCRE2_ERROR_HEAPLIMIT);
   fprintf(stderr, "pcre2grep: Check your regex for nested unlimited loops.\n");
   }
 exit(rc);
@@ -1647,7 +1650,7 @@ for (i = 1; p != NULL; p = p->next, i++)
   FWRITE(matchptr, 1, slen, stderr);   /* In case binary zero included */
   fprintf(stderr, "\n\n");
   if (*mrc == PCRE2_ERROR_MATCHLIMIT || *mrc == PCRE2_ERROR_DEPTHLIMIT ||
-      *mrc == PCRE2_ERROR_JIT_STACKLIMIT)
+      *mrc == PCRE2_ERROR_HEAPLIMIT || *mrc == PCRE2_ERROR_JIT_STACKLIMIT)
     resource_error = TRUE;
   if (error_count++ > 20)
     {
@@ -3796,7 +3799,7 @@ for (i = 1; i < argc; i++)
   /* Otherwise, deal with a single string or numeric data value. */
 
   else if (op->type != OP_NUMBER && op->type != OP_U32NUMBER &&
-           op->type != OP_OP_NUMBER)
+           op->type != OP_OP_NUMBER && op->type != OP_SIZE)
     {
     *((char **)op->dataptr) = option_data;
     }
@@ -3804,6 +3807,7 @@ for (i = 1; i < argc; i++)
     {
     unsigned long int n = decode_number(option_data, op, longop);
     if (op->type == OP_U32NUMBER) *((uint32_t *)op->dataptr) = n;
+      else if (op->type == OP_SIZE) *((PCRE2_SIZE *)op->dataptr) = n; 
       else *((int *)op->dataptr) = n;
     }
   }
@@ -3839,6 +3843,7 @@ if (output_text != NULL &&
 
 /* Put limits into the match data block. */
 
+if (heap_limit != PCRE2_UNSET) pcre2_set_heap_limit(match_context, heap_limit);
 if (match_limit > 0) pcre2_set_match_limit(match_context, match_limit);
 if (depth_limit > 0) pcre2_set_depth_limit(match_context, depth_limit);
 
diff --git a/src/pcre2test.c b/src/pcre2test.c
index d3d90fd..4b58163 100644
--- a/src/pcre2test.c
+++ b/src/pcre2test.c
@@ -588,6 +588,7 @@ static modstruct modlist[] = {
   { "get",                        MOD_DAT,  MOD_NN,  DO(get_numbers),            DO(get_names) },
   { "getall",                     MOD_DAT,  MOD_CTL, CTL_GETALL,                 DO(control) },
   { "global",                     MOD_PNDP, MOD_CTL, CTL_GLOBAL,                 PO(control) },
+  { "heap_limit",                 MOD_CTM,  MOD_INT, 0,                          MO(heap_limit) },
   { "hex",                        MOD_PAT,  MOD_CTL, CTL_HEXPAT,                 PO(control) },
   { "info",                       MOD_PAT,  MOD_CTL, CTL_INFO,                   PO(control) },
   { "jit",                        MOD_PAT,  MOD_IND, 7,                          PO(jit) },
@@ -1207,6 +1208,14 @@ are supported. */
   else \
     pcre2_set_depth_limit_32(G(a,32),b)
 
+#define PCRE2_SET_HEAP_LIMIT(a,b) \
+  if (test_mode == PCRE8_MODE) \
+    pcre2_set_heap_limit_8(G(a,8),b); \
+  else if (test_mode == PCRE16_MODE) \
+    pcre2_set_heap_limit_16(G(a,16),b); \
+  else \
+    pcre2_set_heap_limit_32(G(a,32),b)
+
 #define PCRE2_SET_MATCH_LIMIT(a,b) \
   if (test_mode == PCRE8_MODE) \
     pcre2_set_match_limit_8(G(a,8),b); \
@@ -1643,6 +1652,12 @@ the three different cases. */
   else \
     G(pcre2_set_depth_limit_,BITTWO)(G(a,BITTWO),b)
 
+#define PCRE2_SET_HEAP_LIMIT(a,b) \
+  if (test_mode == G(G(PCRE,BITONE),_MODE)) \
+    G(pcre2_set_heap_limit_,BITONE)(G(a,BITONE),b); \
+  else \
+    G(pcre2_set_heap_limit_,BITTWO)(G(a,BITTWO),b)
+
 #define PCRE2_SET_MATCH_LIMIT(a,b) \
   if (test_mode == G(G(PCRE,BITONE),_MODE)) \
     G(pcre2_set_match_limit_,BITONE)(G(a,BITONE),b); \
@@ -1856,6 +1871,7 @@ the three different cases. */
 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \
   pcre2_set_compile_recursion_guard_8(G(a,8),b,c)
 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_8(G(a,8),b)
+#define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_8(G(a,8),b)
 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_8(G(a,8),b)
 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_8(G(a,8),b)
 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_8(G(a,8),b)
@@ -1952,6 +1968,7 @@ the three different cases. */
 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \
   pcre2_set_compile_recursion_guard_16(G(a,16),b,c)
 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_16(G(a,16),b)
+#define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_16(G(a,16),b)
 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_16(G(a,16),b)
 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_16(G(a,16),b)
 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_16(G(a,16),b)
@@ -2048,6 +2065,7 @@ the three different cases. */
 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \
   pcre2_set_compile_recursion_guard_32(G(a,32),b,c)
 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_32(G(a,32),b)
+#define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_32(G(a,32),b)
 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_32(G(a,32),b)
 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_32(G(a,32),b)
 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_32(G(a,32),b)
@@ -4040,14 +4058,28 @@ if ((pat_patctl.control & CTL_INFO) != 0)
   {
   void *nametable;
   uint8_t *start_bits;
-  BOOL match_limit_set, depth_limit_set;
+  BOOL heap_limit_set, match_limit_set, depth_limit_set;
   uint32_t backrefmax, bsr_convention, capture_count, first_ctype, first_cunit,
     hasbackslashc, hascrorlf, jchanged, last_ctype, last_cunit, match_empty,
-    match_limit, minlength, nameentrysize, namecount, newline_convention,
-    depth_limit;
+    depth_limit, heap_limit, match_limit, minlength, nameentrysize, namecount, 
+    newline_convention;
 
   /* These info requests may return PCRE2_ERROR_UNSET. */
 
+  switch(pattern_info(PCRE2_INFO_HEAPLIMIT, &heap_limit, TRUE))
+    {
+    case 0:
+    heap_limit_set = TRUE;
+    break;
+
+    case PCRE2_ERROR_UNSET:
+    heap_limit_set = FALSE;
+    break;
+
+    default:
+    return PR_ABEND;
+    }
+
   switch(pattern_info(PCRE2_INFO_MATCHLIMIT, &match_limit, TRUE))
     {
     case 0:
@@ -4106,6 +4138,9 @@ if ((pat_patctl.control & CTL_INFO) != 0)
   if (maxlookbehind > 0)
     fprintf(outfile, "Max lookbehind = %d\n", maxlookbehind);
 
+  if (heap_limit_set)
+    fprintf(outfile, "Heap limit = %u\n", heap_limit);
+
   if (match_limit_set)
     fprintf(outfile, "Match limit = %u\n", match_limit);
 
@@ -5353,10 +5388,15 @@ uint32_t max = UINT32_MAX;
 
 PCRE2_SET_MATCH_LIMIT(dat_context, max);
 PCRE2_SET_DEPTH_LIMIT(dat_context, max);
+PCRE2_SET_HEAP_LIMIT(dat_context, max);
 
 for (;;)
   {
-  if (errnumber == PCRE2_ERROR_MATCHLIMIT)
+  if (errnumber == PCRE2_ERROR_HEAPLIMIT)
+    {
+    PCRE2_SET_HEAP_LIMIT(dat_context, mid);
+    }
+  else if (errnumber == PCRE2_ERROR_MATCHLIMIT)
     {
     PCRE2_SET_MATCH_LIMIT(dat_context, mid);
     }
@@ -5393,13 +5433,23 @@ for (;;)
            capcount == PCRE2_ERROR_NOMATCH ||
            capcount == PCRE2_ERROR_PARTIAL)
     {
+    /* If we've not hit the error with a heap limit less than the size of the
+    initial stack frame vector, the heap is not being used, so the minimum
+    limit is zero; there's no need to go on. The other limits are always 
+    greater than zero. */
+     
+    if (errnumber == PCRE2_ERROR_HEAPLIMIT && mid < START_FRAMES_SIZE/1024)   
+      {
+      fprintf(outfile, "Minimum %s limit = 0\n", msg);
+      break;
+      } 
     if (mid == min + 1)
       {
       fprintf(outfile, "Minimum %s limit = %d\n", msg, mid);
       break;
-      }
-    max = mid;
-    mid = (min + mid)/2;
+      } 
+    max = mid; 
+    mid = (min + max)/2;
     }
   else break;    /* Some other error */
   }
@@ -6662,20 +6712,32 @@ else for (gmatched = 0;; gmatched++)
         (double)CLOCKS_PER_SEC);
     }
 
-  /* Find the match and depth limits if requested. The match limit is not 
-  relevant for DFA matching and the depth limit is not relevant for JIT. */
+  /* Find the heap, match and depth limits if requested. The match and heap
+  limits are not relevant for DFA matching and the depth limit is not relevant
+  for JIT. */
 
   if ((dat_datctl.control & CTL_FINDLIMITS) != 0)
     {
     if ((dat_datctl.control & CTL_DFA) == 0)
+      { 
+      if (FLD(compiled_code, executable_jit) == NULL || 
+          (dat_datctl.options & PCRE2_NO_JIT) != 0)
+        {   
+        capcount = check_match_limit(pp, arg_ulen, PCRE2_ERROR_HEAPLIMIT, 
+          "heap");
+        }
       capcount = check_match_limit(pp, arg_ulen, PCRE2_ERROR_MATCHLIMIT, 
         "match");
+      }   
     else capcount = 0;     
+     
     if (FLD(compiled_code, executable_jit) == NULL || 
         (dat_datctl.options & PCRE2_NO_JIT) != 0 ||
         (dat_datctl.control & CTL_DFA) != 0)
+      {   
       capcount = check_match_limit(pp, arg_ulen, PCRE2_ERROR_DEPTHLIMIT,
         "depth");
+      }
     }
 
   /* Otherwise just run a single match, setting up a callout if required (the
@@ -7402,6 +7464,8 @@ printf("  \\C is supported\n");
 printf("  Internal link size = %d\n", optval);
 (void)PCRE2_CONFIG(PCRE2_CONFIG_PARENSLIMIT, &optval);
 printf("  Parentheses nest limit = %d\n", optval);
+(void)PCRE2_CONFIG(PCRE2_CONFIG_HEAPLIMIT, &optval);
+printf("  Default heap limit = %d\n", optval);
 (void)PCRE2_CONFIG(PCRE2_CONFIG_MATCHLIMIT, &optval);
 printf("  Default match limit = %d\n", optval);
 (void)PCRE2_CONFIG(PCRE2_CONFIG_DEPTHLIMIT, &optval);
diff --git a/testdata/testoutput15 b/testdata/testoutput15
index 68bbfac..7deb329 100644
--- a/testdata/testoutput15
+++ b/testdata/testoutput15
@@ -12,11 +12,13 @@ Starting code units: a z
 Last code unit = 'z'
 Subject length lower bound = 2
   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazzbbbbbb\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 7
 Minimum depth limit = 7
  0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazz
  1: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
   aaaaaaaaaaaaaz\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 20481
 Minimum depth limit = 30
 No match
@@ -26,6 +28,7 @@ Capturing subpattern count = 1
 May match empty string
 Subject length lower bound = 0
    /* this is a C style comment */\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 64
 Minimum depth limit = 7
  0: /* this is a C style comment */
@@ -33,21 +36,25 @@ Minimum depth limit = 7
 
 /^(?>a)++/
     aa\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 5
 Minimum depth limit = 3
  0: aa
     aaaaaaaaa\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 12
 Minimum depth limit = 3
  0: aaaaaaaaa
     
 /(a)(?1)++/
     aa\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 7
 Minimum depth limit = 5
  0: aa
  1: a
     aaaaaaaaa\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 21
 Minimum depth limit = 5
  0: aaaaaaaaa
@@ -55,30 +62,35 @@ Minimum depth limit = 5
 
 /a(?:.)*?a/ims
     abbbbbbbbbbbbbbbbbbbbba\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 24
 Minimum depth limit = 3
  0: abbbbbbbbbbbbbbbbbbbbba
     
 /a(?:.(*THEN))*?a/ims
     abbbbbbbbbbbbbbbbbbbbba\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 66
 Minimum depth limit = 45
  0: abbbbbbbbbbbbbbbbbbbbba
 
 /a(?:.(*THEN:ABC))*?a/ims
     abbbbbbbbbbbbbbbbbbbbba\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 66
 Minimum depth limit = 45
  0: abbbbbbbbbbbbbbbbbbbbba
 
 /^(?>a+)(?>b+)(?>c+)(?>d+)(?>e+)/
      aabbccddee\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 7
 Minimum depth limit = 7
  0: aabbccddee
 
 /^(?>(a+))(?>(b+))(?>(c+))(?>(d+))(?>(e+))/
      aabbccddee\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 12
 Minimum depth limit = 12
  0: aabbccddee
@@ -90,6 +102,7 @@ Minimum depth limit = 12
 
 /^(?>(a+))(?>b+)(?>(c+))(?>d+)(?>(e+))/
      aabbccddee\=find_limits
+Minimum heap limit = 0
 Minimum match limit = 10
 Minimum depth limit = 10
  0: aabbccddee
diff --git a/testdata/testoutput2 b/testdata/testoutput2
index 539f853..67dfc1a 100644
--- a/testdata/testoutput2
+++ b/testdata/testoutput2
@@ -15609,7 +15609,7 @@ Last code unit = 'c'
 Subject length lower bound = 4
 
 # End of testinput2 
-Error -63: PCRE2_ERROR_BADDATA (unknown error number)
+Error -64: PCRE2_ERROR_BADDATA (unknown error number)
 Error -62: bad serialized data
 Error -2: partial match
 Error -1: no match