Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 1 | .TH PCRE2PARTIAL 3 "04 September 2019" "PCRE2 10.34" |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 2 | .SH NAME |
| 3 | PCRE2 - Perl-compatible regular expressions |
| 4 | .SH "PARTIAL MATCHING IN PCRE2" |
| 5 | .rs |
| 6 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 7 | In normal use of PCRE2, if there is a match up to the end of a subject string, |
| 8 | but more characters are needed to match the entire pattern, PCRE2_ERROR_NOMATCH |
| 9 | is returned, just like any other failing match. There are circumstances where |
| 10 | it might be helpful to distinguish this "partial match" case. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 11 | .P |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 12 | One example is an application where the subject string is very long, and not |
| 13 | all available at once. The requirement here is to be able to do the matching |
| 14 | segment by segment, but special action is needed when a matched substring spans |
| 15 | the boundary between two segments. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 16 | .P |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 17 | Another example is checking a user input string as it is typed, to ensure that |
| 18 | it conforms to a required format. Invalid characters can be immediately |
| 19 | diagnosed and rejected, giving instant feedback. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 20 | .P |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 21 | Partial matching is a PCRE2-specific feature; it is not Perl-compatible. It is |
| 22 | requested by setting one of the PCRE2_PARTIAL_HARD or PCRE2_PARTIAL_SOFT |
| 23 | options when calling a matching function. The difference between the two |
| 24 | options is whether or not a partial match is preferred to an alternative |
| 25 | complete match, though the details differ between the two types of matching |
| 26 | function. If both options are set, PCRE2_PARTIAL_HARD takes precedence. |
| 27 | .P |
| 28 | If you want to use partial matching with just-in-time optimized code, as well |
| 29 | as setting a partial match option for the matching function, you must also call |
| 30 | \fBpcre2_jit_compile()\fP with one or both of these options: |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 31 | .sp |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 32 | PCRE2_JIT_PARTIAL_HARD |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 33 | PCRE2_JIT_PARTIAL_SOFT |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 34 | .sp |
| 35 | PCRE2_JIT_COMPLETE should also be set if you are going to run non-partial |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 36 | matches on the same pattern. Separate code is compiled for each mode. If the |
| 37 | appropriate JIT mode has not been compiled, interpretive matching code is used. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 38 | .P |
| 39 | Setting a partial matching option disables two of PCRE2's standard |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 40 | optimization hints. PCRE2 remembers the last literal code unit in a pattern, |
| 41 | and abandons matching immediately if it is not present in the subject string. |
| 42 | This optimization cannot be used for a subject string that might match only |
| 43 | partially. PCRE2 also remembers a minimum length of a matching string, and does |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 44 | not bother to run the matching function on shorter strings. This optimization |
| 45 | is also disabled for partial matching. |
| 46 | . |
| 47 | . |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 48 | .SH "REQUIREMENTS FOR A PARTIAL MATCH" |
| 49 | .rs |
| 50 | .sp |
| 51 | A possible partial match occurs during matching when the end of the subject |
| 52 | string is reached successfully, but either more characters are needed to |
| 53 | complete the match, or the addition of more characters might change what is |
| 54 | matched. |
| 55 | .P |
| 56 | Example 1: if the pattern is /abc/ and the subject is "ab", more characters are |
| 57 | definitely needed to complete a match. In this case both hard and soft matching |
| 58 | options yield a partial match. |
| 59 | .P |
| 60 | Example 2: if the pattern is /ab+/ and the subject is "ab", a complete match |
| 61 | can be found, but the addition of more characters might change what is |
| 62 | matched. In this case, only PCRE2_PARTIAL_HARD returns a partial match; |
| 63 | PCRE2_PARTIAL_SOFT returns the complete match. |
| 64 | .P |
| 65 | On reaching the end of the subject, when PCRE2_PARTIAL_HARD is set, if the next |
| 66 | pattern item is \ez, \eZ, \eb, \eB, or $ there is always a partial match. |
| 67 | Otherwise, for both options, the next pattern item must be one that inspects a |
| 68 | character, and at least one of the following must be true: |
| 69 | .P |
| 70 | (1) At least one character has already been inspected. An inspected character |
| 71 | need not form part of the final matched string; lookbehind assertions and the |
| 72 | \eK escape sequence provide ways of inspecting characters before the start of a |
| 73 | matched string. |
| 74 | .P |
| 75 | (2) The pattern contains one or more lookbehind assertions. This condition |
| 76 | exists in case there is a lookbehind that inspects characters before the start |
| 77 | of the match. |
| 78 | .P |
| 79 | (3) There is a special case when the whole pattern can match an empty string. |
| 80 | When the starting point is at the end of the subject, the empty string match is |
| 81 | a possibility, and if PCRE2_PARTIAL_SOFT is set and neither of the above |
| 82 | conditions is true, it is returned. However, because adding more characters |
| 83 | might result in a non-empty match, PCRE2_PARTIAL_HARD returns a partial match, |
| 84 | which in this case means "there is going to be a match at this point, but until |
| 85 | some more characters are added, we do not know if it will be an empty string or |
| 86 | something longer". |
| 87 | . |
| 88 | . |
| 89 | . |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 90 | .SH "PARTIAL MATCHING USING pcre2_match()" |
| 91 | .rs |
| 92 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 93 | When a partial matching option is set, the result of calling |
| 94 | \fBpcre2_match()\fP can be one of the following: |
| 95 | .TP 2 |
| 96 | \fBA successful match\fP |
| 97 | A complete match has been found, starting and ending within this subject. |
| 98 | .TP |
| 99 | \fBPCRE2_ERROR_NOMATCH\fP |
| 100 | No match can start anywhere in this subject. |
| 101 | .TP |
| 102 | \fBPCRE2_ERROR_PARTIAL\fP |
| 103 | Adding more characters may result in a complete match that uses one or more |
| 104 | characters from the end of this subject. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 105 | .P |
| 106 | When a partial match is returned, the first two elements in the ovector point |
| 107 | to the portion of the subject that was matched, but the values in the rest of |
| 108 | the ovector are undefined. The appearance of \eK in the pattern has no effect |
| 109 | for a partial match. Consider this pattern: |
| 110 | .sp |
| 111 | /abc\eK123/ |
| 112 | .sp |
| 113 | If it is matched against "456abc123xyz" the result is a complete match, and the |
| 114 | ovector defines the matched string as "123", because \eK resets the "start of |
| 115 | match" point. However, if a partial match is requested and the subject string |
| 116 | is "456abc12", a partial match is found for the string "abc12", because all |
| 117 | these characters are needed for a subsequent re-match with additional |
| 118 | characters. |
| 119 | .P |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 120 | If there is more than one partial match, the first one that was found provides |
| 121 | the data that is returned. Consider this pattern: |
| 122 | .sp |
| 123 | /123\ew+X|dogY/ |
| 124 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 125 | If this is matched against the subject string "abc123dog", both alternatives |
| 126 | fail to match, but the end of the subject is reached during matching, so |
| 127 | PCRE2_ERROR_PARTIAL is returned. The offsets are set to 3 and 9, identifying |
| 128 | "123dog" as the first partial match. (In this example, there are two partial |
| 129 | matches, because "dog" on its own partially matches the second alternative.) |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 130 | . |
| 131 | . |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 132 | .SS "How a partial match is processed by pcre2_match()" |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 133 | .rs |
| 134 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 135 | What happens when a partial match is identified depends on which of the two |
| 136 | partial matching options is set. |
| 137 | .P |
| 138 | If PCRE2_PARTIAL_HARD is set, PCRE2_ERROR_PARTIAL is returned as soon as a |
| 139 | partial match is found, without continuing to search for possible complete |
| 140 | matches. This option is "hard" because it prefers an earlier partial match over |
| 141 | a later complete match. For this reason, the assumption is made that the end of |
| 142 | the supplied subject string is not the true end of the available data, which is |
| 143 | why \ez, \eZ, \eb, \eB, and $ always give a partial match. |
| 144 | .P |
| 145 | If PCRE2_PARTIAL_SOFT is set, the partial match is remembered, but matching |
| 146 | continues as normal, and other alternatives in the pattern are tried. If no |
| 147 | complete match can be found, PCRE2_ERROR_PARTIAL is returned instead of |
| 148 | PCRE2_ERROR_NOMATCH. This option is "soft" because it prefers a complete match |
| 149 | over a partial match. All the various matching items in a pattern behave as if |
| 150 | the subject string is potentially complete; \ez, \eZ, and $ match at the end of |
| 151 | the subject, as normal, and for \eb and \eB the end of the subject is treated |
| 152 | as a non-alphanumeric. |
| 153 | .P |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 154 | The difference between the two partial matching options can be illustrated by a |
| 155 | pattern such as: |
| 156 | .sp |
| 157 | /dog(sbody)?/ |
| 158 | .sp |
| 159 | This matches either "dog" or "dogsbody", greedily (that is, it prefers the |
| 160 | longer string if possible). If it is matched against the string "dog" with |
| 161 | PCRE2_PARTIAL_SOFT, it yields a complete match for "dog". However, if |
| 162 | PCRE2_PARTIAL_HARD is set, the result is PCRE2_ERROR_PARTIAL. On the other |
| 163 | hand, if the pattern is made ungreedy the result is different: |
| 164 | .sp |
| 165 | /dog(sbody)??/ |
| 166 | .sp |
| 167 | In this case the result is always a complete match because that is found first, |
| 168 | and matching never continues after finding a complete match. It might be easier |
| 169 | to follow this explanation by thinking of the two patterns like this: |
| 170 | .sp |
| 171 | /dog(sbody)?/ is the same as /dogsbody|dog/ |
| 172 | /dog(sbody)??/ is the same as /dog|dogsbody/ |
| 173 | .sp |
| 174 | The second pattern will never match "dogsbody", because it will always find the |
| 175 | shorter match first. |
| 176 | . |
| 177 | . |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 178 | .SS "Example of partial matching using pcre2test" |
| 179 | .rs |
| 180 | .sp |
| 181 | The \fBpcre2test\fP data modifiers \fBpartial_hard\fP (or \fBph\fP) and |
| 182 | \fBpartial_soft\fP (or \fBps\fP) set PCRE2_PARTIAL_HARD and PCRE2_PARTIAL_SOFT, |
| 183 | respectively, when calling \fBpcre2_match()\fP. Here is a run of |
| 184 | \fBpcre2test\fP using a pattern that matches the whole subject in the form of a |
| 185 | date: |
| 186 | .sp |
| 187 | re> /^\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed$/ |
| 188 | data> 25dec3\e=ph |
| 189 | Partial match: 23dec3 |
| 190 | data> 3ju\e=ph |
| 191 | Partial match: 3ju |
| 192 | data> 3juj\e=ph |
| 193 | No match |
| 194 | .sp |
| 195 | This example gives the same results for both hard and soft partial matching |
| 196 | options. Here is an example where there is a difference: |
| 197 | .sp |
| 198 | re> /^\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed$/ |
| 199 | data> 25jun04\e=ps |
| 200 | 0: 25jun04 |
| 201 | 1: jun |
| 202 | data> 25jun04\e=ph |
| 203 | Partial match: 25jun04 |
| 204 | .sp |
| 205 | With PCRE2_PARTIAL_SOFT, the subject is matched completely. For |
| 206 | PCRE2_PARTIAL_HARD, however, the subject is assumed not to be complete, so |
| 207 | there is only a partial match. |
| 208 | . |
| 209 | . |
| 210 | . |
| 211 | .SH "MULTI-SEGMENT MATCHING WITH pcre2_match()" |
| 212 | .rs |
| 213 | .sp |
| 214 | PCRE was not originally designed with multi-segment matching in mind. However, |
| 215 | over time, features (including partial matching) that make multi-segment |
| 216 | matching possible have been added. A very long string can be searched segment |
| 217 | by segment by calling \fBpcre2_match()\fP repeatedly, with the aim of achieving |
| 218 | the same results that would happen if the entire string was available for |
| 219 | searching all the time. Normally, the strings that are being sought are much |
| 220 | shorter than each individual segment, and are in the middle of very long |
| 221 | strings, so the pattern is normally not anchored. |
| 222 | .P |
| 223 | Special logic must be implemented to handle a matched substring that spans a |
| 224 | segment boundary. PCRE2_PARTIAL_HARD should be used, because it returns a |
| 225 | partial match at the end of a segment whenever there is the possibility of |
| 226 | changing the match by adding more characters. The PCRE2_NOTBOL option should |
| 227 | also be set for all but the first segment. |
| 228 | .P |
| 229 | When a partial match occurs, the next segment must be added to the current |
| 230 | subject and the match re-run, using the \fIstartoffset\fP argument of |
| 231 | \fBpcre2_match()\fP to begin at the point where the partial match started. |
| 232 | For example: |
| 233 | .sp |
| 234 | re> /\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed/ |
| 235 | data> ...the date is 23ja\e=ph |
| 236 | Partial match: 23ja |
| 237 | data> ...the date is 23jan19 and on that day...\e=offset=15 |
| 238 | 0: 23jan19 |
| 239 | 1: jan |
| 240 | .sp |
| 241 | Note the use of the \fBoffset\fP modifier to start the new match where the |
| 242 | partial match was found. In this example, the next segment was added to the one |
| 243 | in which the partial match was found. This is the most straightforward |
| 244 | approach, typically using a memory buffer that is twice the size of each |
| 245 | segment. After a partial match, the first half of the buffer is discarded, the |
| 246 | second half is moved to the start of the buffer, and a new segment is added |
| 247 | before repeating the match as in the example above. After a no match, the |
| 248 | entire buffer can be discarded. |
| 249 | .P |
| 250 | If there are memory constraints, you may want to discard text that precedes a |
| 251 | partial match before adding the next segment. Unfortunately, this is not at |
| 252 | present straightforward. In cases such as the above, where the pattern does not |
| 253 | contain any lookbehinds, it is sufficient to retain only the partially matched |
| 254 | substring. However, if the pattern contains a lookbehind assertion, characters |
| 255 | that precede the start of the partial match may have been inspected during the |
| 256 | matching process. When \fBpcre2test\fP displays a partial match, it indicates |
| 257 | these characters with '<' if the \fBallusedtext\fP modifier is set: |
| 258 | .sp |
| 259 | re> "(?<=123)abc" |
| 260 | data> xx123ab\e=ph,allusedtext |
| 261 | Partial match: 123ab |
| 262 | <<< |
| 263 | .sp |
| 264 | However, the \fBallusedtext\fP modifier is not available for JIT matching, |
| 265 | because JIT matching does not record the first (or last) consulted characters. |
| 266 | For this reason, this information is not available via the API. It is therefore |
| 267 | not possible in general to obtain the exact number of characters that must be |
| 268 | retained in order to get the right match result. If you cannot retain the |
| 269 | entire segment, you must find some heuristic way of choosing. |
| 270 | .P |
| 271 | If you know the approximate length of the matching substrings, you can use that |
| 272 | to decide how much text to retain. The only lookbehind information that is |
| 273 | currently available via the API is the length of the longest individual |
| 274 | lookbehind in a pattern, but this can be misleading if there are nested |
| 275 | lookbehinds. The value returned by calling \fBpcre2_pattern_info()\fP with the |
| 276 | PCRE2_INFO_MAXLOOKBEHIND option is the maximum number of characters (not code |
| 277 | units) that any individual lookbehind moves back when it is processed. A |
| 278 | pattern such as "(?<=(?<!b)a)" has a maximum lookbehind value of one, but |
| 279 | inspects two characters before its starting point. |
| 280 | .P |
| 281 | In a non-UTF or a 32-bit case, moving back is just a subtraction, but in |
| 282 | UTF-8 or UTF-16 you have to count characters while moving back through the code |
| 283 | units. |
| 284 | . |
| 285 | . |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 286 | .SH "PARTIAL MATCHING USING pcre2_dfa_match()" |
| 287 | .rs |
| 288 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 289 | The DFA function moves along the subject string character by character, without |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 290 | backtracking, searching for all possible matches simultaneously. If the end of |
| 291 | the subject is reached before the end of the pattern, there is the possibility |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 292 | of a partial match. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 293 | .P |
| 294 | When PCRE2_PARTIAL_SOFT is set, PCRE2_ERROR_PARTIAL is returned only if there |
| 295 | have been no complete matches. Otherwise, the complete matches are returned. |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 296 | If PCRE2_PARTIAL_HARD is set, a partial match takes precedence over any |
| 297 | complete matches. The portion of the string that was matched when the longest |
| 298 | partial match was found is set as the first matching string. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 299 | .P |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 300 | Because the DFA function always searches for all possible matches, and there is |
| 301 | no difference between greedy and ungreedy repetition, its behaviour is |
| 302 | different from the \fBpcre2_match()\fP. Consider the string "dog" matched |
| 303 | against this ungreedy pattern: |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 304 | .sp |
| 305 | /dog(sbody)??/ |
| 306 | .sp |
| 307 | Whereas the standard function stops as soon as it finds the complete match for |
| 308 | "dog", the DFA function also finds the partial match for "dogsbody", and so |
| 309 | returns that when PCRE2_PARTIAL_HARD is set. |
| 310 | . |
| 311 | . |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 312 | .SH "MULTI-SEGMENT MATCHING WITH pcre2_dfa_match()" |
| 313 | .rs |
| 314 | .sp |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 315 | When a partial match has been found using the DFA matching function, it is |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 316 | possible to continue the match by providing additional subject data and calling |
| 317 | the function again with the same compiled regular expression, this time setting |
| 318 | the PCRE2_DFA_RESTART option. You must pass the same working space as before, |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 319 | because this is where details of the previous partial match are stored. You can |
| 320 | set the PCRE2_PARTIAL_SOFT or PCRE2_PARTIAL_HARD options with PCRE2_DFA_RESTART |
| 321 | to continue partial matching over multiple segments. Here is an example using |
| 322 | \fBpcre2test\fP: |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 323 | .sp |
| 324 | re> /^\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed$/ |
| 325 | data> 23ja\e=dfa,ps |
| 326 | Partial match: 23ja |
| 327 | data> n05\e=dfa,dfa_restart |
| 328 | 0: n05 |
| 329 | .sp |
| 330 | The first call has "23ja" as the subject, and requests partial matching; the |
| 331 | second call has "n05" as the subject for the continued (restarted) match. |
| 332 | Notice that when the match is complete, only the last part is shown; PCRE2 does |
| 333 | not retain the previously partially-matched string. It is up to the calling |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 334 | program to do that if it needs to. This means that, for an unanchored pattern, |
| 335 | if a continued match fails, it is not possible to try again at a new starting |
| 336 | point. All this facility is capable of doing is continuing with the previous |
| 337 | match attempt. For example, consider this pattern: |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 338 | .sp |
| 339 | 1234|3789 |
| 340 | .sp |
| 341 | If the first part of the subject is "ABC123", a partial match of the first |
| 342 | alternative is found at offset 3. There is no partial match for the second |
| 343 | alternative, because such a match does not start at the same point in the |
| 344 | subject string. Attempting to continue with the string "7890" does not yield a |
| 345 | match because only those alternatives that match at one point in the subject |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 346 | are remembered. Depending on the application, this may or may not be what you |
| 347 | want. |
| 348 | .P |
| 349 | If you do want to allow for starting again at the next character, one way of |
| 350 | doing it is to retain some or all of the segment and try a new complete match, |
| 351 | as described for \fBpcre2_match()\fP above. Another possibility is to work with |
| 352 | two buffers. If a partial match at offset \fIn\fP in the first buffer is |
| 353 | followed by "no match" when PCRE2_DFA_RESTART is used on the second buffer, you |
| 354 | can then try a new match starting at offset \fIn+1\fP in the first buffer. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 355 | . |
| 356 | . |
| 357 | .SH AUTHOR |
| 358 | .rs |
| 359 | .sp |
| 360 | .nf |
| 361 | Philip Hazel |
| 362 | University Computing Service |
| 363 | Cambridge, England. |
| 364 | .fi |
| 365 | . |
| 366 | . |
| 367 | .SH REVISION |
| 368 | .rs |
| 369 | .sp |
| 370 | .nf |
Elliott Hughes | 2dbd7d2 | 2020-06-03 14:32:37 -0700 | [diff] [blame] | 371 | Last updated: 04 September 2019 |
| 372 | Copyright (c) 1997-2019 University of Cambridge. |
Janis Danisevskis | 112c9cc | 2016-03-31 13:35:25 +0100 | [diff] [blame] | 373 | .fi |