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
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
279 length entry. The first three must be alpha, lower, upper, as this is assumed
356 /* The POSIX class substitutes must be in the order of the POSIX class names,
437 are no longer used. This used to be a table of strings, but in order to reduce
445 substring, so that the whole string ends with \0\0, which can be detected when
483 "(?R or (?[+-]digits must be followed by )\0"
518 "a numbered reference must not be zero\0"
530 "\\c must be followed by an ASCII character\0"
696 value in the first row means that \D+\d can be turned into \D++\d.
698 The Unicode property types (\P and \p) have to be present to fill out the table
699 because of what their opcode values are, but the table values should always be
701 columns apply to items that cannot be repeated, so there is no need to have
800 Note: SPACE and PXSPACE used to be different because Perl excluded VT from
813 question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
904 has been reached or the increase will be rather small.
975 will be placed in chptr. A backreference to group n is returned as negative n.
976 When UTF-8 is enabled, a positive value greater than 255 may be returned in
1013 in a table. A non-zero result is something that can be returned immediately.
1014 Otherwise further processing may be required. */
1049 /* In JavaScript, \u must be followed by four hexadecimal numbers.
1092 class, \g must be followed by one of a number of specific things:
1191 number is less than 8 (used to be 10), or if there are that many previous
1194 be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If
1297 /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal
1321 /* Handle \x in Perl's style. \x{ddd} is a character number which can be
1323 digits. If not, { used to be treated as a data character. However, Perl
1435 odd, but there used to be some cases other than the default, and there may
1436 be again in future, so I haven't "optimized" it. */
1505 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
1574 so the syntax is guaranteed to be correct, but we need to check the values.
1644 skipassert TRUE if certain assertions are to be skipped
1699 because they can be forward references. We solve this by remembering this case
1753 an ALT. If it is END it's the end of the outer call. All can be handled by
1770 be OK. If the subroutine is a forward reference, we can't deal with
2038 so that it can be called from pcre_study() when finding the minimum matching
2058 /* XCLASS is used for classes that cannot be represented just by a bit
2123 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
2193 /* XCLASS is used for classes that cannot be represented just by a bit
2240 /* In UTF-8 mode, opcodes that are followed by a character may be followed
2334 Returns: TRUE if what is matched could be empty
2393 is a recursive call, as otherwise there will be an infinite loop. If it is
2429 /* Groups with zero repeats can of course be empty; skip them. */
2440 /* A nested group that is already marked as "could be empty" can just be
2462 empty branch, so just skip over the conditional, because it could be empty.
2489 cannot be represented just by a bit map. This includes negated single
2510 case OP_CRSTAR: /* These could be empty; continue */
2587 /* These are going to continue, as they may be empty, but we have to
2618 MINUPTO, and POSUPTO and their caseless and negative versions may be
2714 Returns: TRUE if what is matched could be empty
2852 list[0] will be filled with the opcode
2853 list[1] will be non-zero if this opcode
2963 /* The othercase might be the same value. */
3055 which case the base cannot be possessified.
3115 /* TRUE only in greedy case. The non-greedy case could be replaced by
3124 cannot be converted to a possessive form. */
3172 /* The bracket content will be checked by the
3204 /* Character bitsets can also be compared to certain opcodes. */
3245 /* Might be an empty repeat. */
3298 /* Might be an empty repeat. */
3303 processed specially; the rest can be handled with a lookup table. */
3327 /* There's a table that specifies how each combination is to be
3365 for the property being tested against. Therefore, it cannot be used
3424 /* Might be an empty repeat. */
3574 /* At least one character must be matched from this opcode. */
3579 /* Control never reaches here. There used to be a fail-save return FALSE; here,
3671 /* end must not be NULL. */
3748 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
3835 didn't consider this to be a POSIX class. Likewise for [:1234:].
3837 The problem in trying to be exactly like Perl is in the handling of escapes. We
3838 have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
3839 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
3929 that is referenced. This means that groups can be replicated for fixed
3936 is called, the partially compiled regex must be temporarily terminated with
3947 adjust the amount by which the group is to be moved
4118 characters to a class. The character values in the arguments will be within the
4191 length - this means that the same lists of (e.g.) horizontal spaces can be used
4212 /* Regardless of start, c will always be <= 255. */
4242 and can only be > 256 for 16-bit and 32-bit libraries. */
4276 list is in order (which it should be), ranges of characters are detected and
4319 vertical whitespace to a class. The list must be in order.
4432 class_uchardata always so that it can be passed to add_to_class() always,
4433 though it will not be used in non-UTF 8-bit cases. This avoids having to supply
4459 item types that can be repeated set these backoff variables appropriately. */
4706 /* There can never be a first char if '.' is first, whatever happens about
4725 so that data characters > 255 can be handled correctly.
4822 /* Extended class (xclass) will be used when characters > 255
4832 class_has_8bitchar will be non-zero if the class contains at least one <
4833 256 character; class_one_char will be 1 if the class contains just one
4834 character; xclass_has_prop will be TRUE if unicode property checks
4890 goto CHECK_RANGE; /* Could be range if \E follows */
4947 /* The posix_substitutes table specifies which POSIX classes can be
4986 bit map for the POSIX class in a chunk of local store because we may be
4988 may be in the main map already. At the end we or the result into the
5179 This may be greater than 256. */
5185 /* A character may be followed by '-' to form a range. However, Perl does
5186 not permit ']' to be the end of the range. A '-' character at the end is
5242 /* The second part of a range can be a single-character escape
5292 cannot be done anymore. Any value greater than 1 indicates that there
5321 to be set. Otherwise, there can be no first char if this item is first,
5422 /* If this is the first thing in the branch, there can be no first char
5436 well can be ignored. If (when there are explicit characters > 255 that must
5437 be listed) there are no characters < 256, we can omit the bitmap in the
5475 /* If there are no characters > 255, or they are all to be included or
5595 repeated ones could be re-implemented independently so as not to need this,
5623 than one, ensure that it is set in reqchar - it might not be if a sequence
5673 the the Unicode property types will be present only when SUPPORT_UCP is
5695 /* If the maximum is zero then the minimum must also be zero; Perl allows
5941 The first one has to be handled carefully because it's the original
5942 copy, which has to be moved up. The remainder can be handled by code
5957 /* We chain together the bracket offset fields that have to be
5972 forward reference subroutine calls in the group, there will be entries on
6137 ONCE brackets can be converted into non-capturing brackets, as the
6144 that runtime checking can be done. [This check is also applied to ONCE
6149 KETRPOS. (It turns out to be convenient at runtime to detect this kind of
6157 there will be earlier copies of the group, and so we still have to wrap
6244 JavaScript mode. The other ways in which OP_FAIL can be generated, that is
6267 tempcode, not at previous, which might be the first part of a string whose
6277 remains is greater than zero, there's a further opcode that can be
6322 QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
6323 all other cases, tempcode will be pointing to the repeat opcode, and will
6324 be less than code, so the value of len will be greater than 0. */
6429 /* First deal with various "verbs" that can be introduced by '*'. */
6592 /* A condition can be an assertion, a number (referring to a numbered
6600 There is one unfortunate ambiguity, caused by history. 'R' can be the
6604 For compatibility with auto-callouts, we allow a callout to be
6840 thing to do, but Perl allows all assertions to be quantified, and when
6841 they contain capturing parentheses there may be a potential use for
6877 default: /* Could be name define, else bad */
6895 case CHAR_C: /* Callout - may be followed by digits; */
6988 number is the same, break the loop, which causes the name to be
7074 However, with the change of recursive back references to be atomic,
7075 we have to look for the number so that this state can be identified, as
7118 reference to a duplicated name (this cannot be determined until the
7193 group can be made atomic. */
7231 be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
7232 ever be taken. */
7298 be filled in at the end. */
7334 subpattern because the condition might be testing for recursion in
7337 conditional subpatterns will be picked up then. */
7348 character (relevant if it is repeated, because it will then be
7399 item is right at the start of the pattern, the options can be
7401 the compile phase. This can be helpful when matching -- for instance in
7409 we are within parentheses, the starting BRA will still be present. At
7410 any parenthesis level, the length value can be used to test if anything
7436 previous = NULL; /* This item can't be repeated */
7478 /* Assertions used not to be repeatable, but this was changed for Perl
7479 compatibility, so all kinds can now be repeated. We copy code into a
7480 non-register variable (tempcode) in order to be able to pass its address
7530 not be available. */
7612 zerofirstchar outside the main loop so that they can be accessed for the
7661 /* For a forward assertion, we take the reqchar, if set. This can be
7679 are arranged to be the negation of the corresponding OP_values in the
7682 that consume a character may be repeated. We can test for values between
7737 would actually be in error are never taken. */
7751 /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus
7805 group can be made atomic. */
7891 /* Handle a literal character. It is guaranteed not to be whitespace or #
7892 when the extended flag is set. If we are in a UTF mode, it may be a
7953 only if it is not to be matched caselessly. */
7992 error states. Pass back the position in the pattern so that it can be displayed
8091 only OP_CBRA need be tested here; changing this opcode to one of its variants,
8144 /* In the real compile phase, there is some post-processing to be done. */
8205 because there may be forward references that we can't check here. Set a
8208 the problem can be shown. */
8352 be found, because ^ generates OP_CIRCM in that mode.
8354 We can also consider a regex to be anchored if OP_SOM starts all its branches.
8428 it isn't in brackets that are or may be referenced or inside an atomic
8456 "first char" processing can be done to speed things up in multiline
8486 for start of line. Other kinds of condition fail. Note that there may be an
8545 brackets that may be referenced, as long as the pattern does not contain
8559 because the number of characters matched by .* cannot be adjusted inside
8737 can be NULL if you don't want a code value
8804 as soon as possible, so that a fairly large buffer should be sufficient for
8812 similar way to cworkspace, it can be expanded using malloc() if necessary. */
9055 references to help in deciding whether (.*) can be treated as anchored or not.
9097 /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
9099 been put into the cd block so that they can be changed if an option setting is
9129 overflow should no longer be possible because nowadays we limit the maximum
9207 error, errorcode will be set non-zero, so we don't need to look at the result
9241 allocated memory as unaddressable, so that any out-of-bound reads can be
9246 /* Fill in any forward references that are required. There may be repeated
9269 /* If the workspace had to be expanded, free the new memory. Set the pointer to
9281 /* Unless disabled, check whether any single character iterators can be
9283 the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
9295 (recursions or subroutine calls), a flag is set for them to be checked here,
9296 because they may contain forward references. Actual recursions cannot be fixed
9318 pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
9319 int end_op = *be;
9320 *be = OP_END;
9323 *be = end_op;
9356 Otherwise, if we know what the first byte has to be, save it, because that
9479 was compiled can be seen. */
9492 can be provided to applications. */
