| blob | f70386e586c085822fa082e11dc1646a18999e34 |
1 /*************************************************
2 * Perl-Compatible Regular Expressions *
3 *************************************************/
5 /*
6 This is a library of functions to support regular expressions whose syntax
7 and semantics are as close as possible to those of the Perl 5 language. See
8 the file Tech.Notes for some information on the internals.
10 Written by: Philip Hazel <ph10@cam.ac.uk>
12 Copyright (c) 1997-2004 University of Cambridge
14 -----------------------------------------------------------------------------
15 Redistribution and use in source and binary forms, with or without
16 modification, are permitted provided that the following conditions are met:
18 * Redistributions of source code must retain the above copyright notice,
19 this list of conditions and the following disclaimer.
21 * Redistributions in binary form must reproduce the above copyright
22 notice, this list of conditions and the following disclaimer in the
23 documentation and/or other materials provided with the distribution.
25 * Neither the name of the University of Cambridge nor the names of its
26 contributors may be used to endorse or promote products derived from
27 this software without specific prior written permission.
29 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
30 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
33 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39 POSSIBILITY OF SUCH DAMAGE.
40 -----------------------------------------------------------------------------
41 */
44 /* Define DEBUG to get debugging output on stdout. */
45 /* #define DEBUG */
47 /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
48 inline, and there are *still* stupid compilers about that don't like indented
49 pre-processor statements. I suppose it's only been 10 years... */
51 #ifdef DEBUG
52 #define DPRINTF(p) printf p
53 #else
55 #endif
57 /* Include the internals header, which itself includes "config.h", the Standard
58 C headers, and the external pcre header. */
62 /* If Unicode Property support is wanted, include a private copy of the
63 function that does it, and the table that translates names to numbers. */
65 #ifdef SUPPORT_UCP
68 #endif
70 /* Maximum number of items on the nested bracket stacks at compile time. This
71 applies to the nesting of all kinds of parentheses. It does not limit
72 un-nested, non-capturing parentheses. This number can be made bigger if
73 necessary - it is used to dimension one int and one unsigned char vector at
74 compile time. */
76 #define BRASTACK_SIZE 200
79 /* Maximum number of ints of offset to save on the stack for recursive calls.
80 If the offset vector is bigger, malloc is used. This should be a multiple of 3,
81 because the offset vector is always a multiple of 3 long. */
83 #define REC_STACK_SAVE_MAX 30
86 /* The maximum remaining length of subject we are prepared to search for a
87 req_byte match. */
89 #define REQ_BYTE_MAX 1000
92 /* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
93 the definition is next to the definition of the opcodes in internal.h. */
97 /* Min and max values for the common repeats; for the maxima, 0 => infinity */
102 /* Table for handling escaped characters in the range '0'-'z'. Positive returns
103 are simple data values; negative values are for special things like \d and so
104 on. Zero means further processing is needed (for things like \x), or the escape
105 is invalid. */
119 };
146 };
147 #endif
150 /* Tables of names of POSIX character classes and their lengths. The list is
151 terminated by a zero length entry. The first three must be alpha, upper, lower,
152 as this is assumed for handling case independence. */
162 /* Table of class bit maps for each POSIX class; up to three may be combined
163 to form the class. The table for [:blank:] is dynamically modified to remove
164 the vertical space characters. */
181 };
183 /* Table to identify digits and hex digits. This is used when compiling
184 patterns. Note that the tables in chartables are dependent on the locale, and
185 may mark arbitrary characters as digits - but the PCRE compiling code expects
186 to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
187 a private table here. It costs 256 bytes, but it is a lot faster than doing
188 character value tests (at least in some simple cases I timed), and in some
189 applications one wants PCRE to compile efficiently as well as match
190 efficiently.
192 For convenience, we use the same bit definitions as in chartables:
194 0x04 decimal digit
195 0x08 hexadecimal digit
197 Then we can use ctype_digit and ctype_xdigit in the code. */
201 {
237 {
304 #endif
307 /* Definition to allow mutual recursion */
309 static BOOL
313 /* Structure for building a chain of data that actually lives on the
314 stack, for holding the values of the subject pointer at the start of each
315 subpattern, so as to detect when an empty string has been matched by a
316 subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
317 are on the heap, not on the stack. */
324 /* Flag bits for the match() function */
329 /* Non-error returns from the match() function. Error returns are externally
330 defined PCRE_ERROR_xxx codes, which are all negative. */
332 #define MATCH_MATCH 1
333 #define MATCH_NOMATCH 0
337 /*************************************************
338 * Global variables *
339 *************************************************/
341 /* PCRE is thread-clean and doesn't use any global variables in the normal
342 sense. However, it calls memory allocation and free functions via the four
343 indirections below, and it can optionally do callouts. These values can be
344 changed by the caller, but are shared between all threads. However, when
345 compiling for Virtual Pascal, things are done differently (see pcre.in). */
347 #ifndef VPCOMPAT
348 #ifdef __cplusplus
354 #else
360 #endif
361 #endif
364 /*************************************************
365 * Macros and tables for character handling *
366 *************************************************/
368 /* When UTF-8 encoding is being used, a character is no longer just a single
369 byte. The macros for character handling generate simple sequences when used in
370 byte-mode, and more complicated ones for UTF-8 characters. */
372 #ifndef SUPPORT_UTF8
373 #define GETCHAR(c, eptr) c = *eptr;
374 #define GETCHARINC(c, eptr) c = *eptr++;
375 #define GETCHARINCTEST(c, eptr) c = *eptr++;
376 #define GETCHARLEN(c, eptr, len) c = *eptr;
377 #define BACKCHAR(eptr)
381 /* Get the next UTF-8 character, not advancing the pointer. This is called when
382 we know we are in UTF-8 mode. */
384 #define GETCHAR(c, eptr) \
385 c = *eptr; \
386 if ((c & 0xc0) == 0xc0) \
387 { \
388 int gcii; \
390 int gcss = 6*gcaa; \
391 c = (c & utf8_table3[gcaa]) << gcss; \
392 for (gcii = 1; gcii <= gcaa; gcii++) \
393 { \
394 gcss -= 6; \
395 c |= (eptr[gcii] & 0x3f) << gcss; \
396 } \
397 }
399 /* Get the next UTF-8 character, advancing the pointer. This is called when we
400 know we are in UTF-8 mode. */
402 #define GETCHARINC(c, eptr) \
403 c = *eptr++; \
404 if ((c & 0xc0) == 0xc0) \
405 { \
407 int gcss = 6*gcaa; \
408 c = (c & utf8_table3[gcaa]) << gcss; \
409 while (gcaa-- > 0) \
410 { \
411 gcss -= 6; \
412 c |= (*eptr++ & 0x3f) << gcss; \
413 } \
414 }
416 /* Get the next character, testing for UTF-8 mode, and advancing the pointer */
418 #define GETCHARINCTEST(c, eptr) \
419 c = *eptr++; \
420 if (md->utf8 && (c & 0xc0) == 0xc0) \
421 { \
423 int gcss = 6*gcaa; \
424 c = (c & utf8_table3[gcaa]) << gcss; \
425 while (gcaa-- > 0) \
426 { \
427 gcss -= 6; \
428 c |= (*eptr++ & 0x3f) << gcss; \
429 } \
430 }
432 /* Get the next UTF-8 character, not advancing the pointer, incrementing length
433 if there are extra bytes. This is called when we know we are in UTF-8 mode. */
435 #define GETCHARLEN(c, eptr, len) \
436 c = *eptr; \
437 if ((c & 0xc0) == 0xc0) \
438 { \
439 int gcii; \
441 int gcss = 6*gcaa; \
442 c = (c & utf8_table3[gcaa]) << gcss; \
443 for (gcii = 1; gcii <= gcaa; gcii++) \
444 { \
445 gcss -= 6; \
446 c |= (eptr[gcii] & 0x3f) << gcss; \
447 } \
448 len += gcaa; \
449 }
451 /* If the pointer is not at the start of a character, move it back until
452 it is. Called only in UTF-8 mode. */
454 #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--;
456 #endif
460 /*************************************************
461 * Default character tables *
462 *************************************************/
464 /* A default set of character tables is included in the PCRE binary. Its source
465 is built by the maketables auxiliary program, which uses the default C ctypes
466 functions, and put in the file chartables.c. These tables are used by PCRE
467 whenever the caller of pcre_compile() does not provide an alternate set of
468 tables. */
474 #ifdef SUPPORT_UTF8
475 /*************************************************
476 * Tables for UTF-8 support *
477 *************************************************/
479 /* These are the breakpoints for different numbers of bytes in a UTF-8
480 character. */
485 /* These are the indicator bits and the mask for the data bits to set in the
486 first byte of a character, indexed by the number of additional bytes. */
491 /* Table of the number of extra characters, indexed by the first character
492 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
493 0x3d. */
502 /*************************************************
503 * Convert character value to UTF-8 *
504 *************************************************/
506 /* This function takes an integer value in the range 0 - 0x7fffffff
507 and encodes it as a UTF-8 character in 0 to 6 bytes.
509 Arguments:
510 cvalue the character value
511 buffer pointer to buffer for result - at least 6 bytes long
513 Returns: number of characters placed in the buffer
514 */
516 static int
518 {
524 {
527 }
530 }
531 #endif
535 /*************************************************
536 * Print compiled regex *
537 *************************************************/
539 /* The code for doing this is held in a separate file that is also included in
540 pcretest.c. It defines a function called print_internals(). */
542 #ifdef DEBUG
544 #endif
548 /*************************************************
549 * Return version string *
550 *************************************************/
552 #define STRING(a) # a
553 #define XSTRING(s) STRING(s)
557 {
559 }
564 /*************************************************
565 * Flip bytes in an integer *
566 *************************************************/
568 /* This function is called when the magic number in a regex doesn't match in
569 order to flip its bytes to see if we are dealing with a pattern that was
570 compiled on a host of different endianness. If so, this function is used to
571 flip other byte values.
573 Arguments:
574 value the number to flip
575 n the number of bytes to flip (assumed to be 2 or 4)
577 Returns: the flipped value
578 */
580 static long int
582 {
588 }
592 /*************************************************
593 * Test for a byte-flipped compiled regex *
594 *************************************************/
596 /* This function is called from pce_exec() and also from pcre_fullinfo(). Its
597 job is to test whether the regex is byte-flipped - that is, it was compiled on
598 a system of opposite endianness. The function is called only when the native
599 MAGIC_NUMBER test fails. If the regex is indeed flipped, we flip all the
600 relevant values into a different data block, and return it.
602 Arguments:
603 re points to the regex
604 study points to study data, or NULL
605 internal_re points to a new regex block
606 internal_study points to a new study block
608 Returns: the new block if is is indeed a byte-flipped regex
609 NULL if it is not
610 */
615 {
633 {
637 }
640 }
644 /*************************************************
645 * (Obsolete) Return info about compiled pattern *
646 *************************************************/
648 /* This is the original "info" function. It picks potentially useful data out
649 of the private structure, but its interface was too rigid. It remains for
650 backwards compatibility. The public options are passed back in an int - though
651 the re->options field has been expanded to a long int, all the public options
652 at the low end of it, and so even on 16-bit systems this will still be OK.
653 Therefore, I haven't changed the API for pcre_info().
655 Arguments:
656 argument_re points to compiled code
657 optptr where to pass back the options
658 first_byte where to pass back the first character,
659 or -1 if multiline and all branches start ^,
660 or -2 otherwise
662 Returns: number of capturing subpatterns
663 or negative values on error
664 */
666 EXPORT int
668 {
669 real_pcre internal_re;
673 {
676 }
682 }
686 /*************************************************
687 * Return info about compiled pattern *
688 *************************************************/
690 /* This is a newer "info" function which has an extensible interface so
691 that additional items can be added compatibly.
693 Arguments:
694 argument_re points to compiled code
695 extra_data points extra data, or NULL
696 what what information is required
697 where where to put the information
699 Returns: 0 if data returned, negative on error
700 */
702 EXPORT int
705 {
706 real_pcre internal_re;
707 pcre_study_data internal_study;
717 {
721 }
724 {
751 /* Make sure we pass back the pointer to the bit vector in the external
752 block, not the internal copy (with flipped integer fields). */
782 }
785 }
789 /*************************************************
790 * Return info about what features are configured *
791 *************************************************/
793 /* This is function which has an extensible interface so that additional items
794 can be added compatibly.
796 Arguments:
797 what what information is required
798 where where to put the information
800 Returns: 0 if data returned, negative on error
801 */
803 EXPORT int
805 {
807 {
809 #ifdef SUPPORT_UTF8
811 #else
813 #endif
817 #ifdef SUPPORT_UCP
819 #else
821 #endif
841 #ifdef NO_RECURSE
843 #else
845 #endif
849 }
852 }
856 #ifdef DEBUG
857 /*************************************************
858 * Debugging function to print chars *
859 *************************************************/
861 /* Print a sequence of chars in printable format, stopping at the end of the
862 subject if the requested.
864 Arguments:
865 p points to characters
866 length number to print
867 is_subject TRUE if printing from within md->start_subject
868 md pointer to matching data block, if is_subject is TRUE
870 Returns: nothing
871 */
873 static void
875 {
880 }
881 #endif
886 /*************************************************
887 * Handle escapes *
888 *************************************************/
890 /* This function is called when a \ has been encountered. It either returns a
891 positive value for a simple escape such as \n, or a negative value which
892 encodes one of the more complicated things such as \d. When UTF-8 is enabled,
893 a positive value greater than 255 may be returned. On entry, ptr is pointing at
894 the \. On exit, it is on the final character of the escape sequence.
896 Arguments:
897 ptrptr points to the pattern position pointer
898 errorptr points to the pointer to the error message
899 bracount number of previous extracting brackets
900 options the options bits
901 isclass TRUE if inside a character class
903 Returns: zero or positive => a data character
904 negative => a special escape sequence
905 on error, errorptr is set
906 */
908 static int
911 {
915 /* If backslash is at the end of the pattern, it's an error. */
920 /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
921 a table. A non-zero result is something that can be returned immediately.
922 Otherwise further processing may be required. */
931 #endif
933 /* Escapes that need further processing, or are illegal. */
935 else
936 {
939 {
940 /* A number of Perl escapes are not handled by PCRE. We give an explicit
941 error. */
951 /* The handling of escape sequences consisting of a string of digits
952 starting with one that is not zero is not straightforward. By experiment,
953 the way Perl works seems to be as follows:
955 Outside a character class, the digits are read as a decimal number. If the
956 number is less than 10, or if there are that many previous extracting
957 left brackets, then it is a back reference. Otherwise, up to three octal
958 digits are read to form an escaped byte. Thus \123 is likely to be octal
959 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
960 value is greater than 377, the least significant 8 bits are taken. Inside a
961 character class, \ followed by a digit is always an octal number. */
967 {
973 {
976 }
978 }
980 /* Handle an octal number following \. If the first digit is 8 or 9, Perl
981 generates a binary zero byte and treats the digit as a following literal.
982 Thus we have to pull back the pointer by one. */
985 {
986 ptr--;
989 }
991 /* \0 always starts an octal number, but we may drop through to here with a
992 larger first octal digit. */
1001 /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number
1002 which can be greater than 0xff, but only if the ddd are hex digits. */
1005 #ifdef SUPPORT_UTF8
1007 {
1012 {
1014 count++;
1021 #endif
1022 }
1024 {
1028 }
1029 /* If the sequence of hex digits does not end with '}', then we don't
1030 recognize this construct; fall through to the normal \x handling. */
1031 }
1032 #endif
1034 /* Read just a single hex char */
1038 {
1047 #endif
1048 }
1051 /* Other special escapes not starting with a digit are straightforward */
1056 {
1059 }
1061 /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
1062 is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
1063 (However, an EBCDIC equivalent has now been added.) */
1071 #endif
1074 /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
1075 other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
1076 for Perl compatibility, it is a literal. This code looks a bit odd, but
1077 there used to be some cases other than the default, and there may be again
1078 in future, so I haven't "optimized" it. */
1082 {
1086 }
1088 }
1089 }
1093 }
1097 #ifdef SUPPORT_UCP
1098 /*************************************************
1099 * Handle \P and \p *
1100 *************************************************/
1102 /* This function is called after \P or \p has been encountered, provided that
1103 PCRE is compiled with support for Unicode properties. On entry, ptrptr is
1104 pointing at the P or p. On exit, it is pointing at the final character of the
1105 escape sequence.
1107 Argument:
1108 ptrptr points to the pattern position pointer
1109 negptr points to a boolean that is set TRUE for negation else FALSE
1110 errorptr points to the pointer to the error message
1112 Returns: value from ucp_type_table, or -1 for an invalid type
1113 */
1115 static int
1117 {
1127 /* \P or \p can be followed by a one- or two-character name in {}, optionally
1128 preceded by ^ for negation. */
1131 {
1133 {
1135 ptr++;
1136 }
1138 {
1143 }
1145 {
1148 }
1150 }
1152 /* Otherwise there is just one following character */
1154 else
1155 {
1158 }
1162 /* Search for a recognized property name using binary chop */
1168 {
1173 }
1175 UNKNOWN_RETURN:
1180 ERROR_RETURN:
1184 }
1185 #endif
1190 /*************************************************
1191 * Check for counted repeat *
1192 *************************************************/
1194 /* This function is called when a '{' is encountered in a place where it might
1195 start a quantifier. It looks ahead to see if it really is a quantifier or not.
1196 It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
1197 where the ddds are digits.
1199 Arguments:
1200 p pointer to the first char after '{'
1202 Returns: TRUE or FALSE
1203 */
1205 static BOOL
1207 {
1219 }
1223 /*************************************************
1224 * Read repeat counts *
1225 *************************************************/
1227 /* Read an item of the form {n,m} and return the values. This is called only
1228 after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
1229 so the syntax is guaranteed to be correct, but we need to check the values.
1231 Arguments:
1232 p pointer to first char after '{'
1233 minp pointer to int for min
1234 maxp pointer to int for max
1235 returned as -1 if no max
1236 errorptr points to pointer to error message
1238 Returns: pointer to '}' on success;
1239 current ptr on error, with errorptr set
1240 */
1244 {
1251 {
1253 {
1257 {
1260 }
1261 }
1262 }
1264 /* Do paranoid checks, then fill in the required variables, and pass back the
1265 pointer to the terminating '}'. */
1269 else
1270 {
1273 }
1275 }
1279 /*************************************************
1280 * Find first significant op code *
1281 *************************************************/
1283 /* This is called by several functions that scan a compiled expression looking
1284 for a fixed first character, or an anchoring op code etc. It skips over things
1285 that do not influence this. For some calls, a change of option is important.
1286 For some calls, it makes sense to skip negative forward and all backward
1287 assertions, and also the \b assertion; for others it does not.
1289 Arguments:
1290 code pointer to the start of the group
1291 options pointer to external options
1292 optbit the option bit whose changing is significant, or
1293 zero if none are
1294 skipassert TRUE if certain assertions are to be skipped
1296 Returns: pointer to the first significant opcode
1297 */
1301 BOOL skipassert)
1302 {
1304 {
1306 {
1324 /* Fall through */
1334 }
1335 }
1336 /* Control never reaches here */
1337 }
1342 /*************************************************
1343 * Find the fixed length of a pattern *
1344 *************************************************/
1346 /* Scan a pattern and compute the fixed length of subject that will match it,
1347 if the length is fixed. This is needed for dealing with backward assertions.
1348 In UTF8 mode, the result is in characters rather than bytes.
1350 Arguments:
1351 code points to the start of the pattern (the bracket)
1352 options the compiling options
1354 Returns: the fixed length, or -1 if there is no fixed length,
1355 or -2 if \C was encountered
1356 */
1358 static int
1360 {
1366 /* Scan along the opcodes for this branch. If we get to the end of the
1367 branch, check the length against that of the other branches. */
1370 {
1376 {
1387 /* Reached end of a branch; if it's a ket it is the end of a nested
1388 call. If it's ALT it is an alternation in a nested call. If it is
1389 END it's the end of the outer call. All can be handled by the same code. */
1403 /* Skip over assertive subpatterns */
1410 /* Fall through */
1412 /* Skip over things that don't match chars */
1430 /* Handle literal characters */
1434 branchlength++;
1436 #ifdef SUPPORT_UTF8
1438 {
1440 }
1441 #endif
1444 /* Handle exact repetitions. The count is already in characters, but we
1445 need to skip over a multibyte character in UTF8 mode. */
1450 #ifdef SUPPORT_UTF8
1452 {
1454 }
1455 #endif
1463 /* Handle single-char matchers */
1467 cc++;
1468 /* Fall through */
1477 branchlength++;
1478 cc++;
1481 /* The single-byte matcher isn't allowed */
1486 /* Check a class for variable quantification */
1488 #ifdef SUPPORT_UTF8
1491 /* Fall through */
1492 #endif
1499 {
1514 branchlength++;
1515 }
1518 /* Anything else is variable length */
1522 }
1523 }
1524 /* Control never gets here */
1525 }
1530 /*************************************************
1531 * Scan compiled regex for numbered bracket *
1532 *************************************************/
1534 /* This little function scans through a compiled pattern until it finds a
1535 capturing bracket with the given number.
1537 Arguments:
1538 code points to start of expression
1539 utf8 TRUE in UTF-8 mode
1540 number the required bracket number
1542 Returns: pointer to the opcode for the bracket, or NULL if not found
1543 */
1547 {
1548 #ifndef SUPPORT_UTF8
1550 #endif
1553 {
1557 {
1562 }
1563 else
1564 {
1567 #ifdef SUPPORT_UTF8
1569 /* In UTF-8 mode, opcodes that are followed by a character may be followed
1570 by a multi-byte character. The length in the table is a minimum, so we have
1571 to scan along to skip the extra bytes. All opcodes are less than 128, so we
1572 can use relatively efficient code. */
1575 {
1590 /* XCLASS is used for classes that cannot be represented just by a bit
1591 map. This includes negated single high-valued characters. The length in
1592 the table is zero; the actual length is stored in the compiled code. */
1597 }
1598 #endif
1599 }
1600 }
1601 }
1605 /*************************************************
1606 * Scan compiled regex for recursion reference *
1607 *************************************************/
1609 /* This little function scans through a compiled pattern until it finds an
1610 instance of OP_RECURSE.
1612 Arguments:
1613 code points to start of expression
1614 utf8 TRUE in UTF-8 mode
1616 Returns: pointer to the opcode for OP_RECURSE, or NULL if not found
1617 */
1621 {
1622 #ifndef SUPPORT_UTF8
1624 #endif
1627 {
1632 {
1634 }
1635 else
1636 {
1639 #ifdef SUPPORT_UTF8
1641 /* In UTF-8 mode, opcodes that are followed by a character may be followed
1642 by a multi-byte character. The length in the table is a minimum, so we have
1643 to scan along to skip the extra bytes. All opcodes are less than 128, so we
1644 can use relatively efficient code. */
1647 {
1662 /* XCLASS is used for classes that cannot be represented just by a bit
1663 map. This includes negated single high-valued characters. The length in
1664 the table is zero; the actual length is stored in the compiled code. */
1669 }
1670 #endif
1671 }
1672 }
1673 }
1677 /*************************************************
1678 * Scan compiled branch for non-emptiness *
1679 *************************************************/
1681 /* This function scans through a branch of a compiled pattern to see whether it
1682 can match the empty string or not. It is called only from could_be_empty()
1683 below. Note that first_significant_code() skips over assertions. If we hit an
1684 unclosed bracket, we return "empty" - this means we've struck an inner bracket
1685 whose current branch will already have been scanned.
1687 Arguments:
1688 code points to start of search
1689 endcode points to where to stop
1690 utf8 TRUE if in UTF8 mode
1692 Returns: TRUE if what is matched could be empty
1693 */
1695 static BOOL
1697 {
1702 {
1708 {
1709 BOOL empty_branch;
1712 /* Scan a closed bracket */
1715 do
1716 {
1720 }
1725 }
1728 {
1729 /* Check for quantifiers after a class */
1731 #ifdef SUPPORT_UTF8
1735 #endif
1741 #ifdef SUPPORT_UTF8
1742 CHECK_CLASS_REPEAT:
1743 #endif
1746 {
1762 }
1765 /* Opcodes that must match a character */
1792 /* End of branch */
1800 /* In UTF-8 mode, STAR, MINSTAR, QUERY, MINQUERY, UPTO, and MINUPTO may be
1801 followed by a multibyte character */
1803 #ifdef SUPPORT_UTF8
1812 #endif
1813 }
1814 }
1817 }
1821 /*************************************************
1822 * Scan compiled regex for non-emptiness *
1823 *************************************************/
1825 /* This function is called to check for left recursive calls. We want to check
1826 the current branch of the current pattern to see if it could match the empty
1827 string. If it could, we must look outwards for branches at other levels,
1828 stopping when we pass beyond the bracket which is the subject of the recursion.
1830 Arguments:
1831 code points to start of the recursion
1832 endcode points to where to stop (current RECURSE item)
1833 bcptr points to the chain of current (unclosed) branch starts
1834 utf8 TRUE if in UTF-8 mode
1836 Returns: TRUE if what is matched could be empty
1837 */
1839 static BOOL
1841 BOOL utf8)
1842 {
1844 {
1847 }
1849 }
1853 /*************************************************
1854 * Check for POSIX class syntax *
1855 *************************************************/
1857 /* This function is called when the sequence "[:" or "[." or "[=" is
1858 encountered in a character class. It checks whether this is followed by an
1859 optional ^ and then a sequence of letters, terminated by a matching ":]" or
1860 ".]" or "=]".
1862 Argument:
1863 ptr pointer to the initial [
1864 endptr where to return the end pointer
1865 cd pointer to compile data
1867 Returns: TRUE or FALSE
1868 */
1870 static BOOL
1872 {
1878 {
1881 }
1883 }
1888 /*************************************************
1889 * Check POSIX class name *
1890 *************************************************/
1892 /* This function is called to check the name given in a POSIX-style class entry
1893 such as [:alnum:].
1895 Arguments:
1896 ptr points to the first letter
1897 len the length of the name
1899 Returns: a value representing the name, or -1 if unknown
1900 */
1902 static int
1904 {
1907 {
1910 yield++;
1911 }
1913 }
1916 /*************************************************
1917 * Adjust OP_RECURSE items in repeated group *
1918 *************************************************/
1920 /* OP_RECURSE items contain an offset from the start of the regex to the group
1921 that is referenced. This means that groups can be replicated for fixed
1922 repetition simply by copying (because the recursion is allowed to refer to
1923 earlier groups that are outside the current group). However, when a group is
1924 optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
1925 it, after it has been compiled. This means that any OP_RECURSE items within it
1926 that refer to the group itself or any contained groups have to have their
1927 offsets adjusted. That is the job of this function. Before it is called, the
1928 partially compiled regex must be temporarily terminated with OP_END.
1930 Arguments:
1931 group points to the start of the group
1932 adjust the amount by which the group is to be moved
1933 utf8 TRUE in UTF-8 mode
1934 cd contains pointers to tables etc.
1936 Returns: nothing
1937 */
1939 static void
1941 {
1944 {
1948 }
1949 }
1953 /*************************************************
1954 * Insert an automatic callout point *
1955 *************************************************/
1957 /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
1958 callout points before each pattern item.
1960 Arguments:
1961 code current code pointer
1962 ptr current pattern pointer
1963 cd pointers to tables etc
1965 Returns: new code pointer
1966 */
1970 {
1976 }
1980 /*************************************************
1981 * Complete a callout item *
1982 *************************************************/
1984 /* A callout item contains the length of the next item in the pattern, which
1985 we can't fill in till after we have reached the relevant point. This is used
1986 for both automatic and manual callouts.
1988 Arguments:
1989 previous_callout points to previous callout item
1990 ptr current pattern pointer
1991 cd pointers to tables etc
1993 Returns: nothing
1994 */
1996 static void
1998 {
2001 }
2005 #ifdef SUPPORT_UCP
2006 /*************************************************
2007 * Get othercase range *
2008 *************************************************/
2010 /* This function is passed the start and end of a class range, in UTF-8 mode
2011 with UCP support. It searches up the characters, looking for internal ranges of
2012 characters in the "other" case. Each call returns the next one, updating the
2013 start address.
2015 Arguments:
2016 cptr points to starting character value; updated
2017 d end value
2018 ocptr where to put start of othercase range
2019 odptr where to put end of othercase range
2021 Yield: TRUE when range returned; FALSE when no more
2022 */
2024 static BOOL
2026 {
2030 {
2032 }
2040 {
2043 next++;
2044 }
2050 }
2054 /*************************************************
2055 * Compile one branch *
2056 *************************************************/
2058 /* Scan the pattern, compiling it into the code vector. If the options are
2059 changed during the branch, the pointer is used to change the external options
2060 bits.
2062 Arguments:
2063 optionsptr pointer to the option bits
2064 brackets points to number of extracting brackets used
2065 codeptr points to the pointer to the current code point
2066 ptrptr points to the current pattern pointer
2067 errorptr points to pointer to error message
2068 firstbyteptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
2069 reqbyteptr set to the last literal character required, else < 0
2070 bcptr points to current branch chain
2071 cd contains pointers to tables etc.
2073 Returns: TRUE on success
2074 FALSE, with *errorptr set on error
2075 */
2077 static BOOL
2081 {
2103 #ifdef SUPPORT_UTF8
2104 BOOL class_utf8;
2108 #else
2110 #endif
2112 /* Set up the default and non-default settings for greediness */
2117 /* Initialize no first byte, no required byte. REQ_UNSET means "no char
2118 matching encountered yet". It gets changed to REQ_NONE if we hit something that
2119 matches a non-fixed char first char; reqbyte just remains unset if we never
2120 find one.
2122 When we hit a repeat whose minimum is zero, we may have to adjust these values
2123 to take the zero repeat into account. This is implemented by setting them to
2124 zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
2125 item types that can be repeated set these backoff variables appropriately. */
2129 /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
2130 according to the current setting of the caseless flag. REQ_CASELESS is a bit
2131 value > 255. It is added into the firstbyte or reqbyte variables to record the
2132 case status of the value. This is used only for ASCII characters. */
2136 /* Switch on next character until the end of the branch */
2139 {
2140 BOOL negate_class;
2141 BOOL possessive_quantifier;
2142 BOOL is_quantifier;
2153 /* Next byte in the pattern */
2157 /* If in \Q...\E, check for the end; if not, we have a literal */
2160 {
2162 {
2164 ptr++;
2166 }
2167 else
2168 {
2170 {
2173 }
2175 {
2178 }
2180 }
2181 }
2183 /* Fill in length of a previous callout, except when the next thing is
2184 a quantifier. */
2191 {
2194 }
2196 /* In extended mode, skip white space and comments */
2199 {
2202 {
2203 /* The space before the ; is to avoid a warning on a silly compiler
2204 on the Macintosh. */
2207 }
2208 }
2210 /* No auto callout for quantifiers. */
2213 {
2216 }
2219 {
2220 /* The branch terminates at end of string, |, or ). */
2231 /* Handle single-character metacharacters. In multiline mode, ^ disables
2232 the setting of any following char as a first character. */
2236 {
2238 }
2248 /* There can never be a first char if '.' is first, whatever happens about
2249 repeats. The value of reqbyte doesn't change either. */
2259 /* Character classes. If the included characters are all < 255 in value, we
2260 build a 32-byte bitmap of the permitted characters, except in the special
2261 case where there is only one such character. For negated classes, we build
2262 the map as usual, then invert it at the end. However, we use a different
2263 opcode so that data characters > 255 can be handled correctly.
2265 If the class contains characters outside the 0-255 range, a different
2266 opcode is compiled. It may optionally have a bit map for characters < 256,
2267 but those above are are explicitly listed afterwards. A flag byte tells
2268 whether the bitmap is present, and whether this is a negated class or not.
2269 */
2274 /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
2275 they are encountered at the top level, so we'll do that too. */
2279 {
2282 }
2284 /* If the first character is '^', set the negation flag and skip it. */
2287 {
2290 }
2291 else
2292 {
2294 }
2296 /* Keep a count of chars with values < 256 so that we can optimize the case
2297 of just a single character (as long as it's < 256). For higher valued UTF-8
2298 characters, we don't yet do any optimization. */
2303 #ifdef SUPPORT_UTF8
2306 #endif
2308 /* Initialize the 32-char bit map to all zeros. We have to build the
2309 map in a temporary bit of store, in case the class contains only 1
2310 character (< 256), because in that case the compiled code doesn't use the
2311 bit map. */
2315 /* Process characters until ] is reached. By writing this as a "do" it
2316 means that an initial ] is taken as a data character. The first pass
2317 through the regex checked the overall syntax, so we don't need to be very
2318 strict here. At the start of the loop, c contains the first byte of the
2319 character. */
2321 do
2322 {
2323 #ifdef SUPPORT_UTF8
2327 }
2328 #endif
2330 /* Inside \Q...\E everything is literal except \E */
2333 {
2335 {
2337 ptr++;
2339 }
2341 }
2343 /* Handle POSIX class names. Perl allows a negation extension of the
2344 form [:^name:]. A square bracket that doesn't match the syntax is
2345 treated as a literal. We also recognize the POSIX constructions
2346 [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
2347 5.6 and 5.8 do. */
2352 {
2358 {
2361 }
2365 {
2367 ptr++;
2368 }
2372 {
2375 }
2377 /* If matching is caseless, upper and lower are converted to
2378 alpha. This relies on the fact that the class table starts with
2379 alpha, lower, upper as the first 3 entries. */
2384 /* Or into the map we are building up to 3 of the static class
2385 tables, or their negations. The [:blank:] class sets up the same
2386 chars as the [:space:] class (all white space). We remove the vertical
2387 white space chars afterwards. */
2391 {
2396 {
2399 else
2402 }
2403 else
2404 {
2407 }
2408 }
2413 }
2415 /* Backslash may introduce a single character, or it may introduce one
2416 of the specials, which just set a flag. Escaped items are checked for
2417 validity in the pre-compiling pass. The sequence \b is a special case.
2418 Inside a class (and only there) it is treated as backspace. Elsewhere
2419 it marks a word boundary. Other escapes have preset maps ready to
2420 or into the one we are building. We assume they have more than one
2421 character in them, so set class_charcount bigger than one. */
2424 {
2430 {
2432 {
2434 }
2437 }
2440 {
2444 {
2471 #ifdef SUPPORT_UCP
2474 {
2475 BOOL negated;
2483 }
2485 #endif
2487 /* Unrecognized escapes are faulted if PCRE is running in its
2488 strict mode. By default, for compatibility with Perl, they are
2489 treated as literals. */
2493 {
2496 }
2499 }
2500 }
2502 /* Fall through if we have a single character (c >= 0). This may be
2503 > 256 in UTF-8 mode. */
2507 /* A single character may be followed by '-' to form a range. However,
2508 Perl does not permit ']' to be the end of the range. A '-' character
2509 here is treated as a literal. */
2512 {
2516 #ifdef SUPPORT_UTF8
2520 }
2521 else
2522 #endif
2525 /* The second part of a range can be a single-character escape, but
2526 not any of the other escapes. Perl 5.6 treats a hyphen as a literal
2527 in such circumstances. */
2530 {
2534 /* \b is backslash; \X is literal X; any other special means the '-'
2535 was literal */
2538 {
2541 {
2544 }
2545 }
2546 }
2548 /* The check that the two values are in the correct order happens in
2549 the pre-pass. Optimize one-character ranges */
2553 /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
2554 matching, we have to use an XCLASS with extra data items. Caseless
2555 matching for characters > 127 is available only if UCP support is
2556 available. */
2558 #ifdef SUPPORT_UTF8
2560 {
2563 /* With UCP support, we can find the other case equivalents of
2564 the relevant characters. There may be several ranges. Optimize how
2565 they fit with the basic range. */
2567 #ifdef SUPPORT_UCP
2569 {
2574 {
2586 }
2589 {
2591 }
2592 else
2593 {
2596 }
2598 }
2599 }
2602 /* Now record the original range, possibly modified for UCP caseless
2603 overlapping ranges. */
2609 /* With UCP support, we are done. Without UCP support, there is no
2610 caseless matching for UTF-8 characters > 127; we can use the bit map
2611 for the smaller ones. */
2613 #ifdef SUPPORT_UCP
2615 #else
2618 /* Adjust upper limit and fall through to set up the map */
2623 }
2626 /* We use the bit map for all cases when not in UTF-8 mode; else
2627 ranges that lie entirely within 0-127 when there is UCP support; else
2628 for partial ranges without UCP support. */
2631 {
2634 {
2637 }
2640 }
2643 }
2645 /* Handle a lone single character - we can get here for a normal
2646 non-escape char, or after \ that introduces a single character or for an
2647 apparent range that isn't. */
2649 LONE_SINGLE_CHARACTER:
2651 /* Handle a character that cannot go in the bit map */
2653 #ifdef SUPPORT_UTF8
2655 {
2660 #ifdef SUPPORT_UCP
2662 {
2666 {
2669 }
2670 }
2673 }
2674 else
2677 /* Handle a single-byte character */
2678 {
2681 {
2684 }
2685 class_charcount++;
2687 }
2688 }
2690 /* Loop until ']' reached; the check for end of string happens inside the
2691 loop. This "while" is the end of the "do" above. */
2695 /* If class_charcount is 1, we saw precisely one character whose value is
2696 less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
2697 can optimize the negative case only if there were no characters >= 128
2698 because OP_NOT and the related opcodes like OP_NOTSTAR operate on
2699 single-bytes only. This is an historical hangover. Maybe one day we can
2700 tidy these opcodes to handle multi-byte characters.
2702 The optimization throws away the bit map. We turn the item into a
2703 1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
2704 that OP_NOT does not support multibyte characters. In the positive case, it
2705 can cause firstbyte to be set. Otherwise, there can be no first char if
2706 this item is first, whatever repeat count may follow. In the case of
2707 reqbyte, save the previous value for reinstating. */
2709 #ifdef SUPPORT_UTF8
2714 #else
2716 #endif
2717 {
2720 /* The OP_NOT opcode works on one-byte characters only. */
2723 {
2729 }
2731 /* For a single, positive character, get the value into mcbuffer, and
2732 then we can handle this with the normal one-character code. */
2734 #ifdef SUPPORT_UTF8
2737 else
2738 #endif
2739 {
2742 }
2746 /* The general case - not the one-char optimization. If this is the first
2747 thing in the branch, there can be no first char setting, whatever the
2748 repeat count. Any reqbyte setting must remain unchanged after any kind of
2749 repeat. */
2755 /* If there are characters with values > 255, we have to compile an
2756 extended class, with its own opcode. If there are no characters < 256,
2757 we can omit the bitmap. */
2759 #ifdef SUPPORT_UTF8
2761 {
2767 /* If the map is required, install it, and move on to the end of
2768 the extra data */
2771 {
2775 }
2777 /* If the map is not required, slide down the extra data. */
2779 else
2780 {
2784 }
2786 /* Now fill in the complete length of the item */
2790 }
2791 #endif
2793 /* If there are no characters > 255, negate the 32-byte map if necessary,
2794 and copy it into the code vector. If this is the first thing in the branch,
2795 there can be no first char setting, whatever the repeat count. Any reqbyte
2796 setting must remain unchanged after any kind of repeat. */
2799 {
2802 }
2803 else
2804 {
2807 }
2811 /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
2812 has been tested above. */
2834 REPEAT:
2836 {
2839 }
2842 {
2845 }
2847 /* Remember whether this is a variable length repeat */
2854 /* Save start of previous item, in case we have to move it up to make space
2855 for an inserted OP_ONCE for the additional '+' extension. */
2859 /* If the next character is '+', we have a possessive quantifier. This
2860 implies greediness, whatever the setting of the PCRE_UNGREEDY option.
2861 If the next character is '?' this is a minimizing repeat, by default,
2862 but if PCRE_UNGREEDY is set, it works the other way round. We change the
2863 repeat type to the non-default. */
2866 {
2869 ptr++;
2870 }
2872 {
2874 ptr++;
2875 }
2878 /* If previous was a recursion, we need to wrap it inside brackets so that
2879 it can be replicated if necessary. */
2882 {
2890 }
2892 /* If previous was a character match, abolish the item and generate a
2893 repeat item instead. If a char item has a minumum of more than one, ensure
2894 that it is set in reqbyte - it might not be if a sequence such as x{3} is
2895 the first thing in a branch because the x will have gone into firstbyte
2896 instead. */
2899 {
2900 /* Deal with UTF-8 characters that take up more than one byte. It's
2901 easier to write this out separately than try to macrify it. Use c to
2902 hold the length of the character in bytes, plus 0x80 to flag that it's a
2903 length rather than a small character. */
2905 #ifdef SUPPORT_UTF8
2907 {
2913 }
2914 else
2915 #endif
2917 /* Handle the case of a single byte - either with no UTF8 support, or
2918 with UTF-8 disabled, or for a UTF-8 character < 128. */
2920 {
2923 }
2926 }
2928 /* If previous was a single negated character ([^a] or similar), we use
2929 one of the special opcodes, replacing it. The code is shared with single-
2930 character repeats by setting opt_type to add a suitable offset into
2931 repeat_type. OP_NOT is currently used only for single-byte chars. */
2934 {
2938 }
2940 /* If previous was a character type match (\d or similar), abolish it and
2941 create a suitable repeat item. The code is shared with single-character
2942 repeats by setting op_type to add a suitable offset into repeat_type. Note
2943 the the Unicode property types will be present only when SUPPORT_UCP is
2944 defined, but we don't wrap the little bits of code here because it just
2945 makes it horribly messy. */
2948 {
2954 OUTPUT_SINGLE_REPEAT:
2961 /* If the maximum is zero then the minimum must also be zero; Perl allows
2962 this case, so we do too - by simply omitting the item altogether. */
2966 /* All real repeats make it impossible to handle partial matching (maybe
2967 one day we will be able to remove this restriction). */
2971 /* Combine the op_type with the repeat_type */
2975 /* A minimum of zero is handled either as the special case * or ?, or as
2976 an UPTO, with the maximum given. */
2979 {
2982 else
2983 {
2986 }
2987 }
2989 /* A repeat minimum of 1 is optimized into some special cases. If the
2990 maximum is unlimited, we use OP_PLUS. Otherwise, the original item it
2991 left in place and, if the maximum is greater than 1, we use OP_UPTO with
2992 one less than the maximum. */
2995 {
2998 else
2999 {
3004 }
3005 }
3007 /* The case {n,n} is just an EXACT, while the general case {n,m} is
3008 handled as an EXACT followed by an UPTO. */
3010 else
3011 {
3015 /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
3016 we have to insert the character for the previous code. For a repeated
3017 Unicode property match, there is an extra byte that defines the
3018 required property. In UTF-8 mode, long characters have their length in
3019 c, with the 0x80 bit as a flag. */
3022 {
3023 #ifdef SUPPORT_UTF8
3025 {
3028 }
3029 else
3030 #endif
3031 {
3034 }
3036 }
3038 /* Else insert an UPTO if the max is greater than the min, again
3039 preceded by the character, for the previously inserted code. */
3042 {
3043 #ifdef SUPPORT_UTF8
3045 {
3048 }
3049 else
3050 #endif
3056 }
3057 }
3059 /* The character or character type itself comes last in all cases. */
3061 #ifdef SUPPORT_UTF8
3063 {
3066 }
3067 else
3068 #endif
3071 /* For a repeated Unicode property match, there is an extra byte that
3072 defines the required property. */
3074 #ifdef SUPPORT_UCP
3076 #endif
3077 }
3079 /* If previous was a character class or a back reference, we put the repeat
3080 stuff after it, but just skip the item if the repeat was {0,0}. */
3084 #ifdef SUPPORT_UTF8
3086 #endif
3088 {
3090 {
3093 }
3095 /* All real repeats make it impossible to handle partial matching (maybe
3096 one day we will be able to remove this restriction). */
3106 else
3107 {
3112 }
3113 }
3115 /* If previous was a bracket group, we may have to replicate it in certain
3116 cases. */
3120 {
3126 /* If the maximum repeat count is unlimited, find the end of the bracket
3127 by scanning through from the start, and compute the offset back to it
3128 from the current code pointer. There may be an OP_OPT setting following
3129 the final KET, so we can't find the end just by going back from the code
3130 pointer. */
3133 {
3137 }
3139 /* The case of a zero minimum is special because of the need to stick
3140 OP_BRAZERO in front of it, and because the group appears once in the
3141 data, whereas in other cases it appears the minimum number of times. For
3142 this reason, it is simplest to treat this case separately, as otherwise
3143 the code gets far too messy. There are several special subcases when the
3144 minimum is zero. */
3147 {
3148 /* If the maximum is also zero, we just omit the group from the output
3149 altogether. */
3152 {
3155 }
3157 /* If the maximum is 1 or unlimited, we just have to stick in the
3158 BRAZERO and do no more at this point. However, we do need to adjust
3159 any OP_RECURSE calls inside the group that refer to the group itself or
3160 any internal group, because the offset is from the start of the whole
3161 regex. Temporarily terminate the pattern while doing this. */
3164 {
3168 code++;
3170 }
3172 /* If the maximum is greater than 1 and limited, we have to replicate
3173 in a nested fashion, sticking OP_BRAZERO before each set of brackets.
3174 The first one has to be handled carefully because it's the original
3175 copy, which has to be moved up. The remainder can be handled by code
3176 that is common with the non-zero minimum case below. We have to
3177 adjust the value or repeat_max, since one less copy is required. Once
3178 again, we may have to adjust any OP_RECURSE calls inside the group. */
3180 else
3181 {
3190 /* We chain together the bracket offset fields that have to be
3191 filled in later when the ends of the brackets are reached. */
3196 }
3198 repeat_max--;
3199 }
3201 /* If the minimum is greater than zero, replicate the group as many
3202 times as necessary, and adjust the maximum to the number of subsequent
3203 copies that we need. If we set a first char from the group, and didn't
3204 set a required char, copy the latter from the former. */
3206 else
3207 {
3209 {
3212 {
3215 }
3216 }
3218 }
3220 /* This code is common to both the zero and non-zero minimum cases. If
3221 the maximum is limited, it replicates the group in a nested fashion,
3222 remembering the bracket starts on a stack. In the case of a zero minimum,
3223 the first one was set up above. In all cases the repeat_max now specifies
3224 the number of additional copies needed. */
3227 {
3229 {
3232 /* All but the final copy start a new nesting, maintaining the
3233 chain of brackets outstanding. */
3236 {
3242 }
3246 }
3248 /* Now chain through the pending brackets, and fill in their length
3249 fields (which are holding the chain links pro tem). */
3252 {
3261 }
3262 }
3264 /* If the maximum is unlimited, set a repeater in the final copy. We
3265 can't just offset backwards from the current code point, because we
3266 don't know if there's been an options resetting after the ket. The
3267 correct offset was computed above. */
3270 }
3272 /* Else there's some kind of shambles */
3274 else
3275 {
3278 }
3280 /* If the character following a repeat is '+', we wrap the entire repeated
3281 item inside OP_ONCE brackets. This is just syntactic sugar, taken from
3282 Sun's Java package. The repeated item starts at tempcode, not at previous,
3283 which might be the first part of a string whose (former) last char we
3284 repeated. However, we don't support '+' after a greediness '?'. */
3287 {
3296 }
3298 /* In all case we no longer have a previous item. We also set the
3299 "follows varying string" flag for subsequently encountered reqbytes if
3300 it isn't already set and we have just passed a varying length item. */
3302 END_REPEAT:
3308 /* Start of nested bracket sub-expression, or comment or lookahead or
3309 lookbehind or option setting or condition. First deal with special things
3310 that can come after a bracket; all are introduced by ?, and the appearance
3311 of any of them means that this is not a referencing group. They were
3312 checked for validity in the first pass over the string, so we don't have to
3313 check for syntax errors here. */
3320 {
3325 {
3327 ptr++;
3333 ptr++;
3339 /* Condition to test for recursion */
3342 {
3347 }
3349 /* Condition to test for a numbered subpattern match. We know that
3350 if a digit follows ( then there will just be digits until ) because
3351 the syntax was checked in the first pass. */
3354 {
3359 {
3362 }
3363 ptr++;
3367 }
3368 /* For conditions that are assertions, we just fall through, having
3369 set bravalue above. */
3374 ptr++;
3379 ptr++;
3384 {
3387 ptr++;
3392 ptr++;
3394 }
3399 ptr++;
3411 {
3414 }
3419 }
3425 {
3435 {
3438 {
3440 {
3443 }
3445 }
3447 {
3451 }
3453 }
3460 }
3463 {
3473 {
3476 }
3478 {
3481 }
3487 /* Back reference */
3495 }
3497 /* Should never happen */
3502 /* Fall through */
3504 /* Recursion or "subroutine" call */
3508 {
3514 /* Come here from code above that handles a named recursion */
3516 HANDLE_RECURSION:
3520 /* Find the bracket that is being referenced. Temporarily end the
3521 regex in case it doesn't exist. */
3528 {
3531 }
3533 /* If the subpattern is still open, this is a recursive call. We
3534 check to see if this is a left recursion that could loop for ever,
3535 and diagnose that case. */
3538 {
3541 }
3543 /* Insert the recursion/subroutine item */
3548 }
3551 /* Character after (? not specially recognized */
3558 {
3560 {
3569 }
3570 }
3572 /* Set up the changed option bits, but don't change anything yet. */
3576 /* If the options ended with ')' this is not the start of a nested
3577 group with option changes, so the options change at this level. Compile
3578 code to change the ims options if this setting actually changes any of
3579 them. We also pass the new setting back so that it can be put at the
3580 start of any following branches, and when this group ends (if we are in
3581 a group), a resetting item can be compiled.
3583 Note that if this item is right at the start of the pattern, the
3584 options will have been abstracted and made global, so there will be no
3585 change to compile. */
3588 {
3590 {
3593 }
3595 /* Change options at this level, and pass them back for use
3596 in subsequent branches. Reset the greedy defaults and the case
3597 value for firstbyte and reqbyte. */
3606 }
3608 /* If the options ended with ':' we are heading into a nested group
3609 with possible change of options. Such groups are non-capturing and are
3610 not assertions of any kind. All we need to do is skip over the ':';
3611 the newoptions value is handled below. */
3614 ptr++;
3615 }
3616 }
3618 /* If PCRE_NO_AUTO_CAPTURE is set, all unadorned brackets become
3619 non-capturing and behave like (?:...) brackets */
3622 {
3624 }
3626 /* Else we have a referencing group; adjust the opcode. If the bracket
3627 number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
3628 arrange for the true number to follow later, in an OP_BRANUMBER item. */
3630 else
3631 {
3632 NUMBERED_GROUP:
3634 {
3639 }
3641 }
3643 /* Process nested bracketed re. Assertions may not be repeated, but other
3644 kinds can be. We copy code into a non-register variable in order to be able
3645 to pass its address because some compilers complain otherwise. Pass in a
3646 new setting for the ims options if they have changed. */
3669 /* At the end of compiling, code is still pointing to the start of the
3670 group, while tempcode has been updated to point past the end of the group
3671 and any option resetting that may follow it. The pattern pointer (ptr)
3672 is on the bracket. */
3674 /* If this is a conditional bracket, check that there are no more than
3675 two branches in the group. */
3678 {
3683 condcount++;
3685 }
3689 {
3692 }
3694 /* If there is just one branch, we must not make use of its firstbyte or
3695 reqbyte, because this is equivalent to an empty second branch. */
3698 }
3700 /* Handle updating of the required and first characters. Update for normal
3701 brackets of all kinds, and conditions with two branches (see code above).
3702 If the bracket is followed by a quantifier with zero repeat, we have to
3703 back off. Hence the definition of zeroreqbyte and zerofirstbyte outside the
3704 main loop so that they can be accessed for the back off. */
3711 {
3712 /* If we have not yet set a firstbyte in this branch, take it from the
3713 subpattern, remembering that it was set here so that a repeat of more
3714 than one can replicate it as reqbyte if necessary. If the subpattern has
3715 no firstbyte, set "none" for the whole branch. In both cases, a zero
3716 repeat forces firstbyte to "none". */
3719 {
3721 {
3724 }
3727 }
3729 /* If firstbyte was previously set, convert the subpattern's firstbyte
3730 into reqbyte if there wasn't one, using the vary flag that was in
3731 existence beforehand. */
3736 /* If the subpattern set a required byte (or set a first byte that isn't
3737 really the first byte - see above), set it. */
3740 }
3742 /* For a forward assertion, we take the reqbyte, if set. This can be
3743 helpful if the pattern that follows the assertion doesn't set a different
3744 char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
3745 for an assertion, however because it leads to incorrect effect for patterns
3746 such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
3747 of a firstbyte. This is overcome by a scan at the end if there's no
3748 firstbyte, looking for an asserted first char. */
3752 /* Now update the main code pointer to the end of the group. */
3756 /* Error if hit end of pattern */
3759 {
3762 }
3765 /* Check \ for being a real metacharacter; if not, fall through and handle
3766 it as a data character at the start of a string. Escape items are checked
3767 for validity in the pre-compiling pass. */
3773 /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
3774 are arranged to be the negation of the corresponding OP_values. For the
3775 back references, the values are ESC_REF plus the reference number. Only
3776 back references and those types that consume a character may be repeated.
3777 We can test for values between ESC_b and ESC_Z for the latter; this may
3778 have to change if any new ones are ever created. */
3781 {
3783 {
3787 }
3789 /* For metasequences that actually match a character, we disable the
3790 setting of a first character if it hasn't already been set. */
3795 /* Set values to reset to if this is followed by a zero repeat. */
3800 /* Back references are handled specially */
3803 {
3808 }
3810 /* So are Unicode property matches, if supported. We know that get_ucp
3811 won't fail because it was tested in the pre-pass. */
3813 #ifdef SUPPORT_UCP
3815 {
3816 BOOL negated;
3821 }
3822 #endif
3824 /* For the rest, we can obtain the OP value by negating the escape
3825 value */
3827 else
3828 {
3831 }
3833 }
3835 /* We have a data character whose value is in c. In UTF-8 mode it may have
3836 a value > 127. We set its representation in the length/buffer, and then
3837 handle it as a data character. */
3839 #ifdef SUPPORT_UTF8
3842 else
3843 #endif
3845 {
3848 }
3852 /* Handle a literal character. It is guaranteed not to be whitespace or #
3853 when the extended flag is set. If we are in UTF-8 mode, it may be a
3854 multi-byte literal character. */
3857 NORMAL_CHAR:
3861 #ifdef SUPPORT_UTF8
3863 {
3866 }
3867 #endif
3869 /* At this point we have the character's bytes in mcbuffer, and the length
3870 in mclength. When not in UTF-8 mode, the length is always 1. */
3872 ONE_CHAR:
3877 /* Set the first and required bytes appropriately. If no previous first
3878 byte, set it from this character, but revert to none on a zero repeat.
3879 Otherwise, leave the firstbyte value alone, and don't change it on a zero
3880 repeat. */
3883 {
3887 /* If the character is more than one byte long, we can set firstbyte
3888 only if it is not to be matched caselessly. */
3891 {
3894 }
3896 }
3898 /* firstbyte was previously set; we can set reqbyte only the length is
3899 1 or the matching is caseful. */
3901 else
3902 {
3907 }
3910 }
3913 /* Control never reaches here by falling through, only by a goto for all the
3914 error states. Pass back the position in the pattern so that it can be displayed
3915 to the user for diagnosing the error. */
3917 FAILED:
3920 }
3925 /*************************************************
3926 * Compile sequence of alternatives *
3927 *************************************************/
3929 /* On entry, ptr is pointing past the bracket character, but on return
3930 it points to the closing bracket, or vertical bar, or end of string.
3931 The code variable is pointing at the byte into which the BRA operator has been
3932 stored. If the ims options are changed at the start (for a (?ims: group) or
3933 during any branch, we need to insert an OP_OPT item at the start of every
3934 following branch to ensure they get set correctly at run time, and also pass
3935 the new options into every subsequent branch compile.
3937 Argument:
3938 options option bits, including any changes for this subpattern
3939 oldims previous settings of ims option bits
3940 brackets -> int containing the number of extracting brackets used
3941 codeptr -> the address of the current code pointer
3942 ptrptr -> the address of the current pattern pointer
3943 errorptr -> pointer to error message
3944 lookbehind TRUE if this is a lookbehind assertion
3945 skipbytes skip this many bytes at start (for OP_COND, OP_BRANUMBER)
3946 firstbyteptr place to put the first required character, or a negative number
3947 reqbyteptr place to put the last required character, or a negative number
3948 bcptr pointer to the chain of currently open branches
3949 cd points to the data block with tables pointers etc.
3951 Returns: TRUE on success
3952 */
3954 static BOOL
3958 {
3966 branch_chain bc;
3973 /* Offset is set zero to mark that this bracket is still open */
3978 /* Loop for each alternative branch */
3981 {
3982 /* Handle a change of ims options at the start of the branch */
3985 {
3988 }
3990 /* Set up dummy OP_REVERSE if lookbehind assertion */
3993 {
3997 }
3999 /* Now compile the branch */
4003 {
4006 }
4008 /* If this is the first branch, the firstbyte and reqbyte values for the
4009 branch become the values for the regex. */
4012 {
4015 }
4017 /* If this is not the first branch, the first char and reqbyte have to
4018 match the values from all the previous branches, except that if the previous
4019 value for reqbyte didn't have REQ_VARY set, it can still match, and we set
4020 REQ_VARY for the regex. */
4022 else
4023 {
4024 /* If we previously had a firstbyte, but it doesn't match the new branch,
4025 we have to abandon the firstbyte for the regex, but if there was previously
4026 no reqbyte, it takes on the value of the old firstbyte. */
4029 {
4032 }
4034 /* If we (now or from before) have no firstbyte, a firstbyte from the
4035 branch becomes a reqbyte if there isn't a branch reqbyte. */
4040 /* Now ensure that the reqbytes match */
4045 }
4047 /* If lookbehind, check that this branch matches a fixed-length string,
4048 and put the length into the OP_REVERSE item. Temporarily mark the end of
4049 the branch with OP_END. */
4052 {
4058 {
4062 }
4064 }
4066 /* Reached end of expression, either ')' or end of pattern. Go back through
4067 the alternative branches and reverse the chain of offsets, with the field in
4068 the BRA item now becoming an offset to the first alternative. If there are
4069 no alternatives, it points to the end of the group. The length in the
4070 terminating ket is always the length of the whole bracketed item. If any of
4071 the ims options were changed inside the group, compile a resetting op-code
4072 following, except at the very end of the pattern. Return leaving the pointer
4073 at the terminating char. */
4076 {
4078 do
4079 {
4084 }
4087 /* Fill in the ket */
4093 /* Resetting option if needed */
4096 {
4099 }
4101 /* Set values to pass back */
4108 }
4110 /* Another branch follows; insert an "or" node. Its length field points back
4111 to the previous branch while the bracket remains open. At the end the chain
4112 is reversed. It's done like this so that the start of the bracket has a
4113 zero offset until it is closed, making it possible to detect recursion. */
4119 ptr++;
4120 }
4121 /* Control never reaches here */
4122 }
4127 /*************************************************
4128 * Check for anchored expression *
4129 *************************************************/
4131 /* Try to find out if this is an anchored regular expression. Consider each
4132 alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
4133 all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
4134 it's anchored. However, if this is a multiline pattern, then only OP_SOD
4135 counts, since OP_CIRC can match in the middle.
4137 We can also consider a regex to be anchored if OP_SOM starts all its branches.
4138 This is the code for \G, which means "match at start of match position, taking
4139 into account the match offset".
4141 A branch is also implicitly anchored if it starts with .* and DOTALL is set,
4142 because that will try the rest of the pattern at all possible matching points,
4143 so there is no point trying again.... er ....
4145 .... except when the .* appears inside capturing parentheses, and there is a
4146 subsequent back reference to those parentheses. We haven't enough information
4147 to catch that case precisely.
4149 At first, the best we could do was to detect when .* was in capturing brackets
4150 and the highest back reference was greater than or equal to that level.
4151 However, by keeping a bitmap of the first 31 back references, we can catch some
4152 of the more common cases more precisely.
4154 Arguments:
4155 code points to start of expression (the bracket)
4156 options points to the options setting
4157 bracket_map a bitmap of which brackets we are inside while testing; this
4158 handles up to substring 31; after that we just have to take
4159 the less precise approach
4160 backref_map the back reference bitmap
4162 Returns: TRUE or FALSE
4163 */
4165 static BOOL
4168 {
4174 /* Capturing brackets */
4177 {
4183 }
4185 /* Other brackets */
4188 {
4190 }
4192 /* .* is not anchored unless DOTALL is set and it isn't in brackets that
4193 are or may be referenced. */
4197 {
4199 }
4201 /* Check for explicit anchoring */
4207 }
4210 }
4214 /*************************************************
4215 * Check for starting with ^ or .* *
4216 *************************************************/
4218 /* This is called to find out if every branch starts with ^ or .* so that
4219 "first char" processing can be done to speed things up in multiline
4220 matching and for non-DOTALL patterns that start with .* (which must start at
4221 the beginning or after \n). As in the case of is_anchored() (see above), we
4222 have to take account of back references to capturing brackets that contain .*
4223 because in that case we can't make the assumption.
4225 Arguments:
4226 code points to start of expression (the bracket)
4227 bracket_map a bitmap of which brackets we are inside while testing; this
4228 handles up to substring 31; after that we just have to take
4229 the less precise approach
4230 backref_map the back reference bitmap
4232 Returns: TRUE or FALSE
4233 */
4235 static BOOL
4238 {
4241 FALSE);
4244 /* Capturing brackets */
4247 {
4253 }
4255 /* Other brackets */
4260 /* .* means "start at start or after \n" if it isn't in brackets that
4261 may be referenced. */
4264 {
4266 }
4268 /* Check for explicit circumflex */
4272 /* Move on to the next alternative */
4275 }
4278 }
4282 /*************************************************
4283 * Check for asserted fixed first char *
4284 *************************************************/
4286 /* During compilation, the "first char" settings from forward assertions are
4287 discarded, because they can cause conflicts with actual literals that follow.
4288 However, if we end up without a first char setting for an unanchored pattern,
4289 it is worth scanning the regex to see if there is an initial asserted first
4290 char. If all branches start with the same asserted char, or with a bracket all
4291 of whose alternatives start with the same asserted char (recurse ad lib), then
4292 we return that char, otherwise -1.
4294 Arguments:
4295 code points to start of expression (the bracket)
4296 options pointer to the options (used to check casing changes)
4297 inassert TRUE if in an assertion
4299 Returns: -1 or the fixed first char
4300 */
4302 static int
4304 {
4315 {
4337 {
4340 }
4343 }
4346 }
4349 }
4354 #ifdef SUPPORT_UTF8
4355 /*************************************************
4356 * Validate a UTF-8 string *
4357 *************************************************/
4359 /* This function is called (optionally) at the start of compile or match, to
4360 validate that a supposed UTF-8 string is actually valid. The early check means
4361 that subsequent code can assume it is dealing with a valid string. The check
4362 can be turned off for maximum performance, but then consequences of supplying
4363 an invalid string are then undefined.
4365 Arguments:
4366 string points to the string
4367 length length of string, or -1 if the string is zero-terminated
4369 Returns: < 0 if the string is a valid UTF-8 string
4370 >= 0 otherwise; the value is the offset of the bad byte
4371 */
4373 static int
4375 {
4379 {
4382 }
4385 {
4394 /* Check top bits in the second byte */
4397 /* Check for overlong sequences for each different length */
4399 {
4400 /* Check for xx00 000x */
4405 /* Check for 1110 0000, xx0x xxxx */
4410 /* Check for 1111 0000, xx00 xxxx */
4415 /* Check for 1111 1000, xx00 0xxx */
4420 /* Check for leading 0xfe or 0xff, and then for 1111 1100, xx00 00xx */
4425 }
4427 /* Check for valid bytes after the 2nd, if any; all must start 10 */
4429 {
4431 }
4432 }
4435 }
4436 #endif
4440 /*************************************************
4441 * Compile a Regular Expression *
4442 *************************************************/
4444 /* This function takes a string and returns a pointer to a block of store
4445 holding a compiled version of the expression.
4447 Arguments:
4448 pattern the regular expression
4449 options various option bits
4450 errorptr pointer to pointer to error text
4451 erroroffset ptr offset in pattern where error was detected
4452 tables pointer to character tables or NULL
4454 Returns: pointer to compiled data block, or NULL on error,
4455 with errorptr and erroroffset set
4456 */
4458 EXPORT pcre *
4461 {
4464 /* int runlength; not used L.M. 2004-09-14 */
4473 #ifdef SUPPORT_UTF8
4474 BOOL utf8;
4475 BOOL class_utf8;
4476 #endif
4483 compile_data compile_block;
4487 /* We can't pass back an error message if errorptr is NULL; I guess the best we
4488 can do is just return NULL. */
4493 /* However, we can give a message for this error */
4496 {
4499 }
4502 /* Can't support UTF8 unless PCRE has been compiled to include the code. */
4504 #ifdef SUPPORT_UTF8
4508 {
4511 }
4512 #else
4514 {
4517 }
4518 #endif
4521 {
4524 }
4526 /* Set up pointers to the individual character tables */
4534 /* Maximum back reference and backref bitmap. This is updated for numeric
4535 references during the first pass, but for named references during the actual
4536 compile pass. The bitmap records up to 31 back references to help in deciding
4537 whether (.*) can be treated as anchored or not. */
4542 /* Reflect pattern for debugging output */
4547 /* The first thing to do is to make a pass over the pattern to compute the
4548 amount of store required to hold the compiled code. This does not have to be
4549 perfect as long as errors are overestimates. At the same time we can detect any
4550 flag settings right at the start, and extract them. Make an attempt to correct
4551 for any counted white space if an "extended" flag setting appears late in the
4552 pattern. We can't be so clever for #-comments. */
4556 {
4562 /* If we are inside a \Q...\E sequence, all chars are literal */
4565 {
4568 }
4570 /* Otherwise, first check for ignored whitespace and comments */
4573 {
4576 {
4577 /* The space before the ; is to avoid a warning on a silly compiler
4578 on the Macintosh. */
4582 }
4583 }
4587 /* Allow space for auto callout before every item except quantifiers. */
4595 {
4596 /* A backslashed item may be an escaped data character or it may be a
4597 character type. */
4606 {
4609 #ifdef SUPPORT_UTF8
4611 {
4617 }
4618 #endif
4621 }
4623 /* If \Q, enter "literal" mode */
4626 {
4629 }
4631 /* \X is supported only if Unicode property support is compiled */
4633 #ifndef SUPPORT_UCP
4635 {
4638 }
4639 #endif
4641 /* \P and \p are for Unicode properties, but only when the support has
4642 been compiled. Each item needs 2 bytes. */
4645 {
4646 #ifdef SUPPORT_UCP
4647 BOOL negated;
4652 #else
4655 #endif
4656 }
4658 /* Other escapes need one byte */
4660 length++;
4662 /* A back reference needs an additional 2 bytes, plus either one or 5
4663 bytes for a repeat. We also need to keep the value of the highest
4664 back reference. */
4667 {
4674 {
4679 length++;
4682 }
4683 }
4689 length++;
4696 length++;
4699 /* This covers the cases of braced repeats after a single char, metachar,
4700 class, or back reference. */
4707 /* These special cases just insert one extra opcode */
4711 length++;
4713 /* These cases might insert additional copies of a preceding character. */
4715 else
4716 {
4718 {
4721 }
4723 }
4729 {
4730 ptr++;
4732 }
4735 /* An alternation contains an offset to the next branch or ket. If any ims
4736 options changed in the previous branch(es), and/or if we are in a
4737 lookbehind assertion, extra space will be needed at the start of the
4738 branch. This is handled by branch_extra. */
4744 /* A character class uses 33 characters provided that all the character
4745 values are less than 256. Otherwise, it uses a bit map for low valued
4746 characters, and individual items for others. Don't worry about character
4747 types that aren't allowed in classes - they'll get picked up during the
4748 compile. A character class that contains only one single-byte character
4749 uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
4750 where we can. (In UTF-8 mode we can do this only for chars < 128.) */
4754 {
4756 ptr++;
4757 }
4760 #ifdef SUPPORT_UTF8
4762 #endif
4764 /* Written as a "do" so that an initial ']' is taken as data */
4767 {
4768 /* Inside \Q...\E everything is literal except \E */
4771 {
4776 }
4778 /* Outside \Q...\E, check for escapes */
4781 {
4785 /* \b is backspace inside a class; \X is literal */
4790 /* \Q enters quoting mode */
4793 {
4796 }
4798 /* Handle escapes that turn into characters */
4802 /* Escapes that are meta-things. The normal ones just affect the
4803 bit map, but Unicode properties require an XCLASS extended item. */
4805 else
4806 {
4808 #ifdef SUPPORT_UTF8
4810 {
4812 {
4815 }
4817 }
4818 #endif
4819 }
4820 }
4822 /* Check the syntax for POSIX stuff. The bits we actually handle are
4823 checked during the real compile phase. */
4826 {
4827 ptr++;
4829 }
4831 /* Anything else increments the possible optimization count. We have to
4832 detect ranges here so that we can compute the number of extra ranges for
4833 caseless wide characters when UCP support is available. If there are wide
4834 characters, we are going to have to use an XCLASS, even for single
4835 characters. */
4837 else
4838 {
4841 GET_ONE_CHARACTER:
4843 #ifdef SUPPORT_UTF8
4845 {
4849 }
4851 #else
4853 #endif
4855 /* Come here from handling \ above when it escapes to a char value */
4857 NON_SPECIAL_CHARACTER:
4858 class_optcount++;
4862 {
4865 {
4866 ptr++;
4871 }
4873 {
4874 ptr++;
4875 #ifdef SUPPORT_UTF8
4877 {
4881 }
4882 else
4883 #endif
4885 }
4887 }
4889 /* If d >= 0 we have a range. In UTF-8 mode, if the end is > 255, or >
4890 127 for caseless matching, we will need to use an XCLASS. */
4893 {
4896 {
4899 }
4901 #ifdef SUPPORT_UTF8
4903 {
4906 {
4909 }
4911 #ifdef SUPPORT_UCP
4912 /* If we have UCP support, find out how many extra ranges are
4913 needed to map the other case of characters within this range. We
4914 have to mimic the range optimization here, because extending the
4915 range upwards might push d over a boundary that makes is use
4916 another byte in the UTF-8 representation. */
4919 {
4924 {
4936 }
4938 /* An extra item is needed */
4942 }
4943 }
4946 /* The length of the (possibly extended) range */
4949 }
4952 }
4954 /* We have a single character. There is nothing to be done unless we
4955 are in UTF-8 mode. If the char is > 255, or 127 when caseless, we must
4956 allow for an XCL_SINGLE item, doubled for caselessness if there is UCP
4957 support. */
4959 else
4960 {
4961 #ifdef SUPPORT_UTF8
4963 {
4967 {
4970 }
4971 #ifdef SUPPORT_UCP
4977 }
4979 }
4980 }
4981 }
4985 {
4988 }
4990 /* We can optimize when there was only one optimizable character. Repeats
4991 for positive and negated single one-byte chars are handled by the general
4992 code. Here, we handle repeats for the class opcodes. */
4995 {
4998 /* A repeat needs either 1 or 5 bytes. If it is a possessive quantifier,
4999 we also need extra for wrapping the whole thing in a sub-pattern. */
5002 {
5007 length++;
5010 {
5011 ptr++;
5013 }
5015 }
5016 }
5019 /* Brackets may be genuine groups or special things */
5025 /* Handle special forms of bracket, which all start (? */
5028 {
5033 {
5034 /* Skip over comments entirely */
5039 {
5042 }
5045 /* Non-referencing groups and lookaheads just move the pointer on, and
5046 then behave like a non-special bracket, except that they don't increment
5047 the count of extracting brackets. Ditto for the "once only" bracket,
5048 which is in Perl from version 5.005. */
5057 /* (?R) specifies a recursive call to the regex, which is an extension
5058 to provide the facility which can be obtained by (?p{perl-code}) in
5059 Perl 5.6. In Perl 5.8 this has become (??{perl-code}).
5061 From PCRE 4.00, items such as (?3) specify subroutine-like "calls" to
5062 the appropriate numbered brackets. This includes both recursive and
5063 non-recursive calls. (?R) is now synonymous with (?0). */
5066 ptr++;
5074 {
5077 }
5080 /* If this item is quantified, it will get wrapped inside brackets so
5081 as to use the code for quantified brackets. We jump down and use the
5082 code that handles this for real brackets. */
5085 {
5089 }
5092 /* (?C) is an extension which provides "callout" - to provide a bit of
5093 the functionality of the Perl (?{...}) feature. An optional number may
5094 follow (default is zero). */
5100 {
5103 }
5107 /* Named subpatterns are an extension copied from Python */
5112 {
5117 {
5120 }
5121 name_count++;
5124 }
5127 {
5130 {
5133 }
5135 }
5137 /* Unknown character after (?P */
5142 /* Lookbehinds are in Perl from version 5.005 */
5147 {
5151 }
5155 /* Conditionals are in Perl from version 5.005. The bracket must either
5156 be followed by a number (for bracket reference) or by an assertion
5157 group, or (a PCRE extension) by 'R' for a recursion test. */
5161 {
5164 }
5166 {
5171 {
5174 }
5175 }
5177 {
5181 {
5185 }
5186 }
5189 /* Else loop checking valid options until ) is met. Anything else is an
5190 error. If we are without any brackets, i.e. at top level, the settings
5191 act as if specified in the options, so massage the options immediately.
5192 This is for backward compatibility with Perl 5.004. */
5200 {
5203 {
5232 /* A termination by ')' indicates an options-setting-only item; if
5233 this is at the very start of the pattern (indicated by item_count
5234 being zero), we use it to set the global options. This is helpful
5235 when analyzing the pattern for first characters, etc. Otherwise
5236 nothing is done here and it is handled during the compiling
5237 process.
5239 [Historical note: Up to Perl 5.8, options settings at top level
5240 were always global settings, wherever they appeared in the pattern.
5241 That is, they were equivalent to an external setting. From 5.8
5242 onwards, they apply only to what follows (which is what you might
5243 expect).] */
5247 {
5251 }
5253 /* Fall through */
5255 /* A termination by ':' indicates the start of a nested group with
5256 the given options set. This is again handled at compile time, but
5257 we must allow for compiled space if any of the ims options are
5258 set. We also have to allow for resetting space at the end of
5259 the group, which is why 4 is added to the length and not just 2.
5260 If there are several changes of options within the same group, this
5261 will lead to an over-estimate on the length, but this shouldn't
5262 matter very much. We also have to allow for resetting options at
5263 the start of any alternations, which we do by setting
5264 branch_newextra to 2. Finally, we record whether the case-dependent
5265 flag ever changes within the regex. This is used by the "required
5266 character" code. */
5270 {
5274 }
5277 /* Unrecognized option character */
5282 }
5283 }
5285 /* If we hit a closing bracket, that's it - this is a freestanding
5286 option-setting. We need to ensure that branch_extra is updated if
5287 necessary. The only values branch_newextra can have here are 0 or 2.
5288 If the value is 2, then branch_extra must either be 2 or 5, depending
5289 on whether this is a lookbehind group or not. */
5291 END_OPTIONS:
5293 {
5298 }
5300 /* If options were terminated by ':' control comes here. Fall through
5301 to handle the group below. */
5302 }
5303 }
5305 /* Extracting brackets must be counted so we can process escapes in a
5306 Perlish way. If the number exceeds EXTRACT_BASIC_MAX we are going to
5307 need an additional 3 bytes of store per extracting bracket. However, if
5308 PCRE_NO_AUTO)CAPTURE is set, unadorned brackets become non-capturing, so we
5309 must leave the count alone (it will aways be zero). */
5312 {
5313 bracount++;
5315 }
5317 /* Save length for computing whole length at end if there's a repeat that
5318 requires duplication of the group. Also save the current value of
5319 branch_extra, and start the new group with the new value. If non-zero, this
5320 will either be 2 for a (?imsx: group, or 3 for a lookbehind assertion. */
5323 {
5326 }
5335 /* Handle ket. Look for subsequent max/min; for certain sets of values we
5336 have to replicate this bracket up to that many times. If brastackptr is
5337 0 this is an unmatched bracket which will generate an error, but take care
5338 not to try to access brastack[-1] when computing the length and restoring
5339 the branch_extra value. */
5344 {
5347 }
5350 /* The following code is also used when a recursion such as (?3) is
5351 followed by a quantifier, because in that case, it has to be wrapped inside
5352 brackets so that the quantifier works. The value of duplength must be
5353 set before arrival. */
5355 HANDLE_QUANTIFIED_BRACKETS:
5357 /* Leave ptr at the final char; for read_repeat_counts this happens
5358 automatically; for the others we need an increment. */
5361 {
5364 }
5370 /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
5371 group, and if the maximum is greater than zero, we have to replicate
5372 maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
5373 bracket set. */
5376 {
5377 length++;
5379 }
5381 /* When the minimum is greater than zero, we have to replicate up to
5382 minval-1 times, with no additions required in the copies. Then, if there
5383 is a limited maximum we have to replicate up to maxval-1 times allowing
5384 for a BRAZERO item before each optional copy and nesting brackets for all
5385 but one of the optional copies. */
5387 else
5388 {
5393 }
5395 /* Allow space for once brackets for "possessive quantifier" */
5398 {
5399 ptr++;
5401 }
5404 /* Non-special character. It won't be space or # in extended mode, so it is
5405 always a genuine character. If we are in a \Q...\E sequence, check for the
5406 end; if not, we have a literal. */
5409 NORMAL_CHAR:
5412 {
5414 ptr++;
5416 }
5421 /* In UTF-8 mode, check for additional bytes. */
5423 #ifdef SUPPORT_UTF8
5425 {
5429 length++;
5430 ptr++;
5431 }
5432 }
5433 #endif
5436 }
5437 }
5445 {
5448 }
5450 /* Compute the size of data block needed and get it, either from malloc or
5451 externally provided function. */
5457 {
5460 }
5462 /* Put in the magic number, and save the sizes, options, and character table
5463 pointer. NULL is used for the default character tables. The nullpad field is at
5464 the end; it's there to help in the case when a regex compiled on a system with
5465 4-byte pointers is run on another with 8-byte pointers. */
5477 /* The starting points of the name/number translation table and of the code are
5478 passed around in the compile data block. */
5489 /* Set up a starting, non-extracting bracket, then compile the expression. On
5490 error, *errorptr will be set non-NULL, so we don't need to look at the result
5491 of the function here. */
5504 /* If not reached end of pattern on success, there's an excess bracket. */
5508 /* Fill in the terminating state and check for disastrous overflow, but
5509 if debugging, leave the test till after things are printed out. */
5513 #ifndef DEBUG
5515 #endif
5517 /* Give an error if there's back reference to a non-existent capturing
5518 subpattern. */
5522 /* Failed to compile, or error while post-processing */
5525 {
5527 PCRE_ERROR_RETURN:
5530 }
5532 /* If the anchored option was not passed, set the flag if we can determine that
5533 the pattern is anchored by virtue of ^ characters or \A or anything else (such
5534 as starting with .* when DOTALL is set).
5536 Otherwise, if we know what the first character has to be, save it, because that
5537 speeds up unanchored matches no end. If not, see if we can set the
5538 PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
5539 start with ^. and also when all branches start with .* for non-DOTALL matches.
5540 */
5543 {
5547 else
5548 {
5552 {
5557 }
5560 }
5561 }
5563 /* For an anchored pattern, we use the "required byte" only if it follows a
5564 variable length item in the regex. Remove the caseless flag for non-caseable
5565 bytes. */
5569 {
5574 }
5576 /* Print out the compiled data for debugging */
5578 #ifdef DEBUG
5584 {
5596 }
5599 {
5604 }
5607 {
5612 }
5616 /* This check is done here in the debugging case so that the code that
5617 was compiled can be seen. */
5620 {
5625 }
5626 #endif
5629 }
5633 /*************************************************
5634 * Match a back-reference *
5635 *************************************************/
5637 /* If a back reference hasn't been set, the length that is passed is greater
5638 than the number of characters left in the string, so the match fails.
5640 Arguments:
5641 offset index into the offset vector
5642 eptr points into the subject
5643 length length to be matched
5644 md points to match data block
5645 ims the ims flags
5647 Returns: TRUE if matched
5648 */
5650 static BOOL
5653 {
5656 #ifdef DEBUG
5659 else
5660 {
5663 }
5667 #endif
5669 /* Always fail if not enough characters left */
5673 /* Separate the caselesss case for speed */
5676 {
5679 }
5680 else
5684 }
5687 #ifdef SUPPORT_UTF8
5688 /*************************************************
5689 * Match character against an XCLASS *
5690 *************************************************/
5692 /* This function is called from within the XCLASS code below, to match a
5693 character against an extended class which might match values > 255.
5695 Arguments:
5696 c the character
5697 data points to the flag byte of the XCLASS data
5699 Returns: TRUE if character matches, else FALSE
5700 */
5702 static BOOL
5704 {
5708 /* Character values < 256 are matched against a bitmap, if one is present. If
5709 not, we still carry on, because there may be ranges that start below 256 in the
5710 additional data. */
5713 {
5716 }
5718 /* First skip the bit map if present. Then match against the list of Unicode
5719 properties or large chars or ranges that end with a large char. We won't ever
5720 encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */
5725 {
5728 {
5731 }
5733 {
5737 }
5739 #ifdef SUPPORT_UCP
5741 {
5746 {
5748 }
5749 else
5750 {
5752 }
5753 }
5755 }
5758 }
5759 #endif
5762 /***************************************************************************
5763 ****************************************************************************
5764 RECURSION IN THE match() FUNCTION
5766 The match() function is highly recursive. Some regular expressions can cause
5767 it to recurse thousands of times. I was writing for Unix, so I just let it
5768 call itself recursively. This uses the stack for saving everything that has
5769 to be saved for a recursive call. On Unix, the stack can be large, and this
5770 works fine.
5772 It turns out that on non-Unix systems there are problems with programs that
5773 use a lot of stack. (This despite the fact that every last chip has oodles
5774 of memory these days, and techniques for extending the stack have been known
5775 for decades.) So....
5777 There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
5778 calls by keeping local variables that need to be preserved in blocks of memory
5779 obtained from malloc instead instead of on the stack. Macros are used to
5780 achieve this so that the actual code doesn't look very different to what it
5781 always used to.
5782 ****************************************************************************
5783 ***************************************************************************/
5786 /* These versions of the macros use the stack, as normal */
5788 #ifndef NO_RECURSE
5789 #define REGISTER register
5790 #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)
5791 #define RRETURN(ra) return ra
5792 #else
5795 /* These versions of the macros manage a private stack on the heap. Note
5796 that the rd argument of RMATCH isn't actually used. It's the md argument of
5797 match(), which never changes. */
5799 #define REGISTER
5801 #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
5802 {\
5803 heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
5804 if (setjmp(frame->Xwhere) == 0)\
5805 {\
5806 newframe->Xeptr = ra;\
5807 newframe->Xecode = rb;\
5808 newframe->Xoffset_top = rc;\
5809 newframe->Xims = re;\
5810 newframe->Xeptrb = rf;\
5811 newframe->Xflags = rg;\
5812 newframe->Xprevframe = frame;\
5813 frame = newframe;\
5815 goto HEAP_RECURSE;\
5816 }\
5817 else\
5818 {\
5820 frame = md->thisframe;\
5821 rx = frame->Xresult;\
5822 }\
5823 }
5825 #define RRETURN(ra)\
5826 {\
5827 heapframe *newframe = frame;\
5828 frame = newframe->Xprevframe;\
5829 (pcre_stack_free)(newframe);\
5830 if (frame != NULL)\
5831 {\
5832 frame->Xresult = ra;\
5833 md->thisframe = frame;\
5834 longjmp(frame->Xwhere, 1);\
5835 }\
5836 return ra;\
5837 }
5840 /* Structure for remembering the local variables in a private frame */
5845 /* Function arguments that may change */
5854 /* Function local variables */
5864 recursion_info Xnew_recursive;
5866 BOOL Xcur_is_word;
5867 BOOL Xcondition;
5868 BOOL Xminimize;
5869 BOOL Xprev_is_word;
5873 #ifdef SUPPORT_UCP
5881 #endif
5896 eptrblock Xnewptrb;
5898 /* Place to pass back result, and where to jump back to */
5905 #endif
5908 /***************************************************************************
5909 ***************************************************************************/
5913 /*************************************************
5914 * Match from current position *
5915 *************************************************/
5917 /* On entry ecode points to the first opcode, and eptr to the first character
5918 in the subject string, while eptrb holds the value of eptr at the start of the
5919 last bracketed group - used for breaking infinite loops matching zero-length
5920 strings. This function is called recursively in many circumstances. Whenever it
5921 returns a negative (error) response, the outer incarnation must also return the
5922 same response.
5924 Performance note: It might be tempting to extract commonly used fields from the
5925 md structure (e.g. utf8, end_subject) into individual variables to improve
5926 performance. Tests using gcc on a SPARC disproved this; in the first case, it
5927 made performance worse.
5929 Arguments:
5930 eptr pointer in subject
5931 ecode position in code
5932 offset_top current top pointer
5933 md pointer to "static" info for the match
5934 ims current /i, /m, and /s options
5935 eptrb pointer to chain of blocks containing eptr at start of
5936 brackets - for testing for empty matches
5937 flags can contain
5938 match_condassert - this is an assertion condition
5939 match_isgroup - this is the start of a bracketed group
5941 Returns: MATCH_MATCH if matched ) these values are >= 0
5942 MATCH_NOMATCH if failed to match )
5943 a negative PCRE_ERROR_xxx value if aborted by an error condition
5944 (e.g. stopped by recursion limit)
5945 */
5947 static int
5951 {
5952 /* These variables do not need to be preserved over recursion in this function,
5953 so they can be ordinary variables in all cases. Mark them with "register"
5954 because they are used a lot in loops. */
5960 /* When recursion is not being used, all "local" variables that have to be
5961 preserved over calls to RMATCH() are part of a "frame" which is obtained from
5962 heap storage. Set up the top-level frame here; others are obtained from the
5963 heap whenever RMATCH() does a "recursion". See the macro definitions above. */
5965 #ifdef NO_RECURSE
5969 /* Copy in the original argument variables */
5978 /* This is where control jumps back to to effect "recursion" */
5980 HEAP_RECURSE:
5982 /* Macros make the argument variables come from the current frame */
5984 #define eptr frame->Xeptr
5985 #define ecode frame->Xecode
5986 #define offset_top frame->Xoffset_top
5987 #define ims frame->Xims
5988 #define eptrb frame->Xeptrb
5989 #define flags frame->Xflags
5991 /* Ditto for the local variables */
5993 #ifdef SUPPORT_UTF8
5994 #define charptr frame->Xcharptr
5995 #endif
5996 #define callpat frame->Xcallpat
5997 #define data frame->Xdata
5998 #define next frame->Xnext
5999 #define pp frame->Xpp
6000 #define prev frame->Xprev
6001 #define saved_eptr frame->Xsaved_eptr
6003 #define new_recursive frame->Xnew_recursive
6005 #define cur_is_word frame->Xcur_is_word
6006 #define condition frame->Xcondition
6007 #define minimize frame->Xminimize
6008 #define prev_is_word frame->Xprev_is_word
6010 #define original_ims frame->Xoriginal_ims
6012 #ifdef SUPPORT_UCP
6013 #define prop_type frame->Xprop_type
6014 #define prop_fail_result frame->Xprop_fail_result
6015 #define prop_category frame->Xprop_category
6016 #define prop_chartype frame->Xprop_chartype
6017 #define prop_othercase frame->Xprop_othercase
6018 #define prop_test_against frame->Xprop_test_against
6019 #define prop_test_variable frame->Xprop_test_variable
6020 #endif
6022 #define ctype frame->Xctype
6023 #define fc frame->Xfc
6024 #define fi frame->Xfi
6025 #define length frame->Xlength
6026 #define max frame->Xmax
6027 #define min frame->Xmin
6028 #define number frame->Xnumber
6029 #define offset frame->Xoffset
6030 #define op frame->Xop
6031 #define save_capture_last frame->Xsave_capture_last
6032 #define save_offset1 frame->Xsave_offset1
6033 #define save_offset2 frame->Xsave_offset2
6034 #define save_offset3 frame->Xsave_offset3
6035 #define stacksave frame->Xstacksave
6037 #define newptrb frame->Xnewptrb
6039 /* When recursion is being used, local variables are allocated on the stack and
6040 get preserved during recursion in the normal way. In this environment, fi and
6041 i, and fc and c, can be the same variables. */
6043 #else
6044 #define fi i
6045 #define fc c
6057 /* be cut out in a block. The only */
6059 /* for variables that do not have to */
6062 BOOL minimize;
6063 BOOL prev_is_word;
6067 #ifdef SUPPORT_UCP
6075 #endif
6088 eptrblock newptrb;
6089 #endif
6091 /* These statements are here to stop the compiler complaining about unitialized
6092 variables. */
6094 #ifdef SUPPORT_UCP
6098 #endif
6100 /* OK, now we can get on with the real code of the function. Recursion is
6101 specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,
6102 these just turn into a recursive call to match() and a "return", respectively.
6103 However, RMATCH isn't like a function call because it's quite a complicated
6104 macro. It has to be used in one particular way. This shouldn't, however, impact
6105 performance when true recursion is being used. */
6111 /* At the start of a bracketed group, add the current subject pointer to the
6112 stack of such pointers, to be re-instated at the end of the group when we hit
6113 the closing ket. When match() is called in other circumstances, we don't add to
6114 this stack. */
6117 {
6121 }
6123 /* Now start processing the operations. */
6126 {
6130 /* For partial matching, remember if we ever hit the end of the subject after
6131 matching at least one subject character. */
6138 /* Opening capturing bracket. If there is space in the offset vector, save
6139 the current subject position in the working slot at the top of the vector. We
6140 mustn't change the current values of the data slot, because they may be set
6141 from a previous iteration of this group, and be referred to by a reference
6142 inside the group.
6144 If the bracket fails to match, we need to restore this value and also the
6145 values of the final offsets, in case they were set by a previous iteration of
6146 the same bracket.
6148 If there isn't enough space in the offset vector, treat this as if it were a
6149 non-capturing bracket. Don't worry about setting the flag for the error case
6150 here; that is handled in the code for KET. */
6153 {
6156 /* For extended extraction brackets (large number), we have to fish out the
6157 number from a dummy opcode at the start. */
6163 #ifdef DEBUG
6167 #endif
6170 {
6179 do
6180 {
6182 match_isgroup);
6186 }
6196 }
6198 /* Insufficient room for saving captured contents */
6201 }
6203 /* Other types of node can be handled by a switch */
6206 {
6209 do
6210 {
6212 match_isgroup);
6215 }
6220 /* Conditional group: compilation checked that there are no more than
6221 two branches. If the condition is false, skipping the first branch takes us
6222 past the end if there is only one branch, but that's OK because that is
6223 exactly what going to the ket would do. */
6227 {
6236 }
6238 /* The condition is an assertion. Call match() to evaluate it - setting
6239 the final argument TRUE causes it to stop at the end of an assertion. */
6241 else
6242 {
6246 {
6249 }
6251 {
6253 }
6256 match_isgroup);
6258 }
6259 /* Control never reaches here */
6261 /* Skip over conditional reference or large extraction number data if
6262 encountered. */
6269 /* End of the pattern. If we are in a recursion, we should restore the
6270 offsets appropriately and continue from after the call. */
6274 {
6284 }
6286 /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
6287 string - backtracking will then try other alternatives, if any. */
6294 /* Change option settings */
6302 /* Assertion brackets. Check the alternative branches in turn - the
6303 matching won't pass the KET for an assertion. If any one branch matches,
6304 the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
6305 start of each branch to move the current point backwards, so the code at
6306 this level is identical to the lookahead case. */
6310 do
6311 {
6313 match_isgroup);
6317 }
6321 /* If checking an assertion for a condition, return MATCH_MATCH. */
6325 /* Continue from after the assertion, updating the offsets high water
6326 mark, since extracts may have been taken during the assertion. */
6333 /* Negative assertion: all branches must fail to match */
6337 do
6338 {
6340 match_isgroup);
6344 }
6352 /* Move the subject pointer back. This occurs only at the start of
6353 each branch of a lookbehind assertion. If we are too close to the start to
6354 move back, this match function fails. When working with UTF-8 we move
6355 back a number of characters, not bytes. */
6358 #ifdef SUPPORT_UTF8
6360 {
6363 {
6364 eptr--;
6367 }
6368 }
6369 else
6370 #endif
6372 /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
6374 {
6377 }
6379 /* Skip to next op code */
6384 /* The callout item calls an external function, if one is provided, passing
6385 details of the match so far. This is mainly for debugging, though the
6386 function is able to force a failure. */
6390 {
6391 pcre_callout_block cb;
6406 }
6410 /* Recursion either matches the current regex, or some subexpression. The
6411 offset data is the offset to the starting bracket from the start of the
6412 whole pattern. (This is so that it works from duplicated subpatterns.)
6414 If there are any capturing brackets started but not finished, we have to
6415 save their starting points and reinstate them after the recursion. However,
6416 we don't know how many such there are (offset_top records the completed
6417 total) so we just have to save all the potential data. There may be up to
6418 65535 such values, which is too large to put on the stack, but using malloc
6419 for small numbers seems expensive. As a compromise, the stack is used when
6420 there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
6421 is used. A problem is what to do if the malloc fails ... there is no way of
6422 returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
6423 values on the stack, and accept that the rest may be wrong.
6425 There are also other values that have to be saved. We use a chained
6426 sequence of blocks that actually live on the stack. Thanks to Robin Houston
6427 for the original version of this logic. */
6430 {
6434 /* For extended extraction brackets (large number), we have to fish out
6435 the number from a dummy opcode at the start. */
6440 /* Add to "recursing stack" */
6445 /* Find where to continue from afterwards */
6450 /* Now save the offset data. */
6455 else
6456 {
6460 }
6467 /* OK, now we can do the recursion. For each top-level alternative we
6468 restore the offset and recursion data. */
6471 do
6472 {
6476 {
6481 }
6488 }
6496 }
6497 /* Control never reaches here */
6499 /* "Once" brackets are like assertion brackets except that after a match,
6500 the point in the subject string is not moved back. Thus there can never be
6501 a move back into the brackets. Friedl calls these "atomic" subpatterns.
6502 Check the alternative branches in turn - the matching won't pass the KET
6503 for this kind of subpattern. If any one branch matches, we carry on as at
6504 the end of a normal bracket, leaving the subject pointer. */
6507 {
6511 do
6512 {
6518 }
6521 /* If hit the end of the group (which could be repeated), fail */
6525 /* Continue as from after the assertion, updating the offsets high water
6526 mark, since extracts may have been taken. */
6533 /* For a non-repeating ket, just continue at this level. This also
6534 happens for a repeating ket if no characters were matched in the group.
6535 This is the forcible breaking of infinite loops as implemented in Perl
6536 5.005. If there is an options reset, it will get obeyed in the normal
6537 course of events. */
6540 {
6543 }
6545 /* The repeating kets try the rest of the pattern or restart from the
6546 preceding bracket, in the appropriate order. We need to reset any options
6547 that changed within the bracket before re-running it, so check the next
6548 opcode. */
6551 {
6554 }
6557 {
6562 }
6564 {
6569 }
6570 }
6573 /* An alternation is the end of a branch; scan along to find the end of the
6574 bracketed group and go to there. */
6580 /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
6581 that it may occur zero times. It may repeat infinitely, or not at all -
6582 i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
6583 repeat limits are compiled as a number of copies, with the optional ones
6584 preceded by BRAZERO or BRAMINZERO. */
6587 {
6593 }
6597 {
6601 match_isgroup);
6603 ecode++;
6604 }
6607 /* End of a group, repeated or non-repeating. If we are at the end of
6608 an assertion "group", stop matching and return MATCH_MATCH, but record the
6609 current high water mark for use by positive assertions. Do this also
6610 for the "once" (not-backup up) groups. */
6615 {
6619 /* Back up the stack of bracket start pointers. */
6626 {
6630 }
6632 /* In all other cases except a conditional group we have to check the
6633 group number back at the start and if necessary complete handling an
6634 extraction by setting the offsets and bumping the high water mark. */
6637 {
6640 /* For extended extraction brackets (large number), we have to fish out
6641 the number from a dummy opcode at the start. */
6646 #ifdef DEBUG
6649 #endif
6651 /* Test for a numbered group. This includes groups called as a result
6652 of recursion. Note that whole-pattern recursion is coded as a recurse
6653 into group 0, so it won't be picked up here. Instead, we catch it when
6654 the OP_END is reached. */
6657 {
6660 {
6665 }
6667 /* Handle a recursively called group. Restore the offsets
6668 appropriately and continue from after the call. */
6671 {
6681 }
6682 }
6683 }
6685 /* Reset the value of the ims flags, in case they got changed during
6686 the group. */
6691 /* For a non-repeating ket, just continue at this level. This also
6692 happens for a repeating ket if no characters were matched in the group.
6693 This is the forcible breaking of infinite loops as implemented in Perl
6694 5.005. If there is an options reset, it will get obeyed in the normal
6695 course of events. */
6698 {
6701 }
6703 /* The repeating kets try the rest of the pattern or restart from the
6704 preceding bracket, in the appropriate order. */
6707 {
6712 }
6714 {
6719 }
6720 }
6724 /* Start of subject unless notbol, or after internal newline if multiline */
6729 {
6732 ecode++;
6734 }
6735 /* ... else fall through */
6737 /* Start of subject assertion */
6741 ecode++;
6744 /* Start of match assertion */
6748 ecode++;
6751 /* Assert before internal newline if multiline, or before a terminating
6752 newline unless endonly is set, else end of subject unless noteol is set. */
6756 {
6759 else
6761 ecode++;
6763 }
6764 else
6765 {
6768 {
6772 ecode++;
6774 }
6775 }
6776 /* ... else fall through */
6778 /* End of subject assertion (\z) */
6782 ecode++;
6785 /* End of subject or ending \n assertion (\Z) */
6790 ecode++;
6793 /* Word boundary assertions */
6797 {
6799 /* Find out if the previous and current characters are "word" characters.
6800 It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
6801 be "non-word" characters. */
6803 #ifdef SUPPORT_UTF8
6805 {
6807 {
6812 }
6814 {
6817 }
6818 }
6819 else
6820 #endif
6822 /* More streamlined when not in UTF-8 mode */
6824 {
6829 }
6831 /* Now see if the situation is what we want */
6836 }
6839 /* Match a single character type; inline for speed */
6845 #ifdef SUPPORT_UTF8
6848 #endif
6849 ecode++;
6852 /* Match a single byte, even in UTF-8 mode. This opcode really does match
6853 any byte, even newline, independent of the setting of PCRE_DOTALL. */
6857 ecode++;
6864 #ifdef SUPPORT_UTF8
6866 #endif
6868 )
6870 ecode++;
6877 #ifdef SUPPORT_UTF8
6879 #endif
6881 )
6883 ecode++;
6890 #ifdef SUPPORT_UTF8
6892 #endif
6894 )
6896 ecode++;
6903 #ifdef SUPPORT_UTF8
6905 #endif
6907 )
6909 ecode++;
6916 #ifdef SUPPORT_UTF8
6918 #endif
6920 )
6922 ecode++;
6929 #ifdef SUPPORT_UTF8
6931 #endif
6933 )
6935 ecode++;
6938 #ifdef SUPPORT_UCP
6939 /* Check the next character by Unicode property. We will get here only
6940 if the support is in the binary; otherwise a compile-time error occurs. */
6946 {
6952 ecode++;
6955 {
6958 }
6959 else
6960 {
6963 }
6964 }
6967 /* Match an extended Unicode sequence. We will get here only if the support
6968 is in the binary; otherwise a compile-time error occurs. */
6973 {
6979 {
6982 {
6984 }
6988 }
6989 }
6990 ecode++;
6992 #endif
6995 /* Match a back reference, possibly repeatedly. Look past the end of the
6996 item to see if there is repeat information following. The code is similar
6997 to that for character classes, but repeated for efficiency. Then obey
6998 similar code to character type repeats - written out again for speed.
6999 However, if the referenced string is the empty string, always treat
7000 it as matched, any number of times (otherwise there could be infinite
7001 loops). */
7004 {
7008 /* If the reference is unset, set the length to be longer than the amount
7009 of subject left; this ensures that every attempt at a match fails. We
7010 can't just fail here, because of the possibility of quantifiers with zero
7011 minima. */
7017 /* Set up for repetition, or handle the non-repeated case */
7020 {
7047 }
7049 /* If the length of the reference is zero, just continue with the
7050 main loop. */
7054 /* First, ensure the minimum number of matches are present. We get back
7055 the length of the reference string explicitly rather than passing the
7056 address of eptr, so that eptr can be a register variable. */
7059 {
7062 }
7064 /* If min = max, continue at the same level without recursion.
7065 They are not both allowed to be zero. */
7069 /* If minimizing, keep trying and advancing the pointer */
7072 {
7074 {
7080 }
7081 /* Control never gets here */
7082 }
7084 /* If maximizing, find the longest string and work backwards */
7086 else
7087 {
7090 {
7093 }
7095 {
7099 }
7101 }
7102 }
7103 /* Control never gets here */
7107 /* Match a bit-mapped character class, possibly repeatedly. This op code is
7108 used when all the characters in the class have values in the range 0-255,
7109 and either the matching is caseful, or the characters are in the range
7110 0-127 when UTF-8 processing is enabled. The only difference between
7111 OP_CLASS and OP_NCLASS occurs when a data character outside the range is
7112 encountered.
7114 First, look past the end of the item to see if there is repeat information
7115 following. Then obey similar code to character type repeats - written out
7116 again for speed. */
7120 {
7125 {
7151 }
7153 /* First, ensure the minimum number of matches are present. */
7155 #ifdef SUPPORT_UTF8
7156 /* UTF-8 mode */
7158 {
7160 {
7164 {
7166 }
7167 else
7168 {
7170 }
7171 }
7172 }
7173 else
7174 #endif
7175 /* Not UTF-8 mode */
7176 {
7178 {
7182 }
7183 }
7185 /* If max == min we can continue with the main loop without the
7186 need to recurse. */
7190 /* If minimizing, keep testing the rest of the expression and advancing
7191 the pointer while it matches the class. */
7194 {
7195 #ifdef SUPPORT_UTF8
7196 /* UTF-8 mode */
7198 {
7200 {
7206 {
7208 }
7209 else
7210 {
7212 }
7213 }
7214 }
7215 else
7216 #endif
7217 /* Not UTF-8 mode */
7218 {
7220 {
7226 }
7227 }
7228 /* Control never gets here */
7229 }
7231 /* If maximizing, find the longest possible run, then work backwards. */
7233 else
7234 {
7237 #ifdef SUPPORT_UTF8
7238 /* UTF-8 mode */
7240 {
7242 {
7247 {
7249 }
7250 else
7251 {
7253 }
7255 }
7257 {
7262 }
7263 }
7264 else
7265 #endif
7266 /* Not UTF-8 mode */
7267 {
7269 {
7273 eptr++;
7274 }
7276 {
7278 eptr--;
7280 }
7281 }
7284 }
7285 }
7286 /* Control never gets here */
7289 /* Match an extended character class. This opcode is encountered only
7290 in UTF-8 mode, because that's the only time it is compiled. */
7292 #ifdef SUPPORT_UTF8
7294 {
7299 {
7325 }
7327 /* First, ensure the minimum number of matches are present. */
7330 {
7334 }
7336 /* If max == min we can continue with the main loop without the
7337 need to recurse. */
7341 /* If minimizing, keep testing the rest of the expression and advancing
7342 the pointer while it matches the class. */
7345 {
7347 {
7353 }
7354 /* Control never gets here */
7355 }
7357 /* If maximizing, find the longest possible run, then work backwards. */
7359 else
7360 {
7363 {
7369 }
7371 {
7376 }
7378 }
7380 /* Control never gets here */
7381 }
7384 /* Match a single character, casefully */
7387 #ifdef SUPPORT_UTF8
7389 {
7391 ecode++;
7395 }
7396 else
7397 #endif
7399 /* Non-UTF-8 mode */
7400 {
7404 }
7407 /* Match a single character, caselessly */
7410 #ifdef SUPPORT_UTF8
7412 {
7414 ecode++;
7419 /* If the pattern character's value is < 128, we have only one byte, and
7420 can use the fast lookup table. */
7423 {
7425 }
7427 /* Otherwise we must pick up the subject character */
7429 else
7430 {
7435 /* If we have Unicode property support, we can use it to test the other
7436 case of the character, if there is one. The result of ucp_findchar() is
7437 < 0 if the char isn't found, and othercase is returned as zero if there
7438 isn't one. */
7441 {
7442 #ifdef SUPPORT_UCP
7446 #endif
7448 }
7449 }
7450 }
7451 else
7454 /* Non-UTF-8 mode */
7455 {
7459 }
7462 /* Match a single character repeatedly; different opcodes share code. */
7489 /* Common code for all repeated single-character matches. We can give
7490 up quickly if there are fewer than the minimum number of characters left in
7491 the subject. */
7493 REPEATCHAR:
7494 #ifdef SUPPORT_UTF8
7496 {
7503 /* Handle multibyte character matching specially here. There is
7504 support for caseless matching if UCP support is present. */
7507 {
7511 #ifdef SUPPORT_UCP
7521 {
7523 /* Need braces because of following else */
7525 else
7526 {
7529 }
7530 }
7535 {
7537 {
7542 /* Need braces because of following else */
7544 else
7545 {
7548 }
7549 }
7550 /* Control never gets here */
7551 }
7552 else
7553 {
7556 {
7560 else
7561 {
7564 }
7565 }
7567 {
7571 }
7573 }
7574 /* Control never gets here */
7575 }
7577 /* If the length of a UTF-8 character is 1, we fall through here, and
7578 obey the code as for non-UTF-8 characters below, though in this case the
7579 value of fc will always be < 128. */
7580 }
7581 else
7584 /* When not in UTF-8 mode, load a single-byte character. */
7585 {
7588 }
7590 /* The value of fc at this point is always less than 256, though we may or
7591 may not be in UTF-8 mode. The code is duplicated for the caseless and
7592 caseful cases, for speed, since matching characters is likely to be quite
7593 common. First, ensure the minimum number of matches are present. If min =
7594 max, continue at the same level without recursing. Otherwise, if
7595 minimizing, keep trying the rest of the expression and advancing one
7596 matching character if failing, up to the maximum. Alternatively, if
7597 maximizing, find the maximum number of characters and work backwards. */
7603 {
7609 {
7611 {
7617 }
7618 /* Control never gets here */
7619 }
7620 else
7621 {
7624 {
7626 eptr++;
7627 }
7629 {
7631 eptr--;
7633 }
7635 }
7636 /* Control never gets here */
7637 }
7639 /* Caseful comparisons (includes all multi-byte characters) */
7641 else
7642 {
7646 {
7648 {
7653 }
7654 /* Control never gets here */
7655 }
7656 else
7657 {
7660 {
7662 eptr++;
7663 }
7665 {
7667 eptr--;
7669 }
7671 }
7672 }
7673 /* Control never gets here */
7675 /* Match a negated single one-byte character. The character we are
7676 checking can be multibyte. */
7680 ecode++;
7683 {
7684 #ifdef SUPPORT_UTF8
7686 #endif
7689 }
7690 else
7691 {
7693 }
7696 /* Match a negated single one-byte character repeatedly. This is almost a
7697 repeat of the code for a repeated single character, but I haven't found a
7698 nice way of commoning these up that doesn't require a test of the
7699 positive/negative option for each character match. Maybe that wouldn't add
7700 very much to the time taken, but character matching *is* what this is all
7701 about... */
7728 /* Common code for all repeated single-byte matches. We can give up quickly
7729 if there are fewer than the minimum number of bytes left in the
7730 subject. */
7732 REPEATNOTCHAR:
7736 /* The code is duplicated for the caseless and caseful cases, for speed,
7737 since matching characters is likely to be quite common. First, ensure the
7738 minimum number of matches are present. If min = max, continue at the same
7739 level without recursing. Otherwise, if minimizing, keep trying the rest of
7740 the expression and advancing one matching character if failing, up to the
7741 maximum. Alternatively, if maximizing, find the maximum number of
7742 characters and work backwards. */
7748 {
7751 #ifdef SUPPORT_UTF8
7752 /* UTF-8 mode */
7754 {
7757 {
7761 }
7762 }
7763 else
7764 #endif
7766 /* Not UTF-8 mode */
7767 {
7770 }
7775 {
7776 #ifdef SUPPORT_UTF8
7777 /* UTF-8 mode */
7779 {
7782 {
7789 }
7790 }
7791 else
7792 #endif
7793 /* Not UTF-8 mode */
7794 {
7796 {
7801 }
7802 }
7803 /* Control never gets here */
7804 }
7806 /* Maximize case */
7808 else
7809 {
7812 #ifdef SUPPORT_UTF8
7813 /* UTF-8 mode */
7815 {
7818 {
7825 }
7827 {
7832 }
7833 }
7834 else
7835 #endif
7836 /* Not UTF-8 mode */
7837 {
7839 {
7841 eptr++;
7842 }
7844 {
7847 eptr--;
7848 }
7849 }
7852 }
7853 /* Control never gets here */
7854 }
7856 /* Caseful comparisons */
7858 else
7859 {
7860 #ifdef SUPPORT_UTF8
7861 /* UTF-8 mode */
7863 {
7866 {
7869 }
7870 }
7871 else
7872 #endif
7873 /* Not UTF-8 mode */
7874 {
7877 }
7882 {
7883 #ifdef SUPPORT_UTF8
7884 /* UTF-8 mode */
7886 {
7889 {
7895 }
7896 }
7897 else
7898 #endif
7899 /* Not UTF-8 mode */
7900 {
7902 {
7907 }
7908 }
7909 /* Control never gets here */
7910 }
7912 /* Maximize case */
7914 else
7915 {
7918 #ifdef SUPPORT_UTF8
7919 /* UTF-8 mode */
7921 {
7924 {
7930 }
7932 {
7937 }
7938 }
7939 else
7940 #endif
7941 /* Not UTF-8 mode */
7942 {
7944 {
7946 eptr++;
7947 }
7949 {
7952 eptr--;
7953 }
7954 }
7957 }
7958 }
7959 /* Control never gets here */
7961 /* Match a single character type repeatedly; several different opcodes
7962 share code. This is very similar to the code for single characters, but we
7963 repeat it in the interests of efficiency. */
7991 /* Common code for all repeated single character type matches. Note that
7992 in UTF-8 mode, '.' matches a character of any length, but for the other
7993 character types, the valid characters are all one-byte long. */
7995 REPEATTYPE:
7998 #ifdef SUPPORT_UCP
8000 {
8004 {
8007 }
8008 else
8009 {
8012 }
8013 }
8015 #endif
8017 /* First, ensure the minimum number of matches are present. Use inline
8018 code for maximizing the speed, and do the type test once at the start
8019 (i.e. keep it out of the loop). Also we can test that there are at least
8020 the minimum number of bytes before we start. This isn't as effective in
8021 UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
8022 is tidier. Also separate the UCP code, which can be the same for both UTF-8
8023 and single-bytes. */
8027 {
8028 #ifdef SUPPORT_UCP
8030 {
8032 {
8037 }
8038 }
8040 /* Match extended Unicode sequences. We will get here only if the
8041 support is in the binary; otherwise a compile-time error occurs. */
8044 {
8046 {
8051 {
8054 {
8056 }
8060 }
8061 }
8062 }
8064 else
8067 /* Handle all other cases when the coding is UTF-8 */
8069 #ifdef SUPPORT_UTF8
8071 {
8074 {
8079 }
8088 {
8093 }
8098 {
8102 /* No need to skip more bytes - we know it's a 1-byte character */
8103 }
8108 {
8113 }
8118 {
8122 /* No need to skip more bytes - we know it's a 1-byte character */
8123 }
8128 {
8133 }
8138 {
8142 /* No need to skip more bytes - we know it's a 1-byte character */
8143 }
8150 else
8153 /* Code for the non-UTF-8 case for minimum matching of operators other
8154 than OP_PROP and OP_NOTPROP. */
8157 {
8160 {
8163 }
8205 }
8206 }
8208 /* If min = max, continue at the same level without recursing */
8212 /* If minimizing, we have to test the rest of the pattern before each
8213 subsequent match. Again, separate the UTF-8 case for speed, and also
8214 separate the UCP cases. */
8217 {
8218 #ifdef SUPPORT_UCP
8220 {
8222 {
8230 }
8231 }
8233 /* Match extended Unicode sequences. We will get here only if the
8234 support is in the binary; otherwise a compile-time error occurs. */
8237 {
8239 {
8247 {
8250 {
8252 }
8256 }
8257 }
8258 }
8260 else
8263 #ifdef SUPPORT_UTF8
8264 /* UTF-8 mode */
8266 {
8268 {
8275 {
8315 }
8316 }
8317 }
8318 else
8319 #endif
8320 /* Not UTF-8 mode */
8321 {
8323 {
8329 {
8363 }
8364 }
8365 }
8366 /* Control never gets here */
8367 }
8369 /* If maximizing it is worth using inline code for speed, doing the type
8370 test once at the start (i.e. keep it out of the loop). Again, keep the
8371 UTF-8 and UCP stuff separate. */
8373 else
8374 {
8377 #ifdef SUPPORT_UCP
8379 {
8381 {
8389 }
8391 /* eptr is now past the end of the maximum run */
8394 {
8399 }
8400 }
8402 /* Match extended Unicode sequences. We will get here only if the
8403 support is in the binary; otherwise a compile-time error occurs. */
8406 {
8408 {
8414 {
8417 {
8419 }
8423 }
8424 }
8426 /* eptr is now past the end of the maximum run */
8429 {
8434 {
8438 {
8440 }
8443 eptr--;
8444 }
8445 }
8446 }
8448 else
8451 #ifdef SUPPORT_UTF8
8452 /* UTF-8 mode */
8455 {
8457 {
8460 /* Special code is required for UTF8, but when the maximum is unlimited
8461 we don't need it, so we repeat the non-UTF8 code. This is probably
8462 worth it, because .* is quite a common idiom. */
8465 {
8467 {
8469 {
8471 eptr++;
8473 }
8474 }
8475 else
8476 {
8478 {
8479 eptr++;
8481 }
8482 }
8483 }
8485 /* Handle unlimited UTF-8 repeat */
8487 else
8488 {
8490 {
8492 {
8494 eptr++;
8495 }
8497 }
8498 else
8499 {
8503 }
8504 }
8507 /* The byte case is the same as non-UTF8 */
8517 {
8523 }
8528 {
8534 }
8539 {
8545 }
8550 {
8556 }
8561 {
8567 }
8572 {
8578 }
8583 }
8585 /* eptr is now past the end of the maximum run */
8588 {
8593 }
8594 }
8595 else
8596 #endif
8598 /* Not UTF-8 mode */
8599 {
8601 {
8604 {
8606 {
8608 eptr++;
8609 }
8611 }
8612 /* For DOTALL case, fall through and treat as \C */
8622 {
8625 eptr++;
8626 }
8631 {
8634 eptr++;
8635 }
8640 {
8643 eptr++;
8644 }
8649 {
8652 eptr++;
8653 }
8658 {
8661 eptr++;
8662 }
8667 {
8670 eptr++;
8671 }
8676 }
8678 /* eptr is now past the end of the maximum run */
8681 {
8683 eptr--;
8685 }
8686 }
8688 /* Get here if we can't make it match with any permitted repetitions */
8691 }
8692 /* Control never gets here */
8694 /* There's been some horrible disaster. Since all codes > OP_BRA are
8695 for capturing brackets, and there shouldn't be any gaps between 0 and
8696 OP_BRA, arrival here can only mean there is something seriously wrong
8697 in the code above or the OP_xxx definitions. */
8702 }
8704 /* Do not stick any code in here without much thought; it is assumed
8705 that "continue" in the code above comes out to here to repeat the main
8706 loop. */
8709 /* Control never reaches here */
8710 }
8713 /***************************************************************************
8714 ****************************************************************************
8715 RECURSION IN THE match() FUNCTION
8717 Undefine all the macros that were defined above to handle this. */
8719 #ifdef NO_RECURSE
8720 #undef eptr
8721 #undef ecode
8722 #undef offset_top
8723 #undef ims
8724 #undef eptrb
8725 #undef flags
8727 #undef callpat
8728 #undef charptr
8729 #undef data
8730 #undef next
8731 #undef pp
8732 #undef prev
8733 #undef saved_eptr
8735 #undef new_recursive
8737 #undef cur_is_word
8738 #undef condition
8739 #undef minimize
8740 #undef prev_is_word
8742 #undef original_ims
8744 #undef ctype
8745 #undef length
8746 #undef max
8747 #undef min
8748 #undef number
8749 #undef offset
8750 #undef op
8751 #undef save_capture_last
8752 #undef save_offset1
8753 #undef save_offset2
8754 #undef save_offset3
8755 #undef stacksave
8757 #undef newptrb
8759 #endif
8761 /* These two are defined as macros in both cases */
8763 #undef fc
8764 #undef fi
8766 /***************************************************************************
8767 ***************************************************************************/
8771 /*************************************************
8772 * Execute a Regular Expression *
8773 *************************************************/
8775 /* This function applies a compiled re to a subject string and picks out
8776 portions of the string if it matches. Two elements in the vector are set for
8777 each substring: the offsets to the start and end of the substring.
8779 Arguments:
8780 argument_re points to the compiled expression
8781 extra_data points to extra data or is NULL
8782 subject points to the subject string
8783 length length of subject string (may contain binary zeros)
8784 start_offset where to start in the subject string
8785 options option bits
8786 offsets points to a vector of ints to be filled in with offsets
8787 offsetcount the number of elements in the vector
8789 Returns: > 0 => success; value is the number of elements filled in
8790 = 0 => success, but offsets is not big enough
8791 -1 => failed to match
8792 < -1 => some kind of unexpected problem
8793 */
8795 EXPORT int
8799 {
8806 BOOL anchored;
8807 BOOL startline;
8810 match_data match_block;
8817 pcre_study_data internal_study;
8820 real_pcre internal_re;
8824 /* Plausibility checks */
8831 /* Fish out the optional data from the extra_data structure, first setting
8832 the default values. */
8838 /* The table pointer is always in native byte order. */
8843 {
8852 }
8854 /* If the exec call supplied NULL for tables, use the inbuilt ones. This
8855 is a feature that makes it possible to save compiled regex and re-use them
8856 in other programs later. */
8860 /* Check that the first field in the block is the magic number. If it is not,
8861 test for a regex that was compiled on a host of opposite endianness. If this is
8862 the case, flipped values are put in internal_re and internal_study if there was
8863 study data too. */
8866 {
8870 }
8872 /* Set up other data */
8877 /* The code starts after the real_pcre block and the capture name table. */
8901 /* Partial matching is supported only for a restricted set of regexes at the
8902 moment. */
8907 /* Check a UTF-8 string if required. Unfortunately there's no way of passing
8908 back the character offset. */
8910 #ifdef SUPPORT_UTF8
8912 {
8916 {
8919 {
8922 }
8923 }
8924 }
8925 #endif
8927 /* The ims options can vary during the matching as a result of the presence
8928 of (?ims) items in the pattern. They are kept in a local variable so that
8929 restoring at the exit of a group is easy. */
8933 /* If the expression has got more back references than the offsets supplied can
8934 hold, we get a temporary chunk of working store to use during the matching.
8935 Otherwise, we can use the vector supplied, rounding down its size to a multiple
8936 of 3. */
8941 {
8947 }
8955 /* Compute the minimum number of offsets that we need to reset each time. Doing
8956 this makes a huge difference to execution time when there aren't many brackets
8957 in the pattern. */
8962 /* Reset the working variable associated with each extraction. These should
8963 never be used unless previously set, but they get saved and restored, and so we
8964 initialize them to avoid reading uninitialized locations. */
8967 {
8971 }
8973 /* Set up the first character to match, if available. The first_byte value is
8974 never set for an anchored regular expression, but the anchoring may be forced
8975 at run time, so we have to test for anchoring. The first char may be unset for
8976 an unanchored pattern, of course. If there's no first char and the pattern was
8977 studied, there may be a bitmap of possible first characters. */
8980 {
8982 {
8986 }
8987 else
8991 }
8993 /* For anchored or unanchored matches, there may be a "last known required
8994 character" set. */
8997 {
9001 }
9003 /* Loop for handling unanchored repeated matching attempts; for anchored regexs
9004 the loop runs just once. */
9006 do
9007 {
9008 /* Reset the maximum number of extractions we might see. */
9011 {
9015 }
9017 /* Advance to a unique first char if possible */
9020 {
9024 start_match++;
9025 else
9027 start_match++;
9028 }
9030 /* Or to just after \n for a multiline match if possible */
9033 {
9035 {
9037 start_match++;
9038 }
9039 }
9041 /* Or to a non-unique first char after study */
9044 {
9046 {
9049 }
9050 }
9056 #endif
9058 /* If req_byte is set, we know that that character must appear in the subject
9059 for the match to succeed. If the first character is set, req_byte must be
9060 later in the subject; otherwise the test starts at the match point. This
9061 optimization can save a huge amount of backtracking in patterns with nested
9062 unlimited repeats that aren't going to match. Writing separate code for
9063 cased/caseless versions makes it go faster, as does using an autoincrement
9064 and backing off on a match.
9066 HOWEVER: when the subject string is very, very long, searching to its end can
9067 take a long time, and give bad performance on quite ordinary patterns. This
9068 showed up when somebody was matching /^C/ on a 32-megabyte string... so we
9069 don't do this when the string is sufficiently long.
9071 ALSO: this processing is disabled when partial matching is requested.
9072 */
9077 {
9080 /* We don't need to repeat the search if we haven't yet reached the
9081 place we found it at last time. */
9084 {
9086 {
9088 {
9091 }
9092 }
9093 else
9094 {
9096 {
9098 }
9099 }
9101 /* If we can't find the required character, break the matching loop */
9105 /* If we have found the required character, save the point where we
9106 found it, so that we don't search again next time round the loop if
9107 the start hasn't passed this character yet. */
9110 }
9111 }
9113 /* When a match occurs, substrings will be set for all internal extractions;
9114 we just need to set up the whole thing as substring 0 before returning. If
9115 there were too many extractions, set the return code to zero. In the case
9116 where we had to get some local store to hold offsets for backreferences, copy
9117 those back references that we can. In this case there need not be overflow
9118 if certain parts of the pattern were not used. */
9124 match_isgroup);
9127 {
9128 start_match++;
9129 #ifdef SUPPORT_UTF8
9132 start_match++;
9133 #endif
9135 }
9138 {
9141 }
9143 /* We have a match! Copy the offset information from temporary store if
9144 necessary */
9147 {
9149 {
9153 }
9159 }
9164 {
9167 }
9171 }
9173 /* This "while" is the end of the "do" above */
9178 {
9181 }
9184 {
9187 }
9188 else
9189 {
9192 }
9193 }
9195 /* End of pcre.c */