Annotation of embedaddon/php/ext/pcre/pcrelib/doc/pcre.txt, revision 1.1.1.1
1.1 misho 1: -----------------------------------------------------------------------------
2: This file contains a concatenation of the PCRE man pages, converted to plain
3: text format for ease of searching with a text editor, or for use on systems
4: that do not have a man page processor. The small individual files that give
5: synopses of each function in the library have not been included. Neither has
6: the pcredemo program. There are separate text files for the pcregrep and
7: pcretest commands.
8: -----------------------------------------------------------------------------
9:
10:
11: PCRE(3) PCRE(3)
12:
13:
14: NAME
15: PCRE - Perl-compatible regular expressions
16:
17:
18: INTRODUCTION
19:
20: The PCRE library is a set of functions that implement regular expres-
21: sion pattern matching using the same syntax and semantics as Perl, with
22: just a few differences. Some features that appeared in Python and PCRE
23: before they appeared in Perl are also available using the Python syn-
24: tax, there is some support for one or two .NET and Oniguruma syntax
25: items, and there is an option for requesting some minor changes that
26: give better JavaScript compatibility.
27:
28: The current implementation of PCRE corresponds approximately with Perl
29: 5.12, including support for UTF-8 encoded strings and Unicode general
30: category properties. However, UTF-8 and Unicode support has to be
31: explicitly enabled; it is not the default. The Unicode tables corre-
32: spond to Unicode release 5.2.0.
33:
34: In addition to the Perl-compatible matching function, PCRE contains an
35: alternative function that matches the same compiled patterns in a dif-
36: ferent way. In certain circumstances, the alternative function has some
37: advantages. For a discussion of the two matching algorithms, see the
38: pcrematching page.
39:
40: PCRE is written in C and released as a C library. A number of people
41: have written wrappers and interfaces of various kinds. In particular,
42: Google Inc. have provided a comprehensive C++ wrapper. This is now
43: included as part of the PCRE distribution. The pcrecpp page has details
44: of this interface. Other people's contributions can be found in the
45: Contrib directory at the primary FTP site, which is:
46:
47: ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
48:
49: Details of exactly which Perl regular expression features are and are
50: not supported by PCRE are given in separate documents. See the pcrepat-
51: tern and pcrecompat pages. There is a syntax summary in the pcresyntax
52: page.
53:
54: Some features of PCRE can be included, excluded, or changed when the
55: library is built. The pcre_config() function makes it possible for a
56: client to discover which features are available. The features them-
57: selves are described in the pcrebuild page. Documentation about build-
58: ing PCRE for various operating systems can be found in the README and
59: NON-UNIX-USE files in the source distribution.
60:
61: The library contains a number of undocumented internal functions and
62: data tables that are used by more than one of the exported external
63: functions, but which are not intended for use by external callers.
64: Their names all begin with "_pcre_", which hopefully will not provoke
65: any name clashes. In some environments, it is possible to control which
66: external symbols are exported when a shared library is built, and in
67: these cases the undocumented symbols are not exported.
68:
69:
70: USER DOCUMENTATION
71:
72: The user documentation for PCRE comprises a number of different sec-
73: tions. In the "man" format, each of these is a separate "man page". In
74: the HTML format, each is a separate page, linked from the index page.
75: In the plain text format, all the sections, except the pcredemo sec-
76: tion, are concatenated, for ease of searching. The sections are as fol-
77: lows:
78:
79: pcre this document
80: pcre-config show PCRE installation configuration information
81: pcreapi details of PCRE's native C API
82: pcrebuild options for building PCRE
83: pcrecallout details of the callout feature
84: pcrecompat discussion of Perl compatibility
85: pcrecpp details of the C++ wrapper
86: pcredemo a demonstration C program that uses PCRE
87: pcregrep description of the pcregrep command
88: pcrematching discussion of the two matching algorithms
89: pcrepartial details of the partial matching facility
90: pcrepattern syntax and semantics of supported
91: regular expressions
92: pcreperform discussion of performance issues
93: pcreposix the POSIX-compatible C API
94: pcreprecompile details of saving and re-using precompiled patterns
95: pcresample discussion of the pcredemo program
96: pcrestack discussion of stack usage
97: pcresyntax quick syntax reference
98: pcretest description of the pcretest testing command
99:
100: In addition, in the "man" and HTML formats, there is a short page for
101: each C library function, listing its arguments and results.
102:
103:
104: LIMITATIONS
105:
106: There are some size limitations in PCRE but it is hoped that they will
107: never in practice be relevant.
108:
109: The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE
110: is compiled with the default internal linkage size of 2. If you want to
111: process regular expressions that are truly enormous, you can compile
112: PCRE with an internal linkage size of 3 or 4 (see the README file in
113: the source distribution and the pcrebuild documentation for details).
114: In these cases the limit is substantially larger. However, the speed
115: of execution is slower.
116:
117: All values in repeating quantifiers must be less than 65536.
118:
119: There is no limit to the number of parenthesized subpatterns, but there
120: can be no more than 65535 capturing subpatterns.
121:
122: The maximum length of name for a named subpattern is 32 characters, and
123: the maximum number of named subpatterns is 10000.
124:
125: The maximum length of a subject string is the largest positive number
126: that an integer variable can hold. However, when using the traditional
127: matching function, PCRE uses recursion to handle subpatterns and indef-
128: inite repetition. This means that the available stack space may limit
129: the size of a subject string that can be processed by certain patterns.
130: For a discussion of stack issues, see the pcrestack documentation.
131:
132:
133: UTF-8 AND UNICODE PROPERTY SUPPORT
134:
135: From release 3.3, PCRE has had some support for character strings
136: encoded in the UTF-8 format. For release 4.0 this was greatly extended
137: to cover most common requirements, and in release 5.0 additional sup-
138: port for Unicode general category properties was added.
139:
140: In order process UTF-8 strings, you must build PCRE to include UTF-8
141: support in the code, and, in addition, you must call pcre_compile()
142: with the PCRE_UTF8 option flag, or the pattern must start with the
143: sequence (*UTF8). When either of these is the case, both the pattern
144: and any subject strings that are matched against it are treated as
145: UTF-8 strings instead of strings of 1-byte characters.
146:
147: If you compile PCRE with UTF-8 support, but do not use it at run time,
148: the library will be a bit bigger, but the additional run time overhead
149: is limited to testing the PCRE_UTF8 flag occasionally, so should not be
150: very big.
151:
152: If PCRE is built with Unicode character property support (which implies
153: UTF-8 support), the escape sequences \p{..}, \P{..}, and \X are sup-
154: ported. The available properties that can be tested are limited to the
155: general category properties such as Lu for an upper case letter or Nd
156: for a decimal number, the Unicode script names such as Arabic or Han,
157: and the derived properties Any and L&. A full list is given in the
158: pcrepattern documentation. Only the short names for properties are sup-
159: ported. For example, \p{L} matches a letter. Its Perl synonym, \p{Let-
160: ter}, is not supported. Furthermore, in Perl, many properties may
161: optionally be prefixed by "Is", for compatibility with Perl 5.6. PCRE
162: does not support this.
163:
164: Validity of UTF-8 strings
165:
166: When you set the PCRE_UTF8 flag, the strings passed as patterns and
167: subjects are (by default) checked for validity on entry to the relevant
168: functions. From release 7.3 of PCRE, the check is according the rules
169: of RFC 3629, which are themselves derived from the Unicode specifica-
170: tion. Earlier releases of PCRE followed the rules of RFC 2279, which
171: allows the full range of 31-bit values (0 to 0x7FFFFFFF). The current
172: check allows only values in the range U+0 to U+10FFFF, excluding U+D800
173: to U+DFFF.
174:
175: The excluded code points are the "Low Surrogate Area" of Unicode, of
176: which the Unicode Standard says this: "The Low Surrogate Area does not
177: contain any character assignments, consequently no character code
178: charts or namelists are provided for this area. Surrogates are reserved
179: for use with UTF-16 and then must be used in pairs." The code points
180: that are encoded by UTF-16 pairs are available as independent code
181: points in the UTF-8 encoding. (In other words, the whole surrogate
182: thing is a fudge for UTF-16 which unfortunately messes up UTF-8.)
183:
184: If an invalid UTF-8 string is passed to PCRE, an error return
185: (PCRE_ERROR_BADUTF8) is given. In some situations, you may already know
186: that your strings are valid, and therefore want to skip these checks in
187: order to improve performance. If you set the PCRE_NO_UTF8_CHECK flag at
188: compile time or at run time, PCRE assumes that the pattern or subject
189: it is given (respectively) contains only valid UTF-8 codes. In this
190: case, it does not diagnose an invalid UTF-8 string.
191:
192: If you pass an invalid UTF-8 string when PCRE_NO_UTF8_CHECK is set,
193: what happens depends on why the string is invalid. If the string con-
194: forms to the "old" definition of UTF-8 (RFC 2279), it is processed as a
195: string of characters in the range 0 to 0x7FFFFFFF. In other words,
196: apart from the initial validity test, PCRE (when in UTF-8 mode) handles
197: strings according to the more liberal rules of RFC 2279. However, if
198: the string does not even conform to RFC 2279, the result is undefined.
199: Your program may crash.
200:
201: If you want to process strings of values in the full range 0 to
202: 0x7FFFFFFF, encoded in a UTF-8-like manner as per the old RFC, you can
203: set PCRE_NO_UTF8_CHECK to bypass the more restrictive test. However, in
204: this situation, you will have to apply your own validity check.
205:
206: General comments about UTF-8 mode
207:
208: 1. An unbraced hexadecimal escape sequence (such as \xb3) matches a
209: two-byte UTF-8 character if the value is greater than 127.
210:
211: 2. Octal numbers up to \777 are recognized, and match two-byte UTF-8
212: characters for values greater than \177.
213:
214: 3. Repeat quantifiers apply to complete UTF-8 characters, not to indi-
215: vidual bytes, for example: \x{100}{3}.
216:
217: 4. The dot metacharacter matches one UTF-8 character instead of a sin-
218: gle byte.
219:
220: 5. The escape sequence \C can be used to match a single byte in UTF-8
221: mode, but its use can lead to some strange effects. This facility is
222: not available in the alternative matching function, pcre_dfa_exec().
223:
224: 6. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
225: test characters of any code value, but, by default, the characters that
226: PCRE recognizes as digits, spaces, or word characters remain the same
227: set as before, all with values less than 256. This remains true even
228: when PCRE is built to include Unicode property support, because to do
229: otherwise would slow down PCRE in many common cases. Note in particular
230: that this applies to \b and \B, because they are defined in terms of \w
231: and \W. If you really want to test for a wider sense of, say, "digit",
232: you can use explicit Unicode property tests such as \p{Nd}. Alterna-
233: tively, if you set the PCRE_UCP option, the way that the character
234: escapes work is changed so that Unicode properties are used to deter-
235: mine which characters match. There are more details in the section on
236: generic character types in the pcrepattern documentation.
237:
238: 7. Similarly, characters that match the POSIX named character classes
239: are all low-valued characters, unless the PCRE_UCP option is set.
240:
241: 8. However, the horizontal and vertical whitespace matching escapes
242: (\h, \H, \v, and \V) do match all the appropriate Unicode characters,
243: whether or not PCRE_UCP is set.
244:
245: 9. Case-insensitive matching applies only to characters whose values
246: are less than 128, unless PCRE is built with Unicode property support.
247: Even when Unicode property support is available, PCRE still uses its
248: own character tables when checking the case of low-valued characters,
249: so as not to degrade performance. The Unicode property information is
250: used only for characters with higher values. Furthermore, PCRE supports
251: case-insensitive matching only when there is a one-to-one mapping
252: between a letter's cases. There are a small number of many-to-one map-
253: pings in Unicode; these are not supported by PCRE.
254:
255:
256: AUTHOR
257:
258: Philip Hazel
259: University Computing Service
260: Cambridge CB2 3QH, England.
261:
262: Putting an actual email address here seems to have been a spam magnet,
263: so I've taken it away. If you want to email me, use my two initials,
264: followed by the two digits 10, at the domain cam.ac.uk.
265:
266:
267: REVISION
268:
269: Last updated: 13 November 2010
270: Copyright (c) 1997-2010 University of Cambridge.
271: ------------------------------------------------------------------------------
272:
273:
274: PCREBUILD(3) PCREBUILD(3)
275:
276:
277: NAME
278: PCRE - Perl-compatible regular expressions
279:
280:
281: PCRE BUILD-TIME OPTIONS
282:
283: This document describes the optional features of PCRE that can be
284: selected when the library is compiled. It assumes use of the configure
285: script, where the optional features are selected or deselected by pro-
286: viding options to configure before running the make command. However,
287: the same options can be selected in both Unix-like and non-Unix-like
288: environments using the GUI facility of cmake-gui if you are using CMake
289: instead of configure to build PCRE.
290:
291: There is a lot more information about building PCRE in non-Unix-like
292: environments in the file called NON_UNIX_USE, which is part of the PCRE
293: distribution. You should consult this file as well as the README file
294: if you are building in a non-Unix-like environment.
295:
296: The complete list of options for configure (which includes the standard
297: ones such as the selection of the installation directory) can be
298: obtained by running
299:
300: ./configure --help
301:
302: The following sections include descriptions of options whose names
303: begin with --enable or --disable. These settings specify changes to the
304: defaults for the configure command. Because of the way that configure
305: works, --enable and --disable always come in pairs, so the complemen-
306: tary option always exists as well, but as it specifies the default, it
307: is not described.
308:
309:
310: C++ SUPPORT
311:
312: By default, the configure script will search for a C++ compiler and C++
313: header files. If it finds them, it automatically builds the C++ wrapper
314: library for PCRE. You can disable this by adding
315:
316: --disable-cpp
317:
318: to the configure command.
319:
320:
321: UTF-8 SUPPORT
322:
323: To build PCRE with support for UTF-8 Unicode character strings, add
324:
325: --enable-utf8
326:
327: to the configure command. Of itself, this does not make PCRE treat
328: strings as UTF-8. As well as compiling PCRE with this option, you also
329: have have to set the PCRE_UTF8 option when you call the pcre_compile()
330: or pcre_compile2() functions.
331:
332: If you set --enable-utf8 when compiling in an EBCDIC environment, PCRE
333: expects its input to be either ASCII or UTF-8 (depending on the runtime
334: option). It is not possible to support both EBCDIC and UTF-8 codes in
335: the same version of the library. Consequently, --enable-utf8 and
336: --enable-ebcdic are mutually exclusive.
337:
338:
339: UNICODE CHARACTER PROPERTY SUPPORT
340:
341: UTF-8 support allows PCRE to process character values greater than 255
342: in the strings that it handles. On its own, however, it does not pro-
343: vide any facilities for accessing the properties of such characters. If
344: you want to be able to use the pattern escapes \P, \p, and \X, which
345: refer to Unicode character properties, you must add
346:
347: --enable-unicode-properties
348:
349: to the configure command. This implies UTF-8 support, even if you have
350: not explicitly requested it.
351:
352: Including Unicode property support adds around 30K of tables to the
353: PCRE library. Only the general category properties such as Lu and Nd
354: are supported. Details are given in the pcrepattern documentation.
355:
356:
357: CODE VALUE OF NEWLINE
358:
359: By default, PCRE interprets the linefeed (LF) character as indicating
360: the end of a line. This is the normal newline character on Unix-like
361: systems. You can compile PCRE to use carriage return (CR) instead, by
362: adding
363:
364: --enable-newline-is-cr
365:
366: to the configure command. There is also a --enable-newline-is-lf
367: option, which explicitly specifies linefeed as the newline character.
368:
369: Alternatively, you can specify that line endings are to be indicated by
370: the two character sequence CRLF. If you want this, add
371:
372: --enable-newline-is-crlf
373:
374: to the configure command. There is a fourth option, specified by
375:
376: --enable-newline-is-anycrlf
377:
378: which causes PCRE to recognize any of the three sequences CR, LF, or
379: CRLF as indicating a line ending. Finally, a fifth option, specified by
380:
381: --enable-newline-is-any
382:
383: causes PCRE to recognize any Unicode newline sequence.
384:
385: Whatever line ending convention is selected when PCRE is built can be
386: overridden when the library functions are called. At build time it is
387: conventional to use the standard for your operating system.
388:
389:
390: WHAT \R MATCHES
391:
392: By default, the sequence \R in a pattern matches any Unicode newline
393: sequence, whatever has been selected as the line ending sequence. If
394: you specify
395:
396: --enable-bsr-anycrlf
397:
398: the default is changed so that \R matches only CR, LF, or CRLF. What-
399: ever is selected when PCRE is built can be overridden when the library
400: functions are called.
401:
402:
403: BUILDING SHARED AND STATIC LIBRARIES
404:
405: The PCRE building process uses libtool to build both shared and static
406: Unix libraries by default. You can suppress one of these by adding one
407: of
408:
409: --disable-shared
410: --disable-static
411:
412: to the configure command, as required.
413:
414:
415: POSIX MALLOC USAGE
416:
417: When PCRE is called through the POSIX interface (see the pcreposix doc-
418: umentation), additional working storage is required for holding the
419: pointers to capturing substrings, because PCRE requires three integers
420: per substring, whereas the POSIX interface provides only two. If the
421: number of expected substrings is small, the wrapper function uses space
422: on the stack, because this is faster than using malloc() for each call.
423: The default threshold above which the stack is no longer used is 10; it
424: can be changed by adding a setting such as
425:
426: --with-posix-malloc-threshold=20
427:
428: to the configure command.
429:
430:
431: HANDLING VERY LARGE PATTERNS
432:
433: Within a compiled pattern, offset values are used to point from one
434: part to another (for example, from an opening parenthesis to an alter-
435: nation metacharacter). By default, two-byte values are used for these
436: offsets, leading to a maximum size for a compiled pattern of around
437: 64K. This is sufficient to handle all but the most gigantic patterns.
438: Nevertheless, some people do want to process truyl enormous patterns,
439: so it is possible to compile PCRE to use three-byte or four-byte off-
440: sets by adding a setting such as
441:
442: --with-link-size=3
443:
444: to the configure command. The value given must be 2, 3, or 4. Using
445: longer offsets slows down the operation of PCRE because it has to load
446: additional bytes when handling them.
447:
448:
449: AVOIDING EXCESSIVE STACK USAGE
450:
451: When matching with the pcre_exec() function, PCRE implements backtrack-
452: ing by making recursive calls to an internal function called match().
453: In environments where the size of the stack is limited, this can se-
454: verely limit PCRE's operation. (The Unix environment does not usually
455: suffer from this problem, but it may sometimes be necessary to increase
456: the maximum stack size. There is a discussion in the pcrestack docu-
457: mentation.) An alternative approach to recursion that uses memory from
458: the heap to remember data, instead of using recursive function calls,
459: has been implemented to work round the problem of limited stack size.
460: If you want to build a version of PCRE that works this way, add
461:
462: --disable-stack-for-recursion
463:
464: to the configure command. With this configuration, PCRE will use the
465: pcre_stack_malloc and pcre_stack_free variables to call memory manage-
466: ment functions. By default these point to malloc() and free(), but you
467: can replace the pointers so that your own functions are used instead.
468:
469: Separate functions are provided rather than using pcre_malloc and
470: pcre_free because the usage is very predictable: the block sizes
471: requested are always the same, and the blocks are always freed in
472: reverse order. A calling program might be able to implement optimized
473: functions that perform better than malloc() and free(). PCRE runs
474: noticeably more slowly when built in this way. This option affects only
475: the pcre_exec() function; it is not relevant for pcre_dfa_exec().
476:
477:
478: LIMITING PCRE RESOURCE USAGE
479:
480: Internally, PCRE has a function called match(), which it calls repeat-
481: edly (sometimes recursively) when matching a pattern with the
482: pcre_exec() function. By controlling the maximum number of times this
483: function may be called during a single matching operation, a limit can
484: be placed on the resources used by a single call to pcre_exec(). The
485: limit can be changed at run time, as described in the pcreapi documen-
486: tation. The default is 10 million, but this can be changed by adding a
487: setting such as
488:
489: --with-match-limit=500000
490:
491: to the configure command. This setting has no effect on the
492: pcre_dfa_exec() matching function.
493:
494: In some environments it is desirable to limit the depth of recursive
495: calls of match() more strictly than the total number of calls, in order
496: to restrict the maximum amount of stack (or heap, if --disable-stack-
497: for-recursion is specified) that is used. A second limit controls this;
498: it defaults to the value that is set for --with-match-limit, which
499: imposes no additional constraints. However, you can set a lower limit
500: by adding, for example,
501:
502: --with-match-limit-recursion=10000
503:
504: to the configure command. This value can also be overridden at run
505: time.
506:
507:
508: CREATING CHARACTER TABLES AT BUILD TIME
509:
510: PCRE uses fixed tables for processing characters whose code values are
511: less than 256. By default, PCRE is built with a set of tables that are
512: distributed in the file pcre_chartables.c.dist. These tables are for
513: ASCII codes only. If you add
514:
515: --enable-rebuild-chartables
516:
517: to the configure command, the distributed tables are no longer used.
518: Instead, a program called dftables is compiled and run. This outputs
519: the source for new set of tables, created in the default locale of your
520: C runtime system. (This method of replacing the tables does not work if
521: you are cross compiling, because dftables is run on the local host. If
522: you need to create alternative tables when cross compiling, you will
523: have to do so "by hand".)
524:
525:
526: USING EBCDIC CODE
527:
528: PCRE assumes by default that it will run in an environment where the
529: character code is ASCII (or Unicode, which is a superset of ASCII).
530: This is the case for most computer operating systems. PCRE can, how-
531: ever, be compiled to run in an EBCDIC environment by adding
532:
533: --enable-ebcdic
534:
535: to the configure command. This setting implies --enable-rebuild-charta-
536: bles. You should only use it if you know that you are in an EBCDIC
537: environment (for example, an IBM mainframe operating system). The
538: --enable-ebcdic option is incompatible with --enable-utf8.
539:
540:
541: PCREGREP OPTIONS FOR COMPRESSED FILE SUPPORT
542:
543: By default, pcregrep reads all files as plain text. You can build it so
544: that it recognizes files whose names end in .gz or .bz2, and reads them
545: with libz or libbz2, respectively, by adding one or both of
546:
547: --enable-pcregrep-libz
548: --enable-pcregrep-libbz2
549:
550: to the configure command. These options naturally require that the rel-
551: evant libraries are installed on your system. Configuration will fail
552: if they are not.
553:
554:
555: PCRETEST OPTION FOR LIBREADLINE SUPPORT
556:
557: If you add
558:
559: --enable-pcretest-libreadline
560:
561: to the configure command, pcretest is linked with the libreadline
562: library, and when its input is from a terminal, it reads it using the
563: readline() function. This provides line-editing and history facilities.
564: Note that libreadline is GPL-licensed, so if you distribute a binary of
565: pcretest linked in this way, there may be licensing issues.
566:
567: Setting this option causes the -lreadline option to be added to the
568: pcretest build. In many operating environments with a sytem-installed
569: libreadline this is sufficient. However, in some environments (e.g. if
570: an unmodified distribution version of readline is in use), some extra
571: configuration may be necessary. The INSTALL file for libreadline says
572: this:
573:
574: "Readline uses the termcap functions, but does not link with the
575: termcap or curses library itself, allowing applications which link
576: with readline the to choose an appropriate library."
577:
578: If your environment has not been set up so that an appropriate library
579: is automatically included, you may need to add something like
580:
581: LIBS="-ncurses"
582:
583: immediately before the configure command.
584:
585:
586: SEE ALSO
587:
588: pcreapi(3), pcre_config(3).
589:
590:
591: AUTHOR
592:
593: Philip Hazel
594: University Computing Service
595: Cambridge CB2 3QH, England.
596:
597:
598: REVISION
599:
600: Last updated: 29 September 2009
601: Copyright (c) 1997-2009 University of Cambridge.
602: ------------------------------------------------------------------------------
603:
604:
605: PCREMATCHING(3) PCREMATCHING(3)
606:
607:
608: NAME
609: PCRE - Perl-compatible regular expressions
610:
611:
612: PCRE MATCHING ALGORITHMS
613:
614: This document describes the two different algorithms that are available
615: in PCRE for matching a compiled regular expression against a given sub-
616: ject string. The "standard" algorithm is the one provided by the
617: pcre_exec() function. This works in the same was as Perl's matching
618: function, and provides a Perl-compatible matching operation.
619:
620: An alternative algorithm is provided by the pcre_dfa_exec() function;
621: this operates in a different way, and is not Perl-compatible. It has
622: advantages and disadvantages compared with the standard algorithm, and
623: these are described below.
624:
625: When there is only one possible way in which a given subject string can
626: match a pattern, the two algorithms give the same answer. A difference
627: arises, however, when there are multiple possibilities. For example, if
628: the pattern
629:
630: ^<.*>
631:
632: is matched against the string
633:
634: <something> <something else> <something further>
635:
636: there are three possible answers. The standard algorithm finds only one
637: of them, whereas the alternative algorithm finds all three.
638:
639:
640: REGULAR EXPRESSIONS AS TREES
641:
642: The set of strings that are matched by a regular expression can be rep-
643: resented as a tree structure. An unlimited repetition in the pattern
644: makes the tree of infinite size, but it is still a tree. Matching the
645: pattern to a given subject string (from a given starting point) can be
646: thought of as a search of the tree. There are two ways to search a
647: tree: depth-first and breadth-first, and these correspond to the two
648: matching algorithms provided by PCRE.
649:
650:
651: THE STANDARD MATCHING ALGORITHM
652:
653: In the terminology of Jeffrey Friedl's book "Mastering Regular Expres-
654: sions", the standard algorithm is an "NFA algorithm". It conducts a
655: depth-first search of the pattern tree. That is, it proceeds along a
656: single path through the tree, checking that the subject matches what is
657: required. When there is a mismatch, the algorithm tries any alterna-
658: tives at the current point, and if they all fail, it backs up to the
659: previous branch point in the tree, and tries the next alternative
660: branch at that level. This often involves backing up (moving to the
661: left) in the subject string as well. The order in which repetition
662: branches are tried is controlled by the greedy or ungreedy nature of
663: the quantifier.
664:
665: If a leaf node is reached, a matching string has been found, and at
666: that point the algorithm stops. Thus, if there is more than one possi-
667: ble match, this algorithm returns the first one that it finds. Whether
668: this is the shortest, the longest, or some intermediate length depends
669: on the way the greedy and ungreedy repetition quantifiers are specified
670: in the pattern.
671:
672: Because it ends up with a single path through the tree, it is rela-
673: tively straightforward for this algorithm to keep track of the sub-
674: strings that are matched by portions of the pattern in parentheses.
675: This provides support for capturing parentheses and back references.
676:
677:
678: THE ALTERNATIVE MATCHING ALGORITHM
679:
680: This algorithm conducts a breadth-first search of the tree. Starting
681: from the first matching point in the subject, it scans the subject
682: string from left to right, once, character by character, and as it does
683: this, it remembers all the paths through the tree that represent valid
684: matches. In Friedl's terminology, this is a kind of "DFA algorithm",
685: though it is not implemented as a traditional finite state machine (it
686: keeps multiple states active simultaneously).
687:
688: Although the general principle of this matching algorithm is that it
689: scans the subject string only once, without backtracking, there is one
690: exception: when a lookaround assertion is encountered, the characters
691: following or preceding the current point have to be independently
692: inspected.
693:
694: The scan continues until either the end of the subject is reached, or
695: there are no more unterminated paths. At this point, terminated paths
696: represent the different matching possibilities (if there are none, the
697: match has failed). Thus, if there is more than one possible match,
698: this algorithm finds all of them, and in particular, it finds the long-
699: est. The matches are returned in decreasing order of length. There is
700: an option to stop the algorithm after the first match (which is neces-
701: sarily the shortest) is found.
702:
703: Note that all the matches that are found start at the same point in the
704: subject. If the pattern
705:
706: cat(er(pillar)?)?
707:
708: is matched against the string "the caterpillar catchment", the result
709: will be the three strings "caterpillar", "cater", and "cat" that start
710: at the fifth character of the subject. The algorithm does not automati-
711: cally move on to find matches that start at later positions.
712:
713: There are a number of features of PCRE regular expressions that are not
714: supported by the alternative matching algorithm. They are as follows:
715:
716: 1. Because the algorithm finds all possible matches, the greedy or
717: ungreedy nature of repetition quantifiers is not relevant. Greedy and
718: ungreedy quantifiers are treated in exactly the same way. However, pos-
719: sessive quantifiers can make a difference when what follows could also
720: match what is quantified, for example in a pattern like this:
721:
722: ^a++\w!
723:
724: This pattern matches "aaab!" but not "aaa!", which would be matched by
725: a non-possessive quantifier. Similarly, if an atomic group is present,
726: it is matched as if it were a standalone pattern at the current point,
727: and the longest match is then "locked in" for the rest of the overall
728: pattern.
729:
730: 2. When dealing with multiple paths through the tree simultaneously, it
731: is not straightforward to keep track of captured substrings for the
732: different matching possibilities, and PCRE's implementation of this
733: algorithm does not attempt to do this. This means that no captured sub-
734: strings are available.
735:
736: 3. Because no substrings are captured, back references within the pat-
737: tern are not supported, and cause errors if encountered.
738:
739: 4. For the same reason, conditional expressions that use a backrefer-
740: ence as the condition or test for a specific group recursion are not
741: supported.
742:
743: 5. Because many paths through the tree may be active, the \K escape
744: sequence, which resets the start of the match when encountered (but may
745: be on some paths and not on others), is not supported. It causes an
746: error if encountered.
747:
748: 6. Callouts are supported, but the value of the capture_top field is
749: always 1, and the value of the capture_last field is always -1.
750:
751: 7. The \C escape sequence, which (in the standard algorithm) matches a
752: single byte, even in UTF-8 mode, is not supported because the alterna-
753: tive algorithm moves through the subject string one character at a
754: time, for all active paths through the tree.
755:
756: 8. Except for (*FAIL), the backtracking control verbs such as (*PRUNE)
757: are not supported. (*FAIL) is supported, and behaves like a failing
758: negative assertion.
759:
760:
761: ADVANTAGES OF THE ALTERNATIVE ALGORITHM
762:
763: Using the alternative matching algorithm provides the following advan-
764: tages:
765:
766: 1. All possible matches (at a single point in the subject) are automat-
767: ically found, and in particular, the longest match is found. To find
768: more than one match using the standard algorithm, you have to do kludgy
769: things with callouts.
770:
771: 2. Because the alternative algorithm scans the subject string just
772: once, and never needs to backtrack, it is possible to pass very long
773: subject strings to the matching function in several pieces, checking
774: for partial matching each time. Although it is possible to do multi-
775: segment matching using the standard algorithm (pcre_exec()), by retain-
776: ing partially matched substrings, it is more complicated. The pcrepar-
777: tial documentation gives details of partial matching and discusses
778: multi-segment matching.
779:
780:
781: DISADVANTAGES OF THE ALTERNATIVE ALGORITHM
782:
783: The alternative algorithm suffers from a number of disadvantages:
784:
785: 1. It is substantially slower than the standard algorithm. This is
786: partly because it has to search for all possible matches, but is also
787: because it is less susceptible to optimization.
788:
789: 2. Capturing parentheses and back references are not supported.
790:
791: 3. Although atomic groups are supported, their use does not provide the
792: performance advantage that it does for the standard algorithm.
793:
794:
795: AUTHOR
796:
797: Philip Hazel
798: University Computing Service
799: Cambridge CB2 3QH, England.
800:
801:
802: REVISION
803:
804: Last updated: 17 November 2010
805: Copyright (c) 1997-2010 University of Cambridge.
806: ------------------------------------------------------------------------------
807:
808:
809: PCREAPI(3) PCREAPI(3)
810:
811:
812: NAME
813: PCRE - Perl-compatible regular expressions
814:
815:
816: PCRE NATIVE API
817:
818: #include <pcre.h>
819:
820: pcre *pcre_compile(const char *pattern, int options,
821: const char **errptr, int *erroffset,
822: const unsigned char *tableptr);
823:
824: pcre *pcre_compile2(const char *pattern, int options,
825: int *errorcodeptr,
826: const char **errptr, int *erroffset,
827: const unsigned char *tableptr);
828:
829: pcre_extra *pcre_study(const pcre *code, int options,
830: const char **errptr);
831:
832: int pcre_exec(const pcre *code, const pcre_extra *extra,
833: const char *subject, int length, int startoffset,
834: int options, int *ovector, int ovecsize);
835:
836: int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
837: const char *subject, int length, int startoffset,
838: int options, int *ovector, int ovecsize,
839: int *workspace, int wscount);
840:
841: int pcre_copy_named_substring(const pcre *code,
842: const char *subject, int *ovector,
843: int stringcount, const char *stringname,
844: char *buffer, int buffersize);
845:
846: int pcre_copy_substring(const char *subject, int *ovector,
847: int stringcount, int stringnumber, char *buffer,
848: int buffersize);
849:
850: int pcre_get_named_substring(const pcre *code,
851: const char *subject, int *ovector,
852: int stringcount, const char *stringname,
853: const char **stringptr);
854:
855: int pcre_get_stringnumber(const pcre *code,
856: const char *name);
857:
858: int pcre_get_stringtable_entries(const pcre *code,
859: const char *name, char **first, char **last);
860:
861: int pcre_get_substring(const char *subject, int *ovector,
862: int stringcount, int stringnumber,
863: const char **stringptr);
864:
865: int pcre_get_substring_list(const char *subject,
866: int *ovector, int stringcount, const char ***listptr);
867:
868: void pcre_free_substring(const char *stringptr);
869:
870: void pcre_free_substring_list(const char **stringptr);
871:
872: const unsigned char *pcre_maketables(void);
873:
874: int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
875: int what, void *where);
876:
877: int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
878:
879: int pcre_refcount(pcre *code, int adjust);
880:
881: int pcre_config(int what, void *where);
882:
883: char *pcre_version(void);
884:
885: void *(*pcre_malloc)(size_t);
886:
887: void (*pcre_free)(void *);
888:
889: void *(*pcre_stack_malloc)(size_t);
890:
891: void (*pcre_stack_free)(void *);
892:
893: int (*pcre_callout)(pcre_callout_block *);
894:
895:
896: PCRE API OVERVIEW
897:
898: PCRE has its own native API, which is described in this document. There
899: are also some wrapper functions that correspond to the POSIX regular
900: expression API. These are described in the pcreposix documentation.
901: Both of these APIs define a set of C function calls. A C++ wrapper is
902: distributed with PCRE. It is documented in the pcrecpp page.
903:
904: The native API C function prototypes are defined in the header file
905: pcre.h, and on Unix systems the library itself is called libpcre. It
906: can normally be accessed by adding -lpcre to the command for linking an
907: application that uses PCRE. The header file defines the macros
908: PCRE_MAJOR and PCRE_MINOR to contain the major and minor release num-
909: bers for the library. Applications can use these to include support
910: for different releases of PCRE.
911:
912: In a Windows environment, if you want to statically link an application
913: program against a non-dll pcre.a file, you must define PCRE_STATIC
914: before including pcre.h or pcrecpp.h, because otherwise the pcre_mal-
915: loc() and pcre_free() exported functions will be declared
916: __declspec(dllimport), with unwanted results.
917:
918: The functions pcre_compile(), pcre_compile2(), pcre_study(), and
919: pcre_exec() are used for compiling and matching regular expressions in
920: a Perl-compatible manner. A sample program that demonstrates the sim-
921: plest way of using them is provided in the file called pcredemo.c in
922: the PCRE source distribution. A listing of this program is given in the
923: pcredemo documentation, and the pcresample documentation describes how
924: to compile and run it.
925:
926: A second matching function, pcre_dfa_exec(), which is not Perl-compati-
927: ble, is also provided. This uses a different algorithm for the match-
928: ing. The alternative algorithm finds all possible matches (at a given
929: point in the subject), and scans the subject just once (unless there
930: are lookbehind assertions). However, this algorithm does not return
931: captured substrings. A description of the two matching algorithms and
932: their advantages and disadvantages is given in the pcrematching docu-
933: mentation.
934:
935: In addition to the main compiling and matching functions, there are
936: convenience functions for extracting captured substrings from a subject
937: string that is matched by pcre_exec(). They are:
938:
939: pcre_copy_substring()
940: pcre_copy_named_substring()
941: pcre_get_substring()
942: pcre_get_named_substring()
943: pcre_get_substring_list()
944: pcre_get_stringnumber()
945: pcre_get_stringtable_entries()
946:
947: pcre_free_substring() and pcre_free_substring_list() are also provided,
948: to free the memory used for extracted strings.
949:
950: The function pcre_maketables() is used to build a set of character
951: tables in the current locale for passing to pcre_compile(),
952: pcre_exec(), or pcre_dfa_exec(). This is an optional facility that is
953: provided for specialist use. Most commonly, no special tables are
954: passed, in which case internal tables that are generated when PCRE is
955: built are used.
956:
957: The function pcre_fullinfo() is used to find out information about a
958: compiled pattern; pcre_info() is an obsolete version that returns only
959: some of the available information, but is retained for backwards com-
960: patibility. The function pcre_version() returns a pointer to a string
961: containing the version of PCRE and its date of release.
962:
963: The function pcre_refcount() maintains a reference count in a data
964: block containing a compiled pattern. This is provided for the benefit
965: of object-oriented applications.
966:
967: The global variables pcre_malloc and pcre_free initially contain the
968: entry points of the standard malloc() and free() functions, respec-
969: tively. PCRE calls the memory management functions via these variables,
970: so a calling program can replace them if it wishes to intercept the
971: calls. This should be done before calling any PCRE functions.
972:
973: The global variables pcre_stack_malloc and pcre_stack_free are also
974: indirections to memory management functions. These special functions
975: are used only when PCRE is compiled to use the heap for remembering
976: data, instead of recursive function calls, when running the pcre_exec()
977: function. See the pcrebuild documentation for details of how to do
978: this. It is a non-standard way of building PCRE, for use in environ-
979: ments that have limited stacks. Because of the greater use of memory
980: management, it runs more slowly. Separate functions are provided so
981: that special-purpose external code can be used for this case. When
982: used, these functions are always called in a stack-like manner (last
983: obtained, first freed), and always for memory blocks of the same size.
984: There is a discussion about PCRE's stack usage in the pcrestack docu-
985: mentation.
986:
987: The global variable pcre_callout initially contains NULL. It can be set
988: by the caller to a "callout" function, which PCRE will then call at
989: specified points during a matching operation. Details are given in the
990: pcrecallout documentation.
991:
992:
993: NEWLINES
994:
995: PCRE supports five different conventions for indicating line breaks in
996: strings: a single CR (carriage return) character, a single LF (line-
997: feed) character, the two-character sequence CRLF, any of the three pre-
998: ceding, or any Unicode newline sequence. The Unicode newline sequences
999: are the three just mentioned, plus the single characters VT (vertical
1000: tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line
1001: separator, U+2028), and PS (paragraph separator, U+2029).
1002:
1003: Each of the first three conventions is used by at least one operating
1004: system as its standard newline sequence. When PCRE is built, a default
1005: can be specified. The default default is LF, which is the Unix stan-
1006: dard. When PCRE is run, the default can be overridden, either when a
1007: pattern is compiled, or when it is matched.
1008:
1009: At compile time, the newline convention can be specified by the options
1010: argument of pcre_compile(), or it can be specified by special text at
1011: the start of the pattern itself; this overrides any other settings. See
1012: the pcrepattern page for details of the special character sequences.
1013:
1014: In the PCRE documentation the word "newline" is used to mean "the char-
1015: acter or pair of characters that indicate a line break". The choice of
1016: newline convention affects the handling of the dot, circumflex, and
1017: dollar metacharacters, the handling of #-comments in /x mode, and, when
1018: CRLF is a recognized line ending sequence, the match position advance-
1019: ment for a non-anchored pattern. There is more detail about this in the
1020: section on pcre_exec() options below.
1021:
1022: The choice of newline convention does not affect the interpretation of
1023: the \n or \r escape sequences, nor does it affect what \R matches,
1024: which is controlled in a similar way, but by separate options.
1025:
1026:
1027: MULTITHREADING
1028:
1029: The PCRE functions can be used in multi-threading applications, with
1030: the proviso that the memory management functions pointed to by
1031: pcre_malloc, pcre_free, pcre_stack_malloc, and pcre_stack_free, and the
1032: callout function pointed to by pcre_callout, are shared by all threads.
1033:
1034: The compiled form of a regular expression is not altered during match-
1035: ing, so the same compiled pattern can safely be used by several threads
1036: at once.
1037:
1038:
1039: SAVING PRECOMPILED PATTERNS FOR LATER USE
1040:
1041: The compiled form of a regular expression can be saved and re-used at a
1042: later time, possibly by a different program, and even on a host other
1043: than the one on which it was compiled. Details are given in the
1044: pcreprecompile documentation. However, compiling a regular expression
1045: with one version of PCRE for use with a different version is not guar-
1046: anteed to work and may cause crashes.
1047:
1048:
1049: CHECKING BUILD-TIME OPTIONS
1050:
1051: int pcre_config(int what, void *where);
1052:
1053: The function pcre_config() makes it possible for a PCRE client to dis-
1054: cover which optional features have been compiled into the PCRE library.
1055: The pcrebuild documentation has more details about these optional fea-
1056: tures.
1057:
1058: The first argument for pcre_config() is an integer, specifying which
1059: information is required; the second argument is a pointer to a variable
1060: into which the information is placed. The following information is
1061: available:
1062:
1063: PCRE_CONFIG_UTF8
1064:
1065: The output is an integer that is set to one if UTF-8 support is avail-
1066: able; otherwise it is set to zero.
1067:
1068: PCRE_CONFIG_UNICODE_PROPERTIES
1069:
1070: The output is an integer that is set to one if support for Unicode
1071: character properties is available; otherwise it is set to zero.
1072:
1073: PCRE_CONFIG_NEWLINE
1074:
1075: The output is an integer whose value specifies the default character
1076: sequence that is recognized as meaning "newline". The four values that
1077: are supported are: 10 for LF, 13 for CR, 3338 for CRLF, -2 for ANYCRLF,
1078: and -1 for ANY. Though they are derived from ASCII, the same values
1079: are returned in EBCDIC environments. The default should normally corre-
1080: spond to the standard sequence for your operating system.
1081:
1082: PCRE_CONFIG_BSR
1083:
1084: The output is an integer whose value indicates what character sequences
1085: the \R escape sequence matches by default. A value of 0 means that \R
1086: matches any Unicode line ending sequence; a value of 1 means that \R
1087: matches only CR, LF, or CRLF. The default can be overridden when a pat-
1088: tern is compiled or matched.
1089:
1090: PCRE_CONFIG_LINK_SIZE
1091:
1092: The output is an integer that contains the number of bytes used for
1093: internal linkage in compiled regular expressions. The value is 2, 3, or
1094: 4. Larger values allow larger regular expressions to be compiled, at
1095: the expense of slower matching. The default value of 2 is sufficient
1096: for all but the most massive patterns, since it allows the compiled
1097: pattern to be up to 64K in size.
1098:
1099: PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
1100:
1101: The output is an integer that contains the threshold above which the
1102: POSIX interface uses malloc() for output vectors. Further details are
1103: given in the pcreposix documentation.
1104:
1105: PCRE_CONFIG_MATCH_LIMIT
1106:
1107: The output is a long integer that gives the default limit for the num-
1108: ber of internal matching function calls in a pcre_exec() execution.
1109: Further details are given with pcre_exec() below.
1110:
1111: PCRE_CONFIG_MATCH_LIMIT_RECURSION
1112:
1113: The output is a long integer that gives the default limit for the depth
1114: of recursion when calling the internal matching function in a
1115: pcre_exec() execution. Further details are given with pcre_exec()
1116: below.
1117:
1118: PCRE_CONFIG_STACKRECURSE
1119:
1120: The output is an integer that is set to one if internal recursion when
1121: running pcre_exec() is implemented by recursive function calls that use
1122: the stack to remember their state. This is the usual way that PCRE is
1123: compiled. The output is zero if PCRE was compiled to use blocks of data
1124: on the heap instead of recursive function calls. In this case,
1125: pcre_stack_malloc and pcre_stack_free are called to manage memory
1126: blocks on the heap, thus avoiding the use of the stack.
1127:
1128:
1129: COMPILING A PATTERN
1130:
1131: pcre *pcre_compile(const char *pattern, int options,
1132: const char **errptr, int *erroffset,
1133: const unsigned char *tableptr);
1134:
1135: pcre *pcre_compile2(const char *pattern, int options,
1136: int *errorcodeptr,
1137: const char **errptr, int *erroffset,
1138: const unsigned char *tableptr);
1139:
1140: Either of the functions pcre_compile() or pcre_compile2() can be called
1141: to compile a pattern into an internal form. The only difference between
1142: the two interfaces is that pcre_compile2() has an additional argument,
1143: errorcodeptr, via which a numerical error code can be returned. To
1144: avoid too much repetition, we refer just to pcre_compile() below, but
1145: the information applies equally to pcre_compile2().
1146:
1147: The pattern is a C string terminated by a binary zero, and is passed in
1148: the pattern argument. A pointer to a single block of memory that is
1149: obtained via pcre_malloc is returned. This contains the compiled code
1150: and related data. The pcre type is defined for the returned block; this
1151: is a typedef for a structure whose contents are not externally defined.
1152: It is up to the caller to free the memory (via pcre_free) when it is no
1153: longer required.
1154:
1155: Although the compiled code of a PCRE regex is relocatable, that is, it
1156: does not depend on memory location, the complete pcre data block is not
1157: fully relocatable, because it may contain a copy of the tableptr argu-
1158: ment, which is an address (see below).
1159:
1160: The options argument contains various bit settings that affect the com-
1161: pilation. It should be zero if no options are required. The available
1162: options are described below. Some of them (in particular, those that
1163: are compatible with Perl, but some others as well) can also be set and
1164: unset from within the pattern (see the detailed description in the
1165: pcrepattern documentation). For those options that can be different in
1166: different parts of the pattern, the contents of the options argument
1167: specifies their settings at the start of compilation and execution. The
1168: PCRE_ANCHORED, PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK, and
1169: PCRE_NO_START_OPT options can be set at the time of matching as well as
1170: at compile time.
1171:
1172: If errptr is NULL, pcre_compile() returns NULL immediately. Otherwise,
1173: if compilation of a pattern fails, pcre_compile() returns NULL, and
1174: sets the variable pointed to by errptr to point to a textual error mes-
1175: sage. This is a static string that is part of the library. You must not
1176: try to free it. The offset from the start of the pattern to the byte
1177: that was being processed when the error was discovered is placed in the
1178: variable pointed to by erroffset, which must not be NULL. If it is, an
1179: immediate error is given. Some errors are not detected until checks are
1180: carried out when the whole pattern has been scanned; in this case the
1181: offset is set to the end of the pattern.
1182:
1183: Note that the offset is in bytes, not characters, even in UTF-8 mode.
1184: It may point into the middle of a UTF-8 character (for example, when
1185: PCRE_ERROR_BADUTF8 is returned for an invalid UTF-8 string).
1186:
1187: If pcre_compile2() is used instead of pcre_compile(), and the error-
1188: codeptr argument is not NULL, a non-zero error code number is returned
1189: via this argument in the event of an error. This is in addition to the
1190: textual error message. Error codes and messages are listed below.
1191:
1192: If the final argument, tableptr, is NULL, PCRE uses a default set of
1193: character tables that are built when PCRE is compiled, using the
1194: default C locale. Otherwise, tableptr must be an address that is the
1195: result of a call to pcre_maketables(). This value is stored with the
1196: compiled pattern, and used again by pcre_exec(), unless another table
1197: pointer is passed to it. For more discussion, see the section on locale
1198: support below.
1199:
1200: This code fragment shows a typical straightforward call to pcre_com-
1201: pile():
1202:
1203: pcre *re;
1204: const char *error;
1205: int erroffset;
1206: re = pcre_compile(
1207: "^A.*Z", /* the pattern */
1208: 0, /* default options */
1209: &error, /* for error message */
1210: &erroffset, /* for error offset */
1211: NULL); /* use default character tables */
1212:
1213: The following names for option bits are defined in the pcre.h header
1214: file:
1215:
1216: PCRE_ANCHORED
1217:
1218: If this bit is set, the pattern is forced to be "anchored", that is, it
1219: is constrained to match only at the first matching point in the string
1220: that is being searched (the "subject string"). This effect can also be
1221: achieved by appropriate constructs in the pattern itself, which is the
1222: only way to do it in Perl.
1223:
1224: PCRE_AUTO_CALLOUT
1225:
1226: If this bit is set, pcre_compile() automatically inserts callout items,
1227: all with number 255, before each pattern item. For discussion of the
1228: callout facility, see the pcrecallout documentation.
1229:
1230: PCRE_BSR_ANYCRLF
1231: PCRE_BSR_UNICODE
1232:
1233: These options (which are mutually exclusive) control what the \R escape
1234: sequence matches. The choice is either to match only CR, LF, or CRLF,
1235: or to match any Unicode newline sequence. The default is specified when
1236: PCRE is built. It can be overridden from within the pattern, or by set-
1237: ting an option when a compiled pattern is matched.
1238:
1239: PCRE_CASELESS
1240:
1241: If this bit is set, letters in the pattern match both upper and lower
1242: case letters. It is equivalent to Perl's /i option, and it can be
1243: changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE
1244: always understands the concept of case for characters whose values are
1245: less than 128, so caseless matching is always possible. For characters
1246: with higher values, the concept of case is supported if PCRE is com-
1247: piled with Unicode property support, but not otherwise. If you want to
1248: use caseless matching for characters 128 and above, you must ensure
1249: that PCRE is compiled with Unicode property support as well as with
1250: UTF-8 support.
1251:
1252: PCRE_DOLLAR_ENDONLY
1253:
1254: If this bit is set, a dollar metacharacter in the pattern matches only
1255: at the end of the subject string. Without this option, a dollar also
1256: matches immediately before a newline at the end of the string (but not
1257: before any other newlines). The PCRE_DOLLAR_ENDONLY option is ignored
1258: if PCRE_MULTILINE is set. There is no equivalent to this option in
1259: Perl, and no way to set it within a pattern.
1260:
1261: PCRE_DOTALL
1262:
1263: If this bit is set, a dot metacharacter in the pattern matches a char-
1264: acter of any value, including one that indicates a newline. However, it
1265: only ever matches one character, even if newlines are coded as CRLF.
1266: Without this option, a dot does not match when the current position is
1267: at a newline. This option is equivalent to Perl's /s option, and it can
1268: be changed within a pattern by a (?s) option setting. A negative class
1269: such as [^a] always matches newline characters, independent of the set-
1270: ting of this option.
1271:
1272: PCRE_DUPNAMES
1273:
1274: If this bit is set, names used to identify capturing subpatterns need
1275: not be unique. This can be helpful for certain types of pattern when it
1276: is known that only one instance of the named subpattern can ever be
1277: matched. There are more details of named subpatterns below; see also
1278: the pcrepattern documentation.
1279:
1280: PCRE_EXTENDED
1281:
1282: If this bit is set, whitespace data characters in the pattern are
1283: totally ignored except when escaped or inside a character class. White-
1284: space does not include the VT character (code 11). In addition, charac-
1285: ters between an unescaped # outside a character class and the next new-
1286: line, inclusive, are also ignored. This is equivalent to Perl's /x
1287: option, and it can be changed within a pattern by a (?x) option set-
1288: ting.
1289:
1290: Which characters are interpreted as newlines is controlled by the
1291: options passed to pcre_compile() or by a special sequence at the start
1292: of the pattern, as described in the section entitled "Newline conven-
1293: tions" in the pcrepattern documentation. Note that the end of this type
1294: of comment is a literal newline sequence in the pattern; escape
1295: sequences that happen to represent a newline do not count.
1296:
1297: This option makes it possible to include comments inside complicated
1298: patterns. Note, however, that this applies only to data characters.
1299: Whitespace characters may never appear within special character
1300: sequences in a pattern, for example within the sequence (?( that intro-
1301: duces a conditional subpattern.
1302:
1303: PCRE_EXTRA
1304:
1305: This option was invented in order to turn on additional functionality
1306: of PCRE that is incompatible with Perl, but it is currently of very
1307: little use. When set, any backslash in a pattern that is followed by a
1308: letter that has no special meaning causes an error, thus reserving
1309: these combinations for future expansion. By default, as in Perl, a
1310: backslash followed by a letter with no special meaning is treated as a
1311: literal. (Perl can, however, be persuaded to give an error for this, by
1312: running it with the -w option.) There are at present no other features
1313: controlled by this option. It can also be set by a (?X) option setting
1314: within a pattern.
1315:
1316: PCRE_FIRSTLINE
1317:
1318: If this option is set, an unanchored pattern is required to match
1319: before or at the first newline in the subject string, though the
1320: matched text may continue over the newline.
1321:
1322: PCRE_JAVASCRIPT_COMPAT
1323:
1324: If this option is set, PCRE's behaviour is changed in some ways so that
1325: it is compatible with JavaScript rather than Perl. The changes are as
1326: follows:
1327:
1328: (1) A lone closing square bracket in a pattern causes a compile-time
1329: error, because this is illegal in JavaScript (by default it is treated
1330: as a data character). Thus, the pattern AB]CD becomes illegal when this
1331: option is set.
1332:
1333: (2) At run time, a back reference to an unset subpattern group matches
1334: an empty string (by default this causes the current matching alterna-
1335: tive to fail). A pattern such as (\1)(a) succeeds when this option is
1336: set (assuming it can find an "a" in the subject), whereas it fails by
1337: default, for Perl compatibility.
1338:
1339: PCRE_MULTILINE
1340:
1341: By default, PCRE treats the subject string as consisting of a single
1342: line of characters (even if it actually contains newlines). The "start
1343: of line" metacharacter (^) matches only at the start of the string,
1344: while the "end of line" metacharacter ($) matches only at the end of
1345: the string, or before a terminating newline (unless PCRE_DOLLAR_ENDONLY
1346: is set). This is the same as Perl.
1347:
1348: When PCRE_MULTILINE it is set, the "start of line" and "end of line"
1349: constructs match immediately following or immediately before internal
1350: newlines in the subject string, respectively, as well as at the very
1351: start and end. This is equivalent to Perl's /m option, and it can be
1352: changed within a pattern by a (?m) option setting. If there are no new-
1353: lines in a subject string, or no occurrences of ^ or $ in a pattern,
1354: setting PCRE_MULTILINE has no effect.
1355:
1356: PCRE_NEWLINE_CR
1357: PCRE_NEWLINE_LF
1358: PCRE_NEWLINE_CRLF
1359: PCRE_NEWLINE_ANYCRLF
1360: PCRE_NEWLINE_ANY
1361:
1362: These options override the default newline definition that was chosen
1363: when PCRE was built. Setting the first or the second specifies that a
1364: newline is indicated by a single character (CR or LF, respectively).
1365: Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by the
1366: two-character CRLF sequence. Setting PCRE_NEWLINE_ANYCRLF specifies
1367: that any of the three preceding sequences should be recognized. Setting
1368: PCRE_NEWLINE_ANY specifies that any Unicode newline sequence should be
1369: recognized. The Unicode newline sequences are the three just mentioned,
1370: plus the single characters VT (vertical tab, U+000B), FF (formfeed,
1371: U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS
1372: (paragraph separator, U+2029). The last two are recognized only in
1373: UTF-8 mode.
1374:
1375: The newline setting in the options word uses three bits that are
1376: treated as a number, giving eight possibilities. Currently only six are
1377: used (default plus the five values above). This means that if you set
1378: more than one newline option, the combination may or may not be sensi-
1379: ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
1380: PCRE_NEWLINE_CRLF, but other combinations may yield unused numbers and
1381: cause an error.
1382:
1383: The only time that a line break in a pattern is specially recognized
1384: when compiling is when PCRE_EXTENDED is set. CR and LF are whitespace
1385: characters, and so are ignored in this mode. Also, an unescaped # out-
1386: side a character class indicates a comment that lasts until after the
1387: next line break sequence. In other circumstances, line break sequences
1388: in patterns are treated as literal data.
1389:
1390: The newline option that is set at compile time becomes the default that
1391: is used for pcre_exec() and pcre_dfa_exec(), but it can be overridden.
1392:
1393: PCRE_NO_AUTO_CAPTURE
1394:
1395: If this option is set, it disables the use of numbered capturing paren-
1396: theses in the pattern. Any opening parenthesis that is not followed by
1397: ? behaves as if it were followed by ?: but named parentheses can still
1398: be used for capturing (and they acquire numbers in the usual way).
1399: There is no equivalent of this option in Perl.
1400:
1401: NO_START_OPTIMIZE
1402:
1403: This is an option that acts at matching time; that is, it is really an
1404: option for pcre_exec() or pcre_dfa_exec(). If it is set at compile
1405: time, it is remembered with the compiled pattern and assumed at match-
1406: ing time. For details see the discussion of PCRE_NO_START_OPTIMIZE
1407: below.
1408:
1409: PCRE_UCP
1410:
1411: This option changes the way PCRE processes \B, \b, \D, \d, \S, \s, \W,
1412: \w, and some of the POSIX character classes. By default, only ASCII
1413: characters are recognized, but if PCRE_UCP is set, Unicode properties
1414: are used instead to classify characters. More details are given in the
1415: section on generic character types in the pcrepattern page. If you set
1416: PCRE_UCP, matching one of the items it affects takes much longer. The
1417: option is available only if PCRE has been compiled with Unicode prop-
1418: erty support.
1419:
1420: PCRE_UNGREEDY
1421:
1422: This option inverts the "greediness" of the quantifiers so that they
1423: are not greedy by default, but become greedy if followed by "?". It is
1424: not compatible with Perl. It can also be set by a (?U) option setting
1425: within the pattern.
1426:
1427: PCRE_UTF8
1428:
1429: This option causes PCRE to regard both the pattern and the subject as
1430: strings of UTF-8 characters instead of single-byte character strings.
1431: However, it is available only when PCRE is built to include UTF-8 sup-
1432: port. If not, the use of this option provokes an error. Details of how
1433: this option changes the behaviour of PCRE are given in the section on
1434: UTF-8 support in the main pcre page.
1435:
1436: PCRE_NO_UTF8_CHECK
1437:
1438: When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
1439: automatically checked. There is a discussion about the validity of
1440: UTF-8 strings in the main pcre page. If an invalid UTF-8 sequence of
1441: bytes is found, pcre_compile() returns an error. If you already know
1442: that your pattern is valid, and you want to skip this check for perfor-
1443: mance reasons, you can set the PCRE_NO_UTF8_CHECK option. When it is
1444: set, the effect of passing an invalid UTF-8 string as a pattern is
1445: undefined. It may cause your program to crash. Note that this option
1446: can also be passed to pcre_exec() and pcre_dfa_exec(), to suppress the
1447: UTF-8 validity checking of subject strings.
1448:
1449:
1450: COMPILATION ERROR CODES
1451:
1452: The following table lists the error codes than may be returned by
1453: pcre_compile2(), along with the error messages that may be returned by
1454: both compiling functions. As PCRE has developed, some error codes have
1455: fallen out of use. To avoid confusion, they have not been re-used.
1456:
1457: 0 no error
1458: 1 \ at end of pattern
1459: 2 \c at end of pattern
1460: 3 unrecognized character follows \
1461: 4 numbers out of order in {} quantifier
1462: 5 number too big in {} quantifier
1463: 6 missing terminating ] for character class
1464: 7 invalid escape sequence in character class
1465: 8 range out of order in character class
1466: 9 nothing to repeat
1467: 10 [this code is not in use]
1468: 11 internal error: unexpected repeat
1469: 12 unrecognized character after (? or (?-
1470: 13 POSIX named classes are supported only within a class
1471: 14 missing )
1472: 15 reference to non-existent subpattern
1473: 16 erroffset passed as NULL
1474: 17 unknown option bit(s) set
1475: 18 missing ) after comment
1476: 19 [this code is not in use]
1477: 20 regular expression is too large
1478: 21 failed to get memory
1479: 22 unmatched parentheses
1480: 23 internal error: code overflow
1481: 24 unrecognized character after (?<
1482: 25 lookbehind assertion is not fixed length
1483: 26 malformed number or name after (?(
1484: 27 conditional group contains more than two branches
1485: 28 assertion expected after (?(
1486: 29 (?R or (?[+-]digits must be followed by )
1487: 30 unknown POSIX class name
1488: 31 POSIX collating elements are not supported
1489: 32 this version of PCRE is not compiled with PCRE_UTF8 support
1490: 33 [this code is not in use]
1491: 34 character value in \x{...} sequence is too large
1492: 35 invalid condition (?(0)
1493: 36 \C not allowed in lookbehind assertion
1494: 37 PCRE does not support \L, \l, \N, \U, or \u
1495: 38 number after (?C is > 255
1496: 39 closing ) for (?C expected
1497: 40 recursive call could loop indefinitely
1498: 41 unrecognized character after (?P
1499: 42 syntax error in subpattern name (missing terminator)
1500: 43 two named subpatterns have the same name
1501: 44 invalid UTF-8 string
1502: 45 support for \P, \p, and \X has not been compiled
1503: 46 malformed \P or \p sequence
1504: 47 unknown property name after \P or \p
1505: 48 subpattern name is too long (maximum 32 characters)
1506: 49 too many named subpatterns (maximum 10000)
1507: 50 [this code is not in use]
1508: 51 octal value is greater than \377 (not in UTF-8 mode)
1509: 52 internal error: overran compiling workspace
1510: 53 internal error: previously-checked referenced subpattern
1511: not found
1512: 54 DEFINE group contains more than one branch
1513: 55 repeating a DEFINE group is not allowed
1514: 56 inconsistent NEWLINE options
1515: 57 \g is not followed by a braced, angle-bracketed, or quoted
1516: name/number or by a plain number
1517: 58 a numbered reference must not be zero
1518: 59 an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)
1519: 60 (*VERB) not recognized
1520: 61 number is too big
1521: 62 subpattern name expected
1522: 63 digit expected after (?+
1523: 64 ] is an invalid data character in JavaScript compatibility mode
1524: 65 different names for subpatterns of the same number are
1525: not allowed
1526: 66 (*MARK) must have an argument
1527: 67 this version of PCRE is not compiled with PCRE_UCP support
1528:
1529: The numbers 32 and 10000 in errors 48 and 49 are defaults; different
1530: values may be used if the limits were changed when PCRE was built.
1531:
1532:
1533: STUDYING A PATTERN
1534:
1535: pcre_extra *pcre_study(const pcre *code, int options
1536: const char **errptr);
1537:
1538: If a compiled pattern is going to be used several times, it is worth
1539: spending more time analyzing it in order to speed up the time taken for
1540: matching. The function pcre_study() takes a pointer to a compiled pat-
1541: tern as its first argument. If studying the pattern produces additional
1542: information that will help speed up matching, pcre_study() returns a
1543: pointer to a pcre_extra block, in which the study_data field points to
1544: the results of the study.
1545:
1546: The returned value from pcre_study() can be passed directly to
1547: pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block also con-
1548: tains other fields that can be set by the caller before the block is
1549: passed; these are described below in the section on matching a pattern.
1550:
1551: If studying the pattern does not produce any useful information,
1552: pcre_study() returns NULL. In that circumstance, if the calling program
1553: wants to pass any of the other fields to pcre_exec() or
1554: pcre_dfa_exec(), it must set up its own pcre_extra block.
1555:
1556: The second argument of pcre_study() contains option bits. At present,
1557: no options are defined, and this argument should always be zero.
1558:
1559: The third argument for pcre_study() is a pointer for an error message.
1560: If studying succeeds (even if no data is returned), the variable it
1561: points to is set to NULL. Otherwise it is set to point to a textual
1562: error message. This is a static string that is part of the library. You
1563: must not try to free it. You should test the error pointer for NULL
1564: after calling pcre_study(), to be sure that it has run successfully.
1565:
1566: This is a typical call to pcre_study():
1567:
1568: pcre_extra *pe;
1569: pe = pcre_study(
1570: re, /* result of pcre_compile() */
1571: 0, /* no options exist */
1572: &error); /* set to NULL or points to a message */
1573:
1574: Studying a pattern does two things: first, a lower bound for the length
1575: of subject string that is needed to match the pattern is computed. This
1576: does not mean that there are any strings of that length that match, but
1577: it does guarantee that no shorter strings match. The value is used by
1578: pcre_exec() and pcre_dfa_exec() to avoid wasting time by trying to
1579: match strings that are shorter than the lower bound. You can find out
1580: the value in a calling program via the pcre_fullinfo() function.
1581:
1582: Studying a pattern is also useful for non-anchored patterns that do not
1583: have a single fixed starting character. A bitmap of possible starting
1584: bytes is created. This speeds up finding a position in the subject at
1585: which to start matching.
1586:
1587: The two optimizations just described can be disabled by setting the
1588: PCRE_NO_START_OPTIMIZE option when calling pcre_exec() or
1589: pcre_dfa_exec(). You might want to do this if your pattern contains
1590: callouts or (*MARK), and you want to make use of these facilities in
1591: cases where matching fails. See the discussion of PCRE_NO_START_OPTI-
1592: MIZE below.
1593:
1594:
1595: LOCALE SUPPORT
1596:
1597: PCRE handles caseless matching, and determines whether characters are
1598: letters, digits, or whatever, by reference to a set of tables, indexed
1599: by character value. When running in UTF-8 mode, this applies only to
1600: characters with codes less than 128. By default, higher-valued codes
1601: never match escapes such as \w or \d, but they can be tested with \p if
1602: PCRE is built with Unicode character property support. Alternatively,
1603: the PCRE_UCP option can be set at compile time; this causes \w and
1604: friends to use Unicode property support instead of built-in tables. The
1605: use of locales with Unicode is discouraged. If you are handling charac-
1606: ters with codes greater than 128, you should either use UTF-8 and Uni-
1607: code, or use locales, but not try to mix the two.
1608:
1609: PCRE contains an internal set of tables that are used when the final
1610: argument of pcre_compile() is NULL. These are sufficient for many
1611: applications. Normally, the internal tables recognize only ASCII char-
1612: acters. However, when PCRE is built, it is possible to cause the inter-
1613: nal tables to be rebuilt in the default "C" locale of the local system,
1614: which may cause them to be different.
1615:
1616: The internal tables can always be overridden by tables supplied by the
1617: application that calls PCRE. These may be created in a different locale
1618: from the default. As more and more applications change to using Uni-
1619: code, the need for this locale support is expected to die away.
1620:
1621: External tables are built by calling the pcre_maketables() function,
1622: which has no arguments, in the relevant locale. The result can then be
1623: passed to pcre_compile() or pcre_exec() as often as necessary. For
1624: example, to build and use tables that are appropriate for the French
1625: locale (where accented characters with values greater than 128 are
1626: treated as letters), the following code could be used:
1627:
1628: setlocale(LC_CTYPE, "fr_FR");
1629: tables = pcre_maketables();
1630: re = pcre_compile(..., tables);
1631:
1632: The locale name "fr_FR" is used on Linux and other Unix-like systems;
1633: if you are using Windows, the name for the French locale is "french".
1634:
1635: When pcre_maketables() runs, the tables are built in memory that is
1636: obtained via pcre_malloc. It is the caller's responsibility to ensure
1637: that the memory containing the tables remains available for as long as
1638: it is needed.
1639:
1640: The pointer that is passed to pcre_compile() is saved with the compiled
1641: pattern, and the same tables are used via this pointer by pcre_study()
1642: and normally also by pcre_exec(). Thus, by default, for any single pat-
1643: tern, compilation, studying and matching all happen in the same locale,
1644: but different patterns can be compiled in different locales.
1645:
1646: It is possible to pass a table pointer or NULL (indicating the use of
1647: the internal tables) to pcre_exec(). Although not intended for this
1648: purpose, this facility could be used to match a pattern in a different
1649: locale from the one in which it was compiled. Passing table pointers at
1650: run time is discussed below in the section on matching a pattern.
1651:
1652:
1653: INFORMATION ABOUT A PATTERN
1654:
1655: int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
1656: int what, void *where);
1657:
1658: The pcre_fullinfo() function returns information about a compiled pat-
1659: tern. It replaces the obsolete pcre_info() function, which is neverthe-
1660: less retained for backwards compability (and is documented below).
1661:
1662: The first argument for pcre_fullinfo() is a pointer to the compiled
1663: pattern. The second argument is the result of pcre_study(), or NULL if
1664: the pattern was not studied. The third argument specifies which piece
1665: of information is required, and the fourth argument is a pointer to a
1666: variable to receive the data. The yield of the function is zero for
1667: success, or one of the following negative numbers:
1668:
1669: PCRE_ERROR_NULL the argument code was NULL
1670: the argument where was NULL
1671: PCRE_ERROR_BADMAGIC the "magic number" was not found
1672: PCRE_ERROR_BADOPTION the value of what was invalid
1673:
1674: The "magic number" is placed at the start of each compiled pattern as
1675: an simple check against passing an arbitrary memory pointer. Here is a
1676: typical call of pcre_fullinfo(), to obtain the length of the compiled
1677: pattern:
1678:
1679: int rc;
1680: size_t length;
1681: rc = pcre_fullinfo(
1682: re, /* result of pcre_compile() */
1683: pe, /* result of pcre_study(), or NULL */
1684: PCRE_INFO_SIZE, /* what is required */
1685: &length); /* where to put the data */
1686:
1687: The possible values for the third argument are defined in pcre.h, and
1688: are as follows:
1689:
1690: PCRE_INFO_BACKREFMAX
1691:
1692: Return the number of the highest back reference in the pattern. The
1693: fourth argument should point to an int variable. Zero is returned if
1694: there are no back references.
1695:
1696: PCRE_INFO_CAPTURECOUNT
1697:
1698: Return the number of capturing subpatterns in the pattern. The fourth
1699: argument should point to an int variable.
1700:
1701: PCRE_INFO_DEFAULT_TABLES
1702:
1703: Return a pointer to the internal default character tables within PCRE.
1704: The fourth argument should point to an unsigned char * variable. This
1705: information call is provided for internal use by the pcre_study() func-
1706: tion. External callers can cause PCRE to use its internal tables by
1707: passing a NULL table pointer.
1708:
1709: PCRE_INFO_FIRSTBYTE
1710:
1711: Return information about the first byte of any matched string, for a
1712: non-anchored pattern. The fourth argument should point to an int vari-
1713: able. (This option used to be called PCRE_INFO_FIRSTCHAR; the old name
1714: is still recognized for backwards compatibility.)
1715:
1716: If there is a fixed first byte, for example, from a pattern such as
1717: (cat|cow|coyote), its value is returned. Otherwise, if either
1718:
1719: (a) the pattern was compiled with the PCRE_MULTILINE option, and every
1720: branch starts with "^", or
1721:
1722: (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
1723: set (if it were set, the pattern would be anchored),
1724:
1725: -1 is returned, indicating that the pattern matches only at the start
1726: of a subject string or after any newline within the string. Otherwise
1727: -2 is returned. For anchored patterns, -2 is returned.
1728:
1729: PCRE_INFO_FIRSTTABLE
1730:
1731: If the pattern was studied, and this resulted in the construction of a
1732: 256-bit table indicating a fixed set of bytes for the first byte in any
1733: matching string, a pointer to the table is returned. Otherwise NULL is
1734: returned. The fourth argument should point to an unsigned char * vari-
1735: able.
1736:
1737: PCRE_INFO_HASCRORLF
1738:
1739: Return 1 if the pattern contains any explicit matches for CR or LF
1740: characters, otherwise 0. The fourth argument should point to an int
1741: variable. An explicit match is either a literal CR or LF character, or
1742: \r or \n.
1743:
1744: PCRE_INFO_JCHANGED
1745:
1746: Return 1 if the (?J) or (?-J) option setting is used in the pattern,
1747: otherwise 0. The fourth argument should point to an int variable. (?J)
1748: and (?-J) set and unset the local PCRE_DUPNAMES option, respectively.
1749:
1750: PCRE_INFO_LASTLITERAL
1751:
1752: Return the value of the rightmost literal byte that must exist in any
1753: matched string, other than at its start, if such a byte has been
1754: recorded. The fourth argument should point to an int variable. If there
1755: is no such byte, -1 is returned. For anchored patterns, a last literal
1756: byte is recorded only if it follows something of variable length. For
1757: example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
1758: /^a\dz\d/ the returned value is -1.
1759:
1760: PCRE_INFO_MINLENGTH
1761:
1762: If the pattern was studied and a minimum length for matching subject
1763: strings was computed, its value is returned. Otherwise the returned
1764: value is -1. The value is a number of characters, not bytes (this may
1765: be relevant in UTF-8 mode). The fourth argument should point to an int
1766: variable. A non-negative value is a lower bound to the length of any
1767: matching string. There may not be any strings of that length that do
1768: actually match, but every string that does match is at least that long.
1769:
1770: PCRE_INFO_NAMECOUNT
1771: PCRE_INFO_NAMEENTRYSIZE
1772: PCRE_INFO_NAMETABLE
1773:
1774: PCRE supports the use of named as well as numbered capturing parenthe-
1775: ses. The names are just an additional way of identifying the parenthe-
1776: ses, which still acquire numbers. Several convenience functions such as
1777: pcre_get_named_substring() are provided for extracting captured sub-
1778: strings by name. It is also possible to extract the data directly, by
1779: first converting the name to a number in order to access the correct
1780: pointers in the output vector (described with pcre_exec() below). To do
1781: the conversion, you need to use the name-to-number map, which is
1782: described by these three values.
1783:
1784: The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
1785: gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
1786: of each entry; both of these return an int value. The entry size
1787: depends on the length of the longest name. PCRE_INFO_NAMETABLE returns
1788: a pointer to the first entry of the table (a pointer to char). The
1789: first two bytes of each entry are the number of the capturing parenthe-
1790: sis, most significant byte first. The rest of the entry is the corre-
1791: sponding name, zero terminated.
1792:
1793: The names are in alphabetical order. Duplicate names may appear if (?|
1794: is used to create multiple groups with the same number, as described in
1795: the section on duplicate subpattern numbers in the pcrepattern page.
1796: Duplicate names for subpatterns with different numbers are permitted
1797: only if PCRE_DUPNAMES is set. In all cases of duplicate names, they
1798: appear in the table in the order in which they were found in the pat-
1799: tern. In the absence of (?| this is the order of increasing number;
1800: when (?| is used this is not necessarily the case because later subpat-
1801: terns may have lower numbers.
1802:
1803: As a simple example of the name/number table, consider the following
1804: pattern (assume PCRE_EXTENDED is set, so white space - including new-
1805: lines - is ignored):
1806:
1807: (?<date> (?<year>(\d\d)?\d\d) -
1808: (?<month>\d\d) - (?<day>\d\d) )
1809:
1810: There are four named subpatterns, so the table has four entries, and
1811: each entry in the table is eight bytes long. The table is as follows,
1812: with non-printing bytes shows in hexadecimal, and undefined bytes shown
1813: as ??:
1814:
1815: 00 01 d a t e 00 ??
1816: 00 05 d a y 00 ?? ??
1817: 00 04 m o n t h 00
1818: 00 02 y e a r 00 ??
1819:
1820: When writing code to extract data from named subpatterns using the
1821: name-to-number map, remember that the length of the entries is likely
1822: to be different for each compiled pattern.
1823:
1824: PCRE_INFO_OKPARTIAL
1825:
1826: Return 1 if the pattern can be used for partial matching with
1827: pcre_exec(), otherwise 0. The fourth argument should point to an int
1828: variable. From release 8.00, this always returns 1, because the
1829: restrictions that previously applied to partial matching have been
1830: lifted. The pcrepartial documentation gives details of partial match-
1831: ing.
1832:
1833: PCRE_INFO_OPTIONS
1834:
1835: Return a copy of the options with which the pattern was compiled. The
1836: fourth argument should point to an unsigned long int variable. These
1837: option bits are those specified in the call to pcre_compile(), modified
1838: by any top-level option settings at the start of the pattern itself. In
1839: other words, they are the options that will be in force when matching
1840: starts. For example, if the pattern /(?im)abc(?-i)d/ is compiled with
1841: the PCRE_EXTENDED option, the result is PCRE_CASELESS, PCRE_MULTILINE,
1842: and PCRE_EXTENDED.
1843:
1844: A pattern is automatically anchored by PCRE if all of its top-level
1845: alternatives begin with one of the following:
1846:
1847: ^ unless PCRE_MULTILINE is set
1848: \A always
1849: \G always
1850: .* if PCRE_DOTALL is set and there are no back
1851: references to the subpattern in which .* appears
1852:
1853: For such patterns, the PCRE_ANCHORED bit is set in the options returned
1854: by pcre_fullinfo().
1855:
1856: PCRE_INFO_SIZE
1857:
1858: Return the size of the compiled pattern, that is, the value that was
1859: passed as the argument to pcre_malloc() when PCRE was getting memory in
1860: which to place the compiled data. The fourth argument should point to a
1861: size_t variable.
1862:
1863: PCRE_INFO_STUDYSIZE
1864:
1865: Return the size of the data block pointed to by the study_data field in
1866: a pcre_extra block. That is, it is the value that was passed to
1867: pcre_malloc() when PCRE was getting memory into which to place the data
1868: created by pcre_study(). If pcre_extra is NULL, or there is no study
1869: data, zero is returned. The fourth argument should point to a size_t
1870: variable.
1871:
1872:
1873: OBSOLETE INFO FUNCTION
1874:
1875: int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
1876:
1877: The pcre_info() function is now obsolete because its interface is too
1878: restrictive to return all the available data about a compiled pattern.
1879: New programs should use pcre_fullinfo() instead. The yield of
1880: pcre_info() is the number of capturing subpatterns, or one of the fol-
1881: lowing negative numbers:
1882:
1883: PCRE_ERROR_NULL the argument code was NULL
1884: PCRE_ERROR_BADMAGIC the "magic number" was not found
1885:
1886: If the optptr argument is not NULL, a copy of the options with which
1887: the pattern was compiled is placed in the integer it points to (see
1888: PCRE_INFO_OPTIONS above).
1889:
1890: If the pattern is not anchored and the firstcharptr argument is not
1891: NULL, it is used to pass back information about the first character of
1892: any matched string (see PCRE_INFO_FIRSTBYTE above).
1893:
1894:
1895: REFERENCE COUNTS
1896:
1897: int pcre_refcount(pcre *code, int adjust);
1898:
1899: The pcre_refcount() function is used to maintain a reference count in
1900: the data block that contains a compiled pattern. It is provided for the
1901: benefit of applications that operate in an object-oriented manner,
1902: where different parts of the application may be using the same compiled
1903: pattern, but you want to free the block when they are all done.
1904:
1905: When a pattern is compiled, the reference count field is initialized to
1906: zero. It is changed only by calling this function, whose action is to
1907: add the adjust value (which may be positive or negative) to it. The
1908: yield of the function is the new value. However, the value of the count
1909: is constrained to lie between 0 and 65535, inclusive. If the new value
1910: is outside these limits, it is forced to the appropriate limit value.
1911:
1912: Except when it is zero, the reference count is not correctly preserved
1913: if a pattern is compiled on one host and then transferred to a host
1914: whose byte-order is different. (This seems a highly unlikely scenario.)
1915:
1916:
1917: MATCHING A PATTERN: THE TRADITIONAL FUNCTION
1918:
1919: int pcre_exec(const pcre *code, const pcre_extra *extra,
1920: const char *subject, int length, int startoffset,
1921: int options, int *ovector, int ovecsize);
1922:
1923: The function pcre_exec() is called to match a subject string against a
1924: compiled pattern, which is passed in the code argument. If the pattern
1925: was studied, the result of the study should be passed in the extra
1926: argument. This function is the main matching facility of the library,
1927: and it operates in a Perl-like manner. For specialist use there is also
1928: an alternative matching function, which is described below in the sec-
1929: tion about the pcre_dfa_exec() function.
1930:
1931: In most applications, the pattern will have been compiled (and option-
1932: ally studied) in the same process that calls pcre_exec(). However, it
1933: is possible to save compiled patterns and study data, and then use them
1934: later in different processes, possibly even on different hosts. For a
1935: discussion about this, see the pcreprecompile documentation.
1936:
1937: Here is an example of a simple call to pcre_exec():
1938:
1939: int rc;
1940: int ovector[30];
1941: rc = pcre_exec(
1942: re, /* result of pcre_compile() */
1943: NULL, /* we didn't study the pattern */
1944: "some string", /* the subject string */
1945: 11, /* the length of the subject string */
1946: 0, /* start at offset 0 in the subject */
1947: 0, /* default options */
1948: ovector, /* vector of integers for substring information */
1949: 30); /* number of elements (NOT size in bytes) */
1950:
1951: Extra data for pcre_exec()
1952:
1953: If the extra argument is not NULL, it must point to a pcre_extra data
1954: block. The pcre_study() function returns such a block (when it doesn't
1955: return NULL), but you can also create one for yourself, and pass addi-
1956: tional information in it. The pcre_extra block contains the following
1957: fields (not necessarily in this order):
1958:
1959: unsigned long int flags;
1960: void *study_data;
1961: unsigned long int match_limit;
1962: unsigned long int match_limit_recursion;
1963: void *callout_data;
1964: const unsigned char *tables;
1965: unsigned char **mark;
1966:
1967: The flags field is a bitmap that specifies which of the other fields
1968: are set. The flag bits are:
1969:
1970: PCRE_EXTRA_STUDY_DATA
1971: PCRE_EXTRA_MATCH_LIMIT
1972: PCRE_EXTRA_MATCH_LIMIT_RECURSION
1973: PCRE_EXTRA_CALLOUT_DATA
1974: PCRE_EXTRA_TABLES
1975: PCRE_EXTRA_MARK
1976:
1977: Other flag bits should be set to zero. The study_data field is set in
1978: the pcre_extra block that is returned by pcre_study(), together with
1979: the appropriate flag bit. You should not set this yourself, but you may
1980: add to the block by setting the other fields and their corresponding
1981: flag bits.
1982:
1983: The match_limit field provides a means of preventing PCRE from using up
1984: a vast amount of resources when running patterns that are not going to
1985: match, but which have a very large number of possibilities in their
1986: search trees. The classic example is a pattern that uses nested unlim-
1987: ited repeats.
1988:
1989: Internally, PCRE uses a function called match() which it calls repeat-
1990: edly (sometimes recursively). The limit set by match_limit is imposed
1991: on the number of times this function is called during a match, which
1992: has the effect of limiting the amount of backtracking that can take
1993: place. For patterns that are not anchored, the count restarts from zero
1994: for each position in the subject string.
1995:
1996: The default value for the limit can be set when PCRE is built; the
1997: default default is 10 million, which handles all but the most extreme
1998: cases. You can override the default by suppling pcre_exec() with a
1999: pcre_extra block in which match_limit is set, and
2000: PCRE_EXTRA_MATCH_LIMIT is set in the flags field. If the limit is
2001: exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT.
2002:
2003: The match_limit_recursion field is similar to match_limit, but instead
2004: of limiting the total number of times that match() is called, it limits
2005: the depth of recursion. The recursion depth is a smaller number than
2006: the total number of calls, because not all calls to match() are recur-
2007: sive. This limit is of use only if it is set smaller than match_limit.
2008:
2009: Limiting the recursion depth limits the amount of stack that can be
2010: used, or, when PCRE has been compiled to use memory on the heap instead
2011: of the stack, the amount of heap memory that can be used.
2012:
2013: The default value for match_limit_recursion can be set when PCRE is
2014: built; the default default is the same value as the default for
2015: match_limit. You can override the default by suppling pcre_exec() with
2016: a pcre_extra block in which match_limit_recursion is set, and
2017: PCRE_EXTRA_MATCH_LIMIT_RECURSION is set in the flags field. If the
2018: limit is exceeded, pcre_exec() returns PCRE_ERROR_RECURSIONLIMIT.
2019:
2020: The callout_data field is used in conjunction with the "callout" fea-
2021: ture, and is described in the pcrecallout documentation.
2022:
2023: The tables field is used to pass a character tables pointer to
2024: pcre_exec(); this overrides the value that is stored with the compiled
2025: pattern. A non-NULL value is stored with the compiled pattern only if
2026: custom tables were supplied to pcre_compile() via its tableptr argu-
2027: ment. If NULL is passed to pcre_exec() using this mechanism, it forces
2028: PCRE's internal tables to be used. This facility is helpful when re-
2029: using patterns that have been saved after compiling with an external
2030: set of tables, because the external tables might be at a different
2031: address when pcre_exec() is called. See the pcreprecompile documenta-
2032: tion for a discussion of saving compiled patterns for later use.
2033:
2034: If PCRE_EXTRA_MARK is set in the flags field, the mark field must be
2035: set to point to a char * variable. If the pattern contains any back-
2036: tracking control verbs such as (*MARK:NAME), and the execution ends up
2037: with a name to pass back, a pointer to the name string (zero termi-
2038: nated) is placed in the variable pointed to by the mark field. The
2039: names are within the compiled pattern; if you wish to retain such a
2040: name you must copy it before freeing the memory of a compiled pattern.
2041: If there is no name to pass back, the variable pointed to by the mark
2042: field set to NULL. For details of the backtracking control verbs, see
2043: the section entitled "Backtracking control" in the pcrepattern documen-
2044: tation.
2045:
2046: Option bits for pcre_exec()
2047:
2048: The unused bits of the options argument for pcre_exec() must be zero.
2049: The only bits that may be set are PCRE_ANCHORED, PCRE_NEWLINE_xxx,
2050: PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART,
2051: PCRE_NO_START_OPTIMIZE, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_SOFT, and
2052: PCRE_PARTIAL_HARD.
2053:
2054: PCRE_ANCHORED
2055:
2056: The PCRE_ANCHORED option limits pcre_exec() to matching at the first
2057: matching position. If a pattern was compiled with PCRE_ANCHORED, or
2058: turned out to be anchored by virtue of its contents, it cannot be made
2059: unachored at matching time.
2060:
2061: PCRE_BSR_ANYCRLF
2062: PCRE_BSR_UNICODE
2063:
2064: These options (which are mutually exclusive) control what the \R escape
2065: sequence matches. The choice is either to match only CR, LF, or CRLF,
2066: or to match any Unicode newline sequence. These options override the
2067: choice that was made or defaulted when the pattern was compiled.
2068:
2069: PCRE_NEWLINE_CR
2070: PCRE_NEWLINE_LF
2071: PCRE_NEWLINE_CRLF
2072: PCRE_NEWLINE_ANYCRLF
2073: PCRE_NEWLINE_ANY
2074:
2075: These options override the newline definition that was chosen or
2076: defaulted when the pattern was compiled. For details, see the descrip-
2077: tion of pcre_compile() above. During matching, the newline choice
2078: affects the behaviour of the dot, circumflex, and dollar metacharac-
2079: ters. It may also alter the way the match position is advanced after a
2080: match failure for an unanchored pattern.
2081:
2082: When PCRE_NEWLINE_CRLF, PCRE_NEWLINE_ANYCRLF, or PCRE_NEWLINE_ANY is
2083: set, and a match attempt for an unanchored pattern fails when the cur-
2084: rent position is at a CRLF sequence, and the pattern contains no
2085: explicit matches for CR or LF characters, the match position is
2086: advanced by two characters instead of one, in other words, to after the
2087: CRLF.
2088:
2089: The above rule is a compromise that makes the most common cases work as
2090: expected. For example, if the pattern is .+A (and the PCRE_DOTALL
2091: option is not set), it does not match the string "\r\nA" because, after
2092: failing at the start, it skips both the CR and the LF before retrying.
2093: However, the pattern [\r\n]A does match that string, because it con-
2094: tains an explicit CR or LF reference, and so advances only by one char-
2095: acter after the first failure.
2096:
2097: An explicit match for CR of LF is either a literal appearance of one of
2098: those characters, or one of the \r or \n escape sequences. Implicit
2099: matches such as [^X] do not count, nor does \s (which includes CR and
2100: LF in the characters that it matches).
2101:
2102: Notwithstanding the above, anomalous effects may still occur when CRLF
2103: is a valid newline sequence and explicit \r or \n escapes appear in the
2104: pattern.
2105:
2106: PCRE_NOTBOL
2107:
2108: This option specifies that first character of the subject string is not
2109: the beginning of a line, so the circumflex metacharacter should not
2110: match before it. Setting this without PCRE_MULTILINE (at compile time)
2111: causes circumflex never to match. This option affects only the behav-
2112: iour of the circumflex metacharacter. It does not affect \A.
2113:
2114: PCRE_NOTEOL
2115:
2116: This option specifies that the end of the subject string is not the end
2117: of a line, so the dollar metacharacter should not match it nor (except
2118: in multiline mode) a newline immediately before it. Setting this with-
2119: out PCRE_MULTILINE (at compile time) causes dollar never to match. This
2120: option affects only the behaviour of the dollar metacharacter. It does
2121: not affect \Z or \z.
2122:
2123: PCRE_NOTEMPTY
2124:
2125: An empty string is not considered to be a valid match if this option is
2126: set. If there are alternatives in the pattern, they are tried. If all
2127: the alternatives match the empty string, the entire match fails. For
2128: example, if the pattern
2129:
2130: a?b?
2131:
2132: is applied to a string not beginning with "a" or "b", it matches an
2133: empty string at the start of the subject. With PCRE_NOTEMPTY set, this
2134: match is not valid, so PCRE searches further into the string for occur-
2135: rences of "a" or "b".
2136:
2137: PCRE_NOTEMPTY_ATSTART
2138:
2139: This is like PCRE_NOTEMPTY, except that an empty string match that is
2140: not at the start of the subject is permitted. If the pattern is
2141: anchored, such a match can occur only if the pattern contains \K.
2142:
2143: Perl has no direct equivalent of PCRE_NOTEMPTY or
2144: PCRE_NOTEMPTY_ATSTART, but it does make a special case of a pattern
2145: match of the empty string within its split() function, and when using
2146: the /g modifier. It is possible to emulate Perl's behaviour after
2147: matching a null string by first trying the match again at the same off-
2148: set with PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED, and then if that
2149: fails, by advancing the starting offset (see below) and trying an ordi-
2150: nary match again. There is some code that demonstrates how to do this
2151: in the pcredemo sample program. In the most general case, you have to
2152: check to see if the newline convention recognizes CRLF as a newline,
2153: and if so, and the current character is CR followed by LF, advance the
2154: starting offset by two characters instead of one.
2155:
2156: PCRE_NO_START_OPTIMIZE
2157:
2158: There are a number of optimizations that pcre_exec() uses at the start
2159: of a match, in order to speed up the process. For example, if it is
2160: known that an unanchored match must start with a specific character, it
2161: searches the subject for that character, and fails immediately if it
2162: cannot find it, without actually running the main matching function.
2163: This means that a special item such as (*COMMIT) at the start of a pat-
2164: tern is not considered until after a suitable starting point for the
2165: match has been found. When callouts or (*MARK) items are in use, these
2166: "start-up" optimizations can cause them to be skipped if the pattern is
2167: never actually used. The start-up optimizations are in effect a pre-
2168: scan of the subject that takes place before the pattern is run.
2169:
2170: The PCRE_NO_START_OPTIMIZE option disables the start-up optimizations,
2171: possibly causing performance to suffer, but ensuring that in cases
2172: where the result is "no match", the callouts do occur, and that items
2173: such as (*COMMIT) and (*MARK) are considered at every possible starting
2174: position in the subject string. If PCRE_NO_START_OPTIMIZE is set at
2175: compile time, it cannot be unset at matching time.
2176:
2177: Setting PCRE_NO_START_OPTIMIZE can change the outcome of a matching
2178: operation. Consider the pattern
2179:
2180: (*COMMIT)ABC
2181:
2182: When this is compiled, PCRE records the fact that a match must start
2183: with the character "A". Suppose the subject string is "DEFABC". The
2184: start-up optimization scans along the subject, finds "A" and runs the
2185: first match attempt from there. The (*COMMIT) item means that the pat-
2186: tern must match the current starting position, which in this case, it
2187: does. However, if the same match is run with PCRE_NO_START_OPTIMIZE
2188: set, the initial scan along the subject string does not happen. The
2189: first match attempt is run starting from "D" and when this fails,
2190: (*COMMIT) prevents any further matches being tried, so the overall
2191: result is "no match". If the pattern is studied, more start-up opti-
2192: mizations may be used. For example, a minimum length for the subject
2193: may be recorded. Consider the pattern
2194:
2195: (*MARK:A)(X|Y)
2196:
2197: The minimum length for a match is one character. If the subject is
2198: "ABC", there will be attempts to match "ABC", "BC", "C", and then
2199: finally an empty string. If the pattern is studied, the final attempt
2200: does not take place, because PCRE knows that the subject is too short,
2201: and so the (*MARK) is never encountered. In this case, studying the
2202: pattern does not affect the overall match result, which is still "no
2203: match", but it does affect the auxiliary information that is returned.
2204:
2205: PCRE_NO_UTF8_CHECK
2206:
2207: When PCRE_UTF8 is set at compile time, the validity of the subject as a
2208: UTF-8 string is automatically checked when pcre_exec() is subsequently
2209: called. The value of startoffset is also checked to ensure that it
2210: points to the start of a UTF-8 character. There is a discussion about
2211: the validity of UTF-8 strings in the section on UTF-8 support in the
2212: main pcre page. If an invalid UTF-8 sequence of bytes is found,
2213: pcre_exec() returns the error PCRE_ERROR_BADUTF8 or, if PCRE_PAR-
2214: TIAL_HARD is set and the problem is a truncated UTF-8 character at the
2215: end of the subject, PCRE_ERROR_SHORTUTF8. If startoffset contains a
2216: value that does not point to the start of a UTF-8 character (or to the
2217: end of the subject), PCRE_ERROR_BADUTF8_OFFSET is returned.
2218:
2219: If you already know that your subject is valid, and you want to skip
2220: these checks for performance reasons, you can set the
2221: PCRE_NO_UTF8_CHECK option when calling pcre_exec(). You might want to
2222: do this for the second and subsequent calls to pcre_exec() if you are
2223: making repeated calls to find all the matches in a single subject
2224: string. However, you should be sure that the value of startoffset
2225: points to the start of a UTF-8 character (or the end of the subject).
2226: When PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid UTF-8
2227: string as a subject or an invalid value of startoffset is undefined.
2228: Your program may crash.
2229:
2230: PCRE_PARTIAL_HARD
2231: PCRE_PARTIAL_SOFT
2232:
2233: These options turn on the partial matching feature. For backwards com-
2234: patibility, PCRE_PARTIAL is a synonym for PCRE_PARTIAL_SOFT. A partial
2235: match occurs if the end of the subject string is reached successfully,
2236: but there are not enough subject characters to complete the match. If
2237: this happens when PCRE_PARTIAL_SOFT (but not PCRE_PARTIAL_HARD) is set,
2238: matching continues by testing any remaining alternatives. Only if no
2239: complete match can be found is PCRE_ERROR_PARTIAL returned instead of
2240: PCRE_ERROR_NOMATCH. In other words, PCRE_PARTIAL_SOFT says that the
2241: caller is prepared to handle a partial match, but only if no complete
2242: match can be found.
2243:
2244: If PCRE_PARTIAL_HARD is set, it overrides PCRE_PARTIAL_SOFT. In this
2245: case, if a partial match is found, pcre_exec() immediately returns
2246: PCRE_ERROR_PARTIAL, without considering any other alternatives. In
2247: other words, when PCRE_PARTIAL_HARD is set, a partial match is consid-
2248: ered to be more important that an alternative complete match.
2249:
2250: In both cases, the portion of the string that was inspected when the
2251: partial match was found is set as the first matching string. There is a
2252: more detailed discussion of partial and multi-segment matching, with
2253: examples, in the pcrepartial documentation.
2254:
2255: The string to be matched by pcre_exec()
2256:
2257: The subject string is passed to pcre_exec() as a pointer in subject, a
2258: length (in bytes) in length, and a starting byte offset in startoffset.
2259: If this is negative or greater than the length of the subject,
2260: pcre_exec() returns PCRE_ERROR_BADOFFSET. When the starting offset is
2261: zero, the search for a match starts at the beginning of the subject,
2262: and this is by far the most common case. In UTF-8 mode, the byte offset
2263: must point to the start of a UTF-8 character (or the end of the sub-
2264: ject). Unlike the pattern string, the subject may contain binary zero
2265: bytes.
2266:
2267: A non-zero starting offset is useful when searching for another match
2268: in the same subject by calling pcre_exec() again after a previous suc-
2269: cess. Setting startoffset differs from just passing over a shortened
2270: string and setting PCRE_NOTBOL in the case of a pattern that begins
2271: with any kind of lookbehind. For example, consider the pattern
2272:
2273: \Biss\B
2274:
2275: which finds occurrences of "iss" in the middle of words. (\B matches
2276: only if the current position in the subject is not a word boundary.)
2277: When applied to the string "Mississipi" the first call to pcre_exec()
2278: finds the first occurrence. If pcre_exec() is called again with just
2279: the remainder of the subject, namely "issipi", it does not match,
2280: because \B is always false at the start of the subject, which is deemed
2281: to be a word boundary. However, if pcre_exec() is passed the entire
2282: string again, but with startoffset set to 4, it finds the second occur-
2283: rence of "iss" because it is able to look behind the starting point to
2284: discover that it is preceded by a letter.
2285:
2286: Finding all the matches in a subject is tricky when the pattern can
2287: match an empty string. It is possible to emulate Perl's /g behaviour by
2288: first trying the match again at the same offset, with the
2289: PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED options, and then if that
2290: fails, advancing the starting offset and trying an ordinary match
2291: again. There is some code that demonstrates how to do this in the pcre-
2292: demo sample program. In the most general case, you have to check to see
2293: if the newline convention recognizes CRLF as a newline, and if so, and
2294: the current character is CR followed by LF, advance the starting offset
2295: by two characters instead of one.
2296:
2297: If a non-zero starting offset is passed when the pattern is anchored,
2298: one attempt to match at the given offset is made. This can only succeed
2299: if the pattern does not require the match to be at the start of the
2300: subject.
2301:
2302: How pcre_exec() returns captured substrings
2303:
2304: In general, a pattern matches a certain portion of the subject, and in
2305: addition, further substrings from the subject may be picked out by
2306: parts of the pattern. Following the usage in Jeffrey Friedl's book,
2307: this is called "capturing" in what follows, and the phrase "capturing
2308: subpattern" is used for a fragment of a pattern that picks out a sub-
2309: string. PCRE supports several other kinds of parenthesized subpattern
2310: that do not cause substrings to be captured.
2311:
2312: Captured substrings are returned to the caller via a vector of integers
2313: whose address is passed in ovector. The number of elements in the vec-
2314: tor is passed in ovecsize, which must be a non-negative number. Note:
2315: this argument is NOT the size of ovector in bytes.
2316:
2317: The first two-thirds of the vector is used to pass back captured sub-
2318: strings, each substring using a pair of integers. The remaining third
2319: of the vector is used as workspace by pcre_exec() while matching cap-
2320: turing subpatterns, and is not available for passing back information.
2321: The number passed in ovecsize should always be a multiple of three. If
2322: it is not, it is rounded down.
2323:
2324: When a match is successful, information about captured substrings is
2325: returned in pairs of integers, starting at the beginning of ovector,
2326: and continuing up to two-thirds of its length at the most. The first
2327: element of each pair is set to the byte offset of the first character
2328: in a substring, and the second is set to the byte offset of the first
2329: character after the end of a substring. Note: these values are always
2330: byte offsets, even in UTF-8 mode. They are not character counts.
2331:
2332: The first pair of integers, ovector[0] and ovector[1], identify the
2333: portion of the subject string matched by the entire pattern. The next
2334: pair is used for the first capturing subpattern, and so on. The value
2335: returned by pcre_exec() is one more than the highest numbered pair that
2336: has been set. For example, if two substrings have been captured, the
2337: returned value is 3. If there are no capturing subpatterns, the return
2338: value from a successful match is 1, indicating that just the first pair
2339: of offsets has been set.
2340:
2341: If a capturing subpattern is matched repeatedly, it is the last portion
2342: of the string that it matched that is returned.
2343:
2344: If the vector is too small to hold all the captured substring offsets,
2345: it is used as far as possible (up to two-thirds of its length), and the
2346: function returns a value of zero. If the substring offsets are not of
2347: interest, pcre_exec() may be called with ovector passed as NULL and
2348: ovecsize as zero. However, if the pattern contains back references and
2349: the ovector is not big enough to remember the related substrings, PCRE
2350: has to get additional memory for use during matching. Thus it is usu-
2351: ally advisable to supply an ovector.
2352:
2353: The pcre_fullinfo() function can be used to find out how many capturing
2354: subpatterns there are in a compiled pattern. The smallest size for
2355: ovector that will allow for n captured substrings, in addition to the
2356: offsets of the substring matched by the whole pattern, is (n+1)*3.
2357:
2358: It is possible for capturing subpattern number n+1 to match some part
2359: of the subject when subpattern n has not been used at all. For example,
2360: if the string "abc" is matched against the pattern (a|(z))(bc) the
2361: return from the function is 4, and subpatterns 1 and 3 are matched, but
2362: 2 is not. When this happens, both values in the offset pairs corre-
2363: sponding to unused subpatterns are set to -1.
2364:
2365: Offset values that correspond to unused subpatterns at the end of the
2366: expression are also set to -1. For example, if the string "abc" is
2367: matched against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are not
2368: matched. The return from the function is 2, because the highest used
2369: capturing subpattern number is 1, and the offsets for for the second
2370: and third capturing subpatterns (assuming the vector is large enough,
2371: of course) are set to -1.
2372:
2373: Note: Elements of ovector that do not correspond to capturing parenthe-
2374: ses in the pattern are never changed. That is, if a pattern contains n
2375: capturing parentheses, no more than ovector[0] to ovector[2n+1] are set
2376: by pcre_exec(). The other elements retain whatever values they previ-
2377: ously had.
2378:
2379: Some convenience functions are provided for extracting the captured
2380: substrings as separate strings. These are described below.
2381:
2382: Error return values from pcre_exec()
2383:
2384: If pcre_exec() fails, it returns a negative number. The following are
2385: defined in the header file:
2386:
2387: PCRE_ERROR_NOMATCH (-1)
2388:
2389: The subject string did not match the pattern.
2390:
2391: PCRE_ERROR_NULL (-2)
2392:
2393: Either code or subject was passed as NULL, or ovector was NULL and
2394: ovecsize was not zero.
2395:
2396: PCRE_ERROR_BADOPTION (-3)
2397:
2398: An unrecognized bit was set in the options argument.
2399:
2400: PCRE_ERROR_BADMAGIC (-4)
2401:
2402: PCRE stores a 4-byte "magic number" at the start of the compiled code,
2403: to catch the case when it is passed a junk pointer and to detect when a
2404: pattern that was compiled in an environment of one endianness is run in
2405: an environment with the other endianness. This is the error that PCRE
2406: gives when the magic number is not present.
2407:
2408: PCRE_ERROR_UNKNOWN_OPCODE (-5)
2409:
2410: While running the pattern match, an unknown item was encountered in the
2411: compiled pattern. This error could be caused by a bug in PCRE or by
2412: overwriting of the compiled pattern.
2413:
2414: PCRE_ERROR_NOMEMORY (-6)
2415:
2416: If a pattern contains back references, but the ovector that is passed
2417: to pcre_exec() is not big enough to remember the referenced substrings,
2418: PCRE gets a block of memory at the start of matching to use for this
2419: purpose. If the call via pcre_malloc() fails, this error is given. The
2420: memory is automatically freed at the end of matching.
2421:
2422: This error is also given if pcre_stack_malloc() fails in pcre_exec().
2423: This can happen only when PCRE has been compiled with --disable-stack-
2424: for-recursion.
2425:
2426: PCRE_ERROR_NOSUBSTRING (-7)
2427:
2428: This error is used by the pcre_copy_substring(), pcre_get_substring(),
2429: and pcre_get_substring_list() functions (see below). It is never
2430: returned by pcre_exec().
2431:
2432: PCRE_ERROR_MATCHLIMIT (-8)
2433:
2434: The backtracking limit, as specified by the match_limit field in a
2435: pcre_extra structure (or defaulted) was reached. See the description
2436: above.
2437:
2438: PCRE_ERROR_CALLOUT (-9)
2439:
2440: This error is never generated by pcre_exec() itself. It is provided for
2441: use by callout functions that want to yield a distinctive error code.
2442: See the pcrecallout documentation for details.
2443:
2444: PCRE_ERROR_BADUTF8 (-10)
2445:
2446: A string that contains an invalid UTF-8 byte sequence was passed as a
2447: subject. However, if PCRE_PARTIAL_HARD is set and the problem is a
2448: truncated UTF-8 character at the end of the subject, PCRE_ERROR_SHORT-
2449: UTF8 is used instead.
2450:
2451: PCRE_ERROR_BADUTF8_OFFSET (-11)
2452:
2453: The UTF-8 byte sequence that was passed as a subject was valid, but the
2454: value of startoffset did not point to the beginning of a UTF-8 charac-
2455: ter or the end of the subject.
2456:
2457: PCRE_ERROR_PARTIAL (-12)
2458:
2459: The subject string did not match, but it did match partially. See the
2460: pcrepartial documentation for details of partial matching.
2461:
2462: PCRE_ERROR_BADPARTIAL (-13)
2463:
2464: This code is no longer in use. It was formerly returned when the
2465: PCRE_PARTIAL option was used with a compiled pattern containing items
2466: that were not supported for partial matching. From release 8.00
2467: onwards, there are no restrictions on partial matching.
2468:
2469: PCRE_ERROR_INTERNAL (-14)
2470:
2471: An unexpected internal error has occurred. This error could be caused
2472: by a bug in PCRE or by overwriting of the compiled pattern.
2473:
2474: PCRE_ERROR_BADCOUNT (-15)
2475:
2476: This error is given if the value of the ovecsize argument is negative.
2477:
2478: PCRE_ERROR_RECURSIONLIMIT (-21)
2479:
2480: The internal recursion limit, as specified by the match_limit_recursion
2481: field in a pcre_extra structure (or defaulted) was reached. See the
2482: description above.
2483:
2484: PCRE_ERROR_BADNEWLINE (-23)
2485:
2486: An invalid combination of PCRE_NEWLINE_xxx options was given.
2487:
2488: PCRE_ERROR_BADOFFSET (-24)
2489:
2490: The value of startoffset was negative or greater than the length of the
2491: subject, that is, the value in length.
2492:
2493: PCRE_ERROR_SHORTUTF8 (-25)
2494:
2495: The subject string ended with an incomplete (truncated) UTF-8 charac-
2496: ter, and the PCRE_PARTIAL_HARD option was set. Without this option,
2497: PCRE_ERROR_BADUTF8 is returned in this situation.
2498:
2499: Error numbers -16 to -20 and -22 are not used by pcre_exec().
2500:
2501:
2502: EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
2503:
2504: int pcre_copy_substring(const char *subject, int *ovector,
2505: int stringcount, int stringnumber, char *buffer,
2506: int buffersize);
2507:
2508: int pcre_get_substring(const char *subject, int *ovector,
2509: int stringcount, int stringnumber,
2510: const char **stringptr);
2511:
2512: int pcre_get_substring_list(const char *subject,
2513: int *ovector, int stringcount, const char ***listptr);
2514:
2515: Captured substrings can be accessed directly by using the offsets
2516: returned by pcre_exec() in ovector. For convenience, the functions
2517: pcre_copy_substring(), pcre_get_substring(), and pcre_get_sub-
2518: string_list() are provided for extracting captured substrings as new,
2519: separate, zero-terminated strings. These functions identify substrings
2520: by number. The next section describes functions for extracting named
2521: substrings.
2522:
2523: A substring that contains a binary zero is correctly extracted and has
2524: a further zero added on the end, but the result is not, of course, a C
2525: string. However, you can process such a string by referring to the
2526: length that is returned by pcre_copy_substring() and pcre_get_sub-
2527: string(). Unfortunately, the interface to pcre_get_substring_list() is
2528: not adequate for handling strings containing binary zeros, because the
2529: end of the final string is not independently indicated.
2530:
2531: The first three arguments are the same for all three of these func-
2532: tions: subject is the subject string that has just been successfully
2533: matched, ovector is a pointer to the vector of integer offsets that was
2534: passed to pcre_exec(), and stringcount is the number of substrings that
2535: were captured by the match, including the substring that matched the
2536: entire regular expression. This is the value returned by pcre_exec() if
2537: it is greater than zero. If pcre_exec() returned zero, indicating that
2538: it ran out of space in ovector, the value passed as stringcount should
2539: be the number of elements in the vector divided by three.
2540:
2541: The functions pcre_copy_substring() and pcre_get_substring() extract a
2542: single substring, whose number is given as stringnumber. A value of
2543: zero extracts the substring that matched the entire pattern, whereas
2544: higher values extract the captured substrings. For pcre_copy_sub-
2545: string(), the string is placed in buffer, whose length is given by
2546: buffersize, while for pcre_get_substring() a new block of memory is
2547: obtained via pcre_malloc, and its address is returned via stringptr.
2548: The yield of the function is the length of the string, not including
2549: the terminating zero, or one of these error codes:
2550:
2551: PCRE_ERROR_NOMEMORY (-6)
2552:
2553: The buffer was too small for pcre_copy_substring(), or the attempt to
2554: get memory failed for pcre_get_substring().
2555:
2556: PCRE_ERROR_NOSUBSTRING (-7)
2557:
2558: There is no substring whose number is stringnumber.
2559:
2560: The pcre_get_substring_list() function extracts all available sub-
2561: strings and builds a list of pointers to them. All this is done in a
2562: single block of memory that is obtained via pcre_malloc. The address of
2563: the memory block is returned via listptr, which is also the start of
2564: the list of string pointers. The end of the list is marked by a NULL
2565: pointer. The yield of the function is zero if all went well, or the
2566: error code
2567:
2568: PCRE_ERROR_NOMEMORY (-6)
2569:
2570: if the attempt to get the memory block failed.
2571:
2572: When any of these functions encounter a substring that is unset, which
2573: can happen when capturing subpattern number n+1 matches some part of
2574: the subject, but subpattern n has not been used at all, they return an
2575: empty string. This can be distinguished from a genuine zero-length sub-
2576: string by inspecting the appropriate offset in ovector, which is nega-
2577: tive for unset substrings.
2578:
2579: The two convenience functions pcre_free_substring() and pcre_free_sub-
2580: string_list() can be used to free the memory returned by a previous
2581: call of pcre_get_substring() or pcre_get_substring_list(), respec-
2582: tively. They do nothing more than call the function pointed to by
2583: pcre_free, which of course could be called directly from a C program.
2584: However, PCRE is used in some situations where it is linked via a spe-
2585: cial interface to another programming language that cannot use
2586: pcre_free directly; it is for these cases that the functions are pro-
2587: vided.
2588:
2589:
2590: EXTRACTING CAPTURED SUBSTRINGS BY NAME
2591:
2592: int pcre_get_stringnumber(const pcre *code,
2593: const char *name);
2594:
2595: int pcre_copy_named_substring(const pcre *code,
2596: const char *subject, int *ovector,
2597: int stringcount, const char *stringname,
2598: char *buffer, int buffersize);
2599:
2600: int pcre_get_named_substring(const pcre *code,
2601: const char *subject, int *ovector,
2602: int stringcount, const char *stringname,
2603: const char **stringptr);
2604:
2605: To extract a substring by name, you first have to find associated num-
2606: ber. For example, for this pattern
2607:
2608: (a+)b(?<xxx>\d+)...
2609:
2610: the number of the subpattern called "xxx" is 2. If the name is known to
2611: be unique (PCRE_DUPNAMES was not set), you can find the number from the
2612: name by calling pcre_get_stringnumber(). The first argument is the com-
2613: piled pattern, and the second is the name. The yield of the function is
2614: the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if there is no
2615: subpattern of that name.
2616:
2617: Given the number, you can extract the substring directly, or use one of
2618: the functions described in the previous section. For convenience, there
2619: are also two functions that do the whole job.
2620:
2621: Most of the arguments of pcre_copy_named_substring() and
2622: pcre_get_named_substring() are the same as those for the similarly
2623: named functions that extract by number. As these are described in the
2624: previous section, they are not re-described here. There are just two
2625: differences:
2626:
2627: First, instead of a substring number, a substring name is given. Sec-
2628: ond, there is an extra argument, given at the start, which is a pointer
2629: to the compiled pattern. This is needed in order to gain access to the
2630: name-to-number translation table.
2631:
2632: These functions call pcre_get_stringnumber(), and if it succeeds, they
2633: then call pcre_copy_substring() or pcre_get_substring(), as appropri-
2634: ate. NOTE: If PCRE_DUPNAMES is set and there are duplicate names, the
2635: behaviour may not be what you want (see the next section).
2636:
2637: Warning: If the pattern uses the (?| feature to set up multiple subpat-
2638: terns with the same number, as described in the section on duplicate
2639: subpattern numbers in the pcrepattern page, you cannot use names to
2640: distinguish the different subpatterns, because names are not included
2641: in the compiled code. The matching process uses only numbers. For this
2642: reason, the use of different names for subpatterns of the same number
2643: causes an error at compile time.
2644:
2645:
2646: DUPLICATE SUBPATTERN NAMES
2647:
2648: int pcre_get_stringtable_entries(const pcre *code,
2649: const char *name, char **first, char **last);
2650:
2651: When a pattern is compiled with the PCRE_DUPNAMES option, names for
2652: subpatterns are not required to be unique. (Duplicate names are always
2653: allowed for subpatterns with the same number, created by using the (?|
2654: feature. Indeed, if such subpatterns are named, they are required to
2655: use the same names.)
2656:
2657: Normally, patterns with duplicate names are such that in any one match,
2658: only one of the named subpatterns participates. An example is shown in
2659: the pcrepattern documentation.
2660:
2661: When duplicates are present, pcre_copy_named_substring() and
2662: pcre_get_named_substring() return the first substring corresponding to
2663: the given name that is set. If none are set, PCRE_ERROR_NOSUBSTRING
2664: (-7) is returned; no data is returned. The pcre_get_stringnumber()
2665: function returns one of the numbers that are associated with the name,
2666: but it is not defined which it is.
2667:
2668: If you want to get full details of all captured substrings for a given
2669: name, you must use the pcre_get_stringtable_entries() function. The
2670: first argument is the compiled pattern, and the second is the name. The
2671: third and fourth are pointers to variables which are updated by the
2672: function. After it has run, they point to the first and last entries in
2673: the name-to-number table for the given name. The function itself
2674: returns the length of each entry, or PCRE_ERROR_NOSUBSTRING (-7) if
2675: there are none. The format of the table is described above in the sec-
2676: tion entitled Information about a pattern. Given all the relevant
2677: entries for the name, you can extract each of their numbers, and hence
2678: the captured data, if any.
2679:
2680:
2681: FINDING ALL POSSIBLE MATCHES
2682:
2683: The traditional matching function uses a similar algorithm to Perl,
2684: which stops when it finds the first match, starting at a given point in
2685: the subject. If you want to find all possible matches, or the longest
2686: possible match, consider using the alternative matching function (see
2687: below) instead. If you cannot use the alternative function, but still
2688: need to find all possible matches, you can kludge it up by making use
2689: of the callout facility, which is described in the pcrecallout documen-
2690: tation.
2691:
2692: What you have to do is to insert a callout right at the end of the pat-
2693: tern. When your callout function is called, extract and save the cur-
2694: rent matched substring. Then return 1, which forces pcre_exec() to
2695: backtrack and try other alternatives. Ultimately, when it runs out of
2696: matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
2697:
2698:
2699: MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
2700:
2701: int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
2702: const char *subject, int length, int startoffset,
2703: int options, int *ovector, int ovecsize,
2704: int *workspace, int wscount);
2705:
2706: The function pcre_dfa_exec() is called to match a subject string
2707: against a compiled pattern, using a matching algorithm that scans the
2708: subject string just once, and does not backtrack. This has different
2709: characteristics to the normal algorithm, and is not compatible with
2710: Perl. Some of the features of PCRE patterns are not supported. Never-
2711: theless, there are times when this kind of matching can be useful. For
2712: a discussion of the two matching algorithms, and a list of features
2713: that pcre_dfa_exec() does not support, see the pcrematching documenta-
2714: tion.
2715:
2716: The arguments for the pcre_dfa_exec() function are the same as for
2717: pcre_exec(), plus two extras. The ovector argument is used in a differ-
2718: ent way, and this is described below. The other common arguments are
2719: used in the same way as for pcre_exec(), so their description is not
2720: repeated here.
2721:
2722: The two additional arguments provide workspace for the function. The
2723: workspace vector should contain at least 20 elements. It is used for
2724: keeping track of multiple paths through the pattern tree. More
2725: workspace will be needed for patterns and subjects where there are a
2726: lot of potential matches.
2727:
2728: Here is an example of a simple call to pcre_dfa_exec():
2729:
2730: int rc;
2731: int ovector[10];
2732: int wspace[20];
2733: rc = pcre_dfa_exec(
2734: re, /* result of pcre_compile() */
2735: NULL, /* we didn't study the pattern */
2736: "some string", /* the subject string */
2737: 11, /* the length of the subject string */
2738: 0, /* start at offset 0 in the subject */
2739: 0, /* default options */
2740: ovector, /* vector of integers for substring information */
2741: 10, /* number of elements (NOT size in bytes) */
2742: wspace, /* working space vector */
2743: 20); /* number of elements (NOT size in bytes) */
2744:
2745: Option bits for pcre_dfa_exec()
2746:
2747: The unused bits of the options argument for pcre_dfa_exec() must be
2748: zero. The only bits that may be set are PCRE_ANCHORED, PCRE_NEW-
2749: LINE_xxx, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY,
2750: PCRE_NOTEMPTY_ATSTART, PCRE_NO_UTF8_CHECK, PCRE_BSR_ANYCRLF,
2751: PCRE_BSR_UNICODE, PCRE_NO_START_OPTIMIZE, PCRE_PARTIAL_HARD, PCRE_PAR-
2752: TIAL_SOFT, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART. All but the last
2753: four of these are exactly the same as for pcre_exec(), so their
2754: description is not repeated here.
2755:
2756: PCRE_PARTIAL_HARD
2757: PCRE_PARTIAL_SOFT
2758:
2759: These have the same general effect as they do for pcre_exec(), but the
2760: details are slightly different. When PCRE_PARTIAL_HARD is set for
2761: pcre_dfa_exec(), it returns PCRE_ERROR_PARTIAL if the end of the sub-
2762: ject is reached and there is still at least one matching possibility
2763: that requires additional characters. This happens even if some complete
2764: matches have also been found. When PCRE_PARTIAL_SOFT is set, the return
2765: code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if the end
2766: of the subject is reached, there have been no complete matches, but
2767: there is still at least one matching possibility. The portion of the
2768: string that was inspected when the longest partial match was found is
2769: set as the first matching string in both cases. There is a more
2770: detailed discussion of partial and multi-segment matching, with exam-
2771: ples, in the pcrepartial documentation.
2772:
2773: PCRE_DFA_SHORTEST
2774:
2775: Setting the PCRE_DFA_SHORTEST option causes the matching algorithm to
2776: stop as soon as it has found one match. Because of the way the alterna-
2777: tive algorithm works, this is necessarily the shortest possible match
2778: at the first possible matching point in the subject string.
2779:
2780: PCRE_DFA_RESTART
2781:
2782: When pcre_dfa_exec() returns a partial match, it is possible to call it
2783: again, with additional subject characters, and have it continue with
2784: the same match. The PCRE_DFA_RESTART option requests this action; when
2785: it is set, the workspace and wscount options must reference the same
2786: vector as before because data about the match so far is left in them
2787: after a partial match. There is more discussion of this facility in the
2788: pcrepartial documentation.
2789:
2790: Successful returns from pcre_dfa_exec()
2791:
2792: When pcre_dfa_exec() succeeds, it may have matched more than one sub-
2793: string in the subject. Note, however, that all the matches from one run
2794: of the function start at the same point in the subject. The shorter
2795: matches are all initial substrings of the longer matches. For example,
2796: if the pattern
2797:
2798: <.*>
2799:
2800: is matched against the string
2801:
2802: This is <something> <something else> <something further> no more
2803:
2804: the three matched strings are
2805:
2806: <something>
2807: <something> <something else>
2808: <something> <something else> <something further>
2809:
2810: On success, the yield of the function is a number greater than zero,
2811: which is the number of matched substrings. The substrings themselves
2812: are returned in ovector. Each string uses two elements; the first is
2813: the offset to the start, and the second is the offset to the end. In
2814: fact, all the strings have the same start offset. (Space could have
2815: been saved by giving this only once, but it was decided to retain some
2816: compatibility with the way pcre_exec() returns data, even though the
2817: meaning of the strings is different.)
2818:
2819: The strings are returned in reverse order of length; that is, the long-
2820: est matching string is given first. If there were too many matches to
2821: fit into ovector, the yield of the function is zero, and the vector is
2822: filled with the longest matches.
2823:
2824: Error returns from pcre_dfa_exec()
2825:
2826: The pcre_dfa_exec() function returns a negative number when it fails.
2827: Many of the errors are the same as for pcre_exec(), and these are
2828: described above. There are in addition the following errors that are
2829: specific to pcre_dfa_exec():
2830:
2831: PCRE_ERROR_DFA_UITEM (-16)
2832:
2833: This return is given if pcre_dfa_exec() encounters an item in the pat-
2834: tern that it does not support, for instance, the use of \C or a back
2835: reference.
2836:
2837: PCRE_ERROR_DFA_UCOND (-17)
2838:
2839: This return is given if pcre_dfa_exec() encounters a condition item
2840: that uses a back reference for the condition, or a test for recursion
2841: in a specific group. These are not supported.
2842:
2843: PCRE_ERROR_DFA_UMLIMIT (-18)
2844:
2845: This return is given if pcre_dfa_exec() is called with an extra block
2846: that contains a setting of the match_limit field. This is not supported
2847: (it is meaningless).
2848:
2849: PCRE_ERROR_DFA_WSSIZE (-19)
2850:
2851: This return is given if pcre_dfa_exec() runs out of space in the
2852: workspace vector.
2853:
2854: PCRE_ERROR_DFA_RECURSE (-20)
2855:
2856: When a recursive subpattern is processed, the matching function calls
2857: itself recursively, using private vectors for ovector and workspace.
2858: This error is given if the output vector is not large enough. This
2859: should be extremely rare, as a vector of size 1000 is used.
2860:
2861:
2862: SEE ALSO
2863:
2864: pcrebuild(3), pcrecallout(3), pcrecpp(3)(3), pcrematching(3), pcrepar-
2865: tial(3), pcreposix(3), pcreprecompile(3), pcresample(3), pcrestack(3).
2866:
2867:
2868: AUTHOR
2869:
2870: Philip Hazel
2871: University Computing Service
2872: Cambridge CB2 3QH, England.
2873:
2874:
2875: REVISION
2876:
2877: Last updated: 21 November 2010
2878: Copyright (c) 1997-2010 University of Cambridge.
2879: ------------------------------------------------------------------------------
2880:
2881:
2882: PCRECALLOUT(3) PCRECALLOUT(3)
2883:
2884:
2885: NAME
2886: PCRE - Perl-compatible regular expressions
2887:
2888:
2889: PCRE CALLOUTS
2890:
2891: int (*pcre_callout)(pcre_callout_block *);
2892:
2893: PCRE provides a feature called "callout", which is a means of temporar-
2894: ily passing control to the caller of PCRE in the middle of pattern
2895: matching. The caller of PCRE provides an external function by putting
2896: its entry point in the global variable pcre_callout. By default, this
2897: variable contains NULL, which disables all calling out.
2898:
2899: Within a regular expression, (?C) indicates the points at which the
2900: external function is to be called. Different callout points can be
2901: identified by putting a number less than 256 after the letter C. The
2902: default value is zero. For example, this pattern has two callout
2903: points:
2904:
2905: (?C1)abc(?C2)def
2906:
2907: If the PCRE_AUTO_CALLOUT option bit is set when pcre_compile() or
2908: pcre_compile2() is called, PCRE automatically inserts callouts, all
2909: with number 255, before each item in the pattern. For example, if
2910: PCRE_AUTO_CALLOUT is used with the pattern
2911:
2912: A(\d{2}|--)
2913:
2914: it is processed as if it were
2915:
2916: (?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
2917:
2918: Notice that there is a callout before and after each parenthesis and
2919: alternation bar. Automatic callouts can be used for tracking the
2920: progress of pattern matching. The pcretest command has an option that
2921: sets automatic callouts; when it is used, the output indicates how the
2922: pattern is matched. This is useful information when you are trying to
2923: optimize the performance of a particular pattern.
2924:
2925:
2926: MISSING CALLOUTS
2927:
2928: You should be aware that, because of optimizations in the way PCRE
2929: matches patterns by default, callouts sometimes do not happen. For
2930: example, if the pattern is
2931:
2932: ab(?C4)cd
2933:
2934: PCRE knows that any matching string must contain the letter "d". If the
2935: subject string is "abyz", the lack of "d" means that matching doesn't
2936: ever start, and the callout is never reached. However, with "abyd",
2937: though the result is still no match, the callout is obeyed.
2938:
2939: If the pattern is studied, PCRE knows the minimum length of a matching
2940: string, and will immediately give a "no match" return without actually
2941: running a match if the subject is not long enough, or, for unanchored
2942: patterns, if it has been scanned far enough.
2943:
2944: You can disable these optimizations by passing the PCRE_NO_START_OPTI-
2945: MIZE option to pcre_compile(), pcre_exec(), or pcre_dfa_exec(), or by
2946: starting the pattern with (*NO_START_OPT). This slows down the matching
2947: process, but does ensure that callouts such as the example above are
2948: obeyed.
2949:
2950:
2951: THE CALLOUT INTERFACE
2952:
2953: During matching, when PCRE reaches a callout point, the external func-
2954: tion defined by pcre_callout is called (if it is set). This applies to
2955: both the pcre_exec() and the pcre_dfa_exec() matching functions. The
2956: only argument to the callout function is a pointer to a pcre_callout
2957: block. This structure contains the following fields:
2958:
2959: int version;
2960: int callout_number;
2961: int *offset_vector;
2962: const char *subject;
2963: int subject_length;
2964: int start_match;
2965: int current_position;
2966: int capture_top;
2967: int capture_last;
2968: void *callout_data;
2969: int pattern_position;
2970: int next_item_length;
2971:
2972: The version field is an integer containing the version number of the
2973: block format. The initial version was 0; the current version is 1. The
2974: version number will change again in future if additional fields are
2975: added, but the intention is never to remove any of the existing fields.
2976:
2977: The callout_number field contains the number of the callout, as com-
2978: piled into the pattern (that is, the number after ?C for manual call-
2979: outs, and 255 for automatically generated callouts).
2980:
2981: The offset_vector field is a pointer to the vector of offsets that was
2982: passed by the caller to pcre_exec() or pcre_dfa_exec(). When
2983: pcre_exec() is used, the contents can be inspected in order to extract
2984: substrings that have been matched so far, in the same way as for
2985: extracting substrings after a match has completed. For pcre_dfa_exec()
2986: this field is not useful.
2987:
2988: The subject and subject_length fields contain copies of the values that
2989: were passed to pcre_exec().
2990:
2991: The start_match field normally contains the offset within the subject
2992: at which the current match attempt started. However, if the escape
2993: sequence \K has been encountered, this value is changed to reflect the
2994: modified starting point. If the pattern is not anchored, the callout
2995: function may be called several times from the same point in the pattern
2996: for different starting points in the subject.
2997:
2998: The current_position field contains the offset within the subject of
2999: the current match pointer.
3000:
3001: When the pcre_exec() function is used, the capture_top field contains
3002: one more than the number of the highest numbered captured substring so
3003: far. If no substrings have been captured, the value of capture_top is
3004: one. This is always the case when pcre_dfa_exec() is used, because it
3005: does not support captured substrings.
3006:
3007: The capture_last field contains the number of the most recently cap-
3008: tured substring. If no substrings have been captured, its value is -1.
3009: This is always the case when pcre_dfa_exec() is used.
3010:
3011: The callout_data field contains a value that is passed to pcre_exec()
3012: or pcre_dfa_exec() specifically so that it can be passed back in call-
3013: outs. It is passed in the pcre_callout field of the pcre_extra data
3014: structure. If no such data was passed, the value of callout_data in a
3015: pcre_callout block is NULL. There is a description of the pcre_extra
3016: structure in the pcreapi documentation.
3017:
3018: The pattern_position field is present from version 1 of the pcre_call-
3019: out structure. It contains the offset to the next item to be matched in
3020: the pattern string.
3021:
3022: The next_item_length field is present from version 1 of the pcre_call-
3023: out structure. It contains the length of the next item to be matched in
3024: the pattern string. When the callout immediately precedes an alterna-
3025: tion bar, a closing parenthesis, or the end of the pattern, the length
3026: is zero. When the callout precedes an opening parenthesis, the length
3027: is that of the entire subpattern.
3028:
3029: The pattern_position and next_item_length fields are intended to help
3030: in distinguishing between different automatic callouts, which all have
3031: the same callout number. However, they are set for all callouts.
3032:
3033:
3034: RETURN VALUES
3035:
3036: The external callout function returns an integer to PCRE. If the value
3037: is zero, matching proceeds as normal. If the value is greater than
3038: zero, matching fails at the current point, but the testing of other
3039: matching possibilities goes ahead, just as if a lookahead assertion had
3040: failed. If the value is less than zero, the match is abandoned, and
3041: pcre_exec() or pcre_dfa_exec() returns the negative value.
3042:
3043: Negative values should normally be chosen from the set of
3044: PCRE_ERROR_xxx values. In particular, PCRE_ERROR_NOMATCH forces a stan-
3045: dard "no match" failure. The error number PCRE_ERROR_CALLOUT is
3046: reserved for use by callout functions; it will never be used by PCRE
3047: itself.
3048:
3049:
3050: AUTHOR
3051:
3052: Philip Hazel
3053: University Computing Service
3054: Cambridge CB2 3QH, England.
3055:
3056:
3057: REVISION
3058:
3059: Last updated: 21 November 2010
3060: Copyright (c) 1997-2010 University of Cambridge.
3061: ------------------------------------------------------------------------------
3062:
3063:
3064: PCRECOMPAT(3) PCRECOMPAT(3)
3065:
3066:
3067: NAME
3068: PCRE - Perl-compatible regular expressions
3069:
3070:
3071: DIFFERENCES BETWEEN PCRE AND PERL
3072:
3073: This document describes the differences in the ways that PCRE and Perl
3074: handle regular expressions. The differences described here are with
3075: respect to Perl versions 5.10 and above.
3076:
3077: 1. PCRE has only a subset of Perl's UTF-8 and Unicode support. Details
3078: of what it does have are given in the section on UTF-8 support in the
3079: main pcre page.
3080:
3081: 2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl
3082: permits them, but they do not mean what you might think. For example,
3083: (?!a){3} does not assert that the next three characters are not "a". It
3084: just asserts that the next character is not "a" three times.
3085:
3086: 3. Capturing subpatterns that occur inside negative lookahead asser-
3087: tions are counted, but their entries in the offsets vector are never
3088: set. Perl sets its numerical variables from any such patterns that are
3089: matched before the assertion fails to match something (thereby succeed-
3090: ing), but only if the negative lookahead assertion contains just one
3091: branch.
3092:
3093: 4. Though binary zero characters are supported in the subject string,
3094: they are not allowed in a pattern string because it is passed as a nor-
3095: mal C string, terminated by zero. The escape sequence \0 can be used in
3096: the pattern to represent a binary zero.
3097:
3098: 5. The following Perl escape sequences are not supported: \l, \u, \L,
3099: \U, and \N. In fact these are implemented by Perl's general string-han-
3100: dling and are not part of its pattern matching engine. If any of these
3101: are encountered by PCRE, an error is generated.
3102:
3103: 6. The Perl escape sequences \p, \P, and \X are supported only if PCRE
3104: is built with Unicode character property support. The properties that
3105: can be tested with \p and \P are limited to the general category prop-
3106: erties such as Lu and Nd, script names such as Greek or Han, and the
3107: derived properties Any and L&. PCRE does support the Cs (surrogate)
3108: property, which Perl does not; the Perl documentation says "Because
3109: Perl hides the need for the user to understand the internal representa-
3110: tion of Unicode characters, there is no need to implement the somewhat
3111: messy concept of surrogates."
3112:
3113: 7. PCRE does support the \Q...\E escape for quoting substrings. Charac-
3114: ters in between are treated as literals. This is slightly different
3115: from Perl in that $ and @ are also handled as literals inside the
3116: quotes. In Perl, they cause variable interpolation (but of course PCRE
3117: does not have variables). Note the following examples:
3118:
3119: Pattern PCRE matches Perl matches
3120:
3121: \Qabc$xyz\E abc$xyz abc followed by the
3122: contents of $xyz
3123: \Qabc\$xyz\E abc\$xyz abc\$xyz
3124: \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
3125:
3126: The \Q...\E sequence is recognized both inside and outside character
3127: classes.
3128:
3129: 8. Fairly obviously, PCRE does not support the (?{code}) and (??{code})
3130: constructions. However, there is support for recursive patterns. This
3131: is not available in Perl 5.8, but it is in Perl 5.10. Also, the PCRE
3132: "callout" feature allows an external function to be called during pat-
3133: tern matching. See the pcrecallout documentation for details.
3134:
3135: 9. Subpatterns that are called recursively or as "subroutines" are
3136: always treated as atomic groups in PCRE. This is like Python, but
3137: unlike Perl. There is a discussion of an example that explains this in
3138: more detail in the section on recursion differences from Perl in the
3139: pcrepattern page.
3140:
3141: 10. There are some differences that are concerned with the settings of
3142: captured strings when part of a pattern is repeated. For example,
3143: matching "aba" against the pattern /^(a(b)?)+$/ in Perl leaves $2
3144: unset, but in PCRE it is set to "b".
3145:
3146: 11. PCRE's handling of duplicate subpattern numbers and duplicate sub-
3147: pattern names is not as general as Perl's. This is a consequence of the
3148: fact the PCRE works internally just with numbers, using an external ta-
3149: ble to translate between numbers and names. In particular, a pattern
3150: such as (?|(?<a>A)|(?<b)B), where the two capturing parentheses have
3151: the same number but different names, is not supported, and causes an
3152: error at compile time. If it were allowed, it would not be possible to
3153: distinguish which parentheses matched, because both names map to cap-
3154: turing subpattern number 1. To avoid this confusing situation, an error
3155: is given at compile time.
3156:
3157: 12. Perl recognizes comments in some places that PCRE doesn't, for
3158: example, between the ( and ? at the start of a subpattern.
3159:
3160: 13. PCRE provides some extensions to the Perl regular expression facil-
3161: ities. Perl 5.10 includes new features that are not in earlier ver-
3162: sions of Perl, some of which (such as named parentheses) have been in
3163: PCRE for some time. This list is with respect to Perl 5.10:
3164:
3165: (a) Although lookbehind assertions in PCRE must match fixed length
3166: strings, each alternative branch of a lookbehind assertion can match a
3167: different length of string. Perl requires them all to have the same
3168: length.
3169:
3170: (b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
3171: meta-character matches only at the very end of the string.
3172:
3173: (c) If PCRE_EXTRA is set, a backslash followed by a letter with no spe-
3174: cial meaning is faulted. Otherwise, like Perl, the backslash is quietly
3175: ignored. (Perl can be made to issue a warning.)
3176:
3177: (d) If PCRE_UNGREEDY is set, the greediness of the repetition quanti-
3178: fiers is inverted, that is, by default they are not greedy, but if fol-
3179: lowed by a question mark they are.
3180:
3181: (e) PCRE_ANCHORED can be used at matching time to force a pattern to be
3182: tried only at the first matching position in the subject string.
3183:
3184: (f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART,
3185: and PCRE_NO_AUTO_CAPTURE options for pcre_exec() have no Perl equiva-
3186: lents.
3187:
3188: (g) The \R escape sequence can be restricted to match only CR, LF, or
3189: CRLF by the PCRE_BSR_ANYCRLF option.
3190:
3191: (h) The callout facility is PCRE-specific.
3192:
3193: (i) The partial matching facility is PCRE-specific.
3194:
3195: (j) Patterns compiled by PCRE can be saved and re-used at a later time,
3196: even on different hosts that have the other endianness.
3197:
3198: (k) The alternative matching function (pcre_dfa_exec()) matches in a
3199: different way and is not Perl-compatible.
3200:
3201: (l) PCRE recognizes some special sequences such as (*CR) at the start
3202: of a pattern that set overall options that cannot be changed within the
3203: pattern.
3204:
3205:
3206: AUTHOR
3207:
3208: Philip Hazel
3209: University Computing Service
3210: Cambridge CB2 3QH, England.
3211:
3212:
3213: REVISION
3214:
3215: Last updated: 31 October 2010
3216: Copyright (c) 1997-2010 University of Cambridge.
3217: ------------------------------------------------------------------------------
3218:
3219:
3220: PCREPATTERN(3) PCREPATTERN(3)
3221:
3222:
3223: NAME
3224: PCRE - Perl-compatible regular expressions
3225:
3226:
3227: PCRE REGULAR EXPRESSION DETAILS
3228:
3229: The syntax and semantics of the regular expressions that are supported
3230: by PCRE are described in detail below. There is a quick-reference syn-
3231: tax summary in the pcresyntax page. PCRE tries to match Perl syntax and
3232: semantics as closely as it can. PCRE also supports some alternative
3233: regular expression syntax (which does not conflict with the Perl syn-
3234: tax) in order to provide some compatibility with regular expressions in
3235: Python, .NET, and Oniguruma.
3236:
3237: Perl's regular expressions are described in its own documentation, and
3238: regular expressions in general are covered in a number of books, some
3239: of which have copious examples. Jeffrey Friedl's "Mastering Regular
3240: Expressions", published by O'Reilly, covers regular expressions in
3241: great detail. This description of PCRE's regular expressions is
3242: intended as reference material.
3243:
3244: The original operation of PCRE was on strings of one-byte characters.
3245: However, there is now also support for UTF-8 character strings. To use
3246: this, PCRE must be built to include UTF-8 support, and you must call
3247: pcre_compile() or pcre_compile2() with the PCRE_UTF8 option. There is
3248: also a special sequence that can be given at the start of a pattern:
3249:
3250: (*UTF8)
3251:
3252: Starting a pattern with this sequence is equivalent to setting the
3253: PCRE_UTF8 option. This feature is not Perl-compatible. How setting
3254: UTF-8 mode affects pattern matching is mentioned in several places
3255: below. There is also a summary of UTF-8 features in the section on
3256: UTF-8 support in the main pcre page.
3257:
3258: Another special sequence that may appear at the start of a pattern or
3259: in combination with (*UTF8) is:
3260:
3261: (*UCP)
3262:
3263: This has the same effect as setting the PCRE_UCP option: it causes
3264: sequences such as \d and \w to use Unicode properties to determine
3265: character types, instead of recognizing only characters with codes less
3266: than 128 via a lookup table.
3267:
3268: If a pattern starts with (*NO_START_OPT), it has the same effect as
3269: setting the PCRE_NO_START_OPTIMIZE option either at compile or matching
3270: time. There are also some more of these special sequences that are con-
3271: cerned with the handling of newlines; they are described below.
3272:
3273: The remainder of this document discusses the patterns that are sup-
3274: ported by PCRE when its main matching function, pcre_exec(), is used.
3275: From release 6.0, PCRE offers a second matching function,
3276: pcre_dfa_exec(), which matches using a different algorithm that is not
3277: Perl-compatible. Some of the features discussed below are not available
3278: when pcre_dfa_exec() is used. The advantages and disadvantages of the
3279: alternative function, and how it differs from the normal function, are
3280: discussed in the pcrematching page.
3281:
3282:
3283: NEWLINE CONVENTIONS
3284:
3285: PCRE supports five different conventions for indicating line breaks in
3286: strings: a single CR (carriage return) character, a single LF (line-
3287: feed) character, the two-character sequence CRLF, any of the three pre-
3288: ceding, or any Unicode newline sequence. The pcreapi page has further
3289: discussion about newlines, and shows how to set the newline convention
3290: in the options arguments for the compiling and matching functions.
3291:
3292: It is also possible to specify a newline convention by starting a pat-
3293: tern string with one of the following five sequences:
3294:
3295: (*CR) carriage return
3296: (*LF) linefeed
3297: (*CRLF) carriage return, followed by linefeed
3298: (*ANYCRLF) any of the three above
3299: (*ANY) all Unicode newline sequences
3300:
3301: These override the default and the options given to pcre_compile() or
3302: pcre_compile2(). For example, on a Unix system where LF is the default
3303: newline sequence, the pattern
3304:
3305: (*CR)a.b
3306:
3307: changes the convention to CR. That pattern matches "a\nb" because LF is
3308: no longer a newline. Note that these special settings, which are not
3309: Perl-compatible, are recognized only at the very start of a pattern,
3310: and that they must be in upper case. If more than one of them is
3311: present, the last one is used.
3312:
3313: The newline convention affects the interpretation of the dot metachar-
3314: acter when PCRE_DOTALL is not set, and also the behaviour of \N. How-
3315: ever, it does not affect what the \R escape sequence matches. By
3316: default, this is any Unicode newline sequence, for Perl compatibility.
3317: However, this can be changed; see the description of \R in the section
3318: entitled "Newline sequences" below. A change of \R setting can be com-
3319: bined with a change of newline convention.
3320:
3321:
3322: CHARACTERS AND METACHARACTERS
3323:
3324: A regular expression is a pattern that is matched against a subject
3325: string from left to right. Most characters stand for themselves in a
3326: pattern, and match the corresponding characters in the subject. As a
3327: trivial example, the pattern
3328:
3329: The quick brown fox
3330:
3331: matches a portion of a subject string that is identical to itself. When
3332: caseless matching is specified (the PCRE_CASELESS option), letters are
3333: matched independently of case. In UTF-8 mode, PCRE always understands
3334: the concept of case for characters whose values are less than 128, so
3335: caseless matching is always possible. For characters with higher val-
3336: ues, the concept of case is supported if PCRE is compiled with Unicode
3337: property support, but not otherwise. If you want to use caseless
3338: matching for characters 128 and above, you must ensure that PCRE is
3339: compiled with Unicode property support as well as with UTF-8 support.
3340:
3341: The power of regular expressions comes from the ability to include
3342: alternatives and repetitions in the pattern. These are encoded in the
3343: pattern by the use of metacharacters, which do not stand for themselves
3344: but instead are interpreted in some special way.
3345:
3346: There are two different sets of metacharacters: those that are recog-
3347: nized anywhere in the pattern except within square brackets, and those
3348: that are recognized within square brackets. Outside square brackets,
3349: the metacharacters are as follows:
3350:
3351: \ general escape character with several uses
3352: ^ assert start of string (or line, in multiline mode)
3353: $ assert end of string (or line, in multiline mode)
3354: . match any character except newline (by default)
3355: [ start character class definition
3356: | start of alternative branch
3357: ( start subpattern
3358: ) end subpattern
3359: ? extends the meaning of (
3360: also 0 or 1 quantifier
3361: also quantifier minimizer
3362: * 0 or more quantifier
3363: + 1 or more quantifier
3364: also "possessive quantifier"
3365: { start min/max quantifier
3366:
3367: Part of a pattern that is in square brackets is called a "character
3368: class". In a character class the only metacharacters are:
3369:
3370: \ general escape character
3371: ^ negate the class, but only if the first character
3372: - indicates character range
3373: [ POSIX character class (only if followed by POSIX
3374: syntax)
3375: ] terminates the character class
3376:
3377: The following sections describe the use of each of the metacharacters.
3378:
3379:
3380: BACKSLASH
3381:
3382: The backslash character has several uses. Firstly, if it is followed by
3383: a character that is not a number or a letter, it takes away any special
3384: meaning that character may have. This use of backslash as an escape
3385: character applies both inside and outside character classes.
3386:
3387: For example, if you want to match a * character, you write \* in the
3388: pattern. This escaping action applies whether or not the following
3389: character would otherwise be interpreted as a metacharacter, so it is
3390: always safe to precede a non-alphanumeric with backslash to specify
3391: that it stands for itself. In particular, if you want to match a back-
3392: slash, you write \\.
3393:
3394: In UTF-8 mode, only ASCII numbers and letters have any special meaning
3395: after a backslash. All other characters (in particular, those whose
3396: codepoints are greater than 127) are treated as literals.
3397:
3398: If a pattern is compiled with the PCRE_EXTENDED option, whitespace in
3399: the pattern (other than in a character class) and characters between a
3400: # outside a character class and the next newline are ignored. An escap-
3401: ing backslash can be used to include a whitespace or # character as
3402: part of the pattern.
3403:
3404: If you want to remove the special meaning from a sequence of charac-
3405: ters, you can do so by putting them between \Q and \E. This is differ-
3406: ent from Perl in that $ and @ are handled as literals in \Q...\E
3407: sequences in PCRE, whereas in Perl, $ and @ cause variable interpola-
3408: tion. Note the following examples:
3409:
3410: Pattern PCRE matches Perl matches
3411:
3412: \Qabc$xyz\E abc$xyz abc followed by the
3413: contents of $xyz
3414: \Qabc\$xyz\E abc\$xyz abc\$xyz
3415: \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
3416:
3417: The \Q...\E sequence is recognized both inside and outside character
3418: classes. An isolated \E that is not preceded by \Q is ignored.
3419:
3420: Non-printing characters
3421:
3422: A second use of backslash provides a way of encoding non-printing char-
3423: acters in patterns in a visible manner. There is no restriction on the
3424: appearance of non-printing characters, apart from the binary zero that
3425: terminates a pattern, but when a pattern is being prepared by text
3426: editing, it is often easier to use one of the following escape
3427: sequences than the binary character it represents:
3428:
3429: \a alarm, that is, the BEL character (hex 07)
3430: \cx "control-x", where x is any ASCII character
3431: \e escape (hex 1B)
3432: \f formfeed (hex 0C)
3433: \n linefeed (hex 0A)
3434: \r carriage return (hex 0D)
3435: \t tab (hex 09)
3436: \ddd character with octal code ddd, or back reference
3437: \xhh character with hex code hh
3438: \x{hhh..} character with hex code hhh..
3439:
3440: The precise effect of \cx is as follows: if x is a lower case letter,
3441: it is converted to upper case. Then bit 6 of the character (hex 40) is
3442: inverted. Thus \cz becomes hex 1A (z is 7A), but \c{ becomes hex 3B ({
3443: is 7B), while \c; becomes hex 7B (; is 3B). If the byte following \c
3444: has a value greater than 127, a compile-time error occurs. This locks
3445: out non-ASCII characters in both byte mode and UTF-8 mode. (When PCRE
3446: is compiled in EBCDIC mode, all byte values are valid. A lower case
3447: letter is converted to upper case, and then the 0xc0 bits are flipped.)
3448:
3449: After \x, from zero to two hexadecimal digits are read (letters can be
3450: in upper or lower case). Any number of hexadecimal digits may appear
3451: between \x{ and }, but the value of the character code must be less
3452: than 256 in non-UTF-8 mode, and less than 2**31 in UTF-8 mode. That is,
3453: the maximum value in hexadecimal is 7FFFFFFF. Note that this is bigger
3454: than the largest Unicode code point, which is 10FFFF.
3455:
3456: If characters other than hexadecimal digits appear between \x{ and },
3457: or if there is no terminating }, this form of escape is not recognized.
3458: Instead, the initial \x will be interpreted as a basic hexadecimal
3459: escape, with no following digits, giving a character whose value is
3460: zero.
3461:
3462: Characters whose value is less than 256 can be defined by either of the
3463: two syntaxes for \x. There is no difference in the way they are han-
3464: dled. For example, \xdc is exactly the same as \x{dc}.
3465:
3466: After \0 up to two further octal digits are read. If there are fewer
3467: than two digits, just those that are present are used. Thus the
3468: sequence \0\x\07 specifies two binary zeros followed by a BEL character
3469: (code value 7). Make sure you supply two digits after the initial zero
3470: if the pattern character that follows is itself an octal digit.
3471:
3472: The handling of a backslash followed by a digit other than 0 is compli-
3473: cated. Outside a character class, PCRE reads it and any following dig-
3474: its as a decimal number. If the number is less than 10, or if there
3475: have been at least that many previous capturing left parentheses in the
3476: expression, the entire sequence is taken as a back reference. A
3477: description of how this works is given later, following the discussion
3478: of parenthesized subpatterns.
3479:
3480: Inside a character class, or if the decimal number is greater than 9
3481: and there have not been that many capturing subpatterns, PCRE re-reads
3482: up to three octal digits following the backslash, and uses them to gen-
3483: erate a data character. Any subsequent digits stand for themselves. In
3484: non-UTF-8 mode, the value of a character specified in octal must be
3485: less than \400. In UTF-8 mode, values up to \777 are permitted. For
3486: example:
3487:
3488: \040 is another way of writing a space
3489: \40 is the same, provided there are fewer than 40
3490: previous capturing subpatterns
3491: \7 is always a back reference
3492: \11 might be a back reference, or another way of
3493: writing a tab
3494: \011 is always a tab
3495: \0113 is a tab followed by the character "3"
3496: \113 might be a back reference, otherwise the
3497: character with octal code 113
3498: \377 might be a back reference, otherwise
3499: the byte consisting entirely of 1 bits
3500: \81 is either a back reference, or a binary zero
3501: followed by the two characters "8" and "1"
3502:
3503: Note that octal values of 100 or greater must not be introduced by a
3504: leading zero, because no more than three octal digits are ever read.
3505:
3506: All the sequences that define a single character value can be used both
3507: inside and outside character classes. In addition, inside a character
3508: class, the sequence \b is interpreted as the backspace character (hex
3509: 08). The sequences \B, \N, \R, and \X are not special inside a charac-
3510: ter class. Like any other unrecognized escape sequences, they are
3511: treated as the literal characters "B", "N", "R", and "X" by default,
3512: but cause an error if the PCRE_EXTRA option is set. Outside a character
3513: class, these sequences have different meanings.
3514:
3515: Absolute and relative back references
3516:
3517: The sequence \g followed by an unsigned or a negative number, option-
3518: ally enclosed in braces, is an absolute or relative back reference. A
3519: named back reference can be coded as \g{name}. Back references are dis-
3520: cussed later, following the discussion of parenthesized subpatterns.
3521:
3522: Absolute and relative subroutine calls
3523:
3524: For compatibility with Oniguruma, the non-Perl syntax \g followed by a
3525: name or a number enclosed either in angle brackets or single quotes, is
3526: an alternative syntax for referencing a subpattern as a "subroutine".
3527: Details are discussed later. Note that \g{...} (Perl syntax) and
3528: \g<...> (Oniguruma syntax) are not synonymous. The former is a back
3529: reference; the latter is a subroutine call.
3530:
3531: Generic character types
3532:
3533: Another use of backslash is for specifying generic character types:
3534:
3535: \d any decimal digit
3536: \D any character that is not a decimal digit
3537: \h any horizontal whitespace character
3538: \H any character that is not a horizontal whitespace character
3539: \s any whitespace character
3540: \S any character that is not a whitespace character
3541: \v any vertical whitespace character
3542: \V any character that is not a vertical whitespace character
3543: \w any "word" character
3544: \W any "non-word" character
3545:
3546: There is also the single sequence \N, which matches a non-newline char-
3547: acter. This is the same as the "." metacharacter when PCRE_DOTALL is
3548: not set.
3549:
3550: Each pair of lower and upper case escape sequences partitions the com-
3551: plete set of characters into two disjoint sets. Any given character
3552: matches one, and only one, of each pair. The sequences can appear both
3553: inside and outside character classes. They each match one character of
3554: the appropriate type. If the current matching point is at the end of
3555: the subject string, all of them fail, because there is no character to
3556: match.
3557:
3558: For compatibility with Perl, \s does not match the VT character (code
3559: 11). This makes it different from the the POSIX "space" class. The \s
3560: characters are HT (9), LF (10), FF (12), CR (13), and space (32). If
3561: "use locale;" is included in a Perl script, \s may match the VT charac-
3562: ter. In PCRE, it never does.
3563:
3564: A "word" character is an underscore or any character that is a letter
3565: or digit. By default, the definition of letters and digits is con-
3566: trolled by PCRE's low-valued character tables, and may vary if locale-
3567: specific matching is taking place (see "Locale support" in the pcreapi
3568: page). For example, in a French locale such as "fr_FR" in Unix-like
3569: systems, or "french" in Windows, some character codes greater than 128
3570: are used for accented letters, and these are then matched by \w. The
3571: use of locales with Unicode is discouraged.
3572:
3573: By default, in UTF-8 mode, characters with values greater than 128
3574: never match \d, \s, or \w, and always match \D, \S, and \W. These
3575: sequences retain their original meanings from before UTF-8 support was
3576: available, mainly for efficiency reasons. However, if PCRE is compiled
3577: with Unicode property support, and the PCRE_UCP option is set, the be-
3578: haviour is changed so that Unicode properties are used to determine
3579: character types, as follows:
3580:
3581: \d any character that \p{Nd} matches (decimal digit)
3582: \s any character that \p{Z} matches, plus HT, LF, FF, CR
3583: \w any character that \p{L} or \p{N} matches, plus underscore
3584:
3585: The upper case escapes match the inverse sets of characters. Note that
3586: \d matches only decimal digits, whereas \w matches any Unicode digit,
3587: as well as any Unicode letter, and underscore. Note also that PCRE_UCP
3588: affects \b, and \B because they are defined in terms of \w and \W.
3589: Matching these sequences is noticeably slower when PCRE_UCP is set.
3590:
3591: The sequences \h, \H, \v, and \V are features that were added to Perl
3592: at release 5.10. In contrast to the other sequences, which match only
3593: ASCII characters by default, these always match certain high-valued
3594: codepoints in UTF-8 mode, whether or not PCRE_UCP is set. The horizon-
3595: tal space characters are:
3596:
3597: U+0009 Horizontal tab
3598: U+0020 Space
3599: U+00A0 Non-break space
3600: U+1680 Ogham space mark
3601: U+180E Mongolian vowel separator
3602: U+2000 En quad
3603: U+2001 Em quad
3604: U+2002 En space
3605: U+2003 Em space
3606: U+2004 Three-per-em space
3607: U+2005 Four-per-em space
3608: U+2006 Six-per-em space
3609: U+2007 Figure space
3610: U+2008 Punctuation space
3611: U+2009 Thin space
3612: U+200A Hair space
3613: U+202F Narrow no-break space
3614: U+205F Medium mathematical space
3615: U+3000 Ideographic space
3616:
3617: The vertical space characters are:
3618:
3619: U+000A Linefeed
3620: U+000B Vertical tab
3621: U+000C Formfeed
3622: U+000D Carriage return
3623: U+0085 Next line
3624: U+2028 Line separator
3625: U+2029 Paragraph separator
3626:
3627: Newline sequences
3628:
3629: Outside a character class, by default, the escape sequence \R matches
3630: any Unicode newline sequence. In non-UTF-8 mode \R is equivalent to the
3631: following:
3632:
3633: (?>\r\n|\n|\x0b|\f|\r|\x85)
3634:
3635: This is an example of an "atomic group", details of which are given
3636: below. This particular group matches either the two-character sequence
3637: CR followed by LF, or one of the single characters LF (linefeed,
3638: U+000A), VT (vertical tab, U+000B), FF (formfeed, U+000C), CR (carriage
3639: return, U+000D), or NEL (next line, U+0085). The two-character sequence
3640: is treated as a single unit that cannot be split.
3641:
3642: In UTF-8 mode, two additional characters whose codepoints are greater
3643: than 255 are added: LS (line separator, U+2028) and PS (paragraph sepa-
3644: rator, U+2029). Unicode character property support is not needed for
3645: these characters to be recognized.
3646:
3647: It is possible to restrict \R to match only CR, LF, or CRLF (instead of
3648: the complete set of Unicode line endings) by setting the option
3649: PCRE_BSR_ANYCRLF either at compile time or when the pattern is matched.
3650: (BSR is an abbrevation for "backslash R".) This can be made the default
3651: when PCRE is built; if this is the case, the other behaviour can be
3652: requested via the PCRE_BSR_UNICODE option. It is also possible to
3653: specify these settings by starting a pattern string with one of the
3654: following sequences:
3655:
3656: (*BSR_ANYCRLF) CR, LF, or CRLF only
3657: (*BSR_UNICODE) any Unicode newline sequence
3658:
3659: These override the default and the options given to pcre_compile() or
3660: pcre_compile2(), but they can be overridden by options given to
3661: pcre_exec() or pcre_dfa_exec(). Note that these special settings, which
3662: are not Perl-compatible, are recognized only at the very start of a
3663: pattern, and that they must be in upper case. If more than one of them
3664: is present, the last one is used. They can be combined with a change of
3665: newline convention; for example, a pattern can start with:
3666:
3667: (*ANY)(*BSR_ANYCRLF)
3668:
3669: They can also be combined with the (*UTF8) or (*UCP) special sequences.
3670: Inside a character class, \R is treated as an unrecognized escape
3671: sequence, and so matches the letter "R" by default, but causes an error
3672: if PCRE_EXTRA is set.
3673:
3674: Unicode character properties
3675:
3676: When PCRE is built with Unicode character property support, three addi-
3677: tional escape sequences that match characters with specific properties
3678: are available. When not in UTF-8 mode, these sequences are of course
3679: limited to testing characters whose codepoints are less than 256, but
3680: they do work in this mode. The extra escape sequences are:
3681:
3682: \p{xx} a character with the xx property
3683: \P{xx} a character without the xx property
3684: \X an extended Unicode sequence
3685:
3686: The property names represented by xx above are limited to the Unicode
3687: script names, the general category properties, "Any", which matches any
3688: character (including newline), and some special PCRE properties
3689: (described in the next section). Other Perl properties such as "InMu-
3690: sicalSymbols" are not currently supported by PCRE. Note that \P{Any}
3691: does not match any characters, so always causes a match failure.
3692:
3693: Sets of Unicode characters are defined as belonging to certain scripts.
3694: A character from one of these sets can be matched using a script name.
3695: For example:
3696:
3697: \p{Greek}
3698: \P{Han}
3699:
3700: Those that are not part of an identified script are lumped together as
3701: "Common". The current list of scripts is:
3702:
3703: Arabic, Armenian, Avestan, Balinese, Bamum, Bengali, Bopomofo, Braille,
3704: Buginese, Buhid, Canadian_Aboriginal, Carian, Cham, Cherokee, Common,
3705: Coptic, Cuneiform, Cypriot, Cyrillic, Deseret, Devanagari, Egyp-
3706: tian_Hieroglyphs, Ethiopic, Georgian, Glagolitic, Gothic, Greek,
3707: Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew, Hiragana, Impe-
3708: rial_Aramaic, Inherited, Inscriptional_Pahlavi, Inscriptional_Parthian,
3709: Javanese, Kaithi, Kannada, Katakana, Kayah_Li, Kharoshthi, Khmer, Lao,
3710: Latin, Lepcha, Limbu, Linear_B, Lisu, Lycian, Lydian, Malayalam,
3711: Meetei_Mayek, Mongolian, Myanmar, New_Tai_Lue, Nko, Ogham, Old_Italic,
3712: Old_Persian, Old_South_Arabian, Old_Turkic, Ol_Chiki, Oriya, Osmanya,
3713: Phags_Pa, Phoenician, Rejang, Runic, Samaritan, Saurashtra, Shavian,
3714: Sinhala, Sundanese, Syloti_Nagri, Syriac, Tagalog, Tagbanwa, Tai_Le,
3715: Tai_Tham, Tai_Viet, Tamil, Telugu, Thaana, Thai, Tibetan, Tifinagh,
3716: Ugaritic, Vai, Yi.
3717:
3718: Each character has exactly one Unicode general category property, spec-
3719: ified by a two-letter abbreviation. For compatibility with Perl, nega-
3720: tion can be specified by including a circumflex between the opening
3721: brace and the property name. For example, \p{^Lu} is the same as
3722: \P{Lu}.
3723:
3724: If only one letter is specified with \p or \P, it includes all the gen-
3725: eral category properties that start with that letter. In this case, in
3726: the absence of negation, the curly brackets in the escape sequence are
3727: optional; these two examples have the same effect:
3728:
3729: \p{L}
3730: \pL
3731:
3732: The following general category property codes are supported:
3733:
3734: C Other
3735: Cc Control
3736: Cf Format
3737: Cn Unassigned
3738: Co Private use
3739: Cs Surrogate
3740:
3741: L Letter
3742: Ll Lower case letter
3743: Lm Modifier letter
3744: Lo Other letter
3745: Lt Title case letter
3746: Lu Upper case letter
3747:
3748: M Mark
3749: Mc Spacing mark
3750: Me Enclosing mark
3751: Mn Non-spacing mark
3752:
3753: N Number
3754: Nd Decimal number
3755: Nl Letter number
3756: No Other number
3757:
3758: P Punctuation
3759: Pc Connector punctuation
3760: Pd Dash punctuation
3761: Pe Close punctuation
3762: Pf Final punctuation
3763: Pi Initial punctuation
3764: Po Other punctuation
3765: Ps Open punctuation
3766:
3767: S Symbol
3768: Sc Currency symbol
3769: Sk Modifier symbol
3770: Sm Mathematical symbol
3771: So Other symbol
3772:
3773: Z Separator
3774: Zl Line separator
3775: Zp Paragraph separator
3776: Zs Space separator
3777:
3778: The special property L& is also supported: it matches a character that
3779: has the Lu, Ll, or Lt property, in other words, a letter that is not
3780: classified as a modifier or "other".
3781:
3782: The Cs (Surrogate) property applies only to characters in the range
3783: U+D800 to U+DFFF. Such characters are not valid in UTF-8 strings (see
3784: RFC 3629) and so cannot be tested by PCRE, unless UTF-8 validity check-
3785: ing has been turned off (see the discussion of PCRE_NO_UTF8_CHECK in
3786: the pcreapi page). Perl does not support the Cs property.
3787:
3788: The long synonyms for property names that Perl supports (such as
3789: \p{Letter}) are not supported by PCRE, nor is it permitted to prefix
3790: any of these properties with "Is".
3791:
3792: No character that is in the Unicode table has the Cn (unassigned) prop-
3793: erty. Instead, this property is assumed for any code point that is not
3794: in the Unicode table.
3795:
3796: Specifying caseless matching does not affect these escape sequences.
3797: For example, \p{Lu} always matches only upper case letters.
3798:
3799: The \X escape matches any number of Unicode characters that form an
3800: extended Unicode sequence. \X is equivalent to
3801:
3802: (?>\PM\pM*)
3803:
3804: That is, it matches a character without the "mark" property, followed
3805: by zero or more characters with the "mark" property, and treats the
3806: sequence as an atomic group (see below). Characters with the "mark"
3807: property are typically accents that affect the preceding character.
3808: None of them have codepoints less than 256, so in non-UTF-8 mode \X
3809: matches any one character.
3810:
3811: Matching characters by Unicode property is not fast, because PCRE has
3812: to search a structure that contains data for over fifteen thousand
3813: characters. That is why the traditional escape sequences such as \d and
3814: \w do not use Unicode properties in PCRE by default, though you can
3815: make them do so by setting the PCRE_UCP option for pcre_compile() or by
3816: starting the pattern with (*UCP).
3817:
3818: PCRE's additional properties
3819:
3820: As well as the standard Unicode properties described in the previous
3821: section, PCRE supports four more that make it possible to convert tra-
3822: ditional escape sequences such as \w and \s and POSIX character classes
3823: to use Unicode properties. PCRE uses these non-standard, non-Perl prop-
3824: erties internally when PCRE_UCP is set. They are:
3825:
3826: Xan Any alphanumeric character
3827: Xps Any POSIX space character
3828: Xsp Any Perl space character
3829: Xwd Any Perl "word" character
3830:
3831: Xan matches characters that have either the L (letter) or the N (num-
3832: ber) property. Xps matches the characters tab, linefeed, vertical tab,
3833: formfeed, or carriage return, and any other character that has the Z
3834: (separator) property. Xsp is the same as Xps, except that vertical tab
3835: is excluded. Xwd matches the same characters as Xan, plus underscore.
3836:
3837: Resetting the match start
3838:
3839: The escape sequence \K causes any previously matched characters not to
3840: be included in the final matched sequence. For example, the pattern:
3841:
3842: foo\Kbar
3843:
3844: matches "foobar", but reports that it has matched "bar". This feature
3845: is similar to a lookbehind assertion (described below). However, in
3846: this case, the part of the subject before the real match does not have
3847: to be of fixed length, as lookbehind assertions do. The use of \K does
3848: not interfere with the setting of captured substrings. For example,
3849: when the pattern
3850:
3851: (foo)\Kbar
3852:
3853: matches "foobar", the first substring is still set to "foo".
3854:
3855: Perl documents that the use of \K within assertions is "not well
3856: defined". In PCRE, \K is acted upon when it occurs inside positive
3857: assertions, but is ignored in negative assertions.
3858:
3859: Simple assertions
3860:
3861: The final use of backslash is for certain simple assertions. An asser-
3862: tion specifies a condition that has to be met at a particular point in
3863: a match, without consuming any characters from the subject string. The
3864: use of subpatterns for more complicated assertions is described below.
3865: The backslashed assertions are:
3866:
3867: \b matches at a word boundary
3868: \B matches when not at a word boundary
3869: \A matches at the start of the subject
3870: \Z matches at the end of the subject
3871: also matches before a newline at the end of the subject
3872: \z matches only at the end of the subject
3873: \G matches at the first matching position in the subject
3874:
3875: Inside a character class, \b has a different meaning; it matches the
3876: backspace character. If any other of these assertions appears in a
3877: character class, by default it matches the corresponding literal char-
3878: acter (for example, \B matches the letter B). However, if the
3879: PCRE_EXTRA option is set, an "invalid escape sequence" error is gener-
3880: ated instead.
3881:
3882: A word boundary is a position in the subject string where the current
3883: character and the previous character do not both match \w or \W (i.e.
3884: one matches \w and the other matches \W), or the start or end of the
3885: string if the first or last character matches \w, respectively. In
3886: UTF-8 mode, the meanings of \w and \W can be changed by setting the
3887: PCRE_UCP option. When this is done, it also affects \b and \B. Neither
3888: PCRE nor Perl has a separate "start of word" or "end of word" metase-
3889: quence. However, whatever follows \b normally determines which it is.
3890: For example, the fragment \ba matches "a" at the start of a word.
3891:
3892: The \A, \Z, and \z assertions differ from the traditional circumflex
3893: and dollar (described in the next section) in that they only ever match
3894: at the very start and end of the subject string, whatever options are
3895: set. Thus, they are independent of multiline mode. These three asser-
3896: tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
3897: affect only the behaviour of the circumflex and dollar metacharacters.
3898: However, if the startoffset argument of pcre_exec() is non-zero, indi-
3899: cating that matching is to start at a point other than the beginning of
3900: the subject, \A can never match. The difference between \Z and \z is
3901: that \Z matches before a newline at the end of the string as well as at
3902: the very end, whereas \z matches only at the end.
3903:
3904: The \G assertion is true only when the current matching position is at
3905: the start point of the match, as specified by the startoffset argument
3906: of pcre_exec(). It differs from \A when the value of startoffset is
3907: non-zero. By calling pcre_exec() multiple times with appropriate argu-
3908: ments, you can mimic Perl's /g option, and it is in this kind of imple-
3909: mentation where \G can be useful.
3910:
3911: Note, however, that PCRE's interpretation of \G, as the start of the
3912: current match, is subtly different from Perl's, which defines it as the
3913: end of the previous match. In Perl, these can be different when the
3914: previously matched string was empty. Because PCRE does just one match
3915: at a time, it cannot reproduce this behaviour.
3916:
3917: If all the alternatives of a pattern begin with \G, the expression is
3918: anchored to the starting match position, and the "anchored" flag is set
3919: in the compiled regular expression.
3920:
3921:
3922: CIRCUMFLEX AND DOLLAR
3923:
3924: Outside a character class, in the default matching mode, the circumflex
3925: character is an assertion that is true only if the current matching
3926: point is at the start of the subject string. If the startoffset argu-
3927: ment of pcre_exec() is non-zero, circumflex can never match if the
3928: PCRE_MULTILINE option is unset. Inside a character class, circumflex
3929: has an entirely different meaning (see below).
3930:
3931: Circumflex need not be the first character of the pattern if a number
3932: of alternatives are involved, but it should be the first thing in each
3933: alternative in which it appears if the pattern is ever to match that
3934: branch. If all possible alternatives start with a circumflex, that is,
3935: if the pattern is constrained to match only at the start of the sub-
3936: ject, it is said to be an "anchored" pattern. (There are also other
3937: constructs that can cause a pattern to be anchored.)
3938:
3939: A dollar character is an assertion that is true only if the current
3940: matching point is at the end of the subject string, or immediately
3941: before a newline at the end of the string (by default). Dollar need not
3942: be the last character of the pattern if a number of alternatives are
3943: involved, but it should be the last item in any branch in which it
3944: appears. Dollar has no special meaning in a character class.
3945:
3946: The meaning of dollar can be changed so that it matches only at the
3947: very end of the string, by setting the PCRE_DOLLAR_ENDONLY option at
3948: compile time. This does not affect the \Z assertion.
3949:
3950: The meanings of the circumflex and dollar characters are changed if the
3951: PCRE_MULTILINE option is set. When this is the case, a circumflex
3952: matches immediately after internal newlines as well as at the start of
3953: the subject string. It does not match after a newline that ends the
3954: string. A dollar matches before any newlines in the string, as well as
3955: at the very end, when PCRE_MULTILINE is set. When newline is specified
3956: as the two-character sequence CRLF, isolated CR and LF characters do
3957: not indicate newlines.
3958:
3959: For example, the pattern /^abc$/ matches the subject string "def\nabc"
3960: (where \n represents a newline) in multiline mode, but not otherwise.
3961: Consequently, patterns that are anchored in single line mode because
3962: all branches start with ^ are not anchored in multiline mode, and a
3963: match for circumflex is possible when the startoffset argument of
3964: pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if
3965: PCRE_MULTILINE is set.
3966:
3967: Note that the sequences \A, \Z, and \z can be used to match the start
3968: and end of the subject in both modes, and if all branches of a pattern
3969: start with \A it is always anchored, whether or not PCRE_MULTILINE is
3970: set.
3971:
3972:
3973: FULL STOP (PERIOD, DOT) AND \N
3974:
3975: Outside a character class, a dot in the pattern matches any one charac-
3976: ter in the subject string except (by default) a character that signi-
3977: fies the end of a line. In UTF-8 mode, the matched character may be
3978: more than one byte long.
3979:
3980: When a line ending is defined as a single character, dot never matches
3981: that character; when the two-character sequence CRLF is used, dot does
3982: not match CR if it is immediately followed by LF, but otherwise it
3983: matches all characters (including isolated CRs and LFs). When any Uni-
3984: code line endings are being recognized, dot does not match CR or LF or
3985: any of the other line ending characters.
3986:
3987: The behaviour of dot with regard to newlines can be changed. If the
3988: PCRE_DOTALL option is set, a dot matches any one character, without
3989: exception. If the two-character sequence CRLF is present in the subject
3990: string, it takes two dots to match it.
3991:
3992: The handling of dot is entirely independent of the handling of circum-
3993: flex and dollar, the only relationship being that they both involve
3994: newlines. Dot has no special meaning in a character class.
3995:
3996: The escape sequence \N behaves like a dot, except that it is not
3997: affected by the PCRE_DOTALL option. In other words, it matches any
3998: character except one that signifies the end of a line.
3999:
4000:
4001: MATCHING A SINGLE BYTE
4002:
4003: Outside a character class, the escape sequence \C matches any one byte,
4004: both in and out of UTF-8 mode. Unlike a dot, it always matches any
4005: line-ending characters. The feature is provided in Perl in order to
4006: match individual bytes in UTF-8 mode. Because it breaks up UTF-8 char-
4007: acters into individual bytes, the rest of the string may start with a
4008: malformed UTF-8 character. For this reason, the \C escape sequence is
4009: best avoided.
4010:
4011: PCRE does not allow \C to appear in lookbehind assertions (described
4012: below), because in UTF-8 mode this would make it impossible to calcu-
4013: late the length of the lookbehind.
4014:
4015:
4016: SQUARE BRACKETS AND CHARACTER CLASSES
4017:
4018: An opening square bracket introduces a character class, terminated by a
4019: closing square bracket. A closing square bracket on its own is not spe-
4020: cial by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set,
4021: a lone closing square bracket causes a compile-time error. If a closing
4022: square bracket is required as a member of the class, it should be the
4023: first data character in the class (after an initial circumflex, if
4024: present) or escaped with a backslash.
4025:
4026: A character class matches a single character in the subject. In UTF-8
4027: mode, the character may be more than one byte long. A matched character
4028: must be in the set of characters defined by the class, unless the first
4029: character in the class definition is a circumflex, in which case the
4030: subject character must not be in the set defined by the class. If a
4031: circumflex is actually required as a member of the class, ensure it is
4032: not the first character, or escape it with a backslash.
4033:
4034: For example, the character class [aeiou] matches any lower case vowel,
4035: while [^aeiou] matches any character that is not a lower case vowel.
4036: Note that a circumflex is just a convenient notation for specifying the
4037: characters that are in the class by enumerating those that are not. A
4038: class that starts with a circumflex is not an assertion; it still con-
4039: sumes a character from the subject string, and therefore it fails if
4040: the current pointer is at the end of the string.
4041:
4042: In UTF-8 mode, characters with values greater than 255 can be included
4043: in a class as a literal string of bytes, or by using the \x{ escaping
4044: mechanism.
4045:
4046: When caseless matching is set, any letters in a class represent both
4047: their upper case and lower case versions, so for example, a caseless
4048: [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
4049: match "A", whereas a caseful version would. In UTF-8 mode, PCRE always
4050: understands the concept of case for characters whose values are less
4051: than 128, so caseless matching is always possible. For characters with
4052: higher values, the concept of case is supported if PCRE is compiled
4053: with Unicode property support, but not otherwise. If you want to use
4054: caseless matching in UTF8-mode for characters 128 and above, you must
4055: ensure that PCRE is compiled with Unicode property support as well as
4056: with UTF-8 support.
4057:
4058: Characters that might indicate line breaks are never treated in any
4059: special way when matching character classes, whatever line-ending
4060: sequence is in use, and whatever setting of the PCRE_DOTALL and
4061: PCRE_MULTILINE options is used. A class such as [^a] always matches one
4062: of these characters.
4063:
4064: The minus (hyphen) character can be used to specify a range of charac-
4065: ters in a character class. For example, [d-m] matches any letter
4066: between d and m, inclusive. If a minus character is required in a
4067: class, it must be escaped with a backslash or appear in a position
4068: where it cannot be interpreted as indicating a range, typically as the
4069: first or last character in the class.
4070:
4071: It is not possible to have the literal character "]" as the end charac-
4072: ter of a range. A pattern such as [W-]46] is interpreted as a class of
4073: two characters ("W" and "-") followed by a literal string "46]", so it
4074: would match "W46]" or "-46]". However, if the "]" is escaped with a
4075: backslash it is interpreted as the end of range, so [W-\]46] is inter-
4076: preted as a class containing a range followed by two other characters.
4077: The octal or hexadecimal representation of "]" can also be used to end
4078: a range.
4079:
4080: Ranges operate in the collating sequence of character values. They can
4081: also be used for characters specified numerically, for example
4082: [\000-\037]. In UTF-8 mode, ranges can include characters whose values
4083: are greater than 255, for example [\x{100}-\x{2ff}].
4084:
4085: If a range that includes letters is used when caseless matching is set,
4086: it matches the letters in either case. For example, [W-c] is equivalent
4087: to [][\\^_`wxyzabc], matched caselessly, and in non-UTF-8 mode, if
4088: character tables for a French locale are in use, [\xc8-\xcb] matches
4089: accented E characters in both cases. In UTF-8 mode, PCRE supports the
4090: concept of case for characters with values greater than 128 only when
4091: it is compiled with Unicode property support.
4092:
4093: The character escape sequences \d, \D, \h, \H, \p, \P, \s, \S, \v, \V,
4094: \w, and \W may appear in a character class, and add the characters that
4095: they match to the class. For example, [\dABCDEF] matches any hexadeci-
4096: mal digit. In UTF-8 mode, the PCRE_UCP option affects the meanings of
4097: \d, \s, \w and their upper case partners, just as it does when they
4098: appear outside a character class, as described in the section entitled
4099: "Generic character types" above. The escape sequence \b has a different
4100: meaning inside a character class; it matches the backspace character.
4101: The sequences \B, \N, \R, and \X are not special inside a character
4102: class. Like any other unrecognized escape sequences, they are treated
4103: as the literal characters "B", "N", "R", and "X" by default, but cause
4104: an error if the PCRE_EXTRA option is set.
4105:
4106: A circumflex can conveniently be used with the upper case character
4107: types to specify a more restricted set of characters than the matching
4108: lower case type. For example, the class [^\W_] matches any letter or
4109: digit, but not underscore, whereas [\w] includes underscore. A positive
4110: character class should be read as "something OR something OR ..." and a
4111: negative class as "NOT something AND NOT something AND NOT ...".
4112:
4113: The only metacharacters that are recognized in character classes are
4114: backslash, hyphen (only where it can be interpreted as specifying a
4115: range), circumflex (only at the start), opening square bracket (only
4116: when it can be interpreted as introducing a POSIX class name - see the
4117: next section), and the terminating closing square bracket. However,
4118: escaping other non-alphanumeric characters does no harm.
4119:
4120:
4121: POSIX CHARACTER CLASSES
4122:
4123: Perl supports the POSIX notation for character classes. This uses names
4124: enclosed by [: and :] within the enclosing square brackets. PCRE also
4125: supports this notation. For example,
4126:
4127: [01[:alpha:]%]
4128:
4129: matches "0", "1", any alphabetic character, or "%". The supported class
4130: names are:
4131:
4132: alnum letters and digits
4133: alpha letters
4134: ascii character codes 0 - 127
4135: blank space or tab only
4136: cntrl control characters
4137: digit decimal digits (same as \d)
4138: graph printing characters, excluding space
4139: lower lower case letters
4140: print printing characters, including space
4141: punct printing characters, excluding letters and digits and space
4142: space white space (not quite the same as \s)
4143: upper upper case letters
4144: word "word" characters (same as \w)
4145: xdigit hexadecimal digits
4146:
4147: The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
4148: and space (32). Notice that this list includes the VT character (code
4149: 11). This makes "space" different to \s, which does not include VT (for
4150: Perl compatibility).
4151:
4152: The name "word" is a Perl extension, and "blank" is a GNU extension
4153: from Perl 5.8. Another Perl extension is negation, which is indicated
4154: by a ^ character after the colon. For example,
4155:
4156: [12[:^digit:]]
4157:
4158: matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the
4159: POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
4160: these are not supported, and an error is given if they are encountered.
4161:
4162: By default, in UTF-8 mode, characters with values greater than 128 do
4163: not match any of the POSIX character classes. However, if the PCRE_UCP
4164: option is passed to pcre_compile(), some of the classes are changed so
4165: that Unicode character properties are used. This is achieved by replac-
4166: ing the POSIX classes by other sequences, as follows:
4167:
4168: [:alnum:] becomes \p{Xan}
4169: [:alpha:] becomes \p{L}
4170: [:blank:] becomes \h
4171: [:digit:] becomes \p{Nd}
4172: [:lower:] becomes \p{Ll}
4173: [:space:] becomes \p{Xps}
4174: [:upper:] becomes \p{Lu}
4175: [:word:] becomes \p{Xwd}
4176:
4177: Negated versions, such as [:^alpha:] use \P instead of \p. The other
4178: POSIX classes are unchanged, and match only characters with code points
4179: less than 128.
4180:
4181:
4182: VERTICAL BAR
4183:
4184: Vertical bar characters are used to separate alternative patterns. For
4185: example, the pattern
4186:
4187: gilbert|sullivan
4188:
4189: matches either "gilbert" or "sullivan". Any number of alternatives may
4190: appear, and an empty alternative is permitted (matching the empty
4191: string). The matching process tries each alternative in turn, from left
4192: to right, and the first one that succeeds is used. If the alternatives
4193: are within a subpattern (defined below), "succeeds" means matching the
4194: rest of the main pattern as well as the alternative in the subpattern.
4195:
4196:
4197: INTERNAL OPTION SETTING
4198:
4199: The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
4200: PCRE_EXTENDED options (which are Perl-compatible) can be changed from
4201: within the pattern by a sequence of Perl option letters enclosed
4202: between "(?" and ")". The option letters are
4203:
4204: i for PCRE_CASELESS
4205: m for PCRE_MULTILINE
4206: s for PCRE_DOTALL
4207: x for PCRE_EXTENDED
4208:
4209: For example, (?im) sets caseless, multiline matching. It is also possi-
4210: ble to unset these options by preceding the letter with a hyphen, and a
4211: combined setting and unsetting such as (?im-sx), which sets PCRE_CASE-
4212: LESS and PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED,
4213: is also permitted. If a letter appears both before and after the
4214: hyphen, the option is unset.
4215:
4216: The PCRE-specific options PCRE_DUPNAMES, PCRE_UNGREEDY, and PCRE_EXTRA
4217: can be changed in the same way as the Perl-compatible options by using
4218: the characters J, U and X respectively.
4219:
4220: When one of these option changes occurs at top level (that is, not
4221: inside subpattern parentheses), the change applies to the remainder of
4222: the pattern that follows. If the change is placed right at the start of
4223: a pattern, PCRE extracts it into the global options (and it will there-
4224: fore show up in data extracted by the pcre_fullinfo() function).
4225:
4226: An option change within a subpattern (see below for a description of
4227: subpatterns) affects only that part of the subpattern that follows it,
4228: so
4229:
4230: (a(?i)b)c
4231:
4232: matches abc and aBc and no other strings (assuming PCRE_CASELESS is not
4233: used). By this means, options can be made to have different settings
4234: in different parts of the pattern. Any changes made in one alternative
4235: do carry on into subsequent branches within the same subpattern. For
4236: example,
4237:
4238: (a(?i)b|c)
4239:
4240: matches "ab", "aB", "c", and "C", even though when matching "C" the
4241: first branch is abandoned before the option setting. This is because
4242: the effects of option settings happen at compile time. There would be
4243: some very weird behaviour otherwise.
4244:
4245: Note: There are other PCRE-specific options that can be set by the
4246: application when the compile or match functions are called. In some
4247: cases the pattern can contain special leading sequences such as (*CRLF)
4248: to override what the application has set or what has been defaulted.
4249: Details are given in the section entitled "Newline sequences" above.
4250: There are also the (*UTF8) and (*UCP) leading sequences that can be
4251: used to set UTF-8 and Unicode property modes; they are equivalent to
4252: setting the PCRE_UTF8 and the PCRE_UCP options, respectively.
4253:
4254:
4255: SUBPATTERNS
4256:
4257: Subpatterns are delimited by parentheses (round brackets), which can be
4258: nested. Turning part of a pattern into a subpattern does two things:
4259:
4260: 1. It localizes a set of alternatives. For example, the pattern
4261:
4262: cat(aract|erpillar|)
4263:
4264: matches "cataract", "caterpillar", or "cat". Without the parentheses,
4265: it would match "cataract", "erpillar" or an empty string.
4266:
4267: 2. It sets up the subpattern as a capturing subpattern. This means
4268: that, when the whole pattern matches, that portion of the subject
4269: string that matched the subpattern is passed back to the caller via the
4270: ovector argument of pcre_exec(). Opening parentheses are counted from
4271: left to right (starting from 1) to obtain numbers for the capturing
4272: subpatterns. For example, if the string "the red king" is matched
4273: against the pattern
4274:
4275: the ((red|white) (king|queen))
4276:
4277: the captured substrings are "red king", "red", and "king", and are num-
4278: bered 1, 2, and 3, respectively.
4279:
4280: The fact that plain parentheses fulfil two functions is not always
4281: helpful. There are often times when a grouping subpattern is required
4282: without a capturing requirement. If an opening parenthesis is followed
4283: by a question mark and a colon, the subpattern does not do any captur-
4284: ing, and is not counted when computing the number of any subsequent
4285: capturing subpatterns. For example, if the string "the white queen" is
4286: matched against the pattern
4287:
4288: the ((?:red|white) (king|queen))
4289:
4290: the captured substrings are "white queen" and "queen", and are numbered
4291: 1 and 2. The maximum number of capturing subpatterns is 65535.
4292:
4293: As a convenient shorthand, if any option settings are required at the
4294: start of a non-capturing subpattern, the option letters may appear
4295: between the "?" and the ":". Thus the two patterns
4296:
4297: (?i:saturday|sunday)
4298: (?:(?i)saturday|sunday)
4299:
4300: match exactly the same set of strings. Because alternative branches are
4301: tried from left to right, and options are not reset until the end of
4302: the subpattern is reached, an option setting in one branch does affect
4303: subsequent branches, so the above patterns match "SUNDAY" as well as
4304: "Saturday".
4305:
4306:
4307: DUPLICATE SUBPATTERN NUMBERS
4308:
4309: Perl 5.10 introduced a feature whereby each alternative in a subpattern
4310: uses the same numbers for its capturing parentheses. Such a subpattern
4311: starts with (?| and is itself a non-capturing subpattern. For example,
4312: consider this pattern:
4313:
4314: (?|(Sat)ur|(Sun))day
4315:
4316: Because the two alternatives are inside a (?| group, both sets of cap-
4317: turing parentheses are numbered one. Thus, when the pattern matches,
4318: you can look at captured substring number one, whichever alternative
4319: matched. This construct is useful when you want to capture part, but
4320: not all, of one of a number of alternatives. Inside a (?| group, paren-
4321: theses are numbered as usual, but the number is reset at the start of
4322: each branch. The numbers of any capturing parentheses that follow the
4323: subpattern start after the highest number used in any branch. The fol-
4324: lowing example is taken from the Perl documentation. The numbers under-
4325: neath show in which buffer the captured content will be stored.
4326:
4327: # before ---------------branch-reset----------- after
4328: / ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
4329: # 1 2 2 3 2 3 4
4330:
4331: A back reference to a numbered subpattern uses the most recent value
4332: that is set for that number by any subpattern. The following pattern
4333: matches "abcabc" or "defdef":
4334:
4335: /(?|(abc)|(def))\1/
4336:
4337: In contrast, a recursive or "subroutine" call to a numbered subpattern
4338: always refers to the first one in the pattern with the given number.
4339: The following pattern matches "abcabc" or "defabc":
4340:
4341: /(?|(abc)|(def))(?1)/
4342:
4343: If a condition test for a subpattern's having matched refers to a non-
4344: unique number, the test is true if any of the subpatterns of that num-
4345: ber have matched.
4346:
4347: An alternative approach to using this "branch reset" feature is to use
4348: duplicate named subpatterns, as described in the next section.
4349:
4350:
4351: NAMED SUBPATTERNS
4352:
4353: Identifying capturing parentheses by number is simple, but it can be
4354: very hard to keep track of the numbers in complicated regular expres-
4355: sions. Furthermore, if an expression is modified, the numbers may
4356: change. To help with this difficulty, PCRE supports the naming of sub-
4357: patterns. This feature was not added to Perl until release 5.10. Python
4358: had the feature earlier, and PCRE introduced it at release 4.0, using
4359: the Python syntax. PCRE now supports both the Perl and the Python syn-
4360: tax. Perl allows identically numbered subpatterns to have different
4361: names, but PCRE does not.
4362:
4363: In PCRE, a subpattern can be named in one of three ways: (?<name>...)
4364: or (?'name'...) as in Perl, or (?P<name>...) as in Python. References
4365: to capturing parentheses from other parts of the pattern, such as back
4366: references, recursion, and conditions, can be made by name as well as
4367: by number.
4368:
4369: Names consist of up to 32 alphanumeric characters and underscores.
4370: Named capturing parentheses are still allocated numbers as well as
4371: names, exactly as if the names were not present. The PCRE API provides
4372: function calls for extracting the name-to-number translation table from
4373: a compiled pattern. There is also a convenience function for extracting
4374: a captured substring by name.
4375:
4376: By default, a name must be unique within a pattern, but it is possible
4377: to relax this constraint by setting the PCRE_DUPNAMES option at compile
4378: time. (Duplicate names are also always permitted for subpatterns with
4379: the same number, set up as described in the previous section.) Dupli-
4380: cate names can be useful for patterns where only one instance of the
4381: named parentheses can match. Suppose you want to match the name of a
4382: weekday, either as a 3-letter abbreviation or as the full name, and in
4383: both cases you want to extract the abbreviation. This pattern (ignoring
4384: the line breaks) does the job:
4385:
4386: (?<DN>Mon|Fri|Sun)(?:day)?|
4387: (?<DN>Tue)(?:sday)?|
4388: (?<DN>Wed)(?:nesday)?|
4389: (?<DN>Thu)(?:rsday)?|
4390: (?<DN>Sat)(?:urday)?
4391:
4392: There are five capturing substrings, but only one is ever set after a
4393: match. (An alternative way of solving this problem is to use a "branch
4394: reset" subpattern, as described in the previous section.)
4395:
4396: The convenience function for extracting the data by name returns the
4397: substring for the first (and in this example, the only) subpattern of
4398: that name that matched. This saves searching to find which numbered
4399: subpattern it was.
4400:
4401: If you make a back reference to a non-unique named subpattern from
4402: elsewhere in the pattern, the one that corresponds to the first occur-
4403: rence of the name is used. In the absence of duplicate numbers (see the
4404: previous section) this is the one with the lowest number. If you use a
4405: named reference in a condition test (see the section about conditions
4406: below), either to check whether a subpattern has matched, or to check
4407: for recursion, all subpatterns with the same name are tested. If the
4408: condition is true for any one of them, the overall condition is true.
4409: This is the same behaviour as testing by number. For further details of
4410: the interfaces for handling named subpatterns, see the pcreapi documen-
4411: tation.
4412:
4413: Warning: You cannot use different names to distinguish between two sub-
4414: patterns with the same number because PCRE uses only the numbers when
4415: matching. For this reason, an error is given at compile time if differ-
4416: ent names are given to subpatterns with the same number. However, you
4417: can give the same name to subpatterns with the same number, even when
4418: PCRE_DUPNAMES is not set.
4419:
4420:
4421: REPETITION
4422:
4423: Repetition is specified by quantifiers, which can follow any of the
4424: following items:
4425:
4426: a literal data character
4427: the dot metacharacter
4428: the \C escape sequence
4429: the \X escape sequence (in UTF-8 mode with Unicode properties)
4430: the \R escape sequence
4431: an escape such as \d or \pL that matches a single character
4432: a character class
4433: a back reference (see next section)
4434: a parenthesized subpattern (unless it is an assertion)
4435: a recursive or "subroutine" call to a subpattern
4436:
4437: The general repetition quantifier specifies a minimum and maximum num-
4438: ber of permitted matches, by giving the two numbers in curly brackets
4439: (braces), separated by a comma. The numbers must be less than 65536,
4440: and the first must be less than or equal to the second. For example:
4441:
4442: z{2,4}
4443:
4444: matches "zz", "zzz", or "zzzz". A closing brace on its own is not a
4445: special character. If the second number is omitted, but the comma is
4446: present, there is no upper limit; if the second number and the comma
4447: are both omitted, the quantifier specifies an exact number of required
4448: matches. Thus
4449:
4450: [aeiou]{3,}
4451:
4452: matches at least 3 successive vowels, but may match many more, while
4453:
4454: \d{8}
4455:
4456: matches exactly 8 digits. An opening curly bracket that appears in a
4457: position where a quantifier is not allowed, or one that does not match
4458: the syntax of a quantifier, is taken as a literal character. For exam-
4459: ple, {,6} is not a quantifier, but a literal string of four characters.
4460:
4461: In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to
4462: individual bytes. Thus, for example, \x{100}{2} matches two UTF-8 char-
4463: acters, each of which is represented by a two-byte sequence. Similarly,
4464: when Unicode property support is available, \X{3} matches three Unicode
4465: extended sequences, each of which may be several bytes long (and they
4466: may be of different lengths).
4467:
4468: The quantifier {0} is permitted, causing the expression to behave as if
4469: the previous item and the quantifier were not present. This may be use-
4470: ful for subpatterns that are referenced as subroutines from elsewhere
4471: in the pattern (but see also the section entitled "Defining subpatterns
4472: for use by reference only" below). Items other than subpatterns that
4473: have a {0} quantifier are omitted from the compiled pattern.
4474:
4475: For convenience, the three most common quantifiers have single-charac-
4476: ter abbreviations:
4477:
4478: * is equivalent to {0,}
4479: + is equivalent to {1,}
4480: ? is equivalent to {0,1}
4481:
4482: It is possible to construct infinite loops by following a subpattern
4483: that can match no characters with a quantifier that has no upper limit,
4484: for example:
4485:
4486: (a?)*
4487:
4488: Earlier versions of Perl and PCRE used to give an error at compile time
4489: for such patterns. However, because there are cases where this can be
4490: useful, such patterns are now accepted, but if any repetition of the
4491: subpattern does in fact match no characters, the loop is forcibly bro-
4492: ken.
4493:
4494: By default, the quantifiers are "greedy", that is, they match as much
4495: as possible (up to the maximum number of permitted times), without
4496: causing the rest of the pattern to fail. The classic example of where
4497: this gives problems is in trying to match comments in C programs. These
4498: appear between /* and */ and within the comment, individual * and /
4499: characters may appear. An attempt to match C comments by applying the
4500: pattern
4501:
4502: /\*.*\*/
4503:
4504: to the string
4505:
4506: /* first comment */ not comment /* second comment */
4507:
4508: fails, because it matches the entire string owing to the greediness of
4509: the .* item.
4510:
4511: However, if a quantifier is followed by a question mark, it ceases to
4512: be greedy, and instead matches the minimum number of times possible, so
4513: the pattern
4514:
4515: /\*.*?\*/
4516:
4517: does the right thing with the C comments. The meaning of the various
4518: quantifiers is not otherwise changed, just the preferred number of
4519: matches. Do not confuse this use of question mark with its use as a
4520: quantifier in its own right. Because it has two uses, it can sometimes
4521: appear doubled, as in
4522:
4523: \d??\d
4524:
4525: which matches one digit by preference, but can match two if that is the
4526: only way the rest of the pattern matches.
4527:
4528: If the PCRE_UNGREEDY option is set (an option that is not available in
4529: Perl), the quantifiers are not greedy by default, but individual ones
4530: can be made greedy by following them with a question mark. In other
4531: words, it inverts the default behaviour.
4532:
4533: When a parenthesized subpattern is quantified with a minimum repeat
4534: count that is greater than 1 or with a limited maximum, more memory is
4535: required for the compiled pattern, in proportion to the size of the
4536: minimum or maximum.
4537:
4538: If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equiv-
4539: alent to Perl's /s) is set, thus allowing the dot to match newlines,
4540: the pattern is implicitly anchored, because whatever follows will be
4541: tried against every character position in the subject string, so there
4542: is no point in retrying the overall match at any position after the
4543: first. PCRE normally treats such a pattern as though it were preceded
4544: by \A.
4545:
4546: In cases where it is known that the subject string contains no new-
4547: lines, it is worth setting PCRE_DOTALL in order to obtain this opti-
4548: mization, or alternatively using ^ to indicate anchoring explicitly.
4549:
4550: However, there is one situation where the optimization cannot be used.
4551: When .* is inside capturing parentheses that are the subject of a back
4552: reference elsewhere in the pattern, a match at the start may fail where
4553: a later one succeeds. Consider, for example:
4554:
4555: (.*)abc\1
4556:
4557: If the subject is "xyz123abc123" the match point is the fourth charac-
4558: ter. For this reason, such a pattern is not implicitly anchored.
4559:
4560: When a capturing subpattern is repeated, the value captured is the sub-
4561: string that matched the final iteration. For example, after
4562:
4563: (tweedle[dume]{3}\s*)+
4564:
4565: has matched "tweedledum tweedledee" the value of the captured substring
4566: is "tweedledee". However, if there are nested capturing subpatterns,
4567: the corresponding captured values may have been set in previous itera-
4568: tions. For example, after
4569:
4570: /(a|(b))+/
4571:
4572: matches "aba" the value of the second captured substring is "b".
4573:
4574:
4575: ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS
4576:
4577: With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
4578: repetition, failure of what follows normally causes the repeated item
4579: to be re-evaluated to see if a different number of repeats allows the
4580: rest of the pattern to match. Sometimes it is useful to prevent this,
4581: either to change the nature of the match, or to cause it fail earlier
4582: than it otherwise might, when the author of the pattern knows there is
4583: no point in carrying on.
4584:
4585: Consider, for example, the pattern \d+foo when applied to the subject
4586: line
4587:
4588: 123456bar
4589:
4590: After matching all 6 digits and then failing to match "foo", the normal
4591: action of the matcher is to try again with only 5 digits matching the
4592: \d+ item, and then with 4, and so on, before ultimately failing.
4593: "Atomic grouping" (a term taken from Jeffrey Friedl's book) provides
4594: the means for specifying that once a subpattern has matched, it is not
4595: to be re-evaluated in this way.
4596:
4597: If we use atomic grouping for the previous example, the matcher gives
4598: up immediately on failing to match "foo" the first time. The notation
4599: is a kind of special parenthesis, starting with (?> as in this example:
4600:
4601: (?>\d+)foo
4602:
4603: This kind of parenthesis "locks up" the part of the pattern it con-
4604: tains once it has matched, and a failure further into the pattern is
4605: prevented from backtracking into it. Backtracking past it to previous
4606: items, however, works as normal.
4607:
4608: An alternative description is that a subpattern of this type matches
4609: the string of characters that an identical standalone pattern would
4610: match, if anchored at the current point in the subject string.
4611:
4612: Atomic grouping subpatterns are not capturing subpatterns. Simple cases
4613: such as the above example can be thought of as a maximizing repeat that
4614: must swallow everything it can. So, while both \d+ and \d+? are pre-
4615: pared to adjust the number of digits they match in order to make the
4616: rest of the pattern match, (?>\d+) can only match an entire sequence of
4617: digits.
4618:
4619: Atomic groups in general can of course contain arbitrarily complicated
4620: subpatterns, and can be nested. However, when the subpattern for an
4621: atomic group is just a single repeated item, as in the example above, a
4622: simpler notation, called a "possessive quantifier" can be used. This
4623: consists of an additional + character following a quantifier. Using
4624: this notation, the previous example can be rewritten as
4625:
4626: \d++foo
4627:
4628: Note that a possessive quantifier can be used with an entire group, for
4629: example:
4630:
4631: (abc|xyz){2,3}+
4632:
4633: Possessive quantifiers are always greedy; the setting of the
4634: PCRE_UNGREEDY option is ignored. They are a convenient notation for the
4635: simpler forms of atomic group. However, there is no difference in the
4636: meaning of a possessive quantifier and the equivalent atomic group,
4637: though there may be a performance difference; possessive quantifiers
4638: should be slightly faster.
4639:
4640: The possessive quantifier syntax is an extension to the Perl 5.8 syn-
4641: tax. Jeffrey Friedl originated the idea (and the name) in the first
4642: edition of his book. Mike McCloskey liked it, so implemented it when he
4643: built Sun's Java package, and PCRE copied it from there. It ultimately
4644: found its way into Perl at release 5.10.
4645:
4646: PCRE has an optimization that automatically "possessifies" certain sim-
4647: ple pattern constructs. For example, the sequence A+B is treated as
4648: A++B because there is no point in backtracking into a sequence of A's
4649: when B must follow.
4650:
4651: When a pattern contains an unlimited repeat inside a subpattern that
4652: can itself be repeated an unlimited number of times, the use of an
4653: atomic group is the only way to avoid some failing matches taking a
4654: very long time indeed. The pattern
4655:
4656: (\D+|<\d+>)*[!?]
4657:
4658: matches an unlimited number of substrings that either consist of non-
4659: digits, or digits enclosed in <>, followed by either ! or ?. When it
4660: matches, it runs quickly. However, if it is applied to
4661:
4662: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
4663:
4664: it takes a long time before reporting failure. This is because the
4665: string can be divided between the internal \D+ repeat and the external
4666: * repeat in a large number of ways, and all have to be tried. (The
4667: example uses [!?] rather than a single character at the end, because
4668: both PCRE and Perl have an optimization that allows for fast failure
4669: when a single character is used. They remember the last single charac-
4670: ter that is required for a match, and fail early if it is not present
4671: in the string.) If the pattern is changed so that it uses an atomic
4672: group, like this:
4673:
4674: ((?>\D+)|<\d+>)*[!?]
4675:
4676: sequences of non-digits cannot be broken, and failure happens quickly.
4677:
4678:
4679: BACK REFERENCES
4680:
4681: Outside a character class, a backslash followed by a digit greater than
4682: 0 (and possibly further digits) is a back reference to a capturing sub-
4683: pattern earlier (that is, to its left) in the pattern, provided there
4684: have been that many previous capturing left parentheses.
4685:
4686: However, if the decimal number following the backslash is less than 10,
4687: it is always taken as a back reference, and causes an error only if
4688: there are not that many capturing left parentheses in the entire pat-
4689: tern. In other words, the parentheses that are referenced need not be
4690: to the left of the reference for numbers less than 10. A "forward back
4691: reference" of this type can make sense when a repetition is involved
4692: and the subpattern to the right has participated in an earlier itera-
4693: tion.
4694:
4695: It is not possible to have a numerical "forward back reference" to a
4696: subpattern whose number is 10 or more using this syntax because a
4697: sequence such as \50 is interpreted as a character defined in octal.
4698: See the subsection entitled "Non-printing characters" above for further
4699: details of the handling of digits following a backslash. There is no
4700: such problem when named parentheses are used. A back reference to any
4701: subpattern is possible using named parentheses (see below).
4702:
4703: Another way of avoiding the ambiguity inherent in the use of digits
4704: following a backslash is to use the \g escape sequence. This escape
4705: must be followed by an unsigned number or a negative number, optionally
4706: enclosed in braces. These examples are all identical:
4707:
4708: (ring), \1
4709: (ring), \g1
4710: (ring), \g{1}
4711:
4712: An unsigned number specifies an absolute reference without the ambigu-
4713: ity that is present in the older syntax. It is also useful when literal
4714: digits follow the reference. A negative number is a relative reference.
4715: Consider this example:
4716:
4717: (abc(def)ghi)\g{-1}
4718:
4719: The sequence \g{-1} is a reference to the most recently started captur-
4720: ing subpattern before \g, that is, is it equivalent to \2 in this exam-
4721: ple. Similarly, \g{-2} would be equivalent to \1. The use of relative
4722: references can be helpful in long patterns, and also in patterns that
4723: are created by joining together fragments that contain references
4724: within themselves.
4725:
4726: A back reference matches whatever actually matched the capturing sub-
4727: pattern in the current subject string, rather than anything matching
4728: the subpattern itself (see "Subpatterns as subroutines" below for a way
4729: of doing that). So the pattern
4730:
4731: (sens|respons)e and \1ibility
4732:
4733: matches "sense and sensibility" and "response and responsibility", but
4734: not "sense and responsibility". If caseful matching is in force at the
4735: time of the back reference, the case of letters is relevant. For exam-
4736: ple,
4737:
4738: ((?i)rah)\s+\1
4739:
4740: matches "rah rah" and "RAH RAH", but not "RAH rah", even though the
4741: original capturing subpattern is matched caselessly.
4742:
4743: There are several different ways of writing back references to named
4744: subpatterns. The .NET syntax \k{name} and the Perl syntax \k<name> or
4745: \k'name' are supported, as is the Python syntax (?P=name). Perl 5.10's
4746: unified back reference syntax, in which \g can be used for both numeric
4747: and named references, is also supported. We could rewrite the above
4748: example in any of the following ways:
4749:
4750: (?<p1>(?i)rah)\s+\k<p1>
4751: (?'p1'(?i)rah)\s+\k{p1}
4752: (?P<p1>(?i)rah)\s+(?P=p1)
4753: (?<p1>(?i)rah)\s+\g{p1}
4754:
4755: A subpattern that is referenced by name may appear in the pattern
4756: before or after the reference.
4757:
4758: There may be more than one back reference to the same subpattern. If a
4759: subpattern has not actually been used in a particular match, any back
4760: references to it always fail by default. For example, the pattern
4761:
4762: (a|(bc))\2
4763:
4764: always fails if it starts to match "a" rather than "bc". However, if
4765: the PCRE_JAVASCRIPT_COMPAT option is set at compile time, a back refer-
4766: ence to an unset value matches an empty string.
4767:
4768: Because there may be many capturing parentheses in a pattern, all dig-
4769: its following a backslash are taken as part of a potential back refer-
4770: ence number. If the pattern continues with a digit character, some
4771: delimiter must be used to terminate the back reference. If the
4772: PCRE_EXTENDED option is set, this can be whitespace. Otherwise, the \g{
4773: syntax or an empty comment (see "Comments" below) can be used.
4774:
4775: Recursive back references
4776:
4777: A back reference that occurs inside the parentheses to which it refers
4778: fails when the subpattern is first used, so, for example, (a\1) never
4779: matches. However, such references can be useful inside repeated sub-
4780: patterns. For example, the pattern
4781:
4782: (a|b\1)+
4783:
4784: matches any number of "a"s and also "aba", "ababbaa" etc. At each iter-
4785: ation of the subpattern, the back reference matches the character
4786: string corresponding to the previous iteration. In order for this to
4787: work, the pattern must be such that the first iteration does not need
4788: to match the back reference. This can be done using alternation, as in
4789: the example above, or by a quantifier with a minimum of zero.
4790:
4791: Back references of this type cause the group that they reference to be
4792: treated as an atomic group. Once the whole group has been matched, a
4793: subsequent matching failure cannot cause backtracking into the middle
4794: of the group.
4795:
4796:
4797: ASSERTIONS
4798:
4799: An assertion is a test on the characters following or preceding the
4800: current matching point that does not actually consume any characters.
4801: The simple assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are
4802: described above.
4803:
4804: More complicated assertions are coded as subpatterns. There are two
4805: kinds: those that look ahead of the current position in the subject
4806: string, and those that look behind it. An assertion subpattern is
4807: matched in the normal way, except that it does not cause the current
4808: matching position to be changed.
4809:
4810: Assertion subpatterns are not capturing subpatterns, and may not be
4811: repeated, because it makes no sense to assert the same thing several
4812: times. If any kind of assertion contains capturing subpatterns within
4813: it, these are counted for the purposes of numbering the capturing sub-
4814: patterns in the whole pattern. However, substring capturing is carried
4815: out only for positive assertions, because it does not make sense for
4816: negative assertions.
4817:
4818: Lookahead assertions
4819:
4820: Lookahead assertions start with (?= for positive assertions and (?! for
4821: negative assertions. For example,
4822:
4823: \w+(?=;)
4824:
4825: matches a word followed by a semicolon, but does not include the semi-
4826: colon in the match, and
4827:
4828: foo(?!bar)
4829:
4830: matches any occurrence of "foo" that is not followed by "bar". Note
4831: that the apparently similar pattern
4832:
4833: (?!foo)bar
4834:
4835: does not find an occurrence of "bar" that is preceded by something
4836: other than "foo"; it finds any occurrence of "bar" whatsoever, because
4837: the assertion (?!foo) is always true when the next three characters are
4838: "bar". A lookbehind assertion is needed to achieve the other effect.
4839:
4840: If you want to force a matching failure at some point in a pattern, the
4841: most convenient way to do it is with (?!) because an empty string
4842: always matches, so an assertion that requires there not to be an empty
4843: string must always fail. The backtracking control verb (*FAIL) or (*F)
4844: is a synonym for (?!).
4845:
4846: Lookbehind assertions
4847:
4848: Lookbehind assertions start with (?<= for positive assertions and (?<!
4849: for negative assertions. For example,
4850:
4851: (?<!foo)bar
4852:
4853: does find an occurrence of "bar" that is not preceded by "foo". The
4854: contents of a lookbehind assertion are restricted such that all the
4855: strings it matches must have a fixed length. However, if there are sev-
4856: eral top-level alternatives, they do not all have to have the same
4857: fixed length. Thus
4858:
4859: (?<=bullock|donkey)
4860:
4861: is permitted, but
4862:
4863: (?<!dogs?|cats?)
4864:
4865: causes an error at compile time. Branches that match different length
4866: strings are permitted only at the top level of a lookbehind assertion.
4867: This is an extension compared with Perl, which requires all branches to
4868: match the same length of string. An assertion such as
4869:
4870: (?<=ab(c|de))
4871:
4872: is not permitted, because its single top-level branch can match two
4873: different lengths, but it is acceptable to PCRE if rewritten to use two
4874: top-level branches:
4875:
4876: (?<=abc|abde)
4877:
4878: In some cases, the escape sequence \K (see above) can be used instead
4879: of a lookbehind assertion to get round the fixed-length restriction.
4880:
4881: The implementation of lookbehind assertions is, for each alternative,
4882: to temporarily move the current position back by the fixed length and
4883: then try to match. If there are insufficient characters before the cur-
4884: rent position, the assertion fails.
4885:
4886: PCRE does not allow the \C escape (which matches a single byte in UTF-8
4887: mode) to appear in lookbehind assertions, because it makes it impossi-
4888: ble to calculate the length of the lookbehind. The \X and \R escapes,
4889: which can match different numbers of bytes, are also not permitted.
4890:
4891: "Subroutine" calls (see below) such as (?2) or (?&X) are permitted in
4892: lookbehinds, as long as the subpattern matches a fixed-length string.
4893: Recursion, however, is not supported.
4894:
4895: Possessive quantifiers can be used in conjunction with lookbehind
4896: assertions to specify efficient matching of fixed-length strings at the
4897: end of subject strings. Consider a simple pattern such as
4898:
4899: abcd$
4900:
4901: when applied to a long string that does not match. Because matching
4902: proceeds from left to right, PCRE will look for each "a" in the subject
4903: and then see if what follows matches the rest of the pattern. If the
4904: pattern is specified as
4905:
4906: ^.*abcd$
4907:
4908: the initial .* matches the entire string at first, but when this fails
4909: (because there is no following "a"), it backtracks to match all but the
4910: last character, then all but the last two characters, and so on. Once
4911: again the search for "a" covers the entire string, from right to left,
4912: so we are no better off. However, if the pattern is written as
4913:
4914: ^.*+(?<=abcd)
4915:
4916: there can be no backtracking for the .*+ item; it can match only the
4917: entire string. The subsequent lookbehind assertion does a single test
4918: on the last four characters. If it fails, the match fails immediately.
4919: For long strings, this approach makes a significant difference to the
4920: processing time.
4921:
4922: Using multiple assertions
4923:
4924: Several assertions (of any sort) may occur in succession. For example,
4925:
4926: (?<=\d{3})(?<!999)foo
4927:
4928: matches "foo" preceded by three digits that are not "999". Notice that
4929: each of the assertions is applied independently at the same point in
4930: the subject string. First there is a check that the previous three
4931: characters are all digits, and then there is a check that the same
4932: three characters are not "999". This pattern does not match "foo" pre-
4933: ceded by six characters, the first of which are digits and the last
4934: three of which are not "999". For example, it doesn't match "123abc-
4935: foo". A pattern to do that is
4936:
4937: (?<=\d{3}...)(?<!999)foo
4938:
4939: This time the first assertion looks at the preceding six characters,
4940: checking that the first three are digits, and then the second assertion
4941: checks that the preceding three characters are not "999".
4942:
4943: Assertions can be nested in any combination. For example,
4944:
4945: (?<=(?<!foo)bar)baz
4946:
4947: matches an occurrence of "baz" that is preceded by "bar" which in turn
4948: is not preceded by "foo", while
4949:
4950: (?<=\d{3}(?!999)...)foo
4951:
4952: is another pattern that matches "foo" preceded by three digits and any
4953: three characters that are not "999".
4954:
4955:
4956: CONDITIONAL SUBPATTERNS
4957:
4958: It is possible to cause the matching process to obey a subpattern con-
4959: ditionally or to choose between two alternative subpatterns, depending
4960: on the result of an assertion, or whether a specific capturing subpat-
4961: tern has already been matched. The two possible forms of conditional
4962: subpattern are:
4963:
4964: (?(condition)yes-pattern)
4965: (?(condition)yes-pattern|no-pattern)
4966:
4967: If the condition is satisfied, the yes-pattern is used; otherwise the
4968: no-pattern (if present) is used. If there are more than two alterna-
4969: tives in the subpattern, a compile-time error occurs. Each of the two
4970: alternatives may itself contain nested subpatterns of any form, includ-
4971: ing conditional subpatterns; the restriction to two alternatives
4972: applies only at the level of the condition. This pattern fragment is an
4973: example where the alternatives are complex:
4974:
4975: (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
4976:
4977:
4978: There are four kinds of condition: references to subpatterns, refer-
4979: ences to recursion, a pseudo-condition called DEFINE, and assertions.
4980:
4981: Checking for a used subpattern by number
4982:
4983: If the text between the parentheses consists of a sequence of digits,
4984: the condition is true if a capturing subpattern of that number has pre-
4985: viously matched. If there is more than one capturing subpattern with
4986: the same number (see the earlier section about duplicate subpattern
4987: numbers), the condition is true if any of them have matched. An alter-
4988: native notation is to precede the digits with a plus or minus sign. In
4989: this case, the subpattern number is relative rather than absolute. The
4990: most recently opened parentheses can be referenced by (?(-1), the next
4991: most recent by (?(-2), and so on. Inside loops it can also make sense
4992: to refer to subsequent groups. The next parentheses to be opened can be
4993: referenced as (?(+1), and so on. (The value zero in any of these forms
4994: is not used; it provokes a compile-time error.)
4995:
4996: Consider the following pattern, which contains non-significant white
4997: space to make it more readable (assume the PCRE_EXTENDED option) and to
4998: divide it into three parts for ease of discussion:
4999:
5000: ( \( )? [^()]+ (?(1) \) )
5001:
5002: The first part matches an optional opening parenthesis, and if that
5003: character is present, sets it as the first captured substring. The sec-
5004: ond part matches one or more characters that are not parentheses. The
5005: third part is a conditional subpattern that tests whether or not the
5006: first set of parentheses matched. If they did, that is, if subject
5007: started with an opening parenthesis, the condition is true, and so the
5008: yes-pattern is executed and a closing parenthesis is required. Other-
5009: wise, since no-pattern is not present, the subpattern matches nothing.
5010: In other words, this pattern matches a sequence of non-parentheses,
5011: optionally enclosed in parentheses.
5012:
5013: If you were embedding this pattern in a larger one, you could use a
5014: relative reference:
5015:
5016: ...other stuff... ( \( )? [^()]+ (?(-1) \) ) ...
5017:
5018: This makes the fragment independent of the parentheses in the larger
5019: pattern.
5020:
5021: Checking for a used subpattern by name
5022:
5023: Perl uses the syntax (?(<name>)...) or (?('name')...) to test for a
5024: used subpattern by name. For compatibility with earlier versions of
5025: PCRE, which had this facility before Perl, the syntax (?(name)...) is
5026: also recognized. However, there is a possible ambiguity with this syn-
5027: tax, because subpattern names may consist entirely of digits. PCRE
5028: looks first for a named subpattern; if it cannot find one and the name
5029: consists entirely of digits, PCRE looks for a subpattern of that num-
5030: ber, which must be greater than zero. Using subpattern names that con-
5031: sist entirely of digits is not recommended.
5032:
5033: Rewriting the above example to use a named subpattern gives this:
5034:
5035: (?<OPEN> \( )? [^()]+ (?(<OPEN>) \) )
5036:
5037: If the name used in a condition of this kind is a duplicate, the test
5038: is applied to all subpatterns of the same name, and is true if any one
5039: of them has matched.
5040:
5041: Checking for pattern recursion
5042:
5043: If the condition is the string (R), and there is no subpattern with the
5044: name R, the condition is true if a recursive call to the whole pattern
5045: or any subpattern has been made. If digits or a name preceded by amper-
5046: sand follow the letter R, for example:
5047:
5048: (?(R3)...) or (?(R&name)...)
5049:
5050: the condition is true if the most recent recursion is into a subpattern
5051: whose number or name is given. This condition does not check the entire
5052: recursion stack. If the name used in a condition of this kind is a
5053: duplicate, the test is applied to all subpatterns of the same name, and
5054: is true if any one of them is the most recent recursion.
5055:
5056: At "top level", all these recursion test conditions are false. The
5057: syntax for recursive patterns is described below.
5058:
5059: Defining subpatterns for use by reference only
5060:
5061: If the condition is the string (DEFINE), and there is no subpattern
5062: with the name DEFINE, the condition is always false. In this case,
5063: there may be only one alternative in the subpattern. It is always
5064: skipped if control reaches this point in the pattern; the idea of
5065: DEFINE is that it can be used to define "subroutines" that can be ref-
5066: erenced from elsewhere. (The use of "subroutines" is described below.)
5067: For example, a pattern to match an IPv4 address such as
5068: "192.168.23.245" could be written like this (ignore whitespace and line
5069: breaks):
5070:
5071: (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
5072: \b (?&byte) (\.(?&byte)){3} \b
5073:
5074: The first part of the pattern is a DEFINE group inside which a another
5075: group named "byte" is defined. This matches an individual component of
5076: an IPv4 address (a number less than 256). When matching takes place,
5077: this part of the pattern is skipped because DEFINE acts like a false
5078: condition. The rest of the pattern uses references to the named group
5079: to match the four dot-separated components of an IPv4 address, insist-
5080: ing on a word boundary at each end.
5081:
5082: Assertion conditions
5083:
5084: If the condition is not in any of the above formats, it must be an
5085: assertion. This may be a positive or negative lookahead or lookbehind
5086: assertion. Consider this pattern, again containing non-significant
5087: white space, and with the two alternatives on the second line:
5088:
5089: (?(?=[^a-z]*[a-z])
5090: \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
5091:
5092: The condition is a positive lookahead assertion that matches an
5093: optional sequence of non-letters followed by a letter. In other words,
5094: it tests for the presence of at least one letter in the subject. If a
5095: letter is found, the subject is matched against the first alternative;
5096: otherwise it is matched against the second. This pattern matches
5097: strings in one of the two forms dd-aaa-dd or dd-dd-dd, where aaa are
5098: letters and dd are digits.
5099:
5100:
5101: COMMENTS
5102:
5103: There are two ways of including comments in patterns that are processed
5104: by PCRE. In both cases, the start of the comment must not be in a char-
5105: acter class, nor in the middle of any other sequence of related charac-
5106: ters such as (?: or a subpattern name or number. The characters that
5107: make up a comment play no part in the pattern matching.
5108:
5109: The sequence (?# marks the start of a comment that continues up to the
5110: next closing parenthesis. Nested parentheses are not permitted. If the
5111: PCRE_EXTENDED option is set, an unescaped # character also introduces a
5112: comment, which in this case continues to immediately after the next
5113: newline character or character sequence in the pattern. Which charac-
5114: ters are interpreted as newlines is controlled by the options passed to
5115: pcre_compile() or by a special sequence at the start of the pattern, as
5116: described in the section entitled "Newline conventions" above. Note
5117: that the end of this type of comment is a literal newline sequence in
5118: the pattern; escape sequences that happen to represent a newline do not
5119: count. For example, consider this pattern when PCRE_EXTENDED is set,
5120: and the default newline convention is in force:
5121:
5122: abc #comment \n still comment
5123:
5124: On encountering the # character, pcre_compile() skips along, looking
5125: for a newline in the pattern. The sequence \n is still literal at this
5126: stage, so it does not terminate the comment. Only an actual character
5127: with the code value 0x0a (the default newline) does so.
5128:
5129:
5130: RECURSIVE PATTERNS
5131:
5132: Consider the problem of matching a string in parentheses, allowing for
5133: unlimited nested parentheses. Without the use of recursion, the best
5134: that can be done is to use a pattern that matches up to some fixed
5135: depth of nesting. It is not possible to handle an arbitrary nesting
5136: depth.
5137:
5138: For some time, Perl has provided a facility that allows regular expres-
5139: sions to recurse (amongst other things). It does this by interpolating
5140: Perl code in the expression at run time, and the code can refer to the
5141: expression itself. A Perl pattern using code interpolation to solve the
5142: parentheses problem can be created like this:
5143:
5144: $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
5145:
5146: The (?p{...}) item interpolates Perl code at run time, and in this case
5147: refers recursively to the pattern in which it appears.
5148:
5149: Obviously, PCRE cannot support the interpolation of Perl code. Instead,
5150: it supports special syntax for recursion of the entire pattern, and
5151: also for individual subpattern recursion. After its introduction in
5152: PCRE and Python, this kind of recursion was subsequently introduced
5153: into Perl at release 5.10.
5154:
5155: A special item that consists of (? followed by a number greater than
5156: zero and a closing parenthesis is a recursive call of the subpattern of
5157: the given number, provided that it occurs inside that subpattern. (If
5158: not, it is a "subroutine" call, which is described in the next sec-
5159: tion.) The special item (?R) or (?0) is a recursive call of the entire
5160: regular expression.
5161:
5162: This PCRE pattern solves the nested parentheses problem (assume the
5163: PCRE_EXTENDED option is set so that white space is ignored):
5164:
5165: \( ( [^()]++ | (?R) )* \)
5166:
5167: First it matches an opening parenthesis. Then it matches any number of
5168: substrings which can either be a sequence of non-parentheses, or a
5169: recursive match of the pattern itself (that is, a correctly parenthe-
5170: sized substring). Finally there is a closing parenthesis. Note the use
5171: of a possessive quantifier to avoid backtracking into sequences of non-
5172: parentheses.
5173:
5174: If this were part of a larger pattern, you would not want to recurse
5175: the entire pattern, so instead you could use this:
5176:
5177: ( \( ( [^()]++ | (?1) )* \) )
5178:
5179: We have put the pattern into parentheses, and caused the recursion to
5180: refer to them instead of the whole pattern.
5181:
5182: In a larger pattern, keeping track of parenthesis numbers can be
5183: tricky. This is made easier by the use of relative references. Instead
5184: of (?1) in the pattern above you can write (?-2) to refer to the second
5185: most recently opened parentheses preceding the recursion. In other
5186: words, a negative number counts capturing parentheses leftwards from
5187: the point at which it is encountered.
5188:
5189: It is also possible to refer to subsequently opened parentheses, by
5190: writing references such as (?+2). However, these cannot be recursive
5191: because the reference is not inside the parentheses that are refer-
5192: enced. They are always "subroutine" calls, as described in the next
5193: section.
5194:
5195: An alternative approach is to use named parentheses instead. The Perl
5196: syntax for this is (?&name); PCRE's earlier syntax (?P>name) is also
5197: supported. We could rewrite the above example as follows:
5198:
5199: (?<pn> \( ( [^()]++ | (?&pn) )* \) )
5200:
5201: If there is more than one subpattern with the same name, the earliest
5202: one is used.
5203:
5204: This particular example pattern that we have been looking at contains
5205: nested unlimited repeats, and so the use of a possessive quantifier for
5206: matching strings of non-parentheses is important when applying the pat-
5207: tern to strings that do not match. For example, when this pattern is
5208: applied to
5209:
5210: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
5211:
5212: it yields "no match" quickly. However, if a possessive quantifier is
5213: not used, the match runs for a very long time indeed because there are
5214: so many different ways the + and * repeats can carve up the subject,
5215: and all have to be tested before failure can be reported.
5216:
5217: At the end of a match, the values of capturing parentheses are those
5218: from the outermost level. If you want to obtain intermediate values, a
5219: callout function can be used (see below and the pcrecallout documenta-
5220: tion). If the pattern above is matched against
5221:
5222: (ab(cd)ef)
5223:
5224: the value for the inner capturing parentheses (numbered 2) is "ef",
5225: which is the last value taken on at the top level. If a capturing sub-
5226: pattern is not matched at the top level, its final value is unset, even
5227: if it is (temporarily) set at a deeper level.
5228:
5229: If there are more than 15 capturing parentheses in a pattern, PCRE has
5230: to obtain extra memory to store data during a recursion, which it does
5231: by using pcre_malloc, freeing it via pcre_free afterwards. If no memory
5232: can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
5233:
5234: Do not confuse the (?R) item with the condition (R), which tests for
5235: recursion. Consider this pattern, which matches text in angle brack-
5236: ets, allowing for arbitrary nesting. Only digits are allowed in nested
5237: brackets (that is, when recursing), whereas any characters are permit-
5238: ted at the outer level.
5239:
5240: < (?: (?(R) \d++ | [^<>]*+) | (?R)) * >
5241:
5242: In this pattern, (?(R) is the start of a conditional subpattern, with
5243: two different alternatives for the recursive and non-recursive cases.
5244: The (?R) item is the actual recursive call.
5245:
5246: Recursion difference from Perl
5247:
5248: In PCRE (like Python, but unlike Perl), a recursive subpattern call is
5249: always treated as an atomic group. That is, once it has matched some of
5250: the subject string, it is never re-entered, even if it contains untried
5251: alternatives and there is a subsequent matching failure. This can be
5252: illustrated by the following pattern, which purports to match a palin-
5253: dromic string that contains an odd number of characters (for example,
5254: "a", "aba", "abcba", "abcdcba"):
5255:
5256: ^(.|(.)(?1)\2)$
5257:
5258: The idea is that it either matches a single character, or two identical
5259: characters surrounding a sub-palindrome. In Perl, this pattern works;
5260: in PCRE it does not if the pattern is longer than three characters.
5261: Consider the subject string "abcba":
5262:
5263: At the top level, the first character is matched, but as it is not at
5264: the end of the string, the first alternative fails; the second alterna-
5265: tive is taken and the recursion kicks in. The recursive call to subpat-
5266: tern 1 successfully matches the next character ("b"). (Note that the
5267: beginning and end of line tests are not part of the recursion).
5268:
5269: Back at the top level, the next character ("c") is compared with what
5270: subpattern 2 matched, which was "a". This fails. Because the recursion
5271: is treated as an atomic group, there are now no backtracking points,
5272: and so the entire match fails. (Perl is able, at this point, to re-
5273: enter the recursion and try the second alternative.) However, if the
5274: pattern is written with the alternatives in the other order, things are
5275: different:
5276:
5277: ^((.)(?1)\2|.)$
5278:
5279: This time, the recursing alternative is tried first, and continues to
5280: recurse until it runs out of characters, at which point the recursion
5281: fails. But this time we do have another alternative to try at the
5282: higher level. That is the big difference: in the previous case the
5283: remaining alternative is at a deeper recursion level, which PCRE cannot
5284: use.
5285:
5286: To change the pattern so that it matches all palindromic strings, not
5287: just those with an odd number of characters, it is tempting to change
5288: the pattern to this:
5289:
5290: ^((.)(?1)\2|.?)$
5291:
5292: Again, this works in Perl, but not in PCRE, and for the same reason.
5293: When a deeper recursion has matched a single character, it cannot be
5294: entered again in order to match an empty string. The solution is to
5295: separate the two cases, and write out the odd and even cases as alter-
5296: natives at the higher level:
5297:
5298: ^(?:((.)(?1)\2|)|((.)(?3)\4|.))
5299:
5300: If you want to match typical palindromic phrases, the pattern has to
5301: ignore all non-word characters, which can be done like this:
5302:
5303: ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$
5304:
5305: If run with the PCRE_CASELESS option, this pattern matches phrases such
5306: as "A man, a plan, a canal: Panama!" and it works well in both PCRE and
5307: Perl. Note the use of the possessive quantifier *+ to avoid backtrack-
5308: ing into sequences of non-word characters. Without this, PCRE takes a
5309: great deal longer (ten times or more) to match typical phrases, and
5310: Perl takes so long that you think it has gone into a loop.
5311:
5312: WARNING: The palindrome-matching patterns above work only if the sub-
5313: ject string does not start with a palindrome that is shorter than the
5314: entire string. For example, although "abcba" is correctly matched, if
5315: the subject is "ababa", PCRE finds the palindrome "aba" at the start,
5316: then fails at top level because the end of the string does not follow.
5317: Once again, it cannot jump back into the recursion to try other alter-
5318: natives, so the entire match fails.
5319:
5320:
5321: SUBPATTERNS AS SUBROUTINES
5322:
5323: If the syntax for a recursive subpattern reference (either by number or
5324: by name) is used outside the parentheses to which it refers, it oper-
5325: ates like a subroutine in a programming language. The "called" subpat-
5326: tern may be defined before or after the reference. A numbered reference
5327: can be absolute or relative, as in these examples:
5328:
5329: (...(absolute)...)...(?2)...
5330: (...(relative)...)...(?-1)...
5331: (...(?+1)...(relative)...
5332:
5333: An earlier example pointed out that the pattern
5334:
5335: (sens|respons)e and \1ibility
5336:
5337: matches "sense and sensibility" and "response and responsibility", but
5338: not "sense and responsibility". If instead the pattern
5339:
5340: (sens|respons)e and (?1)ibility
5341:
5342: is used, it does match "sense and responsibility" as well as the other
5343: two strings. Another example is given in the discussion of DEFINE
5344: above.
5345:
5346: Like recursive subpatterns, a subroutine call is always treated as an
5347: atomic group. That is, once it has matched some of the subject string,
5348: it is never re-entered, even if it contains untried alternatives and
5349: there is a subsequent matching failure. Any capturing parentheses that
5350: are set during the subroutine call revert to their previous values
5351: afterwards.
5352:
5353: When a subpattern is used as a subroutine, processing options such as
5354: case-independence are fixed when the subpattern is defined. They cannot
5355: be changed for different calls. For example, consider this pattern:
5356:
5357: (abc)(?i:(?-1))
5358:
5359: It matches "abcabc". It does not match "abcABC" because the change of
5360: processing option does not affect the called subpattern.
5361:
5362:
5363: ONIGURUMA SUBROUTINE SYNTAX
5364:
5365: For compatibility with Oniguruma, the non-Perl syntax \g followed by a
5366: name or a number enclosed either in angle brackets or single quotes, is
5367: an alternative syntax for referencing a subpattern as a subroutine,
5368: possibly recursively. Here are two of the examples used above, rewrit-
5369: ten using this syntax:
5370:
5371: (?<pn> \( ( (?>[^()]+) | \g<pn> )* \) )
5372: (sens|respons)e and \g'1'ibility
5373:
5374: PCRE supports an extension to Oniguruma: if a number is preceded by a
5375: plus or a minus sign it is taken as a relative reference. For example:
5376:
5377: (abc)(?i:\g<-1>)
5378:
5379: Note that \g{...} (Perl syntax) and \g<...> (Oniguruma syntax) are not
5380: synonymous. The former is a back reference; the latter is a subroutine
5381: call.
5382:
5383:
5384: CALLOUTS
5385:
5386: Perl has a feature whereby using the sequence (?{...}) causes arbitrary
5387: Perl code to be obeyed in the middle of matching a regular expression.
5388: This makes it possible, amongst other things, to extract different sub-
5389: strings that match the same pair of parentheses when there is a repeti-
5390: tion.
5391:
5392: PCRE provides a similar feature, but of course it cannot obey arbitrary
5393: Perl code. The feature is called "callout". The caller of PCRE provides
5394: an external function by putting its entry point in the global variable
5395: pcre_callout. By default, this variable contains NULL, which disables
5396: all calling out.
5397:
5398: Within a regular expression, (?C) indicates the points at which the
5399: external function is to be called. If you want to identify different
5400: callout points, you can put a number less than 256 after the letter C.
5401: The default value is zero. For example, this pattern has two callout
5402: points:
5403:
5404: (?C1)abc(?C2)def
5405:
5406: If the PCRE_AUTO_CALLOUT flag is passed to pcre_compile(), callouts are
5407: automatically installed before each item in the pattern. They are all
5408: numbered 255.
5409:
5410: During matching, when PCRE reaches a callout point (and pcre_callout is
5411: set), the external function is called. It is provided with the number
5412: of the callout, the position in the pattern, and, optionally, one item
5413: of data originally supplied by the caller of pcre_exec(). The callout
5414: function may cause matching to proceed, to backtrack, or to fail alto-
5415: gether. A complete description of the interface to the callout function
5416: is given in the pcrecallout documentation.
5417:
5418:
5419: BACKTRACKING CONTROL
5420:
5421: Perl 5.10 introduced a number of "Special Backtracking Control Verbs",
5422: which are described in the Perl documentation as "experimental and sub-
5423: ject to change or removal in a future version of Perl". It goes on to
5424: say: "Their usage in production code should be noted to avoid problems
5425: during upgrades." The same remarks apply to the PCRE features described
5426: in this section.
5427:
5428: Since these verbs are specifically related to backtracking, most of
5429: them can be used only when the pattern is to be matched using
5430: pcre_exec(), which uses a backtracking algorithm. With the exception of
5431: (*FAIL), which behaves like a failing negative assertion, they cause an
5432: error if encountered by pcre_dfa_exec().
5433:
5434: If any of these verbs are used in an assertion or subroutine subpattern
5435: (including recursive subpatterns), their effect is confined to that
5436: subpattern; it does not extend to the surrounding pattern. Note that
5437: such subpatterns are processed as anchored at the point where they are
5438: tested.
5439:
5440: The new verbs make use of what was previously invalid syntax: an open-
5441: ing parenthesis followed by an asterisk. They are generally of the form
5442: (*VERB) or (*VERB:NAME). Some may take either form, with differing be-
5443: haviour, depending on whether or not an argument is present. An name is
5444: a sequence of letters, digits, and underscores. If the name is empty,
5445: that is, if the closing parenthesis immediately follows the colon, the
5446: effect is as if the colon were not there. Any number of these verbs may
5447: occur in a pattern.
5448:
5449: PCRE contains some optimizations that are used to speed up matching by
5450: running some checks at the start of each match attempt. For example, it
5451: may know the minimum length of matching subject, or that a particular
5452: character must be present. When one of these optimizations suppresses
5453: the running of a match, any included backtracking verbs will not, of
5454: course, be processed. You can suppress the start-of-match optimizations
5455: by setting the PCRE_NO_START_OPTIMIZE option when calling pcre_com-
5456: pile() or pcre_exec(), or by starting the pattern with (*NO_START_OPT).
5457:
5458: Verbs that act immediately
5459:
5460: The following verbs act as soon as they are encountered. They may not
5461: be followed by a name.
5462:
5463: (*ACCEPT)
5464:
5465: This verb causes the match to end successfully, skipping the remainder
5466: of the pattern. When inside a recursion, only the innermost pattern is
5467: ended immediately. If (*ACCEPT) is inside capturing parentheses, the
5468: data so far is captured. (This feature was added to PCRE at release
5469: 8.00.) For example:
5470:
5471: A((?:A|B(*ACCEPT)|C)D)
5472:
5473: This matches "AB", "AAD", or "ACD"; when it matches "AB", "B" is cap-
5474: tured by the outer parentheses.
5475:
5476: (*FAIL) or (*F)
5477:
5478: This verb causes the match to fail, forcing backtracking to occur. It
5479: is equivalent to (?!) but easier to read. The Perl documentation notes
5480: that it is probably useful only when combined with (?{}) or (??{}).
5481: Those are, of course, Perl features that are not present in PCRE. The
5482: nearest equivalent is the callout feature, as for example in this pat-
5483: tern:
5484:
5485: a+(?C)(*FAIL)
5486:
5487: A match with the string "aaaa" always fails, but the callout is taken
5488: before each backtrack happens (in this example, 10 times).
5489:
5490: Recording which path was taken
5491:
5492: There is one verb whose main purpose is to track how a match was
5493: arrived at, though it also has a secondary use in conjunction with
5494: advancing the match starting point (see (*SKIP) below).
5495:
5496: (*MARK:NAME) or (*:NAME)
5497:
5498: A name is always required with this verb. There may be as many
5499: instances of (*MARK) as you like in a pattern, and their names do not
5500: have to be unique.
5501:
5502: When a match succeeds, the name of the last-encountered (*MARK) is
5503: passed back to the caller via the pcre_extra data structure, as
5504: described in the section on pcre_extra in the pcreapi documentation. No
5505: data is returned for a partial match. Here is an example of pcretest
5506: output, where the /K modifier requests the retrieval and outputting of
5507: (*MARK) data:
5508:
5509: /X(*MARK:A)Y|X(*MARK:B)Z/K
5510: XY
5511: 0: XY
5512: MK: A
5513: XZ
5514: 0: XZ
5515: MK: B
5516:
5517: The (*MARK) name is tagged with "MK:" in this output, and in this exam-
5518: ple it indicates which of the two alternatives matched. This is a more
5519: efficient way of obtaining this information than putting each alterna-
5520: tive in its own capturing parentheses.
5521:
5522: A name may also be returned after a failed match if the final path
5523: through the pattern involves (*MARK). However, unless (*MARK) used in
5524: conjunction with (*COMMIT), this is unlikely to happen for an unan-
5525: chored pattern because, as the starting point for matching is advanced,
5526: the final check is often with an empty string, causing a failure before
5527: (*MARK) is reached. For example:
5528:
5529: /X(*MARK:A)Y|X(*MARK:B)Z/K
5530: XP
5531: No match
5532:
5533: There are three potential starting points for this match (starting with
5534: X, starting with P, and with an empty string). If the pattern is
5535: anchored, the result is different:
5536:
5537: /^X(*MARK:A)Y|^X(*MARK:B)Z/K
5538: XP
5539: No match, mark = B
5540:
5541: PCRE's start-of-match optimizations can also interfere with this. For
5542: example, if, as a result of a call to pcre_study(), it knows the mini-
5543: mum subject length for a match, a shorter subject will not be scanned
5544: at all.
5545:
5546: Note that similar anomalies (though different in detail) exist in Perl,
5547: no doubt for the same reasons. The use of (*MARK) data after a failed
5548: match of an unanchored pattern is not recommended, unless (*COMMIT) is
5549: involved.
5550:
5551: Verbs that act after backtracking
5552:
5553: The following verbs do nothing when they are encountered. Matching con-
5554: tinues with what follows, but if there is no subsequent match, causing
5555: a backtrack to the verb, a failure is forced. That is, backtracking
5556: cannot pass to the left of the verb. However, when one of these verbs
5557: appears inside an atomic group, its effect is confined to that group,
5558: because once the group has been matched, there is never any backtrack-
5559: ing into it. In this situation, backtracking can "jump back" to the
5560: left of the entire atomic group. (Remember also, as stated above, that
5561: this localization also applies in subroutine calls and assertions.)
5562:
5563: These verbs differ in exactly what kind of failure occurs when back-
5564: tracking reaches them.
5565:
5566: (*COMMIT)
5567:
5568: This verb, which may not be followed by a name, causes the whole match
5569: to fail outright if the rest of the pattern does not match. Even if the
5570: pattern is unanchored, no further attempts to find a match by advancing
5571: the starting point take place. Once (*COMMIT) has been passed,
5572: pcre_exec() is committed to finding a match at the current starting
5573: point, or not at all. For example:
5574:
5575: a+(*COMMIT)b
5576:
5577: This matches "xxaab" but not "aacaab". It can be thought of as a kind
5578: of dynamic anchor, or "I've started, so I must finish." The name of the
5579: most recently passed (*MARK) in the path is passed back when (*COMMIT)
5580: forces a match failure.
5581:
5582: Note that (*COMMIT) at the start of a pattern is not the same as an
5583: anchor, unless PCRE's start-of-match optimizations are turned off, as
5584: shown in this pcretest example:
5585:
5586: /(*COMMIT)abc/
5587: xyzabc
5588: 0: abc
5589: xyzabc\Y
5590: No match
5591:
5592: PCRE knows that any match must start with "a", so the optimization
5593: skips along the subject to "a" before running the first match attempt,
5594: which succeeds. When the optimization is disabled by the \Y escape in
5595: the second subject, the match starts at "x" and so the (*COMMIT) causes
5596: it to fail without trying any other starting points.
5597:
5598: (*PRUNE) or (*PRUNE:NAME)
5599:
5600: This verb causes the match to fail at the current starting position in
5601: the subject if the rest of the pattern does not match. If the pattern
5602: is unanchored, the normal "bumpalong" advance to the next starting
5603: character then happens. Backtracking can occur as usual to the left of
5604: (*PRUNE), before it is reached, or when matching to the right of
5605: (*PRUNE), but if there is no match to the right, backtracking cannot
5606: cross (*PRUNE). In simple cases, the use of (*PRUNE) is just an alter-
5607: native to an atomic group or possessive quantifier, but there are some
5608: uses of (*PRUNE) that cannot be expressed in any other way. The behav-
5609: iour of (*PRUNE:NAME) is the same as (*MARK:NAME)(*PRUNE) when the
5610: match fails completely; the name is passed back if this is the final
5611: attempt. (*PRUNE:NAME) does not pass back a name if the match suc-
5612: ceeds. In an anchored pattern (*PRUNE) has the same effect as (*COM-
5613: MIT).
5614:
5615: (*SKIP)
5616:
5617: This verb, when given without a name, is like (*PRUNE), except that if
5618: the pattern is unanchored, the "bumpalong" advance is not to the next
5619: character, but to the position in the subject where (*SKIP) was encoun-
5620: tered. (*SKIP) signifies that whatever text was matched leading up to
5621: it cannot be part of a successful match. Consider:
5622:
5623: a+(*SKIP)b
5624:
5625: If the subject is "aaaac...", after the first match attempt fails
5626: (starting at the first character in the string), the starting point
5627: skips on to start the next attempt at "c". Note that a possessive quan-
5628: tifer does not have the same effect as this example; although it would
5629: suppress backtracking during the first match attempt, the second
5630: attempt would start at the second character instead of skipping on to
5631: "c".
5632:
5633: (*SKIP:NAME)
5634:
5635: When (*SKIP) has an associated name, its behaviour is modified. If the
5636: following pattern fails to match, the previous path through the pattern
5637: is searched for the most recent (*MARK) that has the same name. If one
5638: is found, the "bumpalong" advance is to the subject position that cor-
5639: responds to that (*MARK) instead of to where (*SKIP) was encountered.
5640: If no (*MARK) with a matching name is found, normal "bumpalong" of one
5641: character happens (the (*SKIP) is ignored).
5642:
5643: (*THEN) or (*THEN:NAME)
5644:
5645: This verb causes a skip to the next alternation in the innermost
5646: enclosing group if the rest of the pattern does not match. That is, it
5647: cancels pending backtracking, but only within the current alternation.
5648: Its name comes from the observation that it can be used for a pattern-
5649: based if-then-else block:
5650:
5651: ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
5652:
5653: If the COND1 pattern matches, FOO is tried (and possibly further items
5654: after the end of the group if FOO succeeds); on failure the matcher
5655: skips to the second alternative and tries COND2, without backtracking
5656: into COND1. The behaviour of (*THEN:NAME) is exactly the same as
5657: (*MARK:NAME)(*THEN) if the overall match fails. If (*THEN) is not
5658: directly inside an alternation, it acts like (*PRUNE).
5659:
5660: The above verbs provide four different "strengths" of control when sub-
5661: sequent matching fails. (*THEN) is the weakest, carrying on the match
5662: at the next alternation. (*PRUNE) comes next, failing the match at the
5663: current starting position, but allowing an advance to the next charac-
5664: ter (for an unanchored pattern). (*SKIP) is similar, except that the
5665: advance may be more than one character. (*COMMIT) is the strongest,
5666: causing the entire match to fail.
5667:
5668: If more than one is present in a pattern, the "stongest" one wins. For
5669: example, consider this pattern, where A, B, etc. are complex pattern
5670: fragments:
5671:
5672: (A(*COMMIT)B(*THEN)C|D)
5673:
5674: Once A has matched, PCRE is committed to this match, at the current
5675: starting position. If subsequently B matches, but C does not, the nor-
5676: mal (*THEN) action of trying the next alternation (that is, D) does not
5677: happen because (*COMMIT) overrides.
5678:
5679:
5680: SEE ALSO
5681:
5682: pcreapi(3), pcrecallout(3), pcrematching(3), pcresyntax(3), pcre(3).
5683:
5684:
5685: AUTHOR
5686:
5687: Philip Hazel
5688: University Computing Service
5689: Cambridge CB2 3QH, England.
5690:
5691:
5692: REVISION
5693:
5694: Last updated: 21 November 2010
5695: Copyright (c) 1997-2010 University of Cambridge.
5696: ------------------------------------------------------------------------------
5697:
5698:
5699: PCRESYNTAX(3) PCRESYNTAX(3)
5700:
5701:
5702: NAME
5703: PCRE - Perl-compatible regular expressions
5704:
5705:
5706: PCRE REGULAR EXPRESSION SYNTAX SUMMARY
5707:
5708: The full syntax and semantics of the regular expressions that are sup-
5709: ported by PCRE are described in the pcrepattern documentation. This
5710: document contains just a quick-reference summary of the syntax.
5711:
5712:
5713: QUOTING
5714:
5715: \x where x is non-alphanumeric is a literal x
5716: \Q...\E treat enclosed characters as literal
5717:
5718:
5719: CHARACTERS
5720:
5721: \a alarm, that is, the BEL character (hex 07)
5722: \cx "control-x", where x is any ASCII character
5723: \e escape (hex 1B)
5724: \f formfeed (hex 0C)
5725: \n newline (hex 0A)
5726: \r carriage return (hex 0D)
5727: \t tab (hex 09)
5728: \ddd character with octal code ddd, or backreference
5729: \xhh character with hex code hh
5730: \x{hhh..} character with hex code hhh..
5731:
5732:
5733: CHARACTER TYPES
5734:
5735: . any character except newline;
5736: in dotall mode, any character whatsoever
5737: \C one byte, even in UTF-8 mode (best avoided)
5738: \d a decimal digit
5739: \D a character that is not a decimal digit
5740: \h a horizontal whitespace character
5741: \H a character that is not a horizontal whitespace character
5742: \N a character that is not a newline
5743: \p{xx} a character with the xx property
5744: \P{xx} a character without the xx property
5745: \R a newline sequence
5746: \s a whitespace character
5747: \S a character that is not a whitespace character
5748: \v a vertical whitespace character
5749: \V a character that is not a vertical whitespace character
5750: \w a "word" character
5751: \W a "non-word" character
5752: \X an extended Unicode sequence
5753:
5754: In PCRE, by default, \d, \D, \s, \S, \w, and \W recognize only ASCII
5755: characters, even in UTF-8 mode. However, this can be changed by setting
5756: the PCRE_UCP option.
5757:
5758:
5759: GENERAL CATEGORY PROPERTIES FOR \p and \P
5760:
5761: C Other
5762: Cc Control
5763: Cf Format
5764: Cn Unassigned
5765: Co Private use
5766: Cs Surrogate
5767:
5768: L Letter
5769: Ll Lower case letter
5770: Lm Modifier letter
5771: Lo Other letter
5772: Lt Title case letter
5773: Lu Upper case letter
5774: L& Ll, Lu, or Lt
5775:
5776: M Mark
5777: Mc Spacing mark
5778: Me Enclosing mark
5779: Mn Non-spacing mark
5780:
5781: N Number
5782: Nd Decimal number
5783: Nl Letter number
5784: No Other number
5785:
5786: P Punctuation
5787: Pc Connector punctuation
5788: Pd Dash punctuation
5789: Pe Close punctuation
5790: Pf Final punctuation
5791: Pi Initial punctuation
5792: Po Other punctuation
5793: Ps Open punctuation
5794:
5795: S Symbol
5796: Sc Currency symbol
5797: Sk Modifier symbol
5798: Sm Mathematical symbol
5799: So Other symbol
5800:
5801: Z Separator
5802: Zl Line separator
5803: Zp Paragraph separator
5804: Zs Space separator
5805:
5806:
5807: PCRE SPECIAL CATEGORY PROPERTIES FOR \p and \P
5808:
5809: Xan Alphanumeric: union of properties L and N
5810: Xps POSIX space: property Z or tab, NL, VT, FF, CR
5811: Xsp Perl space: property Z or tab, NL, FF, CR
5812: Xwd Perl word: property Xan or underscore
5813:
5814:
5815: SCRIPT NAMES FOR \p AND \P
5816:
5817: Arabic, Armenian, Avestan, Balinese, Bamum, Bengali, Bopomofo, Braille,
5818: Buginese, Buhid, Canadian_Aboriginal, Carian, Cham, Cherokee, Common,
5819: Coptic, Cuneiform, Cypriot, Cyrillic, Deseret, Devanagari, Egyp-
5820: tian_Hieroglyphs, Ethiopic, Georgian, Glagolitic, Gothic, Greek,
5821: Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew, Hiragana, Impe-
5822: rial_Aramaic, Inherited, Inscriptional_Pahlavi, Inscriptional_Parthian,
5823: Javanese, Kaithi, Kannada, Katakana, Kayah_Li, Kharoshthi, Khmer, Lao,
5824: Latin, Lepcha, Limbu, Linear_B, Lisu, Lycian, Lydian, Malayalam,
5825: Meetei_Mayek, Mongolian, Myanmar, New_Tai_Lue, Nko, Ogham, Old_Italic,
5826: Old_Persian, Old_South_Arabian, Old_Turkic, Ol_Chiki, Oriya, Osmanya,
5827: Phags_Pa, Phoenician, Rejang, Runic, Samaritan, Saurashtra, Shavian,
5828: Sinhala, Sundanese, Syloti_Nagri, Syriac, Tagalog, Tagbanwa, Tai_Le,
5829: Tai_Tham, Tai_Viet, Tamil, Telugu, Thaana, Thai, Tibetan, Tifinagh,
5830: Ugaritic, Vai, Yi.
5831:
5832:
5833: CHARACTER CLASSES
5834:
5835: [...] positive character class
5836: [^...] negative character class
5837: [x-y] range (can be used for hex characters)
5838: [[:xxx:]] positive POSIX named set
5839: [[:^xxx:]] negative POSIX named set
5840:
5841: alnum alphanumeric
5842: alpha alphabetic
5843: ascii 0-127
5844: blank space or tab
5845: cntrl control character
5846: digit decimal digit
5847: graph printing, excluding space
5848: lower lower case letter
5849: print printing, including space
5850: punct printing, excluding alphanumeric
5851: space whitespace
5852: upper upper case letter
5853: word same as \w
5854: xdigit hexadecimal digit
5855:
5856: In PCRE, POSIX character set names recognize only ASCII characters by
5857: default, but some of them use Unicode properties if PCRE_UCP is set.
5858: You can use \Q...\E inside a character class.
5859:
5860:
5861: QUANTIFIERS
5862:
5863: ? 0 or 1, greedy
5864: ?+ 0 or 1, possessive
5865: ?? 0 or 1, lazy
5866: * 0 or more, greedy
5867: *+ 0 or more, possessive
5868: *? 0 or more, lazy
5869: + 1 or more, greedy
5870: ++ 1 or more, possessive
5871: +? 1 or more, lazy
5872: {n} exactly n
5873: {n,m} at least n, no more than m, greedy
5874: {n,m}+ at least n, no more than m, possessive
5875: {n,m}? at least n, no more than m, lazy
5876: {n,} n or more, greedy
5877: {n,}+ n or more, possessive
5878: {n,}? n or more, lazy
5879:
5880:
5881: ANCHORS AND SIMPLE ASSERTIONS
5882:
5883: \b word boundary
5884: \B not a word boundary
5885: ^ start of subject
5886: also after internal newline in multiline mode
5887: \A start of subject
5888: $ end of subject
5889: also before newline at end of subject
5890: also before internal newline in multiline mode
5891: \Z end of subject
5892: also before newline at end of subject
5893: \z end of subject
5894: \G first matching position in subject
5895:
5896:
5897: MATCH POINT RESET
5898:
5899: \K reset start of match
5900:
5901:
5902: ALTERNATION
5903:
5904: expr|expr|expr...
5905:
5906:
5907: CAPTURING
5908:
5909: (...) capturing group
5910: (?<name>...) named capturing group (Perl)
5911: (?'name'...) named capturing group (Perl)
5912: (?P<name>...) named capturing group (Python)
5913: (?:...) non-capturing group
5914: (?|...) non-capturing group; reset group numbers for
5915: capturing groups in each alternative
5916:
5917:
5918: ATOMIC GROUPS
5919:
5920: (?>...) atomic, non-capturing group
5921:
5922:
5923: COMMENT
5924:
5925: (?#....) comment (not nestable)
5926:
5927:
5928: OPTION SETTING
5929:
5930: (?i) caseless
5931: (?J) allow duplicate names
5932: (?m) multiline
5933: (?s) single line (dotall)
5934: (?U) default ungreedy (lazy)
5935: (?x) extended (ignore white space)
5936: (?-...) unset option(s)
5937:
5938: The following are recognized only at the start of a pattern or after
5939: one of the newline-setting options with similar syntax:
5940:
5941: (*NO_START_OPT) no start-match optimization (PCRE_NO_START_OPTIMIZE)
5942: (*UTF8) set UTF-8 mode (PCRE_UTF8)
5943: (*UCP) set PCRE_UCP (use Unicode properties for \d etc)
5944:
5945:
5946: LOOKAHEAD AND LOOKBEHIND ASSERTIONS
5947:
5948: (?=...) positive look ahead
5949: (?!...) negative look ahead
5950: (?<=...) positive look behind
5951: (?<!...) negative look behind
5952:
5953: Each top-level branch of a look behind must be of a fixed length.
5954:
5955:
5956: BACKREFERENCES
5957:
5958: \n reference by number (can be ambiguous)
5959: \gn reference by number
5960: \g{n} reference by number
5961: \g{-n} relative reference by number
5962: \k<name> reference by name (Perl)
5963: \k'name' reference by name (Perl)
5964: \g{name} reference by name (Perl)
5965: \k{name} reference by name (.NET)
5966: (?P=name) reference by name (Python)
5967:
5968:
5969: SUBROUTINE REFERENCES (POSSIBLY RECURSIVE)
5970:
5971: (?R) recurse whole pattern
5972: (?n) call subpattern by absolute number
5973: (?+n) call subpattern by relative number
5974: (?-n) call subpattern by relative number
5975: (?&name) call subpattern by name (Perl)
5976: (?P>name) call subpattern by name (Python)
5977: \g<name> call subpattern by name (Oniguruma)
5978: \g'name' call subpattern by name (Oniguruma)
5979: \g<n> call subpattern by absolute number (Oniguruma)
5980: \g'n' call subpattern by absolute number (Oniguruma)
5981: \g<+n> call subpattern by relative number (PCRE extension)
5982: \g'+n' call subpattern by relative number (PCRE extension)
5983: \g<-n> call subpattern by relative number (PCRE extension)
5984: \g'-n' call subpattern by relative number (PCRE extension)
5985:
5986:
5987: CONDITIONAL PATTERNS
5988:
5989: (?(condition)yes-pattern)
5990: (?(condition)yes-pattern|no-pattern)
5991:
5992: (?(n)... absolute reference condition
5993: (?(+n)... relative reference condition
5994: (?(-n)... relative reference condition
5995: (?(<name>)... named reference condition (Perl)
5996: (?('name')... named reference condition (Perl)
5997: (?(name)... named reference condition (PCRE)
5998: (?(R)... overall recursion condition
5999: (?(Rn)... specific group recursion condition
6000: (?(R&name)... specific recursion condition
6001: (?(DEFINE)... define subpattern for reference
6002: (?(assert)... assertion condition
6003:
6004:
6005: BACKTRACKING CONTROL
6006:
6007: The following act immediately they are reached:
6008:
6009: (*ACCEPT) force successful match
6010: (*FAIL) force backtrack; synonym (*F)
6011:
6012: The following act only when a subsequent match failure causes a back-
6013: track to reach them. They all force a match failure, but they differ in
6014: what happens afterwards. Those that advance the start-of-match point do
6015: so only if the pattern is not anchored.
6016:
6017: (*COMMIT) overall failure, no advance of starting point
6018: (*PRUNE) advance to next starting character
6019: (*SKIP) advance start to current matching position
6020: (*THEN) local failure, backtrack to next alternation
6021:
6022:
6023: NEWLINE CONVENTIONS
6024:
6025: These are recognized only at the very start of the pattern or after a
6026: (*BSR_...) or (*UTF8) or (*UCP) option.
6027:
6028: (*CR) carriage return only
6029: (*LF) linefeed only
6030: (*CRLF) carriage return followed by linefeed
6031: (*ANYCRLF) all three of the above
6032: (*ANY) any Unicode newline sequence
6033:
6034:
6035: WHAT \R MATCHES
6036:
6037: These are recognized only at the very start of the pattern or after a
6038: (*...) option that sets the newline convention or UTF-8 or UCP mode.
6039:
6040: (*BSR_ANYCRLF) CR, LF, or CRLF
6041: (*BSR_UNICODE) any Unicode newline sequence
6042:
6043:
6044: CALLOUTS
6045:
6046: (?C) callout
6047: (?Cn) callout with data n
6048:
6049:
6050: SEE ALSO
6051:
6052: pcrepattern(3), pcreapi(3), pcrecallout(3), pcrematching(3), pcre(3).
6053:
6054:
6055: AUTHOR
6056:
6057: Philip Hazel
6058: University Computing Service
6059: Cambridge CB2 3QH, England.
6060:
6061:
6062: REVISION
6063:
6064: Last updated: 21 November 2010
6065: Copyright (c) 1997-2010 University of Cambridge.
6066: ------------------------------------------------------------------------------
6067:
6068:
6069: PCREPARTIAL(3) PCREPARTIAL(3)
6070:
6071:
6072: NAME
6073: PCRE - Perl-compatible regular expressions
6074:
6075:
6076: PARTIAL MATCHING IN PCRE
6077:
6078: In normal use of PCRE, if the subject string that is passed to
6079: pcre_exec() or pcre_dfa_exec() matches as far as it goes, but is too
6080: short to match the entire pattern, PCRE_ERROR_NOMATCH is returned.
6081: There are circumstances where it might be helpful to distinguish this
6082: case from other cases in which there is no match.
6083:
6084: Consider, for example, an application where a human is required to type
6085: in data for a field with specific formatting requirements. An example
6086: might be a date in the form ddmmmyy, defined by this pattern:
6087:
6088: ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
6089:
6090: If the application sees the user's keystrokes one by one, and can check
6091: that what has been typed so far is potentially valid, it is able to
6092: raise an error as soon as a mistake is made, by beeping and not
6093: reflecting the character that has been typed, for example. This immedi-
6094: ate feedback is likely to be a better user interface than a check that
6095: is delayed until the entire string has been entered. Partial matching
6096: can also be useful when the subject string is very long and is not all
6097: available at once.
6098:
6099: PCRE supports partial matching by means of the PCRE_PARTIAL_SOFT and
6100: PCRE_PARTIAL_HARD options, which can be set when calling pcre_exec() or
6101: pcre_dfa_exec(). For backwards compatibility, PCRE_PARTIAL is a synonym
6102: for PCRE_PARTIAL_SOFT. The essential difference between the two options
6103: is whether or not a partial match is preferred to an alternative com-
6104: plete match, though the details differ between the two matching func-
6105: tions. If both options are set, PCRE_PARTIAL_HARD takes precedence.
6106:
6107: Setting a partial matching option disables two of PCRE's optimizations.
6108: PCRE remembers the last literal byte in a pattern, and abandons match-
6109: ing immediately if such a byte is not present in the subject string.
6110: This optimization cannot be used for a subject string that might match
6111: only partially. If the pattern was studied, PCRE knows the minimum
6112: length of a matching string, and does not bother to run the matching
6113: function on shorter strings. This optimization is also disabled for
6114: partial matching.
6115:
6116:
6117: PARTIAL MATCHING USING pcre_exec()
6118:
6119: A partial match occurs during a call to pcre_exec() when the end of the
6120: subject string is reached successfully, but matching cannot continue
6121: because more characters are needed. However, at least one character in
6122: the subject must have been inspected. This character need not form part
6123: of the final matched string; lookbehind assertions and the \K escape
6124: sequence provide ways of inspecting characters before the start of a
6125: matched substring. The requirement for inspecting at least one charac-
6126: ter exists because an empty string can always be matched; without such
6127: a restriction there would always be a partial match of an empty string
6128: at the end of the subject.
6129:
6130: If there are at least two slots in the offsets vector when pcre_exec()
6131: returns with a partial match, the first slot is set to the offset of
6132: the earliest character that was inspected when the partial match was
6133: found. For convenience, the second offset points to the end of the sub-
6134: ject so that a substring can easily be identified.
6135:
6136: For the majority of patterns, the first offset identifies the start of
6137: the partially matched string. However, for patterns that contain look-
6138: behind assertions, or \K, or begin with \b or \B, earlier characters
6139: have been inspected while carrying out the match. For example:
6140:
6141: /(?<=abc)123/
6142:
6143: This pattern matches "123", but only if it is preceded by "abc". If the
6144: subject string is "xyzabc12", the offsets after a partial match are for
6145: the substring "abc12", because all these characters are needed if
6146: another match is tried with extra characters added to the subject.
6147:
6148: What happens when a partial match is identified depends on which of the
6149: two partial matching options are set.
6150:
6151: PCRE_PARTIAL_SOFT with pcre_exec()
6152:
6153: If PCRE_PARTIAL_SOFT is set when pcre_exec() identifies a partial
6154: match, the partial match is remembered, but matching continues as nor-
6155: mal, and other alternatives in the pattern are tried. If no complete
6156: match can be found, pcre_exec() returns PCRE_ERROR_PARTIAL instead of
6157: PCRE_ERROR_NOMATCH.
6158:
6159: This option is "soft" because it prefers a complete match over a par-
6160: tial match. All the various matching items in a pattern behave as if
6161: the subject string is potentially complete. For example, \z, \Z, and $
6162: match at the end of the subject, as normal, and for \b and \B the end
6163: of the subject is treated as a non-alphanumeric.
6164:
6165: If there is more than one partial match, the first one that was found
6166: provides the data that is returned. Consider this pattern:
6167:
6168: /123\w+X|dogY/
6169:
6170: If this is matched against the subject string "abc123dog", both alter-
6171: natives fail to match, but the end of the subject is reached during
6172: matching, so PCRE_ERROR_PARTIAL is returned. The offsets are set to 3
6173: and 9, identifying "123dog" as the first partial match that was found.
6174: (In this example, there are two partial matches, because "dog" on its
6175: own partially matches the second alternative.)
6176:
6177: PCRE_PARTIAL_HARD with pcre_exec()
6178:
6179: If PCRE_PARTIAL_HARD is set for pcre_exec(), it returns PCRE_ERROR_PAR-
6180: TIAL as soon as a partial match is found, without continuing to search
6181: for possible complete matches. This option is "hard" because it prefers
6182: an earlier partial match over a later complete match. For this reason,
6183: the assumption is made that the end of the supplied subject string may
6184: not be the true end of the available data, and so, if \z, \Z, \b, \B,
6185: or $ are encountered at the end of the subject, the result is
6186: PCRE_ERROR_PARTIAL.
6187:
6188: Setting PCRE_PARTIAL_HARD also affects the way pcre_exec() checks UTF-8
6189: subject strings for validity. Normally, an invalid UTF-8 sequence
6190: causes the error PCRE_ERROR_BADUTF8. However, in the special case of a
6191: truncated UTF-8 character at the end of the subject, PCRE_ERROR_SHORT-
6192: UTF8 is returned when PCRE_PARTIAL_HARD is set.
6193:
6194: Comparing hard and soft partial matching
6195:
6196: The difference between the two partial matching options can be illus-
6197: trated by a pattern such as:
6198:
6199: /dog(sbody)?/
6200:
6201: This matches either "dog" or "dogsbody", greedily (that is, it prefers
6202: the longer string if possible). If it is matched against the string
6203: "dog" with PCRE_PARTIAL_SOFT, it yields a complete match for "dog".
6204: However, if PCRE_PARTIAL_HARD is set, the result is PCRE_ERROR_PARTIAL.
6205: On the other hand, if the pattern is made ungreedy the result is dif-
6206: ferent:
6207:
6208: /dog(sbody)??/
6209:
6210: In this case the result is always a complete match because pcre_exec()
6211: finds that first, and it never continues after finding a match. It
6212: might be easier to follow this explanation by thinking of the two pat-
6213: terns like this:
6214:
6215: /dog(sbody)?/ is the same as /dogsbody|dog/
6216: /dog(sbody)??/ is the same as /dog|dogsbody/
6217:
6218: The second pattern will never match "dogsbody" when pcre_exec() is
6219: used, because it will always find the shorter match first.
6220:
6221:
6222: PARTIAL MATCHING USING pcre_dfa_exec()
6223:
6224: The pcre_dfa_exec() function moves along the subject string character
6225: by character, without backtracking, searching for all possible matches
6226: simultaneously. If the end of the subject is reached before the end of
6227: the pattern, there is the possibility of a partial match, again pro-
6228: vided that at least one character has been inspected.
6229:
6230: When PCRE_PARTIAL_SOFT is set, PCRE_ERROR_PARTIAL is returned only if
6231: there have been no complete matches. Otherwise, the complete matches
6232: are returned. However, if PCRE_PARTIAL_HARD is set, a partial match
6233: takes precedence over any complete matches. The portion of the string
6234: that was inspected when the longest partial match was found is set as
6235: the first matching string, provided there are at least two slots in the
6236: offsets vector.
6237:
6238: Because pcre_dfa_exec() always searches for all possible matches, and
6239: there is no difference between greedy and ungreedy repetition, its be-
6240: haviour is different from pcre_exec when PCRE_PARTIAL_HARD is set. Con-
6241: sider the string "dog" matched against the ungreedy pattern shown
6242: above:
6243:
6244: /dog(sbody)??/
6245:
6246: Whereas pcre_exec() stops as soon as it finds the complete match for
6247: "dog", pcre_dfa_exec() also finds the partial match for "dogsbody", and
6248: so returns that when PCRE_PARTIAL_HARD is set.
6249:
6250:
6251: PARTIAL MATCHING AND WORD BOUNDARIES
6252:
6253: If a pattern ends with one of sequences \b or \B, which test for word
6254: boundaries, partial matching with PCRE_PARTIAL_SOFT can give counter-
6255: intuitive results. Consider this pattern:
6256:
6257: /\bcat\b/
6258:
6259: This matches "cat", provided there is a word boundary at either end. If
6260: the subject string is "the cat", the comparison of the final "t" with a
6261: following character cannot take place, so a partial match is found.
6262: However, pcre_exec() carries on with normal matching, which matches \b
6263: at the end of the subject when the last character is a letter, thus
6264: finding a complete match. The result, therefore, is not PCRE_ERROR_PAR-
6265: TIAL. The same thing happens with pcre_dfa_exec(), because it also
6266: finds the complete match.
6267:
6268: Using PCRE_PARTIAL_HARD in this case does yield PCRE_ERROR_PARTIAL,
6269: because then the partial match takes precedence.
6270:
6271:
6272: FORMERLY RESTRICTED PATTERNS
6273:
6274: For releases of PCRE prior to 8.00, because of the way certain internal
6275: optimizations were implemented in the pcre_exec() function, the
6276: PCRE_PARTIAL option (predecessor of PCRE_PARTIAL_SOFT) could not be
6277: used with all patterns. From release 8.00 onwards, the restrictions no
6278: longer apply, and partial matching with pcre_exec() can be requested
6279: for any pattern.
6280:
6281: Items that were formerly restricted were repeated single characters and
6282: repeated metasequences. If PCRE_PARTIAL was set for a pattern that did
6283: not conform to the restrictions, pcre_exec() returned the error code
6284: PCRE_ERROR_BADPARTIAL (-13). This error code is no longer in use. The
6285: PCRE_INFO_OKPARTIAL call to pcre_fullinfo() to find out if a compiled
6286: pattern can be used for partial matching now always returns 1.
6287:
6288:
6289: EXAMPLE OF PARTIAL MATCHING USING PCRETEST
6290:
6291: If the escape sequence \P is present in a pcretest data line, the
6292: PCRE_PARTIAL_SOFT option is used for the match. Here is a run of
6293: pcretest that uses the date example quoted above:
6294:
6295: re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
6296: data> 25jun04\P
6297: 0: 25jun04
6298: 1: jun
6299: data> 25dec3\P
6300: Partial match: 23dec3
6301: data> 3ju\P
6302: Partial match: 3ju
6303: data> 3juj\P
6304: No match
6305: data> j\P
6306: No match
6307:
6308: The first data string is matched completely, so pcretest shows the
6309: matched substrings. The remaining four strings do not match the com-
6310: plete pattern, but the first two are partial matches. Similar output is
6311: obtained when pcre_dfa_exec() is used.
6312:
6313: If the escape sequence \P is present more than once in a pcretest data
6314: line, the PCRE_PARTIAL_HARD option is set for the match.
6315:
6316:
6317: MULTI-SEGMENT MATCHING WITH pcre_dfa_exec()
6318:
6319: When a partial match has been found using pcre_dfa_exec(), it is possi-
6320: ble to continue the match by providing additional subject data and
6321: calling pcre_dfa_exec() again with the same compiled regular expres-
6322: sion, this time setting the PCRE_DFA_RESTART option. You must pass the
6323: same working space as before, because this is where details of the pre-
6324: vious partial match are stored. Here is an example using pcretest,
6325: using the \R escape sequence to set the PCRE_DFA_RESTART option (\D
6326: specifies the use of pcre_dfa_exec()):
6327:
6328: re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
6329: data> 23ja\P\D
6330: Partial match: 23ja
6331: data> n05\R\D
6332: 0: n05
6333:
6334: The first call has "23ja" as the subject, and requests partial match-
6335: ing; the second call has "n05" as the subject for the continued
6336: (restarted) match. Notice that when the match is complete, only the
6337: last part is shown; PCRE does not retain the previously partially-
6338: matched string. It is up to the calling program to do that if it needs
6339: to.
6340:
6341: You can set the PCRE_PARTIAL_SOFT or PCRE_PARTIAL_HARD options with
6342: PCRE_DFA_RESTART to continue partial matching over multiple segments.
6343: This facility can be used to pass very long subject strings to
6344: pcre_dfa_exec().
6345:
6346:
6347: MULTI-SEGMENT MATCHING WITH pcre_exec()
6348:
6349: From release 8.00, pcre_exec() can also be used to do multi-segment
6350: matching. Unlike pcre_dfa_exec(), it is not possible to restart the
6351: previous match with a new segment of data. Instead, new data must be
6352: added to the previous subject string, and the entire match re-run,
6353: starting from the point where the partial match occurred. Earlier data
6354: can be discarded. It is best to use PCRE_PARTIAL_HARD in this situa-
6355: tion, because it does not treat the end of a segment as the end of the
6356: subject when matching \z, \Z, \b, \B, and $. Consider an unanchored
6357: pattern that matches dates:
6358:
6359: re> /\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d/
6360: data> The date is 23ja\P\P
6361: Partial match: 23ja
6362:
6363: At this stage, an application could discard the text preceding "23ja",
6364: add on text from the next segment, and call pcre_exec() again. Unlike
6365: pcre_dfa_exec(), the entire matching string must always be available,
6366: and the complete matching process occurs for each call, so more memory
6367: and more processing time is needed.
6368:
6369: Note: If the pattern contains lookbehind assertions, or \K, or starts
6370: with \b or \B, the string that is returned for a partial match will
6371: include characters that precede the partially matched string itself,
6372: because these must be retained when adding on more characters for a
6373: subsequent matching attempt.
6374:
6375:
6376: ISSUES WITH MULTI-SEGMENT MATCHING
6377:
6378: Certain types of pattern may give problems with multi-segment matching,
6379: whichever matching function is used.
6380:
6381: 1. If the pattern contains a test for the beginning of a line, you need
6382: to pass the PCRE_NOTBOL option when the subject string for any call
6383: does start at the beginning of a line. There is also a PCRE_NOTEOL
6384: option, but in practice when doing multi-segment matching you should be
6385: using PCRE_PARTIAL_HARD, which includes the effect of PCRE_NOTEOL.
6386:
6387: 2. Lookbehind assertions at the start of a pattern are catered for in
6388: the offsets that are returned for a partial match. However, in theory,
6389: a lookbehind assertion later in the pattern could require even earlier
6390: characters to be inspected, and it might not have been reached when a
6391: partial match occurs. This is probably an extremely unlikely case; you
6392: could guard against it to a certain extent by always including extra
6393: characters at the start.
6394:
6395: 3. Matching a subject string that is split into multiple segments may
6396: not always produce exactly the same result as matching over one single
6397: long string, especially when PCRE_PARTIAL_SOFT is used. The section
6398: "Partial Matching and Word Boundaries" above describes an issue that
6399: arises if the pattern ends with \b or \B. Another kind of difference
6400: may occur when there are multiple matching possibilities, because (for
6401: PCRE_PARTIAL_SOFT) a partial match result is given only when there are
6402: no completed matches. This means that as soon as the shortest match has
6403: been found, continuation to a new subject segment is no longer possi-
6404: ble. Consider again this pcretest example:
6405:
6406: re> /dog(sbody)?/
6407: data> dogsb\P
6408: 0: dog
6409: data> do\P\D
6410: Partial match: do
6411: data> gsb\R\P\D
6412: 0: g
6413: data> dogsbody\D
6414: 0: dogsbody
6415: 1: dog
6416:
6417: The first data line passes the string "dogsb" to pcre_exec(), setting
6418: the PCRE_PARTIAL_SOFT option. Although the string is a partial match
6419: for "dogsbody", the result is not PCRE_ERROR_PARTIAL, because the
6420: shorter string "dog" is a complete match. Similarly, when the subject
6421: is presented to pcre_dfa_exec() in several parts ("do" and "gsb" being
6422: the first two) the match stops when "dog" has been found, and it is not
6423: possible to continue. On the other hand, if "dogsbody" is presented as
6424: a single string, pcre_dfa_exec() finds both matches.
6425:
6426: Because of these problems, it is best to use PCRE_PARTIAL_HARD when
6427: matching multi-segment data. The example above then behaves differ-
6428: ently:
6429:
6430: re> /dog(sbody)?/
6431: data> dogsb\P\P
6432: Partial match: dogsb
6433: data> do\P\D
6434: Partial match: do
6435: data> gsb\R\P\P\D
6436: Partial match: gsb
6437:
6438: 4. Patterns that contain alternatives at the top level which do not all
6439: start with the same pattern item may not work as expected when
6440: PCRE_DFA_RESTART is used with pcre_dfa_exec(). For example, consider
6441: this pattern:
6442:
6443: 1234|3789
6444:
6445: If the first part of the subject is "ABC123", a partial match of the
6446: first alternative is found at offset 3. There is no partial match for
6447: the second alternative, because such a match does not start at the same
6448: point in the subject string. Attempting to continue with the string
6449: "7890" does not yield a match because only those alternatives that
6450: match at one point in the subject are remembered. The problem arises
6451: because the start of the second alternative matches within the first
6452: alternative. There is no problem with anchored patterns or patterns
6453: such as:
6454:
6455: 1234|ABCD
6456:
6457: where no string can be a partial match for both alternatives. This is
6458: not a problem if pcre_exec() is used, because the entire match has to
6459: be rerun each time:
6460:
6461: re> /1234|3789/
6462: data> ABC123\P\P
6463: Partial match: 123
6464: data> 1237890
6465: 0: 3789
6466:
6467: Of course, instead of using PCRE_DFA_RESTART, the same technique of re-
6468: running the entire match can also be used with pcre_dfa_exec(). Another
6469: possibility is to work with two buffers. If a partial match at offset n
6470: in the first buffer is followed by "no match" when PCRE_DFA_RESTART is
6471: used on the second buffer, you can then try a new match starting at
6472: offset n+1 in the first buffer.
6473:
6474:
6475: AUTHOR
6476:
6477: Philip Hazel
6478: University Computing Service
6479: Cambridge CB2 3QH, England.
6480:
6481:
6482: REVISION
6483:
6484: Last updated: 07 November 2010
6485: Copyright (c) 1997-2010 University of Cambridge.
6486: ------------------------------------------------------------------------------
6487:
6488:
6489: PCREPRECOMPILE(3) PCREPRECOMPILE(3)
6490:
6491:
6492: NAME
6493: PCRE - Perl-compatible regular expressions
6494:
6495:
6496: SAVING AND RE-USING PRECOMPILED PCRE PATTERNS
6497:
6498: If you are running an application that uses a large number of regular
6499: expression patterns, it may be useful to store them in a precompiled
6500: form instead of having to compile them every time the application is
6501: run. If you are not using any private character tables (see the
6502: pcre_maketables() documentation), this is relatively straightforward.
6503: If you are using private tables, it is a little bit more complicated.
6504:
6505: If you save compiled patterns to a file, you can copy them to a differ-
6506: ent host and run them there. This works even if the new host has the
6507: opposite endianness to the one on which the patterns were compiled.
6508: There may be a small performance penalty, but it should be insignifi-
6509: cant. However, compiling regular expressions with one version of PCRE
6510: for use with a different version is not guaranteed to work and may
6511: cause crashes.
6512:
6513:
6514: SAVING A COMPILED PATTERN
6515:
6516: The value returned by pcre_compile() points to a single block of memory
6517: that holds the compiled pattern and associated data. You can find the
6518: length of this block in bytes by calling pcre_fullinfo() with an argu-
6519: ment of PCRE_INFO_SIZE. You can then save the data in any appropriate
6520: manner. Here is sample code that compiles a pattern and writes it to a
6521: file. It assumes that the variable fd refers to a file that is open for
6522: output:
6523:
6524: int erroroffset, rc, size;
6525: char *error;
6526: pcre *re;
6527:
6528: re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
6529: if (re == NULL) { ... handle errors ... }
6530: rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
6531: if (rc < 0) { ... handle errors ... }
6532: rc = fwrite(re, 1, size, fd);
6533: if (rc != size) { ... handle errors ... }
6534:
6535: In this example, the bytes that comprise the compiled pattern are
6536: copied exactly. Note that this is binary data that may contain any of
6537: the 256 possible byte values. On systems that make a distinction
6538: between binary and non-binary data, be sure that the file is opened for
6539: binary output.
6540:
6541: If you want to write more than one pattern to a file, you will have to
6542: devise a way of separating them. For binary data, preceding each pat-
6543: tern with its length is probably the most straightforward approach.
6544: Another possibility is to write out the data in hexadecimal instead of
6545: binary, one pattern to a line.
6546:
6547: Saving compiled patterns in a file is only one possible way of storing
6548: them for later use. They could equally well be saved in a database, or
6549: in the memory of some daemon process that passes them via sockets to
6550: the processes that want them.
6551:
6552: If the pattern has been studied, it is also possible to save the study
6553: data in a similar way to the compiled pattern itself. When studying
6554: generates additional information, pcre_study() returns a pointer to a
6555: pcre_extra data block. Its format is defined in the section on matching
6556: a pattern in the pcreapi documentation. The study_data field points to
6557: the binary study data, and this is what you must save (not the
6558: pcre_extra block itself). The length of the study data can be obtained
6559: by calling pcre_fullinfo() with an argument of PCRE_INFO_STUDYSIZE.
6560: Remember to check that pcre_study() did return a non-NULL value before
6561: trying to save the study data.
6562:
6563:
6564: RE-USING A PRECOMPILED PATTERN
6565:
6566: Re-using a precompiled pattern is straightforward. Having reloaded it
6567: into main memory, you pass its pointer to pcre_exec() or
6568: pcre_dfa_exec() in the usual way. This should work even on another
6569: host, and even if that host has the opposite endianness to the one
6570: where the pattern was compiled.
6571:
6572: However, if you passed a pointer to custom character tables when the
6573: pattern was compiled (the tableptr argument of pcre_compile()), you
6574: must now pass a similar pointer to pcre_exec() or pcre_dfa_exec(),
6575: because the value saved with the compiled pattern will obviously be
6576: nonsense. A field in a pcre_extra() block is used to pass this data, as
6577: described in the section on matching a pattern in the pcreapi documen-
6578: tation.
6579:
6580: If you did not provide custom character tables when the pattern was
6581: compiled, the pointer in the compiled pattern is NULL, which causes
6582: pcre_exec() to use PCRE's internal tables. Thus, you do not need to
6583: take any special action at run time in this case.
6584:
6585: If you saved study data with the compiled pattern, you need to create
6586: your own pcre_extra data block and set the study_data field to point to
6587: the reloaded study data. You must also set the PCRE_EXTRA_STUDY_DATA
6588: bit in the flags field to indicate that study data is present. Then
6589: pass the pcre_extra block to pcre_exec() or pcre_dfa_exec() in the
6590: usual way.
6591:
6592:
6593: COMPATIBILITY WITH DIFFERENT PCRE RELEASES
6594:
6595: In general, it is safest to recompile all saved patterns when you
6596: update to a new PCRE release, though not all updates actually require
6597: this.
6598:
6599:
6600: AUTHOR
6601:
6602: Philip Hazel
6603: University Computing Service
6604: Cambridge CB2 3QH, England.
6605:
6606:
6607: REVISION
6608:
6609: Last updated: 17 November 2010
6610: Copyright (c) 1997-2010 University of Cambridge.
6611: ------------------------------------------------------------------------------
6612:
6613:
6614: PCREPERFORM(3) PCREPERFORM(3)
6615:
6616:
6617: NAME
6618: PCRE - Perl-compatible regular expressions
6619:
6620:
6621: PCRE PERFORMANCE
6622:
6623: Two aspects of performance are discussed below: memory usage and pro-
6624: cessing time. The way you express your pattern as a regular expression
6625: can affect both of them.
6626:
6627:
6628: COMPILED PATTERN MEMORY USAGE
6629:
6630: Patterns are compiled by PCRE into a reasonably efficient byte code, so
6631: that most simple patterns do not use much memory. However, there is one
6632: case where the memory usage of a compiled pattern can be unexpectedly
6633: large. If a parenthesized subpattern has a quantifier with a minimum
6634: greater than 1 and/or a limited maximum, the whole subpattern is
6635: repeated in the compiled code. For example, the pattern
6636:
6637: (abc|def){2,4}
6638:
6639: is compiled as if it were
6640:
6641: (abc|def)(abc|def)((abc|def)(abc|def)?)?
6642:
6643: (Technical aside: It is done this way so that backtrack points within
6644: each of the repetitions can be independently maintained.)
6645:
6646: For regular expressions whose quantifiers use only small numbers, this
6647: is not usually a problem. However, if the numbers are large, and par-
6648: ticularly if such repetitions are nested, the memory usage can become
6649: an embarrassment. For example, the very simple pattern
6650:
6651: ((ab){1,1000}c){1,3}
6652:
6653: uses 51K bytes when compiled. When PCRE is compiled with its default
6654: internal pointer size of two bytes, the size limit on a compiled pat-
6655: tern is 64K, and this is reached with the above pattern if the outer
6656: repetition is increased from 3 to 4. PCRE can be compiled to use larger
6657: internal pointers and thus handle larger compiled patterns, but it is
6658: better to try to rewrite your pattern to use less memory if you can.
6659:
6660: One way of reducing the memory usage for such patterns is to make use
6661: of PCRE's "subroutine" facility. Re-writing the above pattern as
6662:
6663: ((ab)(?2){0,999}c)(?1){0,2}
6664:
6665: reduces the memory requirements to 18K, and indeed it remains under 20K
6666: even with the outer repetition increased to 100. However, this pattern
6667: is not exactly equivalent, because the "subroutine" calls are treated
6668: as atomic groups into which there can be no backtracking if there is a
6669: subsequent matching failure. Therefore, PCRE cannot do this kind of
6670: rewriting automatically. Furthermore, there is a noticeable loss of
6671: speed when executing the modified pattern. Nevertheless, if the atomic
6672: grouping is not a problem and the loss of speed is acceptable, this
6673: kind of rewriting will allow you to process patterns that PCRE cannot
6674: otherwise handle.
6675:
6676:
6677: STACK USAGE AT RUN TIME
6678:
6679: When pcre_exec() is used for matching, certain kinds of pattern can
6680: cause it to use large amounts of the process stack. In some environ-
6681: ments the default process stack is quite small, and if it runs out the
6682: result is often SIGSEGV. This issue is probably the most frequently
6683: raised problem with PCRE. Rewriting your pattern can often help. The
6684: pcrestack documentation discusses this issue in detail.
6685:
6686:
6687: PROCESSING TIME
6688:
6689: Certain items in regular expression patterns are processed more effi-
6690: ciently than others. It is more efficient to use a character class like
6691: [aeiou] than a set of single-character alternatives such as
6692: (a|e|i|o|u). In general, the simplest construction that provides the
6693: required behaviour is usually the most efficient. Jeffrey Friedl's book
6694: contains a lot of useful general discussion about optimizing regular
6695: expressions for efficient performance. This document contains a few
6696: observations about PCRE.
6697:
6698: Using Unicode character properties (the \p, \P, and \X escapes) is
6699: slow, because PCRE has to scan a structure that contains data for over
6700: fifteen thousand characters whenever it needs a character's property.
6701: If you can find an alternative pattern that does not use character
6702: properties, it will probably be faster.
6703:
6704: By default, the escape sequences \b, \d, \s, and \w, and the POSIX
6705: character classes such as [:alpha:] do not use Unicode properties,
6706: partly for backwards compatibility, and partly for performance reasons.
6707: However, you can set PCRE_UCP if you want Unicode character properties
6708: to be used. This can double the matching time for items such as \d,
6709: when matched with pcre_exec(); the performance loss is less with
6710: pcre_dfa_exec(), and in both cases there is not much difference for \b.
6711:
6712: When a pattern begins with .* not in parentheses, or in parentheses
6713: that are not the subject of a backreference, and the PCRE_DOTALL option
6714: is set, the pattern is implicitly anchored by PCRE, since it can match
6715: only at the start of a subject string. However, if PCRE_DOTALL is not
6716: set, PCRE cannot make this optimization, because the . metacharacter
6717: does not then match a newline, and if the subject string contains new-
6718: lines, the pattern may match from the character immediately following
6719: one of them instead of from the very start. For example, the pattern
6720:
6721: .*second
6722:
6723: matches the subject "first\nand second" (where \n stands for a newline
6724: character), with the match starting at the seventh character. In order
6725: to do this, PCRE has to retry the match starting after every newline in
6726: the subject.
6727:
6728: If you are using such a pattern with subject strings that do not con-
6729: tain newlines, the best performance is obtained by setting PCRE_DOTALL,
6730: or starting the pattern with ^.* or ^.*? to indicate explicit anchor-
6731: ing. That saves PCRE from having to scan along the subject looking for
6732: a newline to restart at.
6733:
6734: Beware of patterns that contain nested indefinite repeats. These can
6735: take a long time to run when applied to a string that does not match.
6736: Consider the pattern fragment
6737:
6738: ^(a+)*
6739:
6740: This can match "aaaa" in 16 different ways, and this number increases
6741: very rapidly as the string gets longer. (The * repeat can match 0, 1,
6742: 2, 3, or 4 times, and for each of those cases other than 0 or 4, the +
6743: repeats can match different numbers of times.) When the remainder of
6744: the pattern is such that the entire match is going to fail, PCRE has in
6745: principle to try every possible variation, and this can take an
6746: extremely long time, even for relatively short strings.
6747:
6748: An optimization catches some of the more simple cases such as
6749:
6750: (a+)*b
6751:
6752: where a literal character follows. Before embarking on the standard
6753: matching procedure, PCRE checks that there is a "b" later in the sub-
6754: ject string, and if there is not, it fails the match immediately. How-
6755: ever, when there is no following literal this optimization cannot be
6756: used. You can see the difference by comparing the behaviour of
6757:
6758: (a+)*\d
6759:
6760: with the pattern above. The former gives a failure almost instantly
6761: when applied to a whole line of "a" characters, whereas the latter
6762: takes an appreciable time with strings longer than about 20 characters.
6763:
6764: In many cases, the solution to this kind of performance issue is to use
6765: an atomic group or a possessive quantifier.
6766:
6767:
6768: AUTHOR
6769:
6770: Philip Hazel
6771: University Computing Service
6772: Cambridge CB2 3QH, England.
6773:
6774:
6775: REVISION
6776:
6777: Last updated: 16 May 2010
6778: Copyright (c) 1997-2010 University of Cambridge.
6779: ------------------------------------------------------------------------------
6780:
6781:
6782: PCREPOSIX(3) PCREPOSIX(3)
6783:
6784:
6785: NAME
6786: PCRE - Perl-compatible regular expressions.
6787:
6788:
6789: SYNOPSIS OF POSIX API
6790:
6791: #include <pcreposix.h>
6792:
6793: int regcomp(regex_t *preg, const char *pattern,
6794: int cflags);
6795:
6796: int regexec(regex_t *preg, const char *string,
6797: size_t nmatch, regmatch_t pmatch[], int eflags);
6798:
6799: size_t regerror(int errcode, const regex_t *preg,
6800: char *errbuf, size_t errbuf_size);
6801:
6802: void regfree(regex_t *preg);
6803:
6804:
6805: DESCRIPTION
6806:
6807: This set of functions provides a POSIX-style API to the PCRE regular
6808: expression package. See the pcreapi documentation for a description of
6809: PCRE's native API, which contains much additional functionality.
6810:
6811: The functions described here are just wrapper functions that ultimately
6812: call the PCRE native API. Their prototypes are defined in the
6813: pcreposix.h header file, and on Unix systems the library itself is
6814: called pcreposix.a, so can be accessed by adding -lpcreposix to the
6815: command for linking an application that uses them. Because the POSIX
6816: functions call the native ones, it is also necessary to add -lpcre.
6817:
6818: I have implemented only those POSIX option bits that can be reasonably
6819: mapped to PCRE native options. In addition, the option REG_EXTENDED is
6820: defined with the value zero. This has no effect, but since programs
6821: that are written to the POSIX interface often use it, this makes it
6822: easier to slot in PCRE as a replacement library. Other POSIX options
6823: are not even defined.
6824:
6825: There are also some other options that are not defined by POSIX. These
6826: have been added at the request of users who want to make use of certain
6827: PCRE-specific features via the POSIX calling interface.
6828:
6829: When PCRE is called via these functions, it is only the API that is
6830: POSIX-like in style. The syntax and semantics of the regular expres-
6831: sions themselves are still those of Perl, subject to the setting of
6832: various PCRE options, as described below. "POSIX-like in style" means
6833: that the API approximates to the POSIX definition; it is not fully
6834: POSIX-compatible, and in multi-byte encoding domains it is probably
6835: even less compatible.
6836:
6837: The header for these functions is supplied as pcreposix.h to avoid any
6838: potential clash with other POSIX libraries. It can, of course, be
6839: renamed or aliased as regex.h, which is the "correct" name. It provides
6840: two structure types, regex_t for compiled internal forms, and reg-
6841: match_t for returning captured substrings. It also defines some con-
6842: stants whose names start with "REG_"; these are used for setting
6843: options and identifying error codes.
6844:
6845:
6846: COMPILING A PATTERN
6847:
6848: The function regcomp() is called to compile a pattern into an internal
6849: form. The pattern is a C string terminated by a binary zero, and is
6850: passed in the argument pattern. The preg argument is a pointer to a
6851: regex_t structure that is used as a base for storing information about
6852: the compiled regular expression.
6853:
6854: The argument cflags is either zero, or contains one or more of the bits
6855: defined by the following macros:
6856:
6857: REG_DOTALL
6858:
6859: The PCRE_DOTALL option is set when the regular expression is passed for
6860: compilation to the native function. Note that REG_DOTALL is not part of
6861: the POSIX standard.
6862:
6863: REG_ICASE
6864:
6865: The PCRE_CASELESS option is set when the regular expression is passed
6866: for compilation to the native function.
6867:
6868: REG_NEWLINE
6869:
6870: The PCRE_MULTILINE option is set when the regular expression is passed
6871: for compilation to the native function. Note that this does not mimic
6872: the defined POSIX behaviour for REG_NEWLINE (see the following sec-
6873: tion).
6874:
6875: REG_NOSUB
6876:
6877: The PCRE_NO_AUTO_CAPTURE option is set when the regular expression is
6878: passed for compilation to the native function. In addition, when a pat-
6879: tern that is compiled with this flag is passed to regexec() for match-
6880: ing, the nmatch and pmatch arguments are ignored, and no captured
6881: strings are returned.
6882:
6883: REG_UCP
6884:
6885: The PCRE_UCP option is set when the regular expression is passed for
6886: compilation to the native function. This causes PCRE to use Unicode
6887: properties when matchine \d, \w, etc., instead of just recognizing
6888: ASCII values. Note that REG_UTF8 is not part of the POSIX standard.
6889:
6890: REG_UNGREEDY
6891:
6892: The PCRE_UNGREEDY option is set when the regular expression is passed
6893: for compilation to the native function. Note that REG_UNGREEDY is not
6894: part of the POSIX standard.
6895:
6896: REG_UTF8
6897:
6898: The PCRE_UTF8 option is set when the regular expression is passed for
6899: compilation to the native function. This causes the pattern itself and
6900: all data strings used for matching it to be treated as UTF-8 strings.
6901: Note that REG_UTF8 is not part of the POSIX standard.
6902:
6903: In the absence of these flags, no options are passed to the native
6904: function. This means the the regex is compiled with PCRE default
6905: semantics. In particular, the way it handles newline characters in the
6906: subject string is the Perl way, not the POSIX way. Note that setting
6907: PCRE_MULTILINE has only some of the effects specified for REG_NEWLINE.
6908: It does not affect the way newlines are matched by . (they are not) or
6909: by a negative class such as [^a] (they are).
6910:
6911: The yield of regcomp() is zero on success, and non-zero otherwise. The
6912: preg structure is filled in on success, and one member of the structure
6913: is public: re_nsub contains the number of capturing subpatterns in the
6914: regular expression. Various error codes are defined in the header file.
6915:
6916: NOTE: If the yield of regcomp() is non-zero, you must not attempt to
6917: use the contents of the preg structure. If, for example, you pass it to
6918: regexec(), the result is undefined and your program is likely to crash.
6919:
6920:
6921: MATCHING NEWLINE CHARACTERS
6922:
6923: This area is not simple, because POSIX and Perl take different views of
6924: things. It is not possible to get PCRE to obey POSIX semantics, but
6925: then PCRE was never intended to be a POSIX engine. The following table
6926: lists the different possibilities for matching newline characters in
6927: PCRE:
6928:
6929: Default Change with
6930:
6931: . matches newline no PCRE_DOTALL
6932: newline matches [^a] yes not changeable
6933: $ matches \n at end yes PCRE_DOLLARENDONLY
6934: $ matches \n in middle no PCRE_MULTILINE
6935: ^ matches \n in middle no PCRE_MULTILINE
6936:
6937: This is the equivalent table for POSIX:
6938:
6939: Default Change with
6940:
6941: . matches newline yes REG_NEWLINE
6942: newline matches [^a] yes REG_NEWLINE
6943: $ matches \n at end no REG_NEWLINE
6944: $ matches \n in middle no REG_NEWLINE
6945: ^ matches \n in middle no REG_NEWLINE
6946:
6947: PCRE's behaviour is the same as Perl's, except that there is no equiva-
6948: lent for PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is
6949: no way to stop newline from matching [^a].
6950:
6951: The default POSIX newline handling can be obtained by setting
6952: PCRE_DOTALL and PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE
6953: behave exactly as for the REG_NEWLINE action.
6954:
6955:
6956: MATCHING A PATTERN
6957:
6958: The function regexec() is called to match a compiled pattern preg
6959: against a given string, which is by default terminated by a zero byte
6960: (but see REG_STARTEND below), subject to the options in eflags. These
6961: can be:
6962:
6963: REG_NOTBOL
6964:
6965: The PCRE_NOTBOL option is set when calling the underlying PCRE matching
6966: function.
6967:
6968: REG_NOTEMPTY
6969:
6970: The PCRE_NOTEMPTY option is set when calling the underlying PCRE match-
6971: ing function. Note that REG_NOTEMPTY is not part of the POSIX standard.
6972: However, setting this option can give more POSIX-like behaviour in some
6973: situations.
6974:
6975: REG_NOTEOL
6976:
6977: The PCRE_NOTEOL option is set when calling the underlying PCRE matching
6978: function.
6979:
6980: REG_STARTEND
6981:
6982: The string is considered to start at string + pmatch[0].rm_so and to
6983: have a terminating NUL located at string + pmatch[0].rm_eo (there need
6984: not actually be a NUL at that location), regardless of the value of
6985: nmatch. This is a BSD extension, compatible with but not specified by
6986: IEEE Standard 1003.2 (POSIX.2), and should be used with caution in
6987: software intended to be portable to other systems. Note that a non-zero
6988: rm_so does not imply REG_NOTBOL; REG_STARTEND affects only the location
6989: of the string, not how it is matched.
6990:
6991: If the pattern was compiled with the REG_NOSUB flag, no data about any
6992: matched strings is returned. The nmatch and pmatch arguments of
6993: regexec() are ignored.
6994:
6995: If the value of nmatch is zero, or if the value pmatch is NULL, no data
6996: about any matched strings is returned.
6997:
6998: Otherwise,the portion of the string that was matched, and also any cap-
6999: tured substrings, are returned via the pmatch argument, which points to
7000: an array of nmatch structures of type regmatch_t, containing the mem-
7001: bers rm_so and rm_eo. These contain the offset to the first character
7002: of each substring and the offset to the first character after the end
7003: of each substring, respectively. The 0th element of the vector relates
7004: to the entire portion of string that was matched; subsequent elements
7005: relate to the capturing subpatterns of the regular expression. Unused
7006: entries in the array have both structure members set to -1.
7007:
7008: A successful match yields a zero return; various error codes are
7009: defined in the header file, of which REG_NOMATCH is the "expected"
7010: failure code.
7011:
7012:
7013: ERROR MESSAGES
7014:
7015: The regerror() function maps a non-zero errorcode from either regcomp()
7016: or regexec() to a printable message. If preg is not NULL, the error
7017: should have arisen from the use of that structure. A message terminated
7018: by a binary zero is placed in errbuf. The length of the message,
7019: including the zero, is limited to errbuf_size. The yield of the func-
7020: tion is the size of buffer needed to hold the whole message.
7021:
7022:
7023: MEMORY USAGE
7024:
7025: Compiling a regular expression causes memory to be allocated and asso-
7026: ciated with the preg structure. The function regfree() frees all such
7027: memory, after which preg may no longer be used as a compiled expres-
7028: sion.
7029:
7030:
7031: AUTHOR
7032:
7033: Philip Hazel
7034: University Computing Service
7035: Cambridge CB2 3QH, England.
7036:
7037:
7038: REVISION
7039:
7040: Last updated: 16 May 2010
7041: Copyright (c) 1997-2010 University of Cambridge.
7042: ------------------------------------------------------------------------------
7043:
7044:
7045: PCRECPP(3) PCRECPP(3)
7046:
7047:
7048: NAME
7049: PCRE - Perl-compatible regular expressions.
7050:
7051:
7052: SYNOPSIS OF C++ WRAPPER
7053:
7054: #include <pcrecpp.h>
7055:
7056:
7057: DESCRIPTION
7058:
7059: The C++ wrapper for PCRE was provided by Google Inc. Some additional
7060: functionality was added by Giuseppe Maxia. This brief man page was con-
7061: structed from the notes in the pcrecpp.h file, which should be con-
7062: sulted for further details.
7063:
7064:
7065: MATCHING INTERFACE
7066:
7067: The "FullMatch" operation checks that supplied text matches a supplied
7068: pattern exactly. If pointer arguments are supplied, it copies matched
7069: sub-strings that match sub-patterns into them.
7070:
7071: Example: successful match
7072: pcrecpp::RE re("h.*o");
7073: re.FullMatch("hello");
7074:
7075: Example: unsuccessful match (requires full match):
7076: pcrecpp::RE re("e");
7077: !re.FullMatch("hello");
7078:
7079: Example: creating a temporary RE object:
7080: pcrecpp::RE("h.*o").FullMatch("hello");
7081:
7082: You can pass in a "const char*" or a "string" for "text". The examples
7083: below tend to use a const char*. You can, as in the different examples
7084: above, store the RE object explicitly in a variable or use a temporary
7085: RE object. The examples below use one mode or the other arbitrarily.
7086: Either could correctly be used for any of these examples.
7087:
7088: You must supply extra pointer arguments to extract matched subpieces.
7089:
7090: Example: extracts "ruby" into "s" and 1234 into "i"
7091: int i;
7092: string s;
7093: pcrecpp::RE re("(\\w+):(\\d+)");
7094: re.FullMatch("ruby:1234", &s, &i);
7095:
7096: Example: does not try to extract any extra sub-patterns
7097: re.FullMatch("ruby:1234", &s);
7098:
7099: Example: does not try to extract into NULL
7100: re.FullMatch("ruby:1234", NULL, &i);
7101:
7102: Example: integer overflow causes failure
7103: !re.FullMatch("ruby:1234567891234", NULL, &i);
7104:
7105: Example: fails because there aren't enough sub-patterns:
7106: !pcrecpp::RE("\\w+:\\d+").FullMatch("ruby:1234", &s);
7107:
7108: Example: fails because string cannot be stored in integer
7109: !pcrecpp::RE("(.*)").FullMatch("ruby", &i);
7110:
7111: The provided pointer arguments can be pointers to any scalar numeric
7112: type, or one of:
7113:
7114: string (matched piece is copied to string)
7115: StringPiece (StringPiece is mutated to point to matched piece)
7116: T (where "bool T::ParseFrom(const char*, int)" exists)
7117: NULL (the corresponding matched sub-pattern is not copied)
7118:
7119: The function returns true iff all of the following conditions are sat-
7120: isfied:
7121:
7122: a. "text" matches "pattern" exactly;
7123:
7124: b. The number of matched sub-patterns is >= number of supplied
7125: pointers;
7126:
7127: c. The "i"th argument has a suitable type for holding the
7128: string captured as the "i"th sub-pattern. If you pass in
7129: void * NULL for the "i"th argument, or a non-void * NULL
7130: of the correct type, or pass fewer arguments than the
7131: number of sub-patterns, "i"th captured sub-pattern is
7132: ignored.
7133:
7134: CAVEAT: An optional sub-pattern that does not exist in the matched
7135: string is assigned the empty string. Therefore, the following will
7136: return false (because the empty string is not a valid number):
7137:
7138: int number;
7139: pcrecpp::RE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
7140:
7141: The matching interface supports at most 16 arguments per call. If you
7142: need more, consider using the more general interface
7143: pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.
7144:
7145: NOTE: Do not use no_arg, which is used internally to mark the end of a
7146: list of optional arguments, as a placeholder for missing arguments, as
7147: this can lead to segfaults.
7148:
7149:
7150: QUOTING METACHARACTERS
7151:
7152: You can use the "QuoteMeta" operation to insert backslashes before all
7153: potentially meaningful characters in a string. The returned string,
7154: used as a regular expression, will exactly match the original string.
7155:
7156: Example:
7157: string quoted = RE::QuoteMeta(unquoted);
7158:
7159: Note that it's legal to escape a character even if it has no special
7160: meaning in a regular expression -- so this function does that. (This
7161: also makes it identical to the perl function of the same name; see
7162: "perldoc -f quotemeta".) For example, "1.5-2.0?" becomes
7163: "1\.5\-2\.0\?".
7164:
7165:
7166: PARTIAL MATCHES
7167:
7168: You can use the "PartialMatch" operation when you want the pattern to
7169: match any substring of the text.
7170:
7171: Example: simple search for a string:
7172: pcrecpp::RE("ell").PartialMatch("hello");
7173:
7174: Example: find first number in a string:
7175: int number;
7176: pcrecpp::RE re("(\\d+)");
7177: re.PartialMatch("x*100 + 20", &number);
7178: assert(number == 100);
7179:
7180:
7181: UTF-8 AND THE MATCHING INTERFACE
7182:
7183: By default, pattern and text are plain text, one byte per character.
7184: The UTF8 flag, passed to the constructor, causes both pattern and
7185: string to be treated as UTF-8 text, still a byte stream but potentially
7186: multiple bytes per character. In practice, the text is likelier to be
7187: UTF-8 than the pattern, but the match returned may depend on the UTF8
7188: flag, so always use it when matching UTF8 text. For example, "." will
7189: match one byte normally but with UTF8 set may match up to three bytes
7190: of a multi-byte character.
7191:
7192: Example:
7193: pcrecpp::RE_Options options;
7194: options.set_utf8();
7195: pcrecpp::RE re(utf8_pattern, options);
7196: re.FullMatch(utf8_string);
7197:
7198: Example: using the convenience function UTF8():
7199: pcrecpp::RE re(utf8_pattern, pcrecpp::UTF8());
7200: re.FullMatch(utf8_string);
7201:
7202: NOTE: The UTF8 flag is ignored if pcre was not configured with the
7203: --enable-utf8 flag.
7204:
7205:
7206: PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE
7207:
7208: PCRE defines some modifiers to change the behavior of the regular
7209: expression engine. The C++ wrapper defines an auxiliary class,
7210: RE_Options, as a vehicle to pass such modifiers to a RE class. Cur-
7211: rently, the following modifiers are supported:
7212:
7213: modifier description Perl corresponding
7214:
7215: PCRE_CASELESS case insensitive match /i
7216: PCRE_MULTILINE multiple lines match /m
7217: PCRE_DOTALL dot matches newlines /s
7218: PCRE_DOLLAR_ENDONLY $ matches only at end N/A
7219: PCRE_EXTRA strict escape parsing N/A
7220: PCRE_EXTENDED ignore whitespaces /x
7221: PCRE_UTF8 handles UTF8 chars built-in
7222: PCRE_UNGREEDY reverses * and *? N/A
7223: PCRE_NO_AUTO_CAPTURE disables capturing parens N/A (*)
7224:
7225: (*) Both Perl and PCRE allow non capturing parentheses by means of the
7226: "?:" modifier within the pattern itself. e.g. (?:ab|cd) does not cap-
7227: ture, while (ab|cd) does.
7228:
7229: For a full account on how each modifier works, please check the PCRE
7230: API reference page.
7231:
7232: For each modifier, there are two member functions whose name is made
7233: out of the modifier in lowercase, without the "PCRE_" prefix. For
7234: instance, PCRE_CASELESS is handled by
7235:
7236: bool caseless()
7237:
7238: which returns true if the modifier is set, and
7239:
7240: RE_Options & set_caseless(bool)
7241:
7242: which sets or unsets the modifier. Moreover, PCRE_EXTRA_MATCH_LIMIT can
7243: be accessed through the set_match_limit() and match_limit() member
7244: functions. Setting match_limit to a non-zero value will limit the exe-
7245: cution of pcre to keep it from doing bad things like blowing the stack
7246: or taking an eternity to return a result. A value of 5000 is good
7247: enough to stop stack blowup in a 2MB thread stack. Setting match_limit
7248: to zero disables match limiting. Alternatively, you can call
7249: match_limit_recursion() which uses PCRE_EXTRA_MATCH_LIMIT_RECURSION to
7250: limit how much PCRE recurses. match_limit() limits the number of
7251: matches PCRE does; match_limit_recursion() limits the depth of internal
7252: recursion, and therefore the amount of stack that is used.
7253:
7254: Normally, to pass one or more modifiers to a RE class, you declare a
7255: RE_Options object, set the appropriate options, and pass this object to
7256: a RE constructor. Example:
7257:
7258: RE_options opt;
7259: opt.set_caseless(true);
7260: if (RE("HELLO", opt).PartialMatch("hello world")) ...
7261:
7262: RE_options has two constructors. The default constructor takes no argu-
7263: ments and creates a set of flags that are off by default. The optional
7264: parameter option_flags is to facilitate transfer of legacy code from C
7265: programs. This lets you do
7266:
7267: RE(pattern,
7268: RE_Options(PCRE_CASELESS|PCRE_MULTILINE)).PartialMatch(str);
7269:
7270: However, new code is better off doing
7271:
7272: RE(pattern,
7273: RE_Options().set_caseless(true).set_multiline(true))
7274: .PartialMatch(str);
7275:
7276: If you are going to pass one of the most used modifiers, there are some
7277: convenience functions that return a RE_Options class with the appropri-
7278: ate modifier already set: CASELESS(), UTF8(), MULTILINE(), DOTALL(),
7279: and EXTENDED().
7280:
7281: If you need to set several options at once, and you don't want to go
7282: through the pains of declaring a RE_Options object and setting several
7283: options, there is a parallel method that give you such ability on the
7284: fly. You can concatenate several set_xxxxx() member functions, since
7285: each of them returns a reference to its class object. For example, to
7286: pass PCRE_CASELESS, PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one
7287: statement, you may write:
7288:
7289: RE(" ^ xyz \\s+ .* blah$",
7290: RE_Options()
7291: .set_caseless(true)
7292: .set_extended(true)
7293: .set_multiline(true)).PartialMatch(sometext);
7294:
7295:
7296: SCANNING TEXT INCREMENTALLY
7297:
7298: The "Consume" operation may be useful if you want to repeatedly match
7299: regular expressions at the front of a string and skip over them as they
7300: match. This requires use of the "StringPiece" type, which represents a
7301: sub-range of a real string. Like RE, StringPiece is defined in the
7302: pcrecpp namespace.
7303:
7304: Example: read lines of the form "var = value" from a string.
7305: string contents = ...; // Fill string somehow
7306: pcrecpp::StringPiece input(contents); // Wrap in a StringPiece
7307:
7308: string var;
7309: int value;
7310: pcrecpp::RE re("(\\w+) = (\\d+)\n");
7311: while (re.Consume(&input, &var, &value)) {
7312: ...;
7313: }
7314:
7315: Each successful call to "Consume" will set "var/value", and also
7316: advance "input" so it points past the matched text.
7317:
7318: The "FindAndConsume" operation is similar to "Consume" but does not
7319: anchor your match at the beginning of the string. For example, you
7320: could extract all words from a string by repeatedly calling
7321:
7322: pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)
7323:
7324:
7325: PARSING HEX/OCTAL/C-RADIX NUMBERS
7326:
7327: By default, if you pass a pointer to a numeric value, the corresponding
7328: text is interpreted as a base-10 number. You can instead wrap the
7329: pointer with a call to one of the operators Hex(), Octal(), or CRadix()
7330: to interpret the text in another base. The CRadix operator interprets
7331: C-style "0" (base-8) and "0x" (base-16) prefixes, but defaults to
7332: base-10.
7333:
7334: Example:
7335: int a, b, c, d;
7336: pcrecpp::RE re("(.*) (.*) (.*) (.*)");
7337: re.FullMatch("100 40 0100 0x40",
7338: pcrecpp::Octal(&a), pcrecpp::Hex(&b),
7339: pcrecpp::CRadix(&c), pcrecpp::CRadix(&d));
7340:
7341: will leave 64 in a, b, c, and d.
7342:
7343:
7344: REPLACING PARTS OF STRINGS
7345:
7346: You can replace the first match of "pattern" in "str" with "rewrite".
7347: Within "rewrite", backslash-escaped digits (\1 to \9) can be used to
7348: insert text matching corresponding parenthesized group from the pat-
7349: tern. \0 in "rewrite" refers to the entire matching text. For example:
7350:
7351: string s = "yabba dabba doo";
7352: pcrecpp::RE("b+").Replace("d", &s);
7353:
7354: will leave "s" containing "yada dabba doo". The result is true if the
7355: pattern matches and a replacement occurs, false otherwise.
7356:
7357: GlobalReplace is like Replace except that it replaces all occurrences
7358: of the pattern in the string with the rewrite. Replacements are not
7359: subject to re-matching. For example:
7360:
7361: string s = "yabba dabba doo";
7362: pcrecpp::RE("b+").GlobalReplace("d", &s);
7363:
7364: will leave "s" containing "yada dada doo". It returns the number of
7365: replacements made.
7366:
7367: Extract is like Replace, except that if the pattern matches, "rewrite"
7368: is copied into "out" (an additional argument) with substitutions. The
7369: non-matching portions of "text" are ignored. Returns true iff a match
7370: occurred and the extraction happened successfully; if no match occurs,
7371: the string is left unaffected.
7372:
7373:
7374: AUTHOR
7375:
7376: The C++ wrapper was contributed by Google Inc.
7377: Copyright (c) 2007 Google Inc.
7378:
7379:
7380: REVISION
7381:
7382: Last updated: 17 March 2009
7383: ------------------------------------------------------------------------------
7384:
7385:
7386: PCRESAMPLE(3) PCRESAMPLE(3)
7387:
7388:
7389: NAME
7390: PCRE - Perl-compatible regular expressions
7391:
7392:
7393: PCRE SAMPLE PROGRAM
7394:
7395: A simple, complete demonstration program, to get you started with using
7396: PCRE, is supplied in the file pcredemo.c in the PCRE distribution. A
7397: listing of this program is given in the pcredemo documentation. If you
7398: do not have a copy of the PCRE distribution, you can save this listing
7399: to re-create pcredemo.c.
7400:
7401: The program compiles the regular expression that is its first argument,
7402: and matches it against the subject string in its second argument. No
7403: PCRE options are set, and default character tables are used. If match-
7404: ing succeeds, the program outputs the portion of the subject that
7405: matched, together with the contents of any captured substrings.
7406:
7407: If the -g option is given on the command line, the program then goes on
7408: to check for further matches of the same regular expression in the same
7409: subject string. The logic is a little bit tricky because of the possi-
7410: bility of matching an empty string. Comments in the code explain what
7411: is going on.
7412:
7413: If PCRE is installed in the standard include and library directories
7414: for your operating system, you should be able to compile the demonstra-
7415: tion program using this command:
7416:
7417: gcc -o pcredemo pcredemo.c -lpcre
7418:
7419: If PCRE is installed elsewhere, you may need to add additional options
7420: to the command line. For example, on a Unix-like system that has PCRE
7421: installed in /usr/local, you can compile the demonstration program
7422: using a command like this:
7423:
7424: gcc -o pcredemo -I/usr/local/include pcredemo.c \
7425: -L/usr/local/lib -lpcre
7426:
7427: In a Windows environment, if you want to statically link the program
7428: against a non-dll pcre.a file, you must uncomment the line that defines
7429: PCRE_STATIC before including pcre.h, because otherwise the pcre_mal-
7430: loc() and pcre_free() exported functions will be declared
7431: __declspec(dllimport), with unwanted results.
7432:
7433: Once you have compiled and linked the demonstration program, you can
7434: run simple tests like this:
7435:
7436: ./pcredemo 'cat|dog' 'the cat sat on the mat'
7437: ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
7438:
7439: Note that there is a much more comprehensive test program, called
7440: pcretest, which supports many more facilities for testing regular
7441: expressions and the PCRE library. The pcredemo program is provided as a
7442: simple coding example.
7443:
7444: If you try to run pcredemo when PCRE is not installed in the standard
7445: library directory, you may get an error like this on some operating
7446: systems (e.g. Solaris):
7447:
7448: ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or
7449: directory
7450:
7451: This is caused by the way shared library support works on those sys-
7452: tems. You need to add
7453:
7454: -R/usr/local/lib
7455:
7456: (for example) to the compile command to get round this problem.
7457:
7458:
7459: AUTHOR
7460:
7461: Philip Hazel
7462: University Computing Service
7463: Cambridge CB2 3QH, England.
7464:
7465:
7466: REVISION
7467:
7468: Last updated: 17 November 2010
7469: Copyright (c) 1997-2010 University of Cambridge.
7470: ------------------------------------------------------------------------------
7471: PCRESTACK(3) PCRESTACK(3)
7472:
7473:
7474: NAME
7475: PCRE - Perl-compatible regular expressions
7476:
7477:
7478: PCRE DISCUSSION OF STACK USAGE
7479:
7480: When you call pcre_exec(), it makes use of an internal function called
7481: match(). This calls itself recursively at branch points in the pattern,
7482: in order to remember the state of the match so that it can back up and
7483: try a different alternative if the first one fails. As matching pro-
7484: ceeds deeper and deeper into the tree of possibilities, the recursion
7485: depth increases.
7486:
7487: Not all calls of match() increase the recursion depth; for an item such
7488: as a* it may be called several times at the same level, after matching
7489: different numbers of a's. Furthermore, in a number of cases where the
7490: result of the recursive call would immediately be passed back as the
7491: result of the current call (a "tail recursion"), the function is just
7492: restarted instead.
7493:
7494: The pcre_dfa_exec() function operates in an entirely different way, and
7495: uses recursion only when there is a regular expression recursion or
7496: subroutine call in the pattern. This includes the processing of asser-
7497: tion and "once-only" subpatterns, which are handled like subroutine
7498: calls. Normally, these are never very deep, and the limit on the com-
7499: plexity of pcre_dfa_exec() is controlled by the amount of workspace it
7500: is given. However, it is possible to write patterns with runaway infi-
7501: nite recursions; such patterns will cause pcre_dfa_exec() to run out of
7502: stack. At present, there is no protection against this.
7503:
7504: The comments that follow do NOT apply to pcre_dfa_exec(); they are rel-
7505: evant only for pcre_exec().
7506:
7507: Reducing pcre_exec()'s stack usage
7508:
7509: Each time that match() is actually called recursively, it uses memory
7510: from the process stack. For certain kinds of pattern and data, very
7511: large amounts of stack may be needed, despite the recognition of "tail
7512: recursion". You can often reduce the amount of recursion, and there-
7513: fore the amount of stack used, by modifying the pattern that is being
7514: matched. Consider, for example, this pattern:
7515:
7516: ([^<]|<(?!inet))+
7517:
7518: It matches from wherever it starts until it encounters "<inet" or the
7519: end of the data, and is the kind of pattern that might be used when
7520: processing an XML file. Each iteration of the outer parentheses matches
7521: either one character that is not "<" or a "<" that is not followed by
7522: "inet". However, each time a parenthesis is processed, a recursion
7523: occurs, so this formulation uses a stack frame for each matched charac-
7524: ter. For a long string, a lot of stack is required. Consider now this
7525: rewritten pattern, which matches exactly the same strings:
7526:
7527: ([^<]++|<(?!inet))+
7528:
7529: This uses very much less stack, because runs of characters that do not
7530: contain "<" are "swallowed" in one item inside the parentheses. Recur-
7531: sion happens only when a "<" character that is not followed by "inet"
7532: is encountered (and we assume this is relatively rare). A possessive
7533: quantifier is used to stop any backtracking into the runs of non-"<"
7534: characters, but that is not related to stack usage.
7535:
7536: This example shows that one way of avoiding stack problems when match-
7537: ing long subject strings is to write repeated parenthesized subpatterns
7538: to match more than one character whenever possible.
7539:
7540: Compiling PCRE to use heap instead of stack for pcre_exec()
7541:
7542: In environments where stack memory is constrained, you might want to
7543: compile PCRE to use heap memory instead of stack for remembering back-
7544: up points when pcre_exec() is running. This makes it run a lot more
7545: slowly, however. Details of how to do this are given in the pcrebuild
7546: documentation. When built in this way, instead of using the stack, PCRE
7547: obtains and frees memory by calling the functions that are pointed to
7548: by the pcre_stack_malloc and pcre_stack_free variables. By default,
7549: these point to malloc() and free(), but you can replace the pointers to
7550: cause PCRE to use your own functions. Since the block sizes are always
7551: the same, and are always freed in reverse order, it may be possible to
7552: implement customized memory handlers that are more efficient than the
7553: standard functions.
7554:
7555: Limiting pcre_exec()'s stack usage
7556:
7557: You can set limits on the number of times that match() is called, both
7558: in total and recursively. If a limit is exceeded, pcre_exec() returns
7559: an error code. Setting suitable limits should prevent it from running
7560: out of stack. The default values of the limits are very large, and
7561: unlikely ever to operate. They can be changed when PCRE is built, and
7562: they can also be set when pcre_exec() is called. For details of these
7563: interfaces, see the pcrebuild documentation and the section on extra
7564: data for pcre_exec() in the pcreapi documentation.
7565:
7566: As a very rough rule of thumb, you should reckon on about 500 bytes per
7567: recursion. Thus, if you want to limit your stack usage to 8Mb, you
7568: should set the limit at 16000 recursions. A 64Mb stack, on the other
7569: hand, can support around 128000 recursions.
7570:
7571: In Unix-like environments, the pcretest test program has a command line
7572: option (-S) that can be used to increase the size of its stack. As long
7573: as the stack is large enough, another option (-M) can be used to find
7574: the smallest limits that allow a particular pattern to match a given
7575: subject string. This is done by calling pcre_exec() repeatedly with
7576: different limits.
7577:
7578: Changing stack size in Unix-like systems
7579:
7580: In Unix-like environments, there is not often a problem with the stack
7581: unless very long strings are involved, though the default limit on
7582: stack size varies from system to system. Values from 8Mb to 64Mb are
7583: common. You can find your default limit by running the command:
7584:
7585: ulimit -s
7586:
7587: Unfortunately, the effect of running out of stack is often SIGSEGV,
7588: though sometimes a more explicit error message is given. You can nor-
7589: mally increase the limit on stack size by code such as this:
7590:
7591: struct rlimit rlim;
7592: getrlimit(RLIMIT_STACK, &rlim);
7593: rlim.rlim_cur = 100*1024*1024;
7594: setrlimit(RLIMIT_STACK, &rlim);
7595:
7596: This reads the current limits (soft and hard) using getrlimit(), then
7597: attempts to increase the soft limit to 100Mb using setrlimit(). You
7598: must do this before calling pcre_exec().
7599:
7600: Changing stack size in Mac OS X
7601:
7602: Using setrlimit(), as described above, should also work on Mac OS X. It
7603: is also possible to set a stack size when linking a program. There is a
7604: discussion about stack sizes in Mac OS X at this web site:
7605: http://developer.apple.com/qa/qa2005/qa1419.html.
7606:
7607:
7608: AUTHOR
7609:
7610: Philip Hazel
7611: University Computing Service
7612: Cambridge CB2 3QH, England.
7613:
7614:
7615: REVISION
7616:
7617: Last updated: 03 January 2010
7618: Copyright (c) 1997-2010 University of Cambridge.
7619: ------------------------------------------------------------------------------
7620:
7621:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre.txt CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pcre / pcrelib / doc