Lines Matching refs:of
6 documentation and the comment at the head of the RunTest file.
15 about the algorithm was that the amount of space required to hold the compiled
16 form of an expression was known in advance. The code to apply an expression did
19 a list of current states and checking all of them as it advanced through the
20 subject string. In the terminology of Jeffrey Friedl's book, it was a "DFA
23 the one matching the longest subset of the subject string was chosen. This did
24 not necessarily maximize the individual wild portions of the pattern, as is
36 maximizing (or, optionally, minimizing in Perl) the amount of the subject that
37 matches individual wild portions of the pattern. This is an "NFA algorithm" in
44 For the set of functions that form the "basic" PCRE library (which are
46 that used an amount of store bounded by a multiple of the number of characters
47 in the pattern, to save on compiling time. However, because of the greater
57 in any combination of 8-bit, 16-bit or 32-bit modes, creating up to three
61 However, so as not to over-complicate the text, the names of PCRE functions are
70 compile - which might use a bit less than the predicted amount of memory. The
80 had become very complicated and hard to maintain. Indeed one of the early
82 I had a flash of inspiration as to how I could run the real compile function in
84 actually only ever using a few hundred bytes of working memory, and without too
85 many tests of the mode that might slow it down. So I refactored the compiling
86 functions to work this way. This got rid of about 600 lines of source. It
91 A side effect of this work was that the previous limit of 200 on the nesting
92 depth of parentheses was removed. However, there is a downside: pcre_compile()
94 is doing a full analysis of the pattern. My hope was that this would not be a
97 At release 8.34, a limit on the nesting depth of parentheses was re-introduced
98 (default 250, settable at build time) so as to put a limit on the amount of
109 as compatible with Perl as possible. This is the function most users of PCRE
110 will use most of the time. From release 8.20, if PCRE is compiled with
112 successful, the JIT code is run instead of the normal pcre_exec() code, but the
128 because it may have a number of states active at one time. More work would be
131 support is not available for this kind of matching.
138 others) may change in the middle of patterns. From PCRE 8.13, their processing
140 different settings. The runtime functions do not need to keep track of an
144 Format of compiled patterns
147 The compiled form of a pattern is a vector of unsigned units (bytes in 8-bit
148 mode, shorts in 16-bit mode, 32-bit words in 32-bit mode), containing items of
150 of the item is either implicit in the opcode or contained in the data that
154 within the compiled pattern. LINK_SIZE always specifies a number of bytes. The
170 OP_END end of pattern
174 OP_SOD match start of data: \A
175 OP_SOM, start of match (subject + offset): \G
176 OP_SET_SOM, set start of match (\K)
177 OP_CIRC ^ (start of data)
178 OP_CIRCM ^ multiline mode (start of data or after newline)
191 OP_EODN match end of data or newline at end: \Z
192 OP_EOD match end of data: \z
193 OP_DOLL $ (end of data, or before final newline)
194 OP_DOLLM $ multiline mode (end of data or before newline)
254 Other repeats make use of these opcodes:
262 Each of these is followed by a count and then the repeated character. OP_UPTO
267 Another set of matching repeating opcodes (called OP_NOTSTAR, OP_NOTSTARI,
276 Repeats of things like \d are done exactly as for single characters, except
277 that instead of a character, the opcode for the type is stored in the data
298 OP_PROP and OP_NOTPROP are used for positive and negative matches of a
301 value. The types are a set of #defines of the form PT_xxx, and the values are
302 enumerations of the form ucp_xx, defined in the ucp.h source file. The value is
306 Repeats of these items use the OP_TYPESTAR etc. set of opcodes, followed by
318 A set of repeating opcodes (called OP_NOTSTAR etc.) are used for repeated,
326 bits are counted from the least significant end of each unit. In caseless mode,
335 are less than 256, followed by a list of pairs (for a range) and single
340 There follows the bit map, if XCL_MAP is set, and then a sequence of items
343 XCL_END marks the end of the list
363 in the group name table of the first entry for the requred name, followed by
364 the number of groups with the same name.
373 opcode to see if it is one of
395 A pair of non-capturing round brackets is wrapped round each expression at
396 compile time, so alternation always happens in the context of brackets.
421 is preceded by one of OP_BRAZERO, OP_BRAMINZERO, or OP_SKIPZERO. These are
423 subpattern entirely is a valid branch. In the case of the first two, not
429 compiled data its minimum number of times (or once with OP_BRAZERO if the
434 fashion up to the maximum number of times, with OP_BRAZERO or OP_BRAMINZERO
451 have POS on the end, e.g. OP_BRAPOS instead of OP_BRA and OP_SCPBRPOS instead
452 of OP_SCBRA. The end of such a group is marked by OP_KETRPOS. If the minimum
476 of the opcodes OP_ASSERT or OP_ASSERT_NOT. Backward assertions use the opcodes
478 is OP_REVERSE, followed by a count of the number of characters to move back the
479 pointer in the subject string. In ASCII mode, the count is a number of units,
482 each alternative of a lookbehind assertion, allowing them to have different
491 the condition is a back reference, this is stored at the start of the
496 names table, and the number of groups with the same name.
498 If the condition is "in recursion" (coded as "(?(R)"), or "in recursion of
499 group x" (coded as "(?(Rx)"), the group number is stored at the start of the
500 subpattern using the opcode OP_RREF (with a value of zero for "the whole
503 conditional subpattern always starts with one of the assertions.
511 bracket from the start of the whole pattern. From release 6.5, OP_RECURSE is
520 OP_CALLOUT is followed by one unit of data that holds a callout number in the
523 start of the following item, and another count giving the length of this item.
