| blob | c6a14ec52813a27e04b4c3b006343c277bcfff68 |
2 /*************************************************
3 * Perl-Compatible Regular Expressions *
4 *************************************************/
6 /* DO NOT EDIT THIS FILE! */
8 /* This file is automatically written by the merge-files.py script
9 included with the PCRE distribution for Python; it's produced from
10 several C files, and code is removed in the process. If you want to
11 modify the code or track down bugs, it will be much easier to work
12 with the code in its original, multiple-file form. Don't edit this
13 file by hand, or submit patches to it.
15 The Python-specific PCRE distribution can be retrieved from
16 http://starship.skyport.net/crew/amk/regex/
18 The unmodified original PCRE distribution is available at
19 ftp://ftp.cus.cam.ac.uk/pub/software/programs/pcre/, and is originally
20 written by: Philip Hazel <ph10@cam.ac.uk>
22 Extensively modified by the Python String-SIG: <string-sig@python.org>
23 Send bug reports to: <string-sig@python.org>
24 (They'll figure out if it's a bug in PCRE or in the Python-specific
25 changes.)
27 Copyright (c) 1997 University of Cambridge
29 -----------------------------------------------------------------------------
30 Permission is granted to anyone to use this software for any purpose on any
31 computer system, and to redistribute it freely, subject to the following
32 restrictions:
34 1. This software is distributed in the hope that it will be useful,
35 but WITHOUT ANY WARRANTY; without even the implied warranty of
36 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
38 2. The origin of this software must not be misrepresented, either by
39 explicit claim or by omission.
41 3. Altered versions must be plainly marked as such, and must not be
42 misrepresented as being the original software.
43 -----------------------------------------------------------------------------
44 */
47 #define FOR_PYTHON
50 #include <ctype.h>
53 /*************************************************
54 * Perl-Compatible Regular Expressions *
55 *************************************************/
57 /* This file is automatically written by the makechartables auxiliary
58 program. If you edit it by hand, you might like to edit the Makefile to
59 prevent its ever being regenerated. */
61 /* This table is a lower casing table. */
97 /* This table is a case flipping table. */
133 /* This table contains bit maps for digits, letters, 'word' chars, and
134 white space. Each map is 32 bytes long and the bits run from the least
135 significant end of each byte. */
158 /* This table identifies various classes of character by individual bits:
159 0x01 white space character
160 0x02 letter
161 0x04 decimal digit
162 0x08 hexadecimal digit
163 0x10 alphanumeric or '_'
164 0x80 regular expression metacharacter or binary zero
165 */
201 /* End of chartables.c */
202 /*************************************************
203 * Perl-Compatible Regular Expressions *
204 *************************************************/
206 /*
207 This is a library of functions to support regular expressions whose syntax
208 and semantics are as close as possible to those of the Perl 5 language. See
209 the file Tech.Notes for some information on the internals.
211 Written by: Philip Hazel <ph10@cam.ac.uk>
213 Copyright (c) 1998 University of Cambridge
215 -----------------------------------------------------------------------------
216 Permission is granted to anyone to use this software for any purpose on any
217 computer system, and to redistribute it freely, subject to the following
218 restrictions:
220 1. This software is distributed in the hope that it will be useful,
221 but WITHOUT ANY WARRANTY; without even the implied warranty of
222 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
224 2. The origin of this software must not be misrepresented, either by
225 explicit claim or by omission.
227 3. Altered versions must be plainly marked as such, and must not be
228 misrepresented as being the original software.
229 -----------------------------------------------------------------------------
230 */
233 /* Include the internals header, which itself includes Standard C headers plus
234 the external pcre header. */
239 /*************************************************
240 * Create bitmap of starting chars *
241 *************************************************/
243 /* This function scans a compiled unanchored expression and attempts to build a
244 bitmap of the set of initial characters. If it can't, it returns FALSE. As time
245 goes by, we may be able to get more clever at doing this.
247 Arguments:
248 code points to an expression
249 start_bits points to a 32-byte table, initialized to 0
251 Returns: TRUE if table built, FALSE otherwise
252 */
254 static BOOL
256 {
260 do
261 {
266 {
270 {
272 }
275 {
279 /* BRAZERO does the bracket, but carries on. */
290 /* Single-char * or ? sets the bit and tries the next item */
301 /* Single-char upto sets the bit and tries the next */
310 /* At least one single char sets the bit and stops */
313 tcode++;
316 tcode++;
323 /* Single character type sets the bits and stops */
351 /* One or more character type fudges the pointer and restarts, knowing
352 it will hit a single character type and stop there. */
356 tcode++;
365 /* Zero or more repeats of character types set the bits and then
366 try again. */
377 {
403 }
409 /* Character class: set the bits and either carry on or not,
410 according to the repeat count. */
414 {
415 tcode++;
419 {
424 tcode++;
431 {
434 }
436 }
437 }
444 }
447 }
451 /*************************************************
452 * Study a compiled expression *
453 *************************************************/
455 /* This function is handed a compiled expression that it must study to produce
456 information that will speed up the matching. It returns a pcre_extra block
457 which then gets handed back to pcre_exec().
459 Arguments:
460 re points to the compiled expression
461 options contains option bits
462 errorptr points to where to place error messages;
463 set NULL unless error
465 Returns: pointer to a pcre_extra block,
466 NULL on error or if no optimization possible
467 */
469 pcre_extra *
471 {
472 BOOL caseless;
480 {
483 }
486 {
489 }
491 /* Caseless can either be from the compiled regex or from options. */
495 /* For an anchored pattern, or an unanchored pattern that has a first char, or a
496 multiline pattern that matches only at "line starts", no further processing at
497 present. */
502 /* See if we can find a fixed set of initial characters for the pattern. */
507 /* If this studying is caseless, scan the created bit map and duplicate the
508 bits for any letters. */
511 {
514 {
517 {
520 }
521 }
522 }
524 /* Get an "extra" block and put the information therein. */
529 {
532 }
538 }
540 /* End of study.c */
541 /*************************************************
542 * Perl-Compatible Regular Expressions *
543 *************************************************/
545 /*
546 This is a library of functions to support regular expressions whose syntax
547 and semantics are as close as possible to those of the Perl 5 language. See
548 the file Tech.Notes for some information on the internals.
550 Written by: Philip Hazel <ph10@cam.ac.uk>
552 Copyright (c) 1998 University of Cambridge
554 -----------------------------------------------------------------------------
555 Permission is granted to anyone to use this software for any purpose on any
556 computer system, and to redistribute it freely, subject to the following
557 restrictions:
559 1. This software is distributed in the hope that it will be useful,
560 but WITHOUT ANY WARRANTY; without even the implied warranty of
561 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
563 2. The origin of this software must not be misrepresented, either by
564 explicit claim or by omission.
566 3. Altered versions must be plainly marked as such, and must not be
567 misrepresented as being the original software.
568 -----------------------------------------------------------------------------
569 */
572 /* Define DEBUG to get debugging output on stdout. */
574 /* #define DEBUG */
576 /* Use a macro for debugging printing, 'cause that eliminates the the use
577 of #ifdef inline, and there are *still* stupid compilers about that don't like
578 indented pre-processor statements. I suppose it's only been 10 years... */
580 #ifdef DEBUG
581 #define DPRINTF(p) printf p
582 #else
584 #endif
586 /* Include the internals header, which itself includes Standard C headers plus
587 the external pcre header. */
592 #ifndef Py_eval_input
593 /* For Python 1.4, graminit.h has to be explicitly included */
594 #define Py_eval_input eval_input
598 /* Allow compilation as C++ source code, should anybody want to do that. */
600 #ifdef __cplusplus
601 #define class pcre_class
602 #endif
605 /* Min and max values for the common repeats; for the maxima, 0 => infinity */
610 /* Text forms of OP_ values and things, for debugging (not all used) */
612 #ifdef DEBUG
626 };
627 #endif
629 /* Table for handling escaped characters in the range '0'-'z'. Positive returns
630 are simple data values; negative values are for special things like \d and so
631 on. Zero means further processing is needed (for things like \x), or the escape
632 is invalid. */
645 };
647 /* Definition to allow mutual recursion */
649 static BOOL
651 PyObject *);
653 /* Structure for passing "static" information around between the functions
654 doing the matching, so that they are thread-safe. */
674 matching operation */
677 /* Pointers to the 6 stacks */
684 /*************************************************
685 * Global variables *
686 *************************************************/
688 /* PCRE is thread-clean and doesn't use any global variables in the normal
689 sense. However, it calls memory allocation and free functions via the two
690 indirections below, which are can be changed by the caller, but are shared
691 between all threads. */
699 /*************************************************
700 * Return version string *
701 *************************************************/
705 {
707 }
712 /*************************************************
713 * Return info about a compiled pattern *
714 *************************************************/
716 /* This function picks potentially useful data out of the private
717 structure.
719 Arguments:
720 external_re points to compiled code
721 optptr where to pass back the options
722 first_char where to pass back the first character,
723 or -1 if multiline and all branches start ^,
724 or -2 otherwise
726 Returns: number of identifying extraction brackets
727 or negative values on error
728 */
730 int
732 {
741 }
746 #ifdef DEBUG
747 /*************************************************
748 * Debugging function to print chars *
749 *************************************************/
751 /* Print a sequence of chars in printable format, stopping at the end of the
752 subject if the requested.
754 Arguments:
755 p points to characters
756 length number to print
757 is_subject TRUE if printing from within md->start_subject
758 md pointer to matching data block, if is_subject is TRUE
760 Returns: nothing
761 */
763 static void
765 {
770 }
771 #endif
776 /*************************************************
777 * Check subpattern for empty operand *
778 *************************************************/
780 /* This function checks a bracketed subpattern to see if any of the paths
781 through it could match an empty string. This is used to diagnose an error if
782 such a subpattern is followed by a quantifier with an unlimited upper bound.
784 Argument:
785 code points to the opening bracket
787 Returns: TRUE or FALSE
788 */
790 static BOOL
792 {
796 /* Scan along the opcodes for this branch; as soon as we find something
797 that matches a non-empty string, break out and advance to test the next
798 branch. If we get to the end of the branch, return TRUE for the whole
799 sub-expression. */
802 {
803 /* Test an embedded subpattern; if it could not be empty, break the
804 loop. Otherwise carry on in the branch. */
807 {
811 }
814 {
815 /* Reached end of a branch: the subpattern may match the empty string */
823 /* Skip over entire bracket groups with zero lower bound */
827 cc++;
828 /* Fall through */
830 /* Skip over assertive subpatterns */
838 /* Skip over things that don't match chars */
848 cc++;
851 /* Skip over simple repeats with zero lower bound */
868 /* Skip over UPTOs (lower bound is zero) */
877 /* Check a class or a back reference for a zero minimum */
884 {
888 }
891 {
896 cc++;
907 }
910 /* Anything else matches at least one character */
914 }
915 }
917 NEXT_BRANCH:
919 }
922 /* No branches match the empty string */
925 }
927 /* Determine the length of a group ID in an expression like
928 (?P<foo_123>...)
929 Arguments:
930 ptr pattern position pointer (say that 3 times fast)
931 finalchar the character that will mark the end of the ID
932 errorptr points to the pointer to the error message
933 */
935 static int
937 {
940 /* If the first character is not in \w, or is in \w but is a digit,
941 report an error */
944 {
947 }
949 /* Increment ptr until we either hit a null byte, the desired
950 final character, or a non-word character */
953 {
954 /* Empty loop body */
955 }
959 {
962 }
965 }
967 /*************************************************
968 * Handle escapes *
969 *************************************************/
971 /* This function is called when a \ has been encountered. It either returns a
972 positive value for a simple escape such as \n, or a negative value which
973 encodes one of the more complicated things such as \d. On entry, ptr is
974 pointing at the \. On exit, it is on the final character of the escape
975 sequence.
977 Arguments:
978 ptrptr points to the pattern position pointer
979 errorptr points to the pointer to the error message
980 bracount number of previous extracting brackets
981 options the options bits
982 isclass TRUE if inside a character class
984 Returns: zero or positive => a data character
985 negative => a special escape sequence
986 on error, errorptr is set
987 */
989 static int
992 {
999 /* Digits or letters may have special meaning; all others are literals. */
1003 /* Do an initial lookup in a table. A non-zero result is something that can be
1004 returned immediately. Otherwise further processing may be required. */
1008 /* Escapes that need further processing, or are illegal. */
1010 else
1011 {
1014 {
1015 /* The handling of escape sequences consisting of a string of digits
1016 starting with one that is not zero is not straightforward. By experiment,
1017 the way Perl works seems to be as follows:
1019 Outside a character class, the digits are read as a decimal number. If the
1020 number is less than 10, or if there are that many previous extracting
1021 left brackets, then it is a back reference. Otherwise, up to three octal
1022 digits are read to form an escaped byte. Thus \123 is likely to be octal
1023 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
1024 value is greater than 377, the least significant 8 bits are taken. Inside a
1025 character class, \ followed by a digit is always an octal number. */
1030 {
1031 /* PYTHON: Try to compute an octal value for a character */
1033 {
1036 else
1038 }
1039 /* It's a character if there were exactly 3 octal digits, or if
1040 we're inside a character class and there was at least one
1041 octal digit. */
1043 {
1046 }
1050 {
1053 }
1056 }
1059 /* \0 always starts an octal number, but we may drop through to here with a
1060 larger first octal digit */
1069 /* Special escapes not starting with a digit are straightforward */
1074 {
1075 ptr++;
1079 }
1083 /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
1084 other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
1085 for Perl compatibility, it is a literal. */
1089 {
1097 }
1099 }
1100 }
1104 }
1108 /*************************************************
1109 * Check for counted repeat *
1110 *************************************************/
1112 /* This function is called when a '{' is encountered in a place where it might
1113 start a quantifier. It looks ahead to see if it really is a quantifier or not.
1114 It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
1115 where the ddds are digits.
1117 Arguments:
1118 p pointer to the first char after '{'
1120 Returns: TRUE or FALSE
1121 */
1123 static BOOL
1125 {
1136 }
1140 /*************************************************
1141 * Read repeat counts *
1142 *************************************************/
1144 /* Read an item of the form {n,m} and return the values. This is called only
1145 after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
1146 so the syntax is guaranteed to be correct, but we need to check the values.
1148 Arguments:
1149 p pointer to first char after '{'
1150 minp pointer to int for min
1151 maxp pointer to int for max
1152 returned as -1 if no max
1153 errorptr points to pointer to error message
1155 Returns: pointer to '}' on success;
1156 current ptr on error, with errorptr set
1157 */
1161 {
1168 {
1170 {
1174 {
1177 }
1178 }
1179 }
1181 /* Do paranoid checks, then fill in the required variables, and pass back the
1182 pointer to the terminating '}'. */
1186 else
1187 {
1190 }
1192 }
1196 /*************************************************
1197 * Compile one branch *
1198 *************************************************/
1200 /* Scan the pattern, compiling it into the code vector.
1202 Arguments:
1203 options the option bits
1204 bracket points to number of brackets used
1205 code points to the pointer to the current code point
1206 ptrptr points to the current pattern pointer
1207 errorptr points to pointer to error message
1209 Returns: TRUE on success
1210 FALSE, with *errorptr set on error
1211 */
1213 static BOOL
1216 {
1229 /* Set up the default and non-default settings for greediness */
1234 /* Switch on next character until the end of the branch */
1237 {
1238 BOOL negate_class;
1244 {
1247 {
1250 }
1251 }
1254 {
1255 /* The branch terminates at end of string, |, or ). */
1264 /* Handle single-character metacharacters */
1281 /* Character classes. These always build a 32-byte bitmap of the permitted
1282 characters, except in the special case where there is only one character.
1283 For negated classes, we build the map as usual, then invert it at the end.
1284 */
1289 {
1291 /* Set the flag for localized classes (like \w) to 0 */
1294 }
1295 else
1296 {
1299 }
1301 /* If the first character is '^', set the negation flag, and use a
1302 different opcode. This only matters if caseless matching is specified at
1303 runtime. */
1306 {
1310 }
1313 /* Keep a count of chars so that we can optimize the case of just a single
1314 character. */
1319 /* Initialize the 32-char bit map to all zeros. We have to build the
1320 map in a temporary bit of store, in case the class contains only 1
1321 character, because in that case the compiled code doesn't use the
1322 bit map. */
1326 /* Process characters until ] is reached. By writing this as a "do" it
1327 means that an initial ] is taken as a data character. */
1329 do
1330 {
1332 {
1335 }
1337 /* Backslash may introduce a single character, or it may introduce one
1338 of the specials, which just set a flag. Escaped items are checked for
1339 validity in the pre-compiling pass. The sequence \b is a special case.
1340 Inside a class (and only there) it is treated as backspace. Elsewhere
1341 it marks a word boundary. Other escapes have preset maps ready to
1342 or into the one we are building. We assume they have more than one
1343 character in them, so set class_count bigger than one. */
1346 {
1350 {
1353 {
1355 {
1357 }
1361 {
1363 }
1368 {
1370 }
1371 else
1372 {
1375 }
1380 {
1382 }
1383 else
1384 {
1387 }
1391 {
1393 }
1397 {
1399 }
1405 }
1406 }
1407 /* Fall through if single character */
1408 }
1410 /* A single character may be followed by '-' to form a range. However,
1411 Perl does not permit ']' to be the end of the range. A '-' character
1412 here is treated as a literal. */
1415 {
1421 {
1424 }
1426 /* The second part of a range can be a single-character escape, but
1427 not any of the other escapes. */
1430 {
1433 {
1435 {
1438 }
1439 }
1440 }
1443 {
1446 }
1449 {
1452 {
1455 }
1458 }
1460 }
1462 /* Handle a lone single character - we can get here for a normal
1463 non-escape char, or after \ that introduces a single character. */
1467 {
1470 }
1471 class_charcount++;
1473 }
1475 /* Loop until ']' reached; the check for end of string happens inside the
1476 loop. This "while" is the end of the "do" above. */
1480 /* If class_charcount is 1 and class_lastchar is not negative, we saw
1481 precisely one character. This doesn't need the whole 32-byte bit map.
1482 We turn it into a 1-character OP_CHAR if it's positive, or OP_NOT if
1483 it's negative. */
1486 {
1488 {
1490 }
1491 else
1492 {
1495 }
1497 }
1499 /* Otherwise, negate the 32-byte map if necessary, and copy it into
1500 the code vector. */
1502 else
1503 {
1504 /* If this is a localized opcode, bump the code pointer up */
1507 {
1510 }
1511 else
1514 }
1517 /* Various kinds of repeat */
1539 REPEAT:
1541 {
1544 }
1546 /* If the next character is '?' this is a minimizing repeat, by default,
1547 but if PCRE_UNGREEDY is set, it works the other way round. Advance to the
1548 next character. */
1554 /* If the maximum is zero then the minimum must also be zero; Perl allows
1555 this case, so we do too - by simply omitting the item altogether. */
1559 /* If previous was a string of characters, chop off the last one and use it
1560 as the subject of the repeat. If there was only one character, we can
1561 abolish the previous item altogether. */
1564 {
1567 {
1570 }
1571 else
1572 {
1575 code--;
1576 }
1579 }
1581 /* If previous was a single negated character ([^a] or similar), we use
1582 one of the special opcodes, replacing it. The code is shared with single-
1583 character repeats by adding a suitable offset into repeat_type. */
1586 {
1591 }
1593 /* If previous was a character type match (\d or similar), abolish it and
1594 create a suitable repeat item. The code is shared with single-character
1595 repeats by adding a suitable offset into repeat_type. */
1598 {
1603 OUTPUT_SINGLE_REPEAT:
1606 /* A minimum of zero is handled either as the special case * or ?, or as
1607 an UPTO, with the maximum given. */
1610 {
1613 else
1614 {
1618 }
1619 }
1621 /* The case {1,} is handled as the special case + */
1626 /* The case {n,n} is just an EXACT, while the general case {n,m} is
1627 handled as an EXACT followed by an UPTO. An EXACT of 1 is optimized. */
1629 else
1630 {
1632 {
1636 }
1638 /* If the minimum is 1 and the previous item was a character string,
1639 we either have to put back the item that got canceled if the string
1640 length was 1, or add the character back onto the end of a longer
1641 string. For a character type nothing need be done; it will just get
1642 put back naturally. Note that the final character is always going to
1643 get added below. */
1646 {
1648 }
1650 /* For a single negated character we also have to put back the
1651 item that got canceled. */
1655 /* If the maximum is unlimited, insert an OP_STAR. */
1658 {
1661 }
1663 /* Else insert an UPTO if the max is greater than the min. */
1666 {
1672 }
1673 }
1675 /* The character or character type itself comes last in all cases. */
1678 }
1680 /* If previous was a character class or a back reference, we put the repeat
1681 stuff after it. */
1685 {
1692 else
1693 {
1700 }
1701 }
1703 /* If previous was a bracket group, we may have to replicate it in certain
1704 cases. If the maximum repeat count is unlimited, check that the bracket
1705 group cannot match the empty string, and diagnose an error if it can. */
1708 {
1713 {
1716 }
1718 /* If the minimum is greater than zero, and the maximum is unlimited or
1719 equal to the minimum, the first copy remains where it is, and is
1720 replicated up to the minimum number of times. This case includes the +
1721 repeat, but of course no replication is needed in that case. */
1724 {
1726 {
1729 }
1730 }
1732 /* If the minimum is zero, stick BRAZERO in front of the first copy.
1733 Then, if there is a fixed upper limit, replicated up to that many times,
1734 sticking BRAZERO in front of all the optional ones. */
1736 else
1737 {
1739 {
1741 code++;
1743 }
1746 {
1749 }
1752 {
1756 }
1757 }
1759 /* If the maximum is unlimited, set a repeater in the final copy. */
1762 }
1764 /* Else there's some kind of shambles */
1766 else
1767 {
1770 }
1772 /* In all case we no longer have a previous item. */
1778 /* Start of nested bracket sub-expression, or comment or lookahead.
1779 First deal with special things that can come after a bracket; all are
1780 introduced by ?, and the appearance of any of them means that this is not a
1781 referencing group. They were checked for validity in the first pass over
1782 the string, so we don't have to check for syntax errors here. */
1787 {
1791 {
1798 ptr++;
1804 ptr++;
1809 ptr++;
1815 ptr++;
1820 ptr++;
1822 {
1823 /* (?P<groupname>...) */
1827 ptr++;
1831 }
1835 {
1840 }
1845 }
1847 {
1848 /* (?P=groupname) */
1852 ptr++;
1856 }
1861 }
1867 }
1871 /* The caller doesn't own the reference to the value
1872 returned from PyDict_GetItem, so intobj is not
1873 DECREF'ed. */
1877 /* The continue will cause the top-level for() loop to
1878 be resumed, so ptr will be immediately incremented.
1879 Therefore, the following line adds just idlen, not
1880 idlen+1 */
1883 }
1884 /* The character after ?P is neither < nor =, so
1885 report an error. Add more Python-extensions here. */
1891 {
1893 ptr++;
1896 }
1897 /* Else fall through */
1902 }
1903 }
1905 /* Else we have a referencing group */
1907 else
1908 {
1909 do_grouping_bracket:
1911 {
1914 }
1916 }
1918 /* Process nested bracketed re; at end pointer is on the bracket. We copy
1919 code into a non-register variable in order to be able to pass its address
1920 because some compilers complain otherwise. */
1923 {
1928 }
1931 {
1934 }
1937 /* Check \ for being a real metacharacter; if not, fall through and handle
1938 it as a data character at the start of a string. Escape items are checked
1939 for validity in the pre-compiling pass. */
1945 /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
1946 are arranged to be the negation of the corresponding OP_values. For the
1947 back references, the values are ESC_REF plus the reference number. Only
1948 back references and those types that consume a character may be repeated.
1949 We can test for values between ESC_b and ESC_Z for the latter; this may
1950 have to change if any new ones are ever created. */
1953 {
1955 {
1958 {
1961 }
1965 }
1966 else
1967 {
1970 {
1972 {
1977 }
1978 }
1980 }
1982 }
1984 /* Data character: Reset and fall through */
1989 /* Handle a run of data characters until a metacharacter is encountered.
1990 The first character is guaranteed not to be whitespace or # when the
1991 extended flag is set. */
1993 NORMAL_CHAR:
2000 do
2001 {
2003 {
2006 {
2010 }
2011 }
2013 /* Backslash may introduce a data char or a metacharacter. Escaped items
2014 are checked for validity in the pre-compiling pass. Stop the string
2015 before a metaitem. */
2018 {
2022 }
2024 /* Ordinary character or single-char escape */
2027 length++;
2028 }
2030 /* This "while" is the end of the "do" above. */
2034 /* Compute the length and set it in the data vector, and advance to
2035 the next state. */
2040 }
2043 /* Control never reaches here by falling through, only by a goto for all the
2044 error states. Pass back the position in the pattern so that it can be displayed
2045 to the user for diagnosing the error. */
2047 FAILED:
2050 }
2055 /*************************************************
2056 * Compile sequence of alternatives *
2057 *************************************************/
2059 /* On entry, ptr is pointing past the bracket character, but on return
2060 it points to the closing bracket, or vertical bar, or end of string.
2061 The code variable is pointing at the byte into which the BRA operator has been
2062 stored.
2064 Argument:
2065 options the option bits
2066 brackets -> int containing the number of extracting brackets used
2067 codeptr -> the address of the current code pointer
2068 ptrptr -> the address of the current pattern pointer
2069 errorptr -> pointer to error message
2071 Returns: TRUE on success
2072 */
2074 static BOOL
2077 {
2083 {
2089 {
2092 }
2094 /* Fill in the length of the last branch */
2100 /* Reached end of expression, either ')' or end of pattern. Insert a
2101 terminating ket and the length of the whole bracketed item, and return,
2102 leaving the pointer at the terminating char. */
2105 {
2113 }
2115 /* Another branch follows; insert an "or" node and advance the pointer. */
2118 ptr++;
2119 }
2120 /* Control never reaches here */
2121 }
2125 /*************************************************
2126 * Check for anchored expression *
2127 *************************************************/
2129 /* Try to find out if this is an anchored regular expression. Consider each
2130 alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
2131 all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
2132 it's anchored. However, if this is a multiline pattern, then only OP_SOD
2133 counts, since OP_CIRC can match in the middle.
2135 A branch is also implicitly anchored if it starts with .* because that will try
2136 the rest of the pattern at all possible matching points, so there is no point
2137 trying them again.
2139 Argument: points to start of expression (the bracket)
2140 Returns: TRUE or FALSE
2141 */
2143 static BOOL
2145 {
2154 }
2157 }
2161 /*************************************************
2162 * Check for start with \n line expression *
2163 *************************************************/
2165 /* This is called for multiline expressions to try to find out if every branch
2166 starts with ^ so that "first char" processing can be done to speed things up.
2168 Argument: points to start of expression (the bracket)
2169 Returns: TRUE or FALSE
2170 */
2172 static BOOL
2174 {
2180 }
2183 }
2187 /*************************************************
2188 * Check for fixed first char *
2189 *************************************************/
2191 /* Try to find out if there is a fixed first character. This is called for
2192 unanchored expressions, as it speeds up their processing quite considerably.
2193 Consider each alternative branch. If they all start with the same char, or with
2194 a bracket all of whose alternatives start with the same char (recurse ad lib),
2195 then we return that char, otherwise -1.
2197 Argument: points to start of expression (the bracket)
2198 Returns: -1 or the fixed first char
2199 */
2201 static int
2203 {
2205 do
2206 {
2210 {
2214 }
2217 {
2222 charoffset++;
2225 charoffset++;
2231 }
2233 }
2236 }
2240 /*************************************************
2241 * Compile a Regular Expression *
2242 *************************************************/
2244 /* This function takes a string and returns a pointer to a block of store
2245 holding a compiled version of the expression.
2247 Arguments:
2248 pattern the regular expression
2249 options various option bits
2250 errorptr pointer to pointer to error text
2251 erroroffset ptr offset in pattern where error was detected
2253 Returns: pointer to compiled data block, or NULL on error,
2254 with errorptr and erroroffset set
2255 */
2257 pcre *
2260 {
2273 #ifdef DEBUG
2275 #endif
2277 /* We can't pass back an error message if errorptr is NULL; I guess the best we
2278 can do is just return NULL. */
2283 /* However, we can give a message for this error */
2286 {
2289 }
2293 {
2296 }
2301 /* The first thing to do is to make a pass over the pattern to compute the
2302 amount of store required to hold the compiled code. This does not have to be
2303 perfect as long as errors are overestimates. At the same time we can detect any
2304 internal flag settings. Make an attempt to correct for any counted white space
2305 if an "extended" flag setting appears late in the pattern. We can't be so
2306 clever for #-comments. */
2310 {
2315 {
2317 spaces++;
2318 }
2321 {
2324 }
2327 {
2328 /* A backslashed item may be an escaped "normal" character or a
2329 character type. For a "normal" character, put the pointers and
2330 character back so that tests for whitespace etc. in the input
2331 are done correctly. */
2334 {
2339 {
2343 }
2344 }
2345 length++;
2347 /* A back reference needs an additional char, plus either one or 5
2348 bytes for a repeat. We also need to keep the value of the highest
2349 back reference. */
2352 {
2357 {
2362 length++;
2365 }
2366 }
2375 length++;
2378 /* This covers the cases of repeats after a single char, metachar, class,
2379 or back reference. */
2387 length++;
2388 else
2389 {
2393 }
2397 /* An alternation contains an offset to the next branch or ket. */
2402 /* A character class uses 33 characters. Don't worry about character types
2403 that aren't allowed in classes - they'll get picked up during the compile.
2404 A character class that contains only one character uses 2 or 3 bytes,
2405 depending on whether it is negated or not. Notice this where we can. */
2410 do
2411 {
2413 {
2417 }
2419 ptr++;
2420 }
2423 /* Repeats for negated single chars are handled by the general code */
2426 {
2430 /* A repeat needs either 1 or 5 bytes. */
2433 {
2438 length++;
2441 }
2442 }
2445 /* Brackets may be genuine groups or special things */
2449 /* Handle special forms of bracket, which all start (? */
2452 {
2453 /* Skip over comments entirely */
2458 {
2461 }
2464 /* Non-referencing groups and lookaheads just move the pointer on, and
2465 then behave like a non-special bracket, except that they don't increment
2466 the count of extracting brackets. */
2475 {
2487 length++;
2489 }
2490 }
2493 /* Ditto for the "once only" bracket, allowed only if the extra bit
2494 is set. */
2498 {
2501 }
2502 /* Else fall through */
2504 /* Else loop setting valid options until ) is met. Anything else is an
2505 error. */
2510 {
2512 {
2515 }
2517 {
2520 }
2522 {
2525 }
2527 {
2530 }
2532 {
2536 }
2541 }
2543 }
2545 /* Extracting brackets must be counted so we can process escapes in a
2546 Perlish way. */
2550 /* Non-special forms of bracket. Save length for computing whole length
2551 at end if there's a repeat that requires duplication of the group. */
2554 {
2557 }
2563 /* Handle ket. Look for subsequent max/min; for certain sets of values we
2564 have to replicate this bracket up to that many times. If brastackptr is
2565 0 this is an unmatched bracket which will generate an error, but take care
2566 not to try to access brastack[-1]. */
2570 {
2575 /* Leave ptr at the final char; for read_repeat_counts this happens
2576 automatically; for the others we need an increment. */
2579 {
2582 }
2587 /* If there is a minimum > 1 we have to replicate up to minval-1 times;
2588 if there is a limited maximum we have to replicate up to maxval-1 times
2589 and allow for a BRAZERO item before each optional copy, as we also have
2590 to do before the first copy if the minimum is zero. */
2595 }
2598 /* Non-special character. For a run of such characters the length required
2599 is the number of characters + 2, except that the maximum run length is 255.
2600 We won't get a skipped space or a non-data escape or the start of a #
2601 comment as the first character, so the length can't be zero. */
2603 NORMAL_CHAR:
2607 do
2608 {
2610 {
2612 spaces++;
2613 }
2616 {
2619 }
2621 /* Backslash may introduce a data char or a metacharacter; stop the
2622 string before the latter. */
2625 {
2630 }
2632 /* Ordinary character or single-char escape */
2634 runlength++;
2635 }
2637 /* This "while" is the end of the "do" above. */
2641 ptr--;
2644 }
2645 }
2650 {
2653 }
2655 /* Compute the size of data block needed and get it, either from malloc or
2656 externally provided function. We specify "code[0]" in the offsetof() expression
2657 rather than just "code", because it has been reported that one broken compiler
2658 fails on "code" because it is also an independent variable. It should make no
2659 difference to the value of the offsetof(). */
2665 {
2668 }
2670 /* Put in the magic number and the options. */
2675 /* Set up a starting, non-extracting bracket, then compile the expression. On
2676 error, *errorptr will be set non-NULL, so we don't need to look at the result
2677 of the function here. */
2687 /* If not reached end of pattern on success, there's an excess bracket. */
2691 /* Fill in the terminating state and check for disastrous overflow, but
2692 if debugging, leave the test till after things are printed out. */
2697 #ifndef DEBUG
2699 #endif
2701 /* Failed to compile */
2704 {
2706 PCRE_ERROR_RETURN:
2709 }
2711 /* If the anchored option was not passed, set flag if we can determine that it
2712 is anchored by virtue of ^ characters or \A or anything else. Otherwise, see if
2713 we can determine what the first character has to be, because that speeds up
2714 unanchored matches no end. In the case of multiline matches, an alternative is
2715 to set the PCRE_STARTLINE flag if all branches start with ^. */
2718 {
2721 else
2722 {
2725 {
2728 }
2731 }
2732 }
2734 /* Print out the compiled data for debugging */
2736 #ifdef DEBUG
2742 {
2752 }
2755 {
2758 }
2764 {
2770 {
2773 }
2776 {
2864 code ++;
2870 {
2874 {
2875 code++;
2878 }
2879 else
2880 {
2883 }
2887 {
2889 {
2896 {
2900 }
2902 }
2903 }
2906 /* code ++;*/
2908 CLASS_REF_REPEAT:
2911 {
2932 code--;
2933 }
2934 }
2937 /* Anything else is just a one-node item */
2942 }
2944 code++;
2946 }
2949 /* This check is done here in the debugging case so that the code that
2950 was compiled can be seen. */
2953 {
2959 }
2960 #endif
2963 }
2967 /*************************************************
2968 * Match a character type *
2969 *************************************************/
2971 /* Not used in all the places it might be as it's sometimes faster
2972 to put the code inline.
2974 Arguments:
2975 type the character type
2976 c the character
2977 dotall the dotall flag
2979 Returns: TRUE if character is of the type
2980 */
2982 static BOOL
2984 {
2986 #ifdef DEBUG
2990 #endif
2993 {
3003 }
3005 }
3009 /*************************************************
3010 * Match a back-reference *
3011 *************************************************/
3013 /* If a back reference hasn't been set, the match fails.
3015 Arguments:
3016 number reference number
3017 eptr points into the subject
3018 length length to be matched
3019 md points to match data block
3021 Returns: TRUE if matched
3022 */
3024 static BOOL
3026 {
3029 #ifdef DEBUG
3032 else
3033 {
3036 }
3040 #endif
3042 /* Always fail if not enough characters left */
3046 /* Separate the caseless case for speed */
3050 else
3054 }
3057 {
3058 /* Free any stack space that was allocated by the call to match(). */
3066 }
3069 {
3071 {
3073 }
3074 else
3075 {
3079 }
3088 {
3091 }
3093 }
3096 /*************************************************
3097 * Match from current position *
3098 *************************************************/
3100 /* On entry ecode points to the first opcode, and eptr to the first character.
3102 Arguments:
3103 eptr pointer in subject
3104 ecode position in code
3105 offset_top current top pointer
3106 md pointer to "static" info for the match
3108 Returns: TRUE if matched
3109 */
3111 static BOOL
3114 {
3116 match_loop:
3118 #define SUCCEED goto succeed
3119 #define FAIL goto fail
3122 {
3128 /* Opening bracket. Check the alternative branches in turn, failing if none
3129 match. We have to set the start offset if required and there is space
3130 in the offset vector so that it is available for subsequent back references
3131 if the bracket matches. However, if the bracket fails, we must put back the
3132 previous value of both offsets in case they were set by a previous copy of
3133 the same bracket. Don't worry about setting the flag for the error case here;
3134 that is handled in the code for KET. */
3137 {
3144 {
3150 }
3152 /* Recurse for all the alternatives. */
3154 do
3155 {
3158 }
3164 {
3167 }
3169 FAIL;
3170 }
3172 /* Other types of node can be handled by a switch */
3175 {
3179 SUCCEED;
3181 /* The equivalent of Prolog's "cut" - if the rest doesn't match, the
3182 whole thing doesn't match, so we have to get out via a longjmp(). */
3188 /* Assertion brackets. Check the alternative branches in turn - the
3189 matching won't pass the KET for an assertion. If any one branch matches,
3190 the assertion is true. */
3193 do
3194 {
3197 }
3201 /* Continue from after the assertion, updating the offsets high water
3202 mark, since extracts may have been taken during the assertion. */
3209 /* Negative assertion: all branches must fail to match */
3212 do
3213 {
3216 }
3221 /* "Once" brackets are like assertion brackets except that after a match,
3222 the point in the subject string is not moved back. Thus there can never be
3223 a move back into the brackets. Check the alternative branches in turn - the
3224 matching won't pass the KET for this kind of subpattern. If any one branch
3225 matches, we carry on, leaving the subject pointer. */
3228 do
3229 {
3232 }
3236 /* Continue as from after the assertion, updating the offsets high water
3237 mark, since extracts may have been taken. */
3245 /* An alternation is the end of a branch; scan along to find the end of the
3246 bracketed group and go to there. */
3252 /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
3253 that it may occur zero times. It may repeat infinitely, or not at all -
3254 i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
3255 repeat limits are compiled as a number of copies, with the optional ones
3256 preceded by BRAZERO or BRAMINZERO. */
3259 {
3264 }
3268 {
3272 ecode++;
3273 }
3276 /* End of a group, repeated or non-repeating. If we are at the end of
3277 an assertion "group", stop matching and SUCCEED, but record the
3278 current high water mark for use by positive assertions. */
3283 {
3288 {
3291 SUCCEED;
3292 }
3294 /* In all other cases we have to check the group number back at the
3295 start and if necessary complete handling an extraction by setting the
3296 final offset and bumping the high water mark. */
3303 {
3305 {
3308 }
3309 }
3311 /* For a non-repeating ket, just advance to the next node and continue at
3312 this level. */
3315 {
3318 }
3320 /* The repeating kets try the rest of the pattern or restart from the
3321 preceding bracket, in the appropriate order. */
3324 {
3327 /* Handle alternation inside the BRA...KET; push the additional
3328 alternatives onto the stack */
3333 {
3335 {
3337 }
3345 }
3348 }
3350 {
3352 /*int points_pushed=0;*/
3354 /* Push one failure point, that will resume matching at the code after
3355 the KETRMAX opcode. */
3357 {
3359 }
3369 /* Handle alternation inside the BRA...KET; push each of the
3370 additional alternatives onto the stack */
3375 {
3378 {
3380 }
3388 /*points_pushed++;*/
3389 }
3391 /* Jump to the first (or only) alternative and resume trying to match */
3393 }
3394 }
3396 /* Start of subject unless notbol, or after internal newline if multiline */
3401 {
3403 ecode++;
3405 }
3406 /* ... else fall through */
3408 /* Start of subject assertion */
3412 ecode++;
3415 /* Assert before internal newline if multiline, or before
3416 a terminating newline unless endonly is set, else end of subject unless
3417 noteol is set. */
3422 {
3424 ecode++;
3426 }
3428 {
3431 ecode++;
3433 }
3434 /* ... else fall through */
3436 /* End of subject assertion */
3440 ecode++;
3443 /* Word boundary assertions */
3447 {
3454 FAIL;
3455 }
3460 {
3467 FAIL;
3468 }
3472 /* Match a single character type; inline for speed */
3477 ecode++;
3482 FAIL;
3483 ecode++;
3488 FAIL;
3489 ecode++;
3494 FAIL;
3495 ecode++;
3500 FAIL;
3501 ecode++;
3506 FAIL;
3507 ecode++;
3512 FAIL;
3513 ecode++;
3518 FAIL;
3519 eptr++;
3520 ecode++;
3525 FAIL;
3526 eptr++;
3527 ecode++;
3530 /* Match a back reference, possibly repeatedly. Look past the end of the
3531 item to see if there is repeat information following. The code is similar
3532 to that for character classes, but repeated for efficiency. Then obey
3533 similar code to character type repeats - written out again for speed.
3534 However, if the referenced string is the empty string, always treat
3535 it as matched, any number of times (otherwise there could be infinite
3536 loops). */
3539 {
3545 {
3547 FAIL;
3548 }
3553 {
3580 }
3582 /* If the length of the reference is zero, just continue with the
3583 main loop. */
3587 /* First, ensure the minimum number of matches are present. We get back
3588 the length of the reference string explicitly rather than passing the
3589 address of eptr, so that eptr can be a register variable. */
3592 {
3595 }
3597 /* If min = max, continue at the same level without recursion.
3598 They are not both allowed to be zero. */
3602 /* If minimizing, keep trying and advancing the pointer */
3605 {
3607 {
3610 FAIL;
3612 }
3613 /* Control never gets here */
3614 }
3616 /* If maximizing, find the longest string and work backwards */
3618 else
3619 {
3622 {
3625 }
3627 {
3630 }
3631 FAIL;
3632 }
3633 }
3634 /* Control never gets here */
3636 /* Match a character class, possibly repeatedly. Look past the end of the
3637 item to see if there is repeat information following. Then obey similar
3638 code to character type repeats - written out again for speed. If caseless
3639 matching was set at runtime but not at compile time, we have to check both
3640 versions of a character, and we have to behave differently for positive and
3641 negative classes. This is the only time where OP_CLASS and OP_NEGCLASS are
3642 treated differently. */
3646 {
3652 {
3678 }
3680 /* First, ensure the minimum number of matches are present. */
3683 {
3687 /* Either not runtime caseless, or it was a positive class. For
3688 runtime caseless, continue if either case is in the map. */
3691 {
3694 {
3697 }
3698 }
3700 /* Runtime caseless and it was a negative class. Continue only if
3701 both cases are in the map. */
3703 else
3704 {
3708 }
3710 FAIL;
3711 }
3713 /* If max == min we can continue with the main loop without the
3714 need to recurse. */
3718 /* If minimizing, keep testing the rest of the expression and advancing
3719 the pointer while it matches the class. */
3722 {
3724 {
3729 /* Either not runtime caseless, or it was a positive class. For
3730 runtime caseless, continue if either case is in the map. */
3733 {
3736 {
3739 }
3740 }
3742 /* Runtime caseless and it was a negative class. Continue only if
3743 both cases are in the map. */
3745 else
3746 {
3750 }
3752 FAIL;
3753 }
3754 /* Control never gets here */
3755 }
3757 /* If maximizing, find the longest possible run, then work backwards. */
3759 else
3760 {
3763 {
3767 /* Either not runtime caseless, or it was a positive class. For
3768 runtime caseless, continue if either case is in the map. */
3771 {
3774 {
3777 }
3778 }
3780 /* Runtime caseless and it was a negative class. Continue only if
3781 both cases are in the map. */
3783 else
3784 {
3788 }
3791 }
3795 FAIL;
3796 }
3797 }
3798 /* Control never gets here */
3800 /* OP_CLASS_L opcode: handles localized character classes */
3803 {
3811 {
3840 #if 0
3845 #endif
3848 {
3854 }
3855 FAIL;
3856 }
3858 /* First, ensure the minimum number of matches are present. */
3861 {
3869 {
3874 }
3875 FAIL;
3876 }
3878 /* If max == min we can continue with the main loop without the
3879 need to recurse. */
3883 /* If minimizing, keep testing the rest of the expression and advancing
3884 the pointer while it matches the class. */
3887 {
3889 {
3898 {
3903 }
3904 FAIL;
3905 }
3906 /* Control never gets here */
3907 }
3909 /* If maximizing, find the longest possible run, then work backwards. */
3911 else
3912 {
3915 {
3922 {
3927 }
3929 }
3933 FAIL;
3934 }
3935 }
3936 /* Control never gets here */
3938 /* Match a run of characters */
3941 {
3948 else
3949 {
3953 }
3956 #endif
3960 {
3962 }
3963 else
3964 {
3966 }
3967 }
3970 /* Match a single character repeatedly; different opcodes share code. */
3997 /* Common code for all repeated single-character matches. We can give
3998 up quickly if there are fewer than the minimum number of characters left in
3999 the subject. */
4001 REPEATCHAR:
4005 /* The code is duplicated for the caseless and caseful cases, for speed,
4006 since matching characters is likely to be quite common. First, ensure the
4007 minimum number of matches are present. If min = max, continue at the same
4008 level without recursing. Otherwise, if minimizing, keep trying the rest of
4009 the expression and advancing one matching character if failing, up to the
4010 maximum. Alternatively, if maximizing, find the maximum number of
4011 characters and work backwards. */
4017 {
4022 {
4024 {
4027 FAIL;
4028 }
4029 /* Control never gets here */
4030 }
4031 else
4032 {
4035 {
4037 eptr++;
4038 }
4041 FAIL;
4042 }
4043 /* Control never gets here */
4044 }
4046 /* Caseful comparisons */
4048 else
4049 {
4053 {
4055 {
4058 }
4059 /* Control never gets here */
4060 }
4061 else
4062 {
4065 {
4067 eptr++;
4068 }
4071 FAIL;
4072 }
4073 }
4074 /* Control never gets here */
4076 /* Match a negated single character */
4080 ecode++;
4082 {
4084 }
4085 else
4086 {
4088 }
4091 /* Match a negated single character repeatedly. This is almost a repeat of
4092 the code for a repeated single character, but I haven't found a nice way of
4093 commoning these up that doesn't require a test of the positive/negative
4094 option for each character match. Maybe that wouldn't add very much to the
4095 time taken, but character matching *is* what this is all about... */
4122 /* Common code for all repeated single-character matches. We can give
4123 up quickly if there are fewer than the minimum number of characters left in
4124 the subject. */
4126 REPEATNOTCHAR:
4130 /* The code is duplicated for the caseless and caseful cases, for speed,
4131 since matching characters is likely to be quite common. First, ensure the
4132 minimum number of matches are present. If min = max, continue at the same
4133 level without recursing. Otherwise, if minimizing, keep trying the rest of
4134 the expression and advancing one matching character if failing, up to the
4135 maximum. Alternatively, if maximizing, find the maximum number of
4136 characters and work backwards. */
4142 {
4147 {
4149 {
4152 FAIL;
4153 }
4154 /* Control never gets here */
4155 }
4156 else
4157 {
4160 {
4162 eptr++;
4163 }
4166 FAIL;
4167 }
4168 /* Control never gets here */
4169 }
4171 /* Caseful comparisons */
4173 else
4174 {
4178 {
4180 {
4183 }
4184 /* Control never gets here */
4185 }
4186 else
4187 {
4190 {
4192 eptr++;
4193 }
4196 FAIL;
4197 }
4198 }
4199 /* Control never gets here */
4201 /* Match a single character type repeatedly; several different opcodes
4202 share code. This is very similar to the code for single characters, but we
4203 repeat it in the interests of efficiency. */
4231 /* Common code for all repeated single character type matches */
4233 REPEATTYPE:
4236 /* First, ensure the minimum number of matches are present. Use inline
4237 code for maximizing the speed, and do the type test once at the start
4238 (i.e. keep it out of the loop). Also test that there are at least the
4239 minimum number of characters before we start. */
4243 {
4272 FAIL;
4277 FAIL;
4282 FAIL;
4287 FAIL;
4289 }
4291 /* If min = max, continue at the same level without recursing */
4295 /* If minimizing, we have to test the rest of the pattern before each
4296 subsequent match, so inlining isn't much help; just use the function. */
4299 {
4301 {
4305 FAIL;
4306 }
4307 /* Control never gets here */
4308 }
4310 /* If maximizing it is worth using inline code for speed, doing the type
4311 test once at the start (i.e. keep it out of the loop). */
4313 else
4314 {
4317 {
4320 {
4322 {
4324 eptr++;
4325 }
4326 }
4327 else
4328 {
4332 }
4337 {
4340 eptr++;
4341 }
4346 {
4349 eptr++;
4350 }
4355 {
4358 eptr++;
4359 }
4364 {
4367 eptr++;
4368 }
4373 {
4376 eptr++;
4377 }
4382 {
4385 eptr++;
4386 }
4390 {
4393 eptr++;
4394 }
4399 {
4402 eptr++;
4403 }
4405 }
4409 FAIL;
4410 }
4411 /* Control never gets here */
4413 /* There's been some horrible disaster. */
4418 FAIL;
4419 }
4421 /* Do not stick any code in here without much thought; it is assumed
4422 that "continue" in the code above comes out to here to repeat the main
4423 loop. */
4426 /* Control never reaches here */
4428 fail:
4430 {
4431 /* If there are still points remaining on the stack, pop the next one off */
4442 }
4443 /* Failure, and nothing left on the stack, so end this function call */
4445 /* Restore the top of the stack to where it was before this function
4446 call. This lets us use one stack for everything; recursive calls
4447 can push and pop information, and may increase the stack. When
4448 the call returns, the parent function can resume pushing and
4449 popping wherever it was. */
4454 succeed:
4456 }
4460 /*************************************************
4461 * Segregate setjmp() *
4462 *************************************************/
4464 /* The -Wall option of gcc gives warnings for all local variables when setjmp()
4465 is used, even if the coding conforms to the rules of ANSI C. To avoid this, we
4466 hide it in a separate function. This is called only when PCRE_EXTRA is set,
4467 since it's needed only for the extension \X option, and with any luck, a good
4468 compiler will spot the tail recursion and compile it efficiently.
4470 Arguments:
4471 eptr pointer in subject
4472 ecode position in code
4473 offset_top current top pointer
4474 md pointer to "static" info for the match
4476 Returns: TRUE if matched
4477 */
4479 static BOOL
4482 {
4485 }
4489 /*************************************************
4490 * Execute a Regular Expression *
4491 *************************************************/
4493 /* This function applies a compiled re to a subject string and picks out
4494 portions of the string if it matches. Two elements in the vector are set for
4495 each substring: the offsets to the start and end of the substring.
4497 Arguments:
4498 external_re points to the compiled expression
4499 external_extra points to "hints" from pcre_study() or is NULL
4500 subject points to the subject string
4501 length length of subject string (may contain binary zeros)
4502 options option bits
4503 offsets points to a vector of ints to be filled in with offsets
4504 offsetcount the number of elements in the vector
4506 Returns: > 0 => success; value is the number of elements filled in
4507 = 0 => success, but offsets is not big enough
4508 -1 => failed to match
4509 < -1 => some kind of unexpected problem
4510 */
4512 int
4516 {
4517 /* The "volatile" directives are to make gcc -Wall stop complaining
4518 that these variables can be clobbered by the longjmp. Hopefully
4519 they won't cost too much performance. */
4524 match_data match_block;
4555 /* Set the stack state to empty */
4561 /* If the expression has got more back references than the offsets supplied can
4562 hold, we get a temporary bit of working store to use during the matching.
4563 Otherwise, we can use the vector supplied, rounding down its size to a multiple
4564 of 2. */
4568 {
4574 }
4580 /* Compute the minimum number of offsets that we need to reset each time. Doing
4581 this makes a huge difference to execution time when there aren't many brackets
4582 in the pattern. */
4587 /* If MULTILINE is set at exec time but was not set at compile time, and the
4588 anchored flag is set, we must re-check because a setting provoked by ^ in the
4589 pattern is not right in multi-line mode. Calling is_anchored() again here does
4590 the right check, because multiline is now set. If it now yields FALSE, the
4591 expression must have had ^ starting some of its branches. Check to see if
4592 that is true for *all* branches, and if so, set the startline flag. */
4596 {
4599 }
4601 /* Set up the first character to match, if available. The first_char value is
4602 never set for an anchored regular expression, but the anchoring may be forced
4603 at run time, so we have to test for anchoring. The first char may be unset for
4604 an unanchored pattern, of course. If there's no first char and the pattern was
4605 studied, the may be a bitmap of possible first characters. However, we can
4606 use this only if the caseless state of the studying was correct. */
4609 {
4611 {
4614 }
4615 else
4620 }
4622 /* Loop for unanchored matches; for anchored regexps the loop runs just once. */
4624 do
4625 {
4630 /* Reset the maximum number of extractions we might see. */
4634 /* Advance to a unique first char if possible */
4637 {
4640 start_match++;
4641 else
4643 start_match++;
4644 }
4646 /* Or to just after \n for a multiline match if possible */
4649 {
4651 {
4653 start_match++;
4654 }
4655 }
4657 /* Or to a non-unique first char */
4660 {
4662 {
4665 }
4666 }
4672 #endif
4674 /* When a match occurs, substrings will be set for all internal extractions;
4675 we just need to set up the whole thing as substring 0 before returning. If
4676 there were too many extractions, set the return code to zero. In the case
4677 where we had to get some local store to hold offsets for backreferences, copy
4678 those back references that we can. In this case there need not be overflow
4679 if certain parts of the pattern were not used.
4681 Before starting the match, we have to set up a longjmp() target to enable
4682 the "cut" operation to fail a match completely without backtracking. This
4683 is done in a separate function to avoid compiler warnings. We need not do
4684 it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
4685 enabled. */
4687 /* To handle errors such as running out of memory for the failure
4688 stack, we need to save this location via setjmp(), so
4689 error-handling code can call longjmp() to jump out of deeply-nested code. */
4691 {
4694 {
4697 }
4700 /* Copy the offset information from temporary store if necessary */
4703 {
4705 {
4709 }
4715 }
4720 {
4723 }
4731 /* Return an error code; pcremodule.c will preserve the exception */
4733 }
4739 {
4742 }
4744 #ifdef DEBUG
4746 #endif
4750 }
4752 /* End of pcre.c */