Lines Matching defs:be
23 contributors may be used to endorse or promote products derived from
59 COMPILE_PCREx macro will already be appropriately set. */
100 soon as they can be, so that hopefully there will never be an overrun. The code
105 remembering forward references to groups so that they can be filled in at the
285 length entry. The first three must be alpha, lower, upper, as this is assumed
362 /* The POSIX class substitutes must be in the order of the POSIX class names,
443 are no longer used. This used to be a table of strings, but in order to reduce
451 substring, so that the whole string ends with \0\0, which can be detected when
489 "(?R or (?[+-]digits must be followed by )\0"
524 "a numbered reference must not be zero\0"
537 "\\c must be followed by an ASCII character\0"
539 "\\c must be followed by a letter or one of [\\]^_?\0"
707 value in the first row means that \D+\d can be turned into \D++\d.
709 The Unicode property types (\P and \p) have to be present to fill out the table
710 because of what their opcode values are, but the table values should always be
712 columns apply to items that cannot be repeated, so there is no need to have
812 Note: SPACE and PXSPACE used to be different because Perl excluded VT from
826 question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
917 has been reached or the increase will be rather small.
988 will be placed in chptr. A backreference to group n is returned as negative n.
989 When UTF-8 is enabled, a positive value greater than 255 may be returned in
1026 in a table. A non-zero result is something that can be returned immediately.
1027 Otherwise further processing may be required. */
1062 /* In JavaScript, \u must be followed by four hexadecimal numbers.
1105 class, \g must be followed by one of a number of specific things:
1204 number is less than 8 (used to be 10), or if there are that many previous
1207 be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If
1310 /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal
1334 /* Handle \x in Perl's style. \x{ddd} is a character number which can be
1336 digits. If not, { used to be treated as a data character. However, Perl
1457 odd, but there used to be some cases other than the default, and there may
1458 be again in future, so I haven't "optimized" it. */
1527 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
1596 so the syntax is guaranteed to be correct, but we need to check the values.
1666 skipassert TRUE if certain assertions are to be skipped
1721 because they can be forward references. We solve this by remembering this case
1778 an ALT. If it is END it's the end of the outer call. All can be handled by
1795 be OK. If the subroutine is a forward reference, we can't deal with
2071 so that it can be called from pcre_study() when finding the minimum matching
2091 /* XCLASS is used for classes that cannot be represented just by a bit
2156 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
2254 /* XCLASS is used for classes that cannot be represented just by a bit
2301 /* In UTF-8 mode, opcodes that are followed by a character may be followed
2395 Returns: TRUE if what is matched could be empty
2449 is a recursive call, as otherwise there will be an infinite loop. If it is
2485 /* Groups with zero repeats can of course be empty; skip them. */
2496 /* A nested group that is already marked as "could be empty" can just be
2518 empty branch, so just skip over the conditional, because it could be empty.
2545 cannot be represented just by a bit map. This includes negated single
2566 case OP_CRSTAR: /* These could be empty; continue */
2643 /* These are going to continue, as they may be empty, but we have to
2674 MINUPTO, and POSUPTO and their caseless and negative versions may be
2770 Returns: TRUE if what is matched could be empty
2908 list[0] will be filled with the opcode
2909 list[1] will be non-zero if this opcode
3019 /* The othercase might be the same value. */
3111 which case the base cannot be possessified.
3174 /* TRUE only in greedy case. The non-greedy case could be replaced by
3183 cannot be converted to a possessive form. */
3232 /* The bracket content will be checked by the
3264 /* Character bitsets can also be compared to certain opcodes. */
3305 /* Might be an empty repeat. */
3358 /* Might be an empty repeat. */
3363 processed specially; the rest can be handled with a lookup table. */
3387 /* There's a table that specifies how each combination is to be
3425 for the property being tested against. Therefore, it cannot be used
3484 /* Might be an empty repeat. */
3634 /* At least one character must be matched from this opcode. */
3639 /* Control never reaches here. There used to be a fail-save return FALSE; here,
3741 /* end must not be NULL. */
3819 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
3906 didn't consider this to be a POSIX class. Likewise for [:1234:].
3908 The problem in trying to be exactly like Perl is in the handling of escapes. We
3909 have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
3910 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
3995 that is referenced. This means that groups can be replicated for fixed
4002 is called, the partially compiled regex must be temporarily terminated with
4014 adjust the amount by which the group is to be moved
4187 characters to a class. The character values in the arguments will be within the
4264 length - this means that the same lists of (e.g.) horizontal spaces can be used
4285 /* Regardless of start, c will always be <= 255. */
4315 and can only be > 256 for 16-bit and 32-bit libraries. */
4349 list is in order (which it should be), ranges of characters are detected and
4392 vertical whitespace to a class. The list must be in order.
4505 class_uchardata always so that it can be passed to add_to_class() always,
4506 though it will not be used in non-UTF 8-bit cases. This avoids having to supply
4532 item types that can be repeated set these backoff variables appropriately. */
4814 /* There can never be a first char if '.' is first, whatever happens about
4834 so that data characters > 255 can be handled correctly.
4932 /* Extended class (xclass) will be used when characters > 255
4942 class_has_8bitchar will be non-zero if the class contains at least one <
4943 256 character; class_one_char will be 1 if the class contains just one
4944 character; xclass_has_prop will be TRUE if unicode property checks
5001 goto CHECK_RANGE; /* Could be range if \E follows */
5058 /* The posix_substitutes table specifies which POSIX classes can be
5095 OP_NCLASS will be used to indicate that characters greater than 255
5115 bit map for the POSIX class in a chunk of local store because we may be
5117 may be in the main map already. At the end we or the result into the
5311 This may be greater than 256. */
5317 /* A character may be followed by '-' to form a range. However, Perl does
5318 not permit ']' to be the end of the range. A '-' character at the end is
5374 /* The second part of a range can be a single-character escape
5424 cannot be done anymore. Any value greater than 1 indicates that there
5453 can cause firstchar to be set. Otherwise, there can be no first char if
5558 /* If this is the first thing in the branch, there can be no first char
5572 well can be ignored. If (when there are explicit characters > 255 that must
5573 be listed) there are no characters < 256, we can omit the bitmap in the
5618 /* If there are no characters > 255, or they are all to be included or
5738 repeated ones could be re-implemented independently so as not to need this,
5766 than one, ensure that it is set in reqchar - it might not be if a sequence
5816 the the Unicode property types will be present only when SUPPORT_UCP is
5838 /* If the maximum is zero then the minimum must also be zero; Perl allows
6085 The first one has to be handled carefully because it's the original
6086 copy, which has to be moved up. The remainder can be handled by code
6101 /* We chain together the bracket offset fields that have to be
6116 forward reference subroutine calls in the group, there will be entries on
6279 ONCE brackets can be converted into non-capturing brackets, as the
6286 that runtime checking can be done. [This check is also applied to ONCE
6291 KETRPOS. (It turns out to be convenient at runtime to detect this kind of
6299 there will be earlier copies of the group, and so we still have to wrap
6392 JavaScript mode. The other ways in which OP_FAIL can be generated, that is
6415 tempcode, not at previous, which might be the first part of a string whose
6425 remains is greater than zero, there's a further opcode that can be
6470 QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
6471 all other cases, tempcode will be pointing to the repeat opcode, and will
6472 be less than code, so the value of len will be greater than 0. */
6573 /* Now deal with various "verbs" that can be introduced by '*'. */
6754 /* A condition can be an assertion, a number (referring to a numbered
6762 There is one unfortunate ambiguity, caused by history. 'R' can be the
6766 For compatibility with auto-callouts, we allow a callout to be
6777 /* tempptr should now be pointing to the opening parenthesis of the
7028 thing to do, but Perl allows all assertions to be quantified, and when
7029 they contain capturing parentheses there may be a potential use for
7065 default: /* Could be name define, else bad */
7083 case CHAR_C: /* Callout - may be followed by digits; */
7176 number is the same, break the loop, which causes the name to be
7262 However, with the change of recursive back references to be atomic,
7263 we have to look for the number so that this state can be identified, as
7293 cannot be determined until the second pass). This needs an extra
7300 currently inside, that is, it could be a recursive reference. In the
7301 real compile this will be picked up and the reference wrapped with
7305 another group with the same number might be created later. This
7311 /* It is even worse than that. The current reference may be to an
7422 group can be made atomic. */
7465 be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
7466 ever be taken. */
7541 be filled in at the end. */
7577 subpattern because the condition might be testing for recursion in
7580 conditional subpatterns will be picked up then. */
7591 character (relevant if it is repeated, because it will then be
7655 previous = NULL; /* This item can't be repeated */
7697 /* All assertions used not to be repeatable, but this was changed for Perl
7698 compatibility. All kinds can now be repeated except for assertions that are
7699 conditions (Perl also forbids these to be repeated). We copy code into a
7700 non-register variable (tempcode) in order to be able to pass its address
7703 here so as to allow assertions later in the group to be quantified. */
7763 not be available. */
7845 zerofirstchar outside the main loop so that they can be accessed for the
7894 /* For a forward assertion, we take the reqchar, if set. This can be
7912 are arranged to be the negation of the corresponding OP_values in the
7915 that consume a character may be repeated. We can test for values between
7960 would actually be in error are never taken. */
7974 /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus
8029 group can be made atomic. */
8117 /* Handle a literal character. It is guaranteed not to be whitespace or #
8118 when the extended flag is set. If we are in a UTF mode, it may be a
8180 only if it is not to be matched caselessly. */
8219 error states. Pass back the position in the pattern so that it can be displayed
8321 only OP_CBRA need be tested here; changing this opcode to one of its variants,
8374 /* In the real compile phase, there is some post-processing to be done. */
8435 because there may be forward references that we can't check here. Set a
8438 the problem can be shown. */
8582 be found, because ^ generates OP_CIRCM in that mode.
8584 We can also consider a regex to be anchored if OP_SOM starts all its branches.
8658 it isn't in brackets that are or may be referenced or inside an atomic
8686 "first char" processing can be done to speed things up in multiline
8716 for start of line. Other kinds of condition fail. Note that there may be an
8776 brackets that may be referenced, as long as the pattern does not contain
8790 because the number of characters matched by .* cannot be adjusted inside
8968 can be NULL if you don't want a code value
9035 as soon as possible, so that a fairly large buffer should be sufficient for
9043 similar way to cworkspace, it can be expanded using malloc() if necessary. */
9286 references to help in deciding whether (.*) can be treated as anchored or not.
9330 /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
9332 been put into the cd block so that they can be changed if an option setting is
9355 overflow should no longer be possible because nowadays we limit the maximum
9434 error, errorcode will be set non-zero, so we don't need to look at the result
9468 allocated memory as unaddressable, so that any out-of-bound reads can be
9473 /* Fill in any forward references that are required. There may be repeated
9506 /* If the workspace had to be expanded, free the new memory. Set the pointer to
9518 /* Unless disabled, check whether any single character iterators can be
9520 the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
9532 (recursions or subroutine calls), a flag is set for them to be checked here,
9533 because they may contain forward references. Actual recursions cannot be fixed
9555 pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
9556 int end_op = *be;
9557 *be = OP_END;
9560 *be = end_op;
9593 Otherwise, if we know what the first byte has to be, save it, because that
9716 was compiled can be seen. */
9729 can be provided to applications. */