Lines Matching refs:this
16 this list of conditions and the following disclaimer.
19 notice, this list of conditions and the following disclaimer in the
24 this software without specific prior written permission.
99 is partly compiled into this space, but the compiled parts are discarded as
102 so this number is very generous.
106 end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
110 that the workspace is expanded using malloc() in this situation. The value
279 length entry. The first three must be alpha, lower, upper, as this is assumed
441 simply count through to the one we want - this isn't a performance issue
487 "this version of PCRE is compiled without UTF support\0"
529 "this version of PCRE is not compiled with Unicode property support\0"
798 unnecessary work is done when checking, but this keeps things much simpler
800 this table is used.
1104 this is synonymous with \k{name}, we fudge it up by pretending it really
1240 then treat the digit as a following literal. At least by Perl 5.18 this
1249 significant 8 bits of octal numbers (I think this is what early Perls used
1382 We used just to recognize this construct and fall through to the normal
1642 that do not influence this. For some calls, it makes sense to skip negative
1698 temporarily terminated with OP_END when this function is called.
1702 However, we cannot do this when the assertion contains subroutine calls,
1703 because they can be forward references. We solve this by remembering this case
1727 /* Scan along the opcodes for this branch. If we get to the end of the
2328 hit an unclosed bracket, we return "empty" - this means we've struck an inner
2396 /* If the reference is to a completed group, we need to detect whether this
2857 list[1] will be non-zero if this opcode
3121 uses more memory, which we cannot get at this stage.) */
3142 a previous iterator, this is not possible. */
3578 /* At least one character must be matched from this opcode. */
3831 encountered in a character class. It checks whether this is followed by a
3835 Originally, this function only recognized a sequence of letters between the
3839 didn't consider this to be a POSIX class. Likewise for [:1234:].
3939 have their offsets adjusted. That one of the jobs of this function. Before it
3946 the current group is on this list, it adjusts the offset in the list, not the
3970 /* See if this recursion is on the forward reference list. If so, adjust the
3983 /* Otherwise, adjust the recursion offset if it's after the start of this
4070 in this case, ocptr contains the original
4195 length - this means that the same lists of (e.g.) horizontal spaces can be used
4290 except character to omit; this is used when adding lists of
4422 must not do this for other options (e.g. PCRE_EXTENDED) because they may change
4518 previous cycle of this loop. */
4532 /* There is at least one situation where code goes backwards: this is the
4535 allow memory for it. Therefore, don't ever reduce the length at this point.
4567 /* Remember where this code item starts so we can pick up the length
4734 whether the bitmap is present, and whether this is a negated class or not.
4854 /* Process characters until ] is reached. By writing this as a "do" it
5214 /* If we hit \Q (not followed by \E) at this point, go into escaped
5322 escapes. If this is the final character in the class, we can optimize by
5325 to be set. Otherwise, there can be no first char if this item is first,
5345 whether this character has more than one other case. If so, generate
5370 /* We are finished with this character class */
5376 then we can handle this with the normal one-character code. */
5391 has been generated. Add this character to the class. */
5415 the second phase this is a sufficient test. However, in the pre-compile
5418 anything at this point. For this reason, xclass gets set TRUE above when
5419 uchar_classdata is emptied, and that's why this code is the way it is here
5426 /* If this is the first thing in the branch, there can be no first char
5499 /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
5537 /* Remember whether this is a variable length repeat */
5551 this point. */
5579 If the next character is '?' this is a minimizing repeat, by default,
5599 repeated ones could be re-implemented independently so as not to need this,
5612 /* When actually compiling, we need to check whether this was a forward
5644 easier to write this out separately than try to macrify it. Use c to
5700 this case, so we do too - by simply omitting the item altogether. */
5865 cases. Note that at this point we can encounter only the "basic" bracket
5866 opcodes such as BRA and CBRA, as this is the place where they get converted
5900 this reason, it is simplest to treat this case separately, as otherwise
5907 output altogether, like this:
5918 don't have a list of which groups are referenced, we cannot do this
5922 and do no more at this point. However, we do need to adjust any
5926 this. */
6142 behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
6146 whether this group is one that could match an empty string. If so,
6153 KETRPOS. (It turns out to be convenient at runtime to detect this kind of
6156 the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
6263 TRUE. For some opcodes, there are special alternative opcodes for this
6270 is always FALSE at this stage. Note that the repeated item starts at
6557 appearance of any of them means that this is not a capturing group. */
6786 after the opening parenthesis [e.g. (?(abc)...] and in this case there
6846 this feature. Not that that applies to a quantified (?!) but we allow
6995 scanning in case this is a duplicate with the same number. For
7079 we have to look for the number so that this state can be identified, as
7122 reference to a duplicated name (this cannot be determined until the
7195 /* Check to see if this back reference is recursive, that it, it
7235 be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
7299 this point. If we end up with a forward reference, first check that
7301 now. Then remember this forward reference in the workspace so it can
7335 this is a recursive call. We check to see if this is a left
7337 must not, however, do this check if we are in a conditional
7401 /* If the options ended with ')' this is not the start of a nested
7402 group with option changes, so the options change at this level. If this
7412 during the pre-compile. However, this can happen only at top level - if
7436 /* Change options at this level, and pass them back for use
7482 /* Assertions used not to be repeatable, but this was changed for Perl
7518 /* If this was an atomic group and there are no capturing groups within it,
7531 If this is a conditional bracket, check that there are no more than
7532 two branches in the group, or just one if it's a DEFINE group. We do this
7561 make use of its firstchar or reqchar, because this is equivalent to an
7627 /* If we have not yet set a firstchar in this branch, take it from the
7687 ESC_b and ESC_Z for the latter; this may have to change if any new ones are
7715 /* Set values to reset to if this is followed by a zero repeat. */
7734 save_hwm = cd->hwm; /* Normally this is set when '(' is read */
7807 /* Check to see if this back reference is recursive, that it, it
7909 /* At this point we have the character's bytes in mcbuffer, and the length
7916 this character has more than one other case. If so, generate a special
7946 byte, set it from this character, but revert to none on a zero repeat.
8018 options option bits, including any changes for this subpattern
8022 lookbehind TRUE if this is a lookbehind assertion
8024 skipbytes skip this many bytes at start (for brackets and OP_COND)
8081 lenthptr for NULL. We cannot do this by looking at the value of code at the
8092 /* If this is a capturing subpattern, add to the chain of open capturing items
8095 only OP_CBRA need be tested here; changing this opcode to one of its variants,
8107 /* Offset is set zero to mark that this bracket is still open */
8152 /* If this is the first branch, the firstchar and reqchar values for the
8163 /* If this is not the first branch, the first char and reqchar have to
8206 /* If lookbehind, check that this branch matches a fixed-length string, and
8324 is reversed. It's done like this so that the start of the bracket has a
8352 /* Try to find out if this is an anchored regular expression. Consider each
8355 it's anchored. However, if this is a multiline pattern, then only OP_SOD will
8376 this prevents the number of characters it matches from being adjusted.
8380 bracket_map a bitmap of which brackets we are inside while testing; this
8470 bracket_map a bitmap of which brackets we are inside while testing; this
8562 in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC
8704 duplicate or later name, carry on. We do this for duplicates so that in the
8733 holding a compiled version of the expression. The original API for this
8809 this purpose. The same space is used in the second phase for remembering where
8820 /* Set this early so that early errors get offset 0. */
8837 /* However, we can give a message for this error */
9077 no longer needed, so hopefully this workspace will never overflow, though there
9178 field; this time it's used for remembering forward references to subpatterns.
9288 used in this code because at least one compiler gives a warning about loss of
9301 length, but subroutine calls can. It is done like this so that those without
9303 exceptional ones forgo this. We scan the pattern to check that they are fixed
9495 /* Check for a pattern than can match an empty string, so that this information