Lines Matching defs:be
23 contributors may be used to endorse or promote products derived from
29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
84 soon as they can be, so that hopefully there will never be an overrun. The code
89 remembering forward references to groups so that they can be filled in at the
225 length entry. The first three must be alpha, lower, upper, as this is assumed
265 substitutes must be in the order of the names, defined above, and there are
318 are no longer used. This used to be a table of strings, but in order to reduce
326 substring, so that the whole string ends with \0\0, which can be detected when
364 "(?R or (?[+-]digits must be followed by )\0"
399 "a numbered reference must not be zero\0"
411 "\\c must be followed by an ASCII character\0"
587 UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
619 in a table. A non-zero result is something that can be returned immediately.
620 Otherwise further processing may be required. */
650 /* \g must be followed by one of a number of specific things:
734 the way Perl works seems to be as follows:
739 digits are read to form an escaped byte. Thus \123 is likely to be octal
790 /* \x is complicated. \x{ddd} is a character number which can be greater
873 odd, but there used to be some cases other than the default, and there may
874 be again in future, so I haven't "optimized" it. */
937 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
1038 so the syntax is guaranteed to be correct, but we need to check the values.
1068 Also, max must not be less than min. */
1112 that if (?< or (?' or (?P< is encountered, the name will be correctly
1182 condition (there can't be any nested parens). */
1243 /* Skip over character classes; this logic must be similar to the way they
1272 /* If the next character is ']', it is a data character that must be
1352 references to subpatterns. We used to be able to start this scan from the
1409 skipassert TRUE if certain assertions are to be skipped
1472 because they can be forward references. We solve this by remembering this case
1518 END it's the end of the outer call. All can be handled by the same code. */
1533 be OK. If the subroutine is a forward reference, we can't deal with
1684 so that it can be called from pcre_study() when finding the minimum matching
1703 /* XCLASS is used for classes that cannot be represented just by a bit
1769 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
1826 /* XCLASS is used for classes that cannot be represented just by a bit
1875 /* In UTF-8 mode, opcodes that are followed by a character may be followed
1927 Returns: TRUE if what is matched could be empty
1953 /* Groups with zero repeats can of course be empty; skip them. */
1993 empty branch, so just skip over the conditional, because it could be empty.
2020 cannot be represented just by a bit map. This includes negated single
2041 case OP_CRSTAR: /* These could be empty; continue */
2090 /* These are going to continue, as they may be empty, but we have to
2119 MINUPTO, and POSUPTO may be followed by a multibyte character */
2179 Returns: TRUE if what is matched could be empty
2210 didn't consider this to be a POSIX class. Likewise for [:1234:].
2212 The problem in trying to be exactly like Perl is in the handling of escapes. We
2213 have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
2214 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
2286 that is referenced. This means that groups can be replicated for fixed
2293 is called, the partially compiled regex must be temporarily terminated with
2304 adjust the amount by which the group is to be moved
2832 their substitutions and process them. The result will always be either
2880 /* In principle, support for Unicode properties should be integrated here as
3014 item types that can be repeated set these backoff variables appropriately. */
3238 /* There can never be a first char if '.' is first, whatever happens about
3255 so that data characters > 255 can be handled correctly.
3387 goto CHECK_RANGE; /* Could be range if \E follows */
3449 chunk of local store because we may be adding and subtracting from it,
3450 and we don't want to subtract bits that may be in the main map already.
3720 /* Fall through if we have a single character (c >= 0). This may be
3725 /* A single character may be followed by '-' to form a range. However,
3726 Perl does not permit ']' to be the end of the range. A '-' character
3778 /* The second part of a range can be a single-character escape, but
3825 the relevant characters. There may be several ranges. Optimize how
3987 can cause firstbyte to be set. Otherwise, there can be no first char if
4027 thing in the branch, there can be no first char setting, whatever the
4039 well can be ignored. If (when there are explicit characters > 255 that must
4040 be listed) there are no characters < 256, we can omit the bitmap in the
4070 /* If there are no characters > 255, or they are all to be included or
4160 that it is set in reqbyte - it might not be if a sequence such as x{3} is
4230 the the Unicode property types will be present only when SUPPORT_UCP is
4260 /* If the maximum is zero then the minimum must also be zero; Perl allows
4270 one day we will be able to remove this restriction). */
4425 one day we will be able to remove this restriction). */
4466 from the current code pointer. There may be an OP_OPT setting following
4523 The first one has to be handled carefully because it's the original
4524 copy, which has to be moved up. The remainder can be handled by code
4539 /* We chain together the bracket offset fields that have to be
4554 forward reference subroutine calls in the group, there will be entries on
4690 that runtime checking can be done. [This check is also applied to
4716 JavaScript mode. The other ways in which OP_FAIL can be generated, that is
4736 tempcode, not at previous, which might be the first part of a string whose
4817 /* First deal with various "verbs" that can be introduced by '*'. */
4951 /* A condition can be an assertion, a number (referring to a numbered
4959 be the recursive thing or the name 'R' (and similarly for 'R' followed
4960 by digits), and (b) a number could be a name that consists of digits.
5043 be digits, in which case recno will be set. */
5187 default: /* Could be name define, else bad */
5204 case CHAR_C: /* Callout - may be followed by digits; */
5287 number are always OK. (An existing number can be re-used if (?|
5292 would all have to be modified, and the compiled code moved down, if
5391 However, with the change of recursive back references to be atomic,
5392 we have to look for the number so that this state can be identified, as
5486 be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
5487 ever be taken. */
5553 be filled in at the end. */
5653 item is right at the start of the pattern, the options can be
5655 the compile phase. This can be helpful when matching -- for instance in
5663 we are within parentheses, the starting BRA will still be present. At
5664 any parenthesis level, the length value can be used to test if anything
5694 information is also necessary so that a resetting item can be
5698 previous = NULL; /* This item can't be repeated */
5731 /* Process nested bracketed regex. Assertions may not be repeated, but
5732 other kinds can be. All their opcodes are >= OP_ONCE. We copy code into a
5733 non-register variable in order to be able to pass its address because some
5770 not be available. */
5852 zerofirstbyte outside the main loop so that they can be accessed for the
5891 /* For a forward assertion, we take the reqbyte, if set. This can be
5905 are arranged to be the negation of the corresponding OP_values in the
5908 that consume a character may be repeated. We can test for values between
5957 would actually be in error are never taken. */
6031 group can be made atomic. */
6110 /* Handle a literal character. It is guaranteed not to be whitespace or #
6111 when the extended flag is set. If we are in UTF-8 mode, it may be a
6151 only if it is not to be matched caselessly. */
6178 error states. Pass back the position in the pattern so that it can be displayed
6335 /* In the real compile phase, there is some post-processing to be done. */
6381 because there may be forward references that we can't check here. Set a
6384 the problem can be shown. */
6528 We can also consider a regex to be anchored if OP_SOM starts all its branches.
6589 it isn't in brackets that are or may be referenced. */
6616 "first char" processing can be done to speed things up in multiline
6643 for start of line. Other kinds of condition fail. Note that there may be an
6693 may be referenced. */
6798 can be NULL if you don't want a code value
6834 as soon as possible, so that a fairly large buffer should be sufficient for
7003 references to help in deciding whether (.*) can be treated as anchored or not.
7035 /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
7037 been put into the cd block so that they can be changed if an option setting is
7059 externally provided function. Integer overflow should no longer be possible
7112 error, errorcode will be set non-zero, so we don't need to look at the result
7159 (recursions or subroutine calls), a flag is set for them to be checked here,
7160 because they may contain forward references. Actual recursions can't be fixed
7182 uschar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
7183 int end_op = *be;
7184 *be = OP_END;
7186 *be = end_op;
7216 Otherwise, if we know what the first byte has to be, save it, because that
7286 was compiled can be seen. */
