Annotation of embedaddon/pcre/doc/pcre.txt, revision 1.1.1.2
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:
1.1.1.2 ! misho 28: Starting with release 8.30, it is possible to compile two separate PCRE
! 29: libraries: the original, which supports 8-bit character strings
! 30: (including UTF-8 strings), and a second library that supports 16-bit
! 31: character strings (including UTF-16 strings). The build process allows
! 32: either one or both to be built. The majority of the work to make this
! 33: possible was done by Zoltan Herczeg.
! 34:
! 35: The two libraries contain identical sets of functions, except that the
! 36: names in the 16-bit library start with pcre16_ instead of pcre_. To
! 37: avoid over-complication and reduce the documentation maintenance load,
! 38: most of the documentation describes the 8-bit library, with the differ-
! 39: ences for the 16-bit library described separately in the pcre16 page.
! 40: References to functions or structures of the form pcre[16]_xxx should
! 41: be read as meaning "pcre_xxx when using the 8-bit library and
! 42: pcre16_xxx when using the 16-bit library".
! 43:
1.1 misho 44: The current implementation of PCRE corresponds approximately with Perl
1.1.1.2 ! misho 45: 5.12, including support for UTF-8/16 encoded strings and Unicode gen-
! 46: eral category properties. However, UTF-8/16 and Unicode support has to
! 47: be explicitly enabled; it is not the default. The Unicode tables corre-
1.1 misho 48: spond to Unicode release 6.0.0.
49:
50: In addition to the Perl-compatible matching function, PCRE contains an
51: alternative function that matches the same compiled patterns in a dif-
52: ferent way. In certain circumstances, the alternative function has some
53: advantages. For a discussion of the two matching algorithms, see the
54: pcrematching page.
55:
56: PCRE is written in C and released as a C library. A number of people
57: have written wrappers and interfaces of various kinds. In particular,
1.1.1.2 ! misho 58: Google Inc. have provided a comprehensive C++ wrapper for the 8-bit
! 59: library. This is now included as part of the PCRE distribution. The
! 60: pcrecpp page has details of this interface. Other people's contribu-
! 61: tions can be found in the Contrib directory at the primary FTP site,
! 62: which is:
1.1 misho 63:
64: ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
65:
1.1.1.2 ! misho 66: Details of exactly which Perl regular expression features are and are
1.1 misho 67: not supported by PCRE are given in separate documents. See the pcrepat-
1.1.1.2 ! misho 68: tern and pcrecompat pages. There is a syntax summary in the pcresyntax
1.1 misho 69: page.
70:
1.1.1.2 ! misho 71: Some features of PCRE can be included, excluded, or changed when the
! 72: library is built. The pcre_config() function makes it possible for a
! 73: client to discover which features are available. The features them-
! 74: selves are described in the pcrebuild page. Documentation about build-
! 75: ing PCRE for various operating systems can be found in the README and
1.1 misho 76: NON-UNIX-USE files in the source distribution.
77:
1.1.1.2 ! misho 78: The libraries contains a number of undocumented internal functions and
! 79: data tables that are used by more than one of the exported external
! 80: functions, but which are not intended for use by external callers.
! 81: Their names all begin with "_pcre_" or "_pcre16_", which hopefully will
! 82: not provoke any name clashes. In some environments, it is possible to
! 83: control which external symbols are exported when a shared library is
! 84: built, and in these cases the undocumented symbols are not exported.
1.1 misho 85:
86:
87: USER DOCUMENTATION
88:
1.1.1.2 ! misho 89: The user documentation for PCRE comprises a number of different sec-
! 90: tions. In the "man" format, each of these is a separate "man page". In
! 91: the HTML format, each is a separate page, linked from the index page.
! 92: In the plain text format, all the sections, except the pcredemo sec-
1.1 misho 93: tion, are concatenated, for ease of searching. The sections are as fol-
94: lows:
95:
96: pcre this document
1.1.1.2 ! misho 97: pcre16 details of the 16-bit library
1.1 misho 98: pcre-config show PCRE installation configuration information
99: pcreapi details of PCRE's native C API
100: pcrebuild options for building PCRE
101: pcrecallout details of the callout feature
102: pcrecompat discussion of Perl compatibility
1.1.1.2 ! misho 103: pcrecpp details of the C++ wrapper for the 8-bit library
1.1 misho 104: pcredemo a demonstration C program that uses PCRE
1.1.1.2 ! misho 105: pcregrep description of the pcregrep command (8-bit only)
1.1 misho 106: pcrejit discussion of the just-in-time optimization support
107: pcrelimits details of size and other limits
108: pcrematching discussion of the two matching algorithms
109: pcrepartial details of the partial matching facility
110: pcrepattern syntax and semantics of supported
111: regular expressions
112: pcreperform discussion of performance issues
1.1.1.2 ! misho 113: pcreposix the POSIX-compatible C API for the 8-bit library
1.1 misho 114: pcreprecompile details of saving and re-using precompiled patterns
115: pcresample discussion of the pcredemo program
116: pcrestack discussion of stack usage
117: pcresyntax quick syntax reference
118: pcretest description of the pcretest testing command
1.1.1.2 ! misho 119: pcreunicode discussion of Unicode and UTF-8/16 support
1.1 misho 120:
1.1.1.2 ! misho 121: In addition, in the "man" and HTML formats, there is a short page for
! 122: each 8-bit C library function, listing its arguments and results.
1.1 misho 123:
124:
125: AUTHOR
126:
127: Philip Hazel
128: University Computing Service
129: Cambridge CB2 3QH, England.
130:
1.1.1.2 ! misho 131: Putting an actual email address here seems to have been a spam magnet,
! 132: so I've taken it away. If you want to email me, use my two initials,
1.1 misho 133: followed by the two digits 10, at the domain cam.ac.uk.
134:
135:
136: REVISION
137:
1.1.1.2 ! misho 138: Last updated: 10 January 2012
! 139: Copyright (c) 1997-2012 University of Cambridge.
! 140: ------------------------------------------------------------------------------
! 141:
! 142:
! 143: PCRE(3) PCRE(3)
! 144:
! 145:
! 146: NAME
! 147: PCRE - Perl-compatible regular expressions
! 148:
! 149: #include <pcre.h>
! 150:
! 151:
! 152: PCRE 16-BIT API BASIC FUNCTIONS
! 153:
! 154: pcre16 *pcre16_compile(PCRE_SPTR16 pattern, int options,
! 155: const char **errptr, int *erroffset,
! 156: const unsigned char *tableptr);
! 157:
! 158: pcre16 *pcre16_compile2(PCRE_SPTR16 pattern, int options,
! 159: int *errorcodeptr,
! 160: const char **errptr, int *erroffset,
! 161: const unsigned char *tableptr);
! 162:
! 163: pcre16_extra *pcre16_study(const pcre16 *code, int options,
! 164: const char **errptr);
! 165:
! 166: void pcre16_free_study(pcre16_extra *extra);
! 167:
! 168: int pcre16_exec(const pcre16 *code, const pcre16_extra *extra,
! 169: PCRE_SPTR16 subject, int length, int startoffset,
! 170: int options, int *ovector, int ovecsize);
! 171:
! 172: int pcre16_dfa_exec(const pcre16 *code, const pcre16_extra *extra,
! 173: PCRE_SPTR16 subject, int length, int startoffset,
! 174: int options, int *ovector, int ovecsize,
! 175: int *workspace, int wscount);
! 176:
! 177:
! 178: PCRE 16-BIT API STRING EXTRACTION FUNCTIONS
! 179:
! 180: int pcre16_copy_named_substring(const pcre16 *code,
! 181: PCRE_SPTR16 subject, int *ovector,
! 182: int stringcount, PCRE_SPTR16 stringname,
! 183: PCRE_UCHAR16 *buffer, int buffersize);
! 184:
! 185: int pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector,
! 186: int stringcount, int stringnumber, PCRE_UCHAR16 *buffer,
! 187: int buffersize);
! 188:
! 189: int pcre16_get_named_substring(const pcre16 *code,
! 190: PCRE_SPTR16 subject, int *ovector,
! 191: int stringcount, PCRE_SPTR16 stringname,
! 192: PCRE_SPTR16 *stringptr);
! 193:
! 194: int pcre16_get_stringnumber(const pcre16 *code,
! 195: PCRE_SPTR16 name);
! 196:
! 197: int pcre16_get_stringtable_entries(const pcre16 *code,
! 198: PCRE_SPTR16 name, PCRE_UCHAR16 **first, PCRE_UCHAR16 **last);
! 199:
! 200: int pcre16_get_substring(PCRE_SPTR16 subject, int *ovector,
! 201: int stringcount, int stringnumber,
! 202: PCRE_SPTR16 *stringptr);
! 203:
! 204: int pcre16_get_substring_list(PCRE_SPTR16 subject,
! 205: int *ovector, int stringcount, PCRE_SPTR16 **listptr);
! 206:
! 207: void pcre16_free_substring(PCRE_SPTR16 stringptr);
! 208:
! 209: void pcre16_free_substring_list(PCRE_SPTR16 *stringptr);
! 210:
! 211:
! 212: PCRE 16-BIT API AUXILIARY FUNCTIONS
! 213:
! 214: pcre16_jit_stack *pcre16_jit_stack_alloc(int startsize, int maxsize);
! 215:
! 216: void pcre16_jit_stack_free(pcre16_jit_stack *stack);
! 217:
! 218: void pcre16_assign_jit_stack(pcre16_extra *extra,
! 219: pcre16_jit_callback callback, void *data);
! 220:
! 221: const unsigned char *pcre16_maketables(void);
! 222:
! 223: int pcre16_fullinfo(const pcre16 *code, const pcre16_extra *extra,
! 224: int what, void *where);
! 225:
! 226: int pcre16_refcount(pcre16 *code, int adjust);
! 227:
! 228: int pcre16_config(int what, void *where);
! 229:
! 230: const char *pcre16_version(void);
! 231:
! 232: int pcre16_pattern_to_host_byte_order(pcre16 *code,
! 233: pcre16_extra *extra, const unsigned char *tables);
! 234:
! 235:
! 236: PCRE 16-BIT API INDIRECTED FUNCTIONS
! 237:
! 238: void *(*pcre16_malloc)(size_t);
! 239:
! 240: void (*pcre16_free)(void *);
! 241:
! 242: void *(*pcre16_stack_malloc)(size_t);
! 243:
! 244: void (*pcre16_stack_free)(void *);
! 245:
! 246: int (*pcre16_callout)(pcre16_callout_block *);
! 247:
! 248:
! 249: PCRE 16-BIT API 16-BIT-ONLY FUNCTION
! 250:
! 251: int pcre16_utf16_to_host_byte_order(PCRE_UCHAR16 *output,
! 252: PCRE_SPTR16 input, int length, int *byte_order,
! 253: int keep_boms);
! 254:
! 255:
! 256: THE PCRE 16-BIT LIBRARY
! 257:
! 258: Starting with release 8.30, it is possible to compile a PCRE library
! 259: that supports 16-bit character strings, including UTF-16 strings, as
! 260: well as or instead of the original 8-bit library. The majority of the
! 261: work to make this possible was done by Zoltan Herczeg. The two
! 262: libraries contain identical sets of functions, used in exactly the same
! 263: way. Only the names of the functions and the data types of their argu-
! 264: ments and results are different. To avoid over-complication and reduce
! 265: the documentation maintenance load, most of the PCRE documentation
! 266: describes the 8-bit library, with only occasional references to the
! 267: 16-bit library. This page describes what is different when you use the
! 268: 16-bit library.
! 269:
! 270: WARNING: A single application can be linked with both libraries, but
! 271: you must take care when processing any particular pattern to use func-
! 272: tions from just one library. For example, if you want to study a pat-
! 273: tern that was compiled with pcre16_compile(), you must do so with
! 274: pcre16_study(), not pcre_study(), and you must free the study data with
! 275: pcre16_free_study().
! 276:
! 277:
! 278: THE HEADER FILE
! 279:
! 280: There is only one header file, pcre.h. It contains prototypes for all
! 281: the functions in both libraries, as well as definitions of flags,
! 282: structures, error codes, etc.
! 283:
! 284:
! 285: THE LIBRARY NAME
! 286:
! 287: In Unix-like systems, the 16-bit library is called libpcre16, and can
! 288: normally be accesss by adding -lpcre16 to the command for linking an
! 289: application that uses PCRE.
! 290:
! 291:
! 292: STRING TYPES
! 293:
! 294: In the 8-bit library, strings are passed to PCRE library functions as
! 295: vectors of bytes with the C type "char *". In the 16-bit library,
! 296: strings are passed as vectors of unsigned 16-bit quantities. The macro
! 297: PCRE_UCHAR16 specifies an appropriate data type, and PCRE_SPTR16 is
! 298: defined as "const PCRE_UCHAR16 *". In very many environments, "short
! 299: int" is a 16-bit data type. When PCRE is built, it defines PCRE_UCHAR16
! 300: as "short int", but checks that it really is a 16-bit data type. If it
! 301: is not, the build fails with an error message telling the maintainer to
! 302: modify the definition appropriately.
! 303:
! 304:
! 305: STRUCTURE TYPES
! 306:
! 307: The types of the opaque structures that are used for compiled 16-bit
! 308: patterns and JIT stacks are pcre16 and pcre16_jit_stack respectively.
! 309: The type of the user-accessible structure that is returned by
! 310: pcre16_study() is pcre16_extra, and the type of the structure that is
! 311: used for passing data to a callout function is pcre16_callout_block.
! 312: These structures contain the same fields, with the same names, as their
! 313: 8-bit counterparts. The only difference is that pointers to character
! 314: strings are 16-bit instead of 8-bit types.
! 315:
! 316:
! 317: 16-BIT FUNCTIONS
! 318:
! 319: For every function in the 8-bit library there is a corresponding func-
! 320: tion in the 16-bit library with a name that starts with pcre16_ instead
! 321: of pcre_. The prototypes are listed above. In addition, there is one
! 322: extra function, pcre16_utf16_to_host_byte_order(). This is a utility
! 323: function that converts a UTF-16 character string to host byte order if
! 324: necessary. The other 16-bit functions expect the strings they are
! 325: passed to be in host byte order.
! 326:
! 327: The input and output arguments of pcre16_utf16_to_host_byte_order() may
! 328: point to the same address, that is, conversion in place is supported.
! 329: The output buffer must be at least as long as the input.
! 330:
! 331: The length argument specifies the number of 16-bit data units in the
! 332: input string; a negative value specifies a zero-terminated string.
! 333:
! 334: If byte_order is NULL, it is assumed that the string starts off in host
! 335: byte order. This may be changed by byte-order marks (BOMs) anywhere in
! 336: the string (commonly as the first character).
! 337:
! 338: If byte_order is not NULL, a non-zero value of the integer to which it
! 339: points means that the input starts off in host byte order, otherwise
! 340: the opposite order is assumed. Again, BOMs in the string can change
! 341: this. The final byte order is passed back at the end of processing.
! 342:
! 343: If keep_boms is not zero, byte-order mark characters (0xfeff) are
! 344: copied into the output string. Otherwise they are discarded.
! 345:
! 346: The result of the function is the number of 16-bit units placed into
! 347: the output buffer, including the zero terminator if the string was
! 348: zero-terminated.
! 349:
! 350:
! 351: SUBJECT STRING OFFSETS
! 352:
! 353: The offsets within subject strings that are returned by the matching
! 354: functions are in 16-bit units rather than bytes.
! 355:
! 356:
! 357: NAMED SUBPATTERNS
! 358:
! 359: The name-to-number translation table that is maintained for named sub-
! 360: patterns uses 16-bit characters. The pcre16_get_stringtable_entries()
! 361: function returns the length of each entry in the table as the number of
! 362: 16-bit data units.
! 363:
! 364:
! 365: OPTION NAMES
! 366:
! 367: There are two new general option names, PCRE_UTF16 and
! 368: PCRE_NO_UTF16_CHECK, which correspond to PCRE_UTF8 and
! 369: PCRE_NO_UTF8_CHECK in the 8-bit library. In fact, these new options
! 370: define the same bits in the options word.
! 371:
! 372: For the pcre16_config() function there is an option PCRE_CONFIG_UTF16
! 373: that returns 1 if UTF-16 support is configured, otherwise 0. If this
! 374: option is given to pcre_config(), or if the PCRE_CONFIG_UTF8 option is
! 375: given to pcre16_config(), the result is the PCRE_ERROR_BADOPTION error.
! 376:
! 377:
! 378: CHARACTER CODES
! 379:
! 380: In 16-bit mode, when PCRE_UTF16 is not set, character values are
! 381: treated in the same way as in 8-bit, non UTF-8 mode, except, of course,
! 382: that they can range from 0 to 0xffff instead of 0 to 0xff. Character
! 383: types for characters less than 0xff can therefore be influenced by the
! 384: locale in the same way as before. Characters greater than 0xff have
! 385: only one case, and no "type" (such as letter or digit).
! 386:
! 387: In UTF-16 mode, the character code is Unicode, in the range 0 to
! 388: 0x10ffff, with the exception of values in the range 0xd800 to 0xdfff
! 389: because those are "surrogate" values that are used in pairs to encode
! 390: values greater than 0xffff.
! 391:
! 392: A UTF-16 string can indicate its endianness by special code knows as a
! 393: byte-order mark (BOM). The PCRE functions do not handle this, expecting
! 394: strings to be in host byte order. A utility function called
! 395: pcre16_utf16_to_host_byte_order() is provided to help with this (see
! 396: above).
! 397:
! 398:
! 399: ERROR NAMES
! 400:
! 401: The errors PCRE_ERROR_BADUTF16_OFFSET and PCRE_ERROR_SHORTUTF16 corre-
! 402: spond to their 8-bit counterparts. The error PCRE_ERROR_BADMODE is
! 403: given when a compiled pattern is passed to a function that processes
! 404: patterns in the other mode, for example, if a pattern compiled with
! 405: pcre_compile() is passed to pcre16_exec().
! 406:
! 407: There are new error codes whose names begin with PCRE_UTF16_ERR for
! 408: invalid UTF-16 strings, corresponding to the PCRE_UTF8_ERR codes for
! 409: UTF-8 strings that are described in the section entitled "Reason codes
! 410: for invalid UTF-8 strings" in the main pcreapi page. The UTF-16 errors
! 411: are:
! 412:
! 413: PCRE_UTF16_ERR1 Missing low surrogate at end of string
! 414: PCRE_UTF16_ERR2 Invalid low surrogate follows high surrogate
! 415: PCRE_UTF16_ERR3 Isolated low surrogate
! 416: PCRE_UTF16_ERR4 Invalid character 0xfffe
! 417:
! 418:
! 419: ERROR TEXTS
! 420:
! 421: If there is an error while compiling a pattern, the error text that is
! 422: passed back by pcre16_compile() or pcre16_compile2() is still an 8-bit
! 423: character string, zero-terminated.
! 424:
! 425:
! 426: CALLOUTS
! 427:
! 428: The subject and mark fields in the callout block that is passed to a
! 429: callout function point to 16-bit vectors.
! 430:
! 431:
! 432: TESTING
! 433:
! 434: The pcretest program continues to operate with 8-bit input and output
! 435: files, but it can be used for testing the 16-bit library. If it is run
! 436: with the command line option -16, patterns and subject strings are con-
! 437: verted from 8-bit to 16-bit before being passed to PCRE, and the 16-bit
! 438: library functions are used instead of the 8-bit ones. Returned 16-bit
! 439: strings are converted to 8-bit for output. If the 8-bit library was not
! 440: compiled, pcretest defaults to 16-bit and the -16 option is ignored.
! 441:
! 442: When PCRE is being built, the RunTest script that is called by "make
! 443: check" uses the pcretest -C option to discover which of the 8-bit and
! 444: 16-bit libraries has been built, and runs the tests appropriately.
! 445:
! 446:
! 447: NOT SUPPORTED IN 16-BIT MODE
! 448:
! 449: Not all the features of the 8-bit library are available with the 16-bit
! 450: library. The C++ and POSIX wrapper functions support only the 8-bit
! 451: library, and the pcregrep program is at present 8-bit only.
! 452:
! 453:
! 454: AUTHOR
! 455:
! 456: Philip Hazel
! 457: University Computing Service
! 458: Cambridge CB2 3QH, England.
! 459:
! 460:
! 461: REVISION
! 462:
! 463: Last updated: 08 January 2012
! 464: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 465: ------------------------------------------------------------------------------
466:
467:
468: PCREBUILD(3) PCREBUILD(3)
469:
470:
471: NAME
472: PCRE - Perl-compatible regular expressions
473:
474:
475: PCRE BUILD-TIME OPTIONS
476:
477: This document describes the optional features of PCRE that can be
478: selected when the library is compiled. It assumes use of the configure
479: script, where the optional features are selected or deselected by pro-
480: viding options to configure before running the make command. However,
481: the same options can be selected in both Unix-like and non-Unix-like
482: environments using the GUI facility of cmake-gui if you are using CMake
483: instead of configure to build PCRE.
484:
485: There is a lot more information about building PCRE in non-Unix-like
486: environments in the file called NON_UNIX_USE, which is part of the PCRE
487: distribution. You should consult this file as well as the README file
488: if you are building in a non-Unix-like environment.
489:
490: The complete list of options for configure (which includes the standard
491: ones such as the selection of the installation directory) can be
492: obtained by running
493:
494: ./configure --help
495:
496: The following sections include descriptions of options whose names
497: begin with --enable or --disable. These settings specify changes to the
498: defaults for the configure command. Because of the way that configure
499: works, --enable and --disable always come in pairs, so the complemen-
500: tary option always exists as well, but as it specifies the default, it
501: is not described.
502:
503:
1.1.1.2 ! misho 504: BUILDING 8-BIT and 16-BIT LIBRARIES
! 505:
! 506: By default, a library called libpcre is built, containing functions
! 507: that take string arguments contained in vectors of bytes, either as
! 508: single-byte characters, or interpreted as UTF-8 strings. You can also
! 509: build a separate library, called libpcre16, in which strings are con-
! 510: tained in vectors of 16-bit data units and interpreted either as sin-
! 511: gle-unit characters or UTF-16 strings, by adding
! 512:
! 513: --enable-pcre16
! 514:
! 515: to the configure command. If you do not want the 8-bit library, add
! 516:
! 517: --disable-pcre8
! 518:
! 519: as well. At least one of the two libraries must be built. Note that the
! 520: C++ and POSIX wrappers are for the 8-bit library only, and that pcre-
! 521: grep is an 8-bit program. None of these are built if you select only
! 522: the 16-bit library.
! 523:
! 524:
1.1 misho 525: BUILDING SHARED AND STATIC LIBRARIES
526:
527: The PCRE building process uses libtool to build both shared and static
528: Unix libraries by default. You can suppress one of these by adding one
529: of
530:
531: --disable-shared
532: --disable-static
533:
534: to the configure command, as required.
535:
536:
537: C++ SUPPORT
538:
1.1.1.2 ! misho 539: By default, if the 8-bit library is being built, the configure script
! 540: will search for a C++ compiler and C++ header files. If it finds them,
! 541: it automatically builds the C++ wrapper library (which supports only
! 542: 8-bit strings). You can disable this by adding
1.1 misho 543:
544: --disable-cpp
545:
546: to the configure command.
547:
548:
1.1.1.2 ! misho 549: UTF-8 and UTF-16 SUPPORT
1.1 misho 550:
1.1.1.2 ! misho 551: To build PCRE with support for UTF Unicode character strings, add
1.1 misho 552:
1.1.1.2 ! misho 553: --enable-utf
1.1 misho 554:
1.1.1.2 ! misho 555: to the configure command. This setting applies to both libraries,
! 556: adding support for UTF-8 to the 8-bit library and support for UTF-16 to
! 557: the 16-bit library. There are no separate options for enabling UTF-8
! 558: and UTF-16 independently because that would allow ridiculous settings
! 559: such as requesting UTF-16 support while building only the 8-bit
! 560: library. It is not possible to build one library with UTF support and
! 561: the other without in the same configuration. (For backwards compatibil-
! 562: ity, --enable-utf8 is a synonym of --enable-utf.)
! 563:
! 564: Of itself, this setting does not make PCRE treat strings as UTF-8 or
! 565: UTF-16. As well as compiling PCRE with this option, you also have have
! 566: to set the PCRE_UTF8 or PCRE_UTF16 option when you call one of the pat-
! 567: tern compiling functions.
1.1 misho 568:
1.1.1.2 ! misho 569: If you set --enable-utf when compiling in an EBCDIC environment, PCRE
1.1 misho 570: expects its input to be either ASCII or UTF-8 (depending on the runtime
571: option). It is not possible to support both EBCDIC and UTF-8 codes in
1.1.1.2 ! misho 572: the same version of the library. Consequently, --enable-utf and
1.1 misho 573: --enable-ebcdic are mutually exclusive.
574:
575:
576: UNICODE CHARACTER PROPERTY SUPPORT
577:
1.1.1.2 ! misho 578: UTF support allows the libraries to process character codepoints up to
! 579: 0x10ffff in the strings that they handle. On its own, however, it does
! 580: not provide any facilities for accessing the properties of such charac-
! 581: ters. If you want to be able to use the pattern escapes \P, \p, and \X,
! 582: which refer to Unicode character properties, you must add
1.1 misho 583:
584: --enable-unicode-properties
585:
1.1.1.2 ! misho 586: to the configure command. This implies UTF support, even if you have
1.1 misho 587: not explicitly requested it.
588:
589: Including Unicode property support adds around 30K of tables to the
590: PCRE library. Only the general category properties such as Lu and Nd
591: are supported. Details are given in the pcrepattern documentation.
592:
593:
594: JUST-IN-TIME COMPILER SUPPORT
595:
596: Just-in-time compiler support is included in the build by specifying
597:
598: --enable-jit
599:
600: This support is available only for certain hardware architectures. If
601: this option is set for an unsupported architecture, a compile time
602: error occurs. See the pcrejit documentation for a discussion of JIT
603: usage. When JIT support is enabled, pcregrep automatically makes use of
604: it, unless you add
605:
606: --disable-pcregrep-jit
607:
608: to the "configure" command.
609:
610:
611: CODE VALUE OF NEWLINE
612:
613: By default, PCRE interprets the linefeed (LF) character as indicating
614: the end of a line. This is the normal newline character on Unix-like
615: systems. You can compile PCRE to use carriage return (CR) instead, by
616: adding
617:
618: --enable-newline-is-cr
619:
620: to the configure command. There is also a --enable-newline-is-lf
621: option, which explicitly specifies linefeed as the newline character.
622:
623: Alternatively, you can specify that line endings are to be indicated by
624: the two character sequence CRLF. If you want this, add
625:
626: --enable-newline-is-crlf
627:
628: to the configure command. There is a fourth option, specified by
629:
630: --enable-newline-is-anycrlf
631:
632: which causes PCRE to recognize any of the three sequences CR, LF, or
633: CRLF as indicating a line ending. Finally, a fifth option, specified by
634:
635: --enable-newline-is-any
636:
637: causes PCRE to recognize any Unicode newline sequence.
638:
639: Whatever line ending convention is selected when PCRE is built can be
640: overridden when the library functions are called. At build time it is
641: conventional to use the standard for your operating system.
642:
643:
644: WHAT \R MATCHES
645:
646: By default, the sequence \R in a pattern matches any Unicode newline
647: sequence, whatever has been selected as the line ending sequence. If
648: you specify
649:
650: --enable-bsr-anycrlf
651:
652: the default is changed so that \R matches only CR, LF, or CRLF. What-
653: ever is selected when PCRE is built can be overridden when the library
654: functions are called.
655:
656:
657: POSIX MALLOC USAGE
658:
1.1.1.2 ! misho 659: When the 8-bit library is called through the POSIX interface (see the
! 660: pcreposix documentation), additional working storage is required for
! 661: holding the pointers to capturing substrings, because PCRE requires
! 662: three integers per substring, whereas the POSIX interface provides only
! 663: two. If the number of expected substrings is small, the wrapper func-
! 664: tion uses space on the stack, because this is faster than using mal-
! 665: loc() for each call. The default threshold above which the stack is no
! 666: longer used is 10; it can be changed by adding a setting such as
1.1 misho 667:
668: --with-posix-malloc-threshold=20
669:
670: to the configure command.
671:
672:
673: HANDLING VERY LARGE PATTERNS
674:
675: Within a compiled pattern, offset values are used to point from one
676: part to another (for example, from an opening parenthesis to an alter-
677: nation metacharacter). By default, two-byte values are used for these
678: offsets, leading to a maximum size for a compiled pattern of around
679: 64K. This is sufficient to handle all but the most gigantic patterns.
1.1.1.2 ! misho 680: Nevertheless, some people do want to process truly enormous patterns,
1.1 misho 681: so it is possible to compile PCRE to use three-byte or four-byte off-
682: sets by adding a setting such as
683:
684: --with-link-size=3
685:
1.1.1.2 ! misho 686: to the configure command. The value given must be 2, 3, or 4. For the
! 687: 16-bit library, a value of 3 is rounded up to 4. Using longer offsets
! 688: slows down the operation of PCRE because it has to load additional data
! 689: when handling them.
1.1 misho 690:
691:
692: AVOIDING EXCESSIVE STACK USAGE
693:
694: When matching with the pcre_exec() function, PCRE implements backtrack-
1.1.1.2 ! misho 695: ing by making recursive calls to an internal function called match().
! 696: In environments where the size of the stack is limited, this can se-
! 697: verely limit PCRE's operation. (The Unix environment does not usually
1.1 misho 698: suffer from this problem, but it may sometimes be necessary to increase
1.1.1.2 ! misho 699: the maximum stack size. There is a discussion in the pcrestack docu-
! 700: mentation.) An alternative approach to recursion that uses memory from
! 701: the heap to remember data, instead of using recursive function calls,
! 702: has been implemented to work round the problem of limited stack size.
1.1 misho 703: If you want to build a version of PCRE that works this way, add
704:
705: --disable-stack-for-recursion
706:
1.1.1.2 ! misho 707: to the configure command. With this configuration, PCRE will use the
! 708: pcre_stack_malloc and pcre_stack_free variables to call memory manage-
! 709: ment functions. By default these point to malloc() and free(), but you
1.1 misho 710: can replace the pointers so that your own functions are used instead.
711:
1.1.1.2 ! misho 712: Separate functions are provided rather than using pcre_malloc and
! 713: pcre_free because the usage is very predictable: the block sizes
! 714: requested are always the same, and the blocks are always freed in
! 715: reverse order. A calling program might be able to implement optimized
! 716: functions that perform better than malloc() and free(). PCRE runs
1.1 misho 717: noticeably more slowly when built in this way. This option affects only
718: the pcre_exec() function; it is not relevant for pcre_dfa_exec().
719:
720:
721: LIMITING PCRE RESOURCE USAGE
722:
1.1.1.2 ! misho 723: Internally, PCRE has a function called match(), which it calls repeat-
! 724: edly (sometimes recursively) when matching a pattern with the
! 725: pcre_exec() function. By controlling the maximum number of times this
! 726: function may be called during a single matching operation, a limit can
! 727: be placed on the resources used by a single call to pcre_exec(). The
! 728: limit can be changed at run time, as described in the pcreapi documen-
! 729: tation. The default is 10 million, but this can be changed by adding a
1.1 misho 730: setting such as
731:
732: --with-match-limit=500000
733:
1.1.1.2 ! misho 734: to the configure command. This setting has no effect on the
1.1 misho 735: pcre_dfa_exec() matching function.
736:
1.1.1.2 ! misho 737: In some environments it is desirable to limit the depth of recursive
1.1 misho 738: calls of match() more strictly than the total number of calls, in order
1.1.1.2 ! misho 739: to restrict the maximum amount of stack (or heap, if --disable-stack-
1.1 misho 740: for-recursion is specified) that is used. A second limit controls this;
1.1.1.2 ! misho 741: it defaults to the value that is set for --with-match-limit, which
! 742: imposes no additional constraints. However, you can set a lower limit
1.1 misho 743: by adding, for example,
744:
745: --with-match-limit-recursion=10000
746:
1.1.1.2 ! misho 747: to the configure command. This value can also be overridden at run
1.1 misho 748: time.
749:
750:
751: CREATING CHARACTER TABLES AT BUILD TIME
752:
1.1.1.2 ! misho 753: PCRE uses fixed tables for processing characters whose code values are
! 754: less than 256. By default, PCRE is built with a set of tables that are
! 755: distributed in the file pcre_chartables.c.dist. These tables are for
1.1 misho 756: ASCII codes only. If you add
757:
758: --enable-rebuild-chartables
759:
1.1.1.2 ! misho 760: to the configure command, the distributed tables are no longer used.
! 761: Instead, a program called dftables is compiled and run. This outputs
1.1 misho 762: the source for new set of tables, created in the default locale of your
763: C runtime system. (This method of replacing the tables does not work if
1.1.1.2 ! misho 764: you are cross compiling, because dftables is run on the local host. If
! 765: you need to create alternative tables when cross compiling, you will
1.1 misho 766: have to do so "by hand".)
767:
768:
769: USING EBCDIC CODE
770:
1.1.1.2 ! misho 771: PCRE assumes by default that it will run in an environment where the
! 772: character code is ASCII (or Unicode, which is a superset of ASCII).
! 773: This is the case for most computer operating systems. PCRE can, how-
1.1 misho 774: ever, be compiled to run in an EBCDIC environment by adding
775:
776: --enable-ebcdic
777:
778: to the configure command. This setting implies --enable-rebuild-charta-
1.1.1.2 ! misho 779: bles. You should only use it if you know that you are in an EBCDIC
! 780: environment (for example, an IBM mainframe operating system). The
! 781: --enable-ebcdic option is incompatible with --enable-utf.
1.1 misho 782:
783:
784: PCREGREP OPTIONS FOR COMPRESSED FILE SUPPORT
785:
786: By default, pcregrep reads all files as plain text. You can build it so
787: that it recognizes files whose names end in .gz or .bz2, and reads them
788: with libz or libbz2, respectively, by adding one or both of
789:
790: --enable-pcregrep-libz
791: --enable-pcregrep-libbz2
792:
793: to the configure command. These options naturally require that the rel-
1.1.1.2 ! misho 794: evant libraries are installed on your system. Configuration will fail
1.1 misho 795: if they are not.
796:
797:
798: PCREGREP BUFFER SIZE
799:
1.1.1.2 ! misho 800: pcregrep uses an internal buffer to hold a "window" on the file it is
1.1 misho 801: scanning, in order to be able to output "before" and "after" lines when
1.1.1.2 ! misho 802: it finds a match. The size of the buffer is controlled by a parameter
1.1 misho 803: whose default value is 20K. The buffer itself is three times this size,
804: but because of the way it is used for holding "before" lines, the long-
1.1.1.2 ! misho 805: est line that is guaranteed to be processable is the parameter size.
1.1 misho 806: You can change the default parameter value by adding, for example,
807:
808: --with-pcregrep-bufsize=50K
809:
810: to the configure command. The caller of pcregrep can, however, override
811: this value by specifying a run-time option.
812:
813:
814: PCRETEST OPTION FOR LIBREADLINE SUPPORT
815:
816: If you add
817:
818: --enable-pcretest-libreadline
819:
1.1.1.2 ! misho 820: to the configure command, pcretest is linked with the libreadline
! 821: library, and when its input is from a terminal, it reads it using the
1.1 misho 822: readline() function. This provides line-editing and history facilities.
823: Note that libreadline is GPL-licensed, so if you distribute a binary of
824: pcretest linked in this way, there may be licensing issues.
825:
1.1.1.2 ! misho 826: Setting this option causes the -lreadline option to be added to the
! 827: pcretest build. In many operating environments with a sytem-installed
1.1 misho 828: libreadline this is sufficient. However, in some environments (e.g. if
1.1.1.2 ! misho 829: an unmodified distribution version of readline is in use), some extra
! 830: configuration may be necessary. The INSTALL file for libreadline says
1.1 misho 831: this:
832:
833: "Readline uses the termcap functions, but does not link with the
834: termcap or curses library itself, allowing applications which link
835: with readline the to choose an appropriate library."
836:
1.1.1.2 ! misho 837: If your environment has not been set up so that an appropriate library
1.1 misho 838: is automatically included, you may need to add something like
839:
840: LIBS="-ncurses"
841:
842: immediately before the configure command.
843:
844:
845: SEE ALSO
846:
1.1.1.2 ! misho 847: pcreapi(3), pcre16, pcre_config(3).
1.1 misho 848:
849:
850: AUTHOR
851:
852: Philip Hazel
853: University Computing Service
854: Cambridge CB2 3QH, England.
855:
856:
857: REVISION
858:
1.1.1.2 ! misho 859: Last updated: 07 January 2012
! 860: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 861: ------------------------------------------------------------------------------
862:
863:
864: PCREMATCHING(3) PCREMATCHING(3)
865:
866:
867: NAME
868: PCRE - Perl-compatible regular expressions
869:
870:
871: PCRE MATCHING ALGORITHMS
872:
873: This document describes the two different algorithms that are available
874: in PCRE for matching a compiled regular expression against a given sub-
875: ject string. The "standard" algorithm is the one provided by the
1.1.1.2 ! misho 876: pcre_exec() and pcre16_exec() functions. These work in the same was as
! 877: Perl's matching function, and provide a Perl-compatible matching opera-
! 878: tion. The just-in-time (JIT) optimization that is described in the
! 879: pcrejit documentation is compatible with these functions.
! 880:
! 881: An alternative algorithm is provided by the pcre_dfa_exec() and
! 882: pcre16_dfa_exec() functions; they operate in a different way, and are
! 883: not Perl-compatible. This alternative has advantages and disadvantages
! 884: compared with the standard algorithm, and these are described below.
1.1 misho 885:
886: When there is only one possible way in which a given subject string can
887: match a pattern, the two algorithms give the same answer. A difference
888: arises, however, when there are multiple possibilities. For example, if
889: the pattern
890:
891: ^<.*>
892:
893: is matched against the string
894:
895: <something> <something else> <something further>
896:
897: there are three possible answers. The standard algorithm finds only one
898: of them, whereas the alternative algorithm finds all three.
899:
900:
901: REGULAR EXPRESSIONS AS TREES
902:
903: The set of strings that are matched by a regular expression can be rep-
904: resented as a tree structure. An unlimited repetition in the pattern
905: makes the tree of infinite size, but it is still a tree. Matching the
906: pattern to a given subject string (from a given starting point) can be
907: thought of as a search of the tree. There are two ways to search a
908: tree: depth-first and breadth-first, and these correspond to the two
909: matching algorithms provided by PCRE.
910:
911:
912: THE STANDARD MATCHING ALGORITHM
913:
914: In the terminology of Jeffrey Friedl's book "Mastering Regular Expres-
915: sions", the standard algorithm is an "NFA algorithm". It conducts a
916: depth-first search of the pattern tree. That is, it proceeds along a
917: single path through the tree, checking that the subject matches what is
918: required. When there is a mismatch, the algorithm tries any alterna-
919: tives at the current point, and if they all fail, it backs up to the
920: previous branch point in the tree, and tries the next alternative
921: branch at that level. This often involves backing up (moving to the
922: left) in the subject string as well. The order in which repetition
923: branches are tried is controlled by the greedy or ungreedy nature of
924: the quantifier.
925:
926: If a leaf node is reached, a matching string has been found, and at
927: that point the algorithm stops. Thus, if there is more than one possi-
928: ble match, this algorithm returns the first one that it finds. Whether
929: this is the shortest, the longest, or some intermediate length depends
930: on the way the greedy and ungreedy repetition quantifiers are specified
931: in the pattern.
932:
933: Because it ends up with a single path through the tree, it is rela-
934: tively straightforward for this algorithm to keep track of the sub-
935: strings that are matched by portions of the pattern in parentheses.
936: This provides support for capturing parentheses and back references.
937:
938:
939: THE ALTERNATIVE MATCHING ALGORITHM
940:
941: This algorithm conducts a breadth-first search of the tree. Starting
942: from the first matching point in the subject, it scans the subject
943: string from left to right, once, character by character, and as it does
944: this, it remembers all the paths through the tree that represent valid
945: matches. In Friedl's terminology, this is a kind of "DFA algorithm",
946: though it is not implemented as a traditional finite state machine (it
947: keeps multiple states active simultaneously).
948:
949: Although the general principle of this matching algorithm is that it
950: scans the subject string only once, without backtracking, there is one
951: exception: when a lookaround assertion is encountered, the characters
952: following or preceding the current point have to be independently
953: inspected.
954:
955: The scan continues until either the end of the subject is reached, or
956: there are no more unterminated paths. At this point, terminated paths
957: represent the different matching possibilities (if there are none, the
958: match has failed). Thus, if there is more than one possible match,
959: this algorithm finds all of them, and in particular, it finds the long-
960: est. The matches are returned in decreasing order of length. There is
961: an option to stop the algorithm after the first match (which is neces-
962: sarily the shortest) is found.
963:
964: Note that all the matches that are found start at the same point in the
965: subject. If the pattern
966:
967: cat(er(pillar)?)?
968:
969: is matched against the string "the caterpillar catchment", the result
970: will be the three strings "caterpillar", "cater", and "cat" that start
971: at the fifth character of the subject. The algorithm does not automati-
972: cally move on to find matches that start at later positions.
973:
974: There are a number of features of PCRE regular expressions that are not
975: supported by the alternative matching algorithm. They are as follows:
976:
977: 1. Because the algorithm finds all possible matches, the greedy or
978: ungreedy nature of repetition quantifiers is not relevant. Greedy and
979: ungreedy quantifiers are treated in exactly the same way. However, pos-
980: sessive quantifiers can make a difference when what follows could also
981: match what is quantified, for example in a pattern like this:
982:
983: ^a++\w!
984:
985: This pattern matches "aaab!" but not "aaa!", which would be matched by
986: a non-possessive quantifier. Similarly, if an atomic group is present,
987: it is matched as if it were a standalone pattern at the current point,
988: and the longest match is then "locked in" for the rest of the overall
989: pattern.
990:
991: 2. When dealing with multiple paths through the tree simultaneously, it
992: is not straightforward to keep track of captured substrings for the
993: different matching possibilities, and PCRE's implementation of this
994: algorithm does not attempt to do this. This means that no captured sub-
995: strings are available.
996:
997: 3. Because no substrings are captured, back references within the pat-
998: tern are not supported, and cause errors if encountered.
999:
1000: 4. For the same reason, conditional expressions that use a backrefer-
1001: ence as the condition or test for a specific group recursion are not
1002: supported.
1003:
1004: 5. Because many paths through the tree may be active, the \K escape
1005: sequence, which resets the start of the match when encountered (but may
1006: be on some paths and not on others), is not supported. It causes an
1007: error if encountered.
1008:
1009: 6. Callouts are supported, but the value of the capture_top field is
1010: always 1, and the value of the capture_last field is always -1.
1011:
1.1.1.2 ! misho 1012: 7. The \C escape sequence, which (in the standard algorithm) always
! 1013: matches a single data unit, even in UTF-8 or UTF-16 modes, is not sup-
! 1014: ported in these modes, because the alternative algorithm moves through
! 1015: the subject string one character (not data unit) at a time, for all
! 1016: active paths through the tree.
1.1 misho 1017:
1.1.1.2 ! misho 1018: 8. Except for (*FAIL), the backtracking control verbs such as (*PRUNE)
! 1019: are not supported. (*FAIL) is supported, and behaves like a failing
1.1 misho 1020: negative assertion.
1021:
1022:
1023: ADVANTAGES OF THE ALTERNATIVE ALGORITHM
1024:
1.1.1.2 ! misho 1025: Using the alternative matching algorithm provides the following advan-
1.1 misho 1026: tages:
1027:
1028: 1. All possible matches (at a single point in the subject) are automat-
1.1.1.2 ! misho 1029: ically found, and in particular, the longest match is found. To find
1.1 misho 1030: more than one match using the standard algorithm, you have to do kludgy
1031: things with callouts.
1032:
1.1.1.2 ! misho 1033: 2. Because the alternative algorithm scans the subject string just
! 1034: once, and never needs to backtrack (except for lookbehinds), it is pos-
! 1035: sible to pass very long subject strings to the matching function in
! 1036: several pieces, checking for partial matching each time. Although it is
! 1037: possible to do multi-segment matching using the standard algorithm by
! 1038: retaining partially matched substrings, it is more complicated. The
! 1039: pcrepartial documentation gives details of partial matching and dis-
! 1040: cusses multi-segment matching.
1.1 misho 1041:
1042:
1043: DISADVANTAGES OF THE ALTERNATIVE ALGORITHM
1044:
1045: The alternative algorithm suffers from a number of disadvantages:
1046:
1.1.1.2 ! misho 1047: 1. It is substantially slower than the standard algorithm. This is
! 1048: partly because it has to search for all possible matches, but is also
1.1 misho 1049: because it is less susceptible to optimization.
1050:
1051: 2. Capturing parentheses and back references are not supported.
1052:
1053: 3. Although atomic groups are supported, their use does not provide the
1054: performance advantage that it does for the standard algorithm.
1055:
1056:
1057: AUTHOR
1058:
1059: Philip Hazel
1060: University Computing Service
1061: Cambridge CB2 3QH, England.
1062:
1063:
1064: REVISION
1065:
1.1.1.2 ! misho 1066: Last updated: 08 January 2012
! 1067: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 1068: ------------------------------------------------------------------------------
1069:
1070:
1071: PCREAPI(3) PCREAPI(3)
1072:
1073:
1074: NAME
1075: PCRE - Perl-compatible regular expressions
1076:
1.1.1.2 ! misho 1077: #include <pcre.h>
1.1 misho 1078:
1079:
1.1.1.2 ! misho 1080: PCRE NATIVE API BASIC FUNCTIONS
1.1 misho 1081:
1082: pcre *pcre_compile(const char *pattern, int options,
1083: const char **errptr, int *erroffset,
1084: const unsigned char *tableptr);
1085:
1086: pcre *pcre_compile2(const char *pattern, int options,
1087: int *errorcodeptr,
1088: const char **errptr, int *erroffset,
1089: const unsigned char *tableptr);
1090:
1091: pcre_extra *pcre_study(const pcre *code, int options,
1092: const char **errptr);
1093:
1094: void pcre_free_study(pcre_extra *extra);
1095:
1096: int pcre_exec(const pcre *code, const pcre_extra *extra,
1097: const char *subject, int length, int startoffset,
1098: int options, int *ovector, int ovecsize);
1099:
1100: int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
1101: const char *subject, int length, int startoffset,
1102: int options, int *ovector, int ovecsize,
1103: int *workspace, int wscount);
1104:
1.1.1.2 ! misho 1105:
! 1106: PCRE NATIVE API STRING EXTRACTION FUNCTIONS
! 1107:
1.1 misho 1108: int pcre_copy_named_substring(const pcre *code,
1109: const char *subject, int *ovector,
1110: int stringcount, const char *stringname,
1111: char *buffer, int buffersize);
1112:
1113: int pcre_copy_substring(const char *subject, int *ovector,
1114: int stringcount, int stringnumber, char *buffer,
1115: int buffersize);
1116:
1117: int pcre_get_named_substring(const pcre *code,
1118: const char *subject, int *ovector,
1119: int stringcount, const char *stringname,
1120: const char **stringptr);
1121:
1122: int pcre_get_stringnumber(const pcre *code,
1123: const char *name);
1124:
1125: int pcre_get_stringtable_entries(const pcre *code,
1126: const char *name, char **first, char **last);
1127:
1128: int pcre_get_substring(const char *subject, int *ovector,
1129: int stringcount, int stringnumber,
1130: const char **stringptr);
1131:
1132: int pcre_get_substring_list(const char *subject,
1133: int *ovector, int stringcount, const char ***listptr);
1134:
1135: void pcre_free_substring(const char *stringptr);
1136:
1137: void pcre_free_substring_list(const char **stringptr);
1138:
1.1.1.2 ! misho 1139:
! 1140: PCRE NATIVE API AUXILIARY FUNCTIONS
! 1141:
! 1142: pcre_jit_stack *pcre_jit_stack_alloc(int startsize, int maxsize);
! 1143:
! 1144: void pcre_jit_stack_free(pcre_jit_stack *stack);
! 1145:
! 1146: void pcre_assign_jit_stack(pcre_extra *extra,
! 1147: pcre_jit_callback callback, void *data);
! 1148:
1.1 misho 1149: const unsigned char *pcre_maketables(void);
1150:
1151: int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
1152: int what, void *where);
1153:
1154: int pcre_refcount(pcre *code, int adjust);
1155:
1156: int pcre_config(int what, void *where);
1157:
1.1.1.2 ! misho 1158: const char *pcre_version(void);
! 1159:
! 1160: int pcre_pattern_to_host_byte_order(pcre *code,
! 1161: pcre_extra *extra, const unsigned char *tables);
1.1 misho 1162:
1163:
1164: PCRE NATIVE API INDIRECTED FUNCTIONS
1165:
1166: void *(*pcre_malloc)(size_t);
1167:
1168: void (*pcre_free)(void *);
1169:
1170: void *(*pcre_stack_malloc)(size_t);
1171:
1172: void (*pcre_stack_free)(void *);
1173:
1174: int (*pcre_callout)(pcre_callout_block *);
1175:
1176:
1.1.1.2 ! misho 1177: PCRE 8-BIT AND 16-BIT LIBRARIES
! 1178:
! 1179: From release 8.30, PCRE can be compiled as a library for handling
! 1180: 16-bit character strings as well as, or instead of, the original
! 1181: library that handles 8-bit character strings. To avoid too much compli-
! 1182: cation, this document describes the 8-bit versions of the functions,
! 1183: with only occasional references to the 16-bit library.
! 1184:
! 1185: The 16-bit functions operate in the same way as their 8-bit counter-
! 1186: parts; they just use different data types for their arguments and
! 1187: results, and their names start with pcre16_ instead of pcre_. For every
! 1188: option that has UTF8 in its name (for example, PCRE_UTF8), there is a
! 1189: corresponding 16-bit name with UTF8 replaced by UTF16. This facility is
! 1190: in fact just cosmetic; the 16-bit option names define the same bit val-
! 1191: ues.
! 1192:
! 1193: References to bytes and UTF-8 in this document should be read as refer-
! 1194: ences to 16-bit data quantities and UTF-16 when using the 16-bit
! 1195: library, unless specified otherwise. More details of the specific dif-
! 1196: ferences for the 16-bit library are given in the pcre16 page.
! 1197:
! 1198:
1.1 misho 1199: PCRE API OVERVIEW
1200:
1201: PCRE has its own native API, which is described in this document. There
1.1.1.2 ! misho 1202: are also some wrapper functions (for the 8-bit library only) that cor-
! 1203: respond to the POSIX regular expression API, but they do not give
! 1204: access to all the functionality. They are described in the pcreposix
! 1205: documentation. Both of these APIs define a set of C function calls. A
! 1206: C++ wrapper (again for the 8-bit library only) is also distributed with
! 1207: PCRE. It is documented in the pcrecpp page.
1.1 misho 1208:
1209: The native API C function prototypes are defined in the header file
1.1.1.2 ! misho 1210: pcre.h, and on Unix-like systems the (8-bit) library itself is called
! 1211: libpcre. It can normally be accessed by adding -lpcre to the command
! 1212: for linking an application that uses PCRE. The header file defines the
! 1213: macros PCRE_MAJOR and PCRE_MINOR to contain the major and minor release
! 1214: numbers for the library. Applications can use these to include support
1.1 misho 1215: for different releases of PCRE.
1216:
1217: In a Windows environment, if you want to statically link an application
1218: program against a non-dll pcre.a file, you must define PCRE_STATIC
1219: before including pcre.h or pcrecpp.h, because otherwise the pcre_mal-
1220: loc() and pcre_free() exported functions will be declared
1221: __declspec(dllimport), with unwanted results.
1222:
1223: The functions pcre_compile(), pcre_compile2(), pcre_study(), and
1224: pcre_exec() are used for compiling and matching regular expressions in
1225: a Perl-compatible manner. A sample program that demonstrates the sim-
1226: plest way of using them is provided in the file called pcredemo.c in
1227: the PCRE source distribution. A listing of this program is given in the
1228: pcredemo documentation, and the pcresample documentation describes how
1229: to compile and run it.
1230:
1231: Just-in-time compiler support is an optional feature of PCRE that can
1232: be built in appropriate hardware environments. It greatly speeds up the
1233: matching performance of many patterns. Simple programs can easily
1234: request that it be used if available, by setting an option that is
1235: ignored when it is not relevant. More complicated programs might need
1236: to make use of the functions pcre_jit_stack_alloc(),
1237: pcre_jit_stack_free(), and pcre_assign_jit_stack() in order to control
1238: the JIT code's memory usage. These functions are discussed in the
1239: pcrejit documentation.
1240:
1241: A second matching function, pcre_dfa_exec(), which is not Perl-compati-
1242: ble, is also provided. This uses a different algorithm for the match-
1243: ing. The alternative algorithm finds all possible matches (at a given
1244: point in the subject), and scans the subject just once (unless there
1245: are lookbehind assertions). However, this algorithm does not return
1246: captured substrings. A description of the two matching algorithms and
1247: their advantages and disadvantages is given in the pcrematching docu-
1248: mentation.
1249:
1250: In addition to the main compiling and matching functions, there are
1251: convenience functions for extracting captured substrings from a subject
1252: string that is matched by pcre_exec(). They are:
1253:
1254: pcre_copy_substring()
1255: pcre_copy_named_substring()
1256: pcre_get_substring()
1257: pcre_get_named_substring()
1258: pcre_get_substring_list()
1259: pcre_get_stringnumber()
1260: pcre_get_stringtable_entries()
1261:
1262: pcre_free_substring() and pcre_free_substring_list() are also provided,
1263: to free the memory used for extracted strings.
1264:
1265: The function pcre_maketables() is used to build a set of character
1266: tables in the current locale for passing to pcre_compile(),
1267: pcre_exec(), or pcre_dfa_exec(). This is an optional facility that is
1268: provided for specialist use. Most commonly, no special tables are
1269: passed, in which case internal tables that are generated when PCRE is
1270: built are used.
1271:
1272: The function pcre_fullinfo() is used to find out information about a
1.1.1.2 ! misho 1273: compiled pattern. The function pcre_version() returns a pointer to a
! 1274: string containing the version of PCRE and its date of release.
1.1 misho 1275:
1276: The function pcre_refcount() maintains a reference count in a data
1277: block containing a compiled pattern. This is provided for the benefit
1278: of object-oriented applications.
1279:
1280: The global variables pcre_malloc and pcre_free initially contain the
1281: entry points of the standard malloc() and free() functions, respec-
1282: tively. PCRE calls the memory management functions via these variables,
1283: so a calling program can replace them if it wishes to intercept the
1284: calls. This should be done before calling any PCRE functions.
1285:
1286: The global variables pcre_stack_malloc and pcre_stack_free are also
1287: indirections to memory management functions. These special functions
1288: are used only when PCRE is compiled to use the heap for remembering
1289: data, instead of recursive function calls, when running the pcre_exec()
1290: function. See the pcrebuild documentation for details of how to do
1291: this. It is a non-standard way of building PCRE, for use in environ-
1292: ments that have limited stacks. Because of the greater use of memory
1293: management, it runs more slowly. Separate functions are provided so
1294: that special-purpose external code can be used for this case. When
1295: used, these functions are always called in a stack-like manner (last
1296: obtained, first freed), and always for memory blocks of the same size.
1297: There is a discussion about PCRE's stack usage in the pcrestack docu-
1298: mentation.
1299:
1300: The global variable pcre_callout initially contains NULL. It can be set
1301: by the caller to a "callout" function, which PCRE will then call at
1302: specified points during a matching operation. Details are given in the
1303: pcrecallout documentation.
1304:
1305:
1306: NEWLINES
1307:
1308: PCRE supports five different conventions for indicating line breaks in
1309: strings: a single CR (carriage return) character, a single LF (line-
1310: feed) character, the two-character sequence CRLF, any of the three pre-
1311: ceding, or any Unicode newline sequence. The Unicode newline sequences
1312: are the three just mentioned, plus the single characters VT (vertical
1313: tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line
1314: separator, U+2028), and PS (paragraph separator, U+2029).
1315:
1316: Each of the first three conventions is used by at least one operating
1317: system as its standard newline sequence. When PCRE is built, a default
1318: can be specified. The default default is LF, which is the Unix stan-
1319: dard. When PCRE is run, the default can be overridden, either when a
1320: pattern is compiled, or when it is matched.
1321:
1322: At compile time, the newline convention can be specified by the options
1323: argument of pcre_compile(), or it can be specified by special text at
1324: the start of the pattern itself; this overrides any other settings. See
1325: the pcrepattern page for details of the special character sequences.
1326:
1327: In the PCRE documentation the word "newline" is used to mean "the char-
1328: acter or pair of characters that indicate a line break". The choice of
1329: newline convention affects the handling of the dot, circumflex, and
1330: dollar metacharacters, the handling of #-comments in /x mode, and, when
1331: CRLF is a recognized line ending sequence, the match position advance-
1332: ment for a non-anchored pattern. There is more detail about this in the
1333: section on pcre_exec() options below.
1334:
1335: The choice of newline convention does not affect the interpretation of
1336: the \n or \r escape sequences, nor does it affect what \R matches,
1337: which is controlled in a similar way, but by separate options.
1338:
1339:
1340: MULTITHREADING
1341:
1342: The PCRE functions can be used in multi-threading applications, with
1343: the proviso that the memory management functions pointed to by
1344: pcre_malloc, pcre_free, pcre_stack_malloc, and pcre_stack_free, and the
1345: callout function pointed to by pcre_callout, are shared by all threads.
1346:
1347: The compiled form of a regular expression is not altered during match-
1348: ing, so the same compiled pattern can safely be used by several threads
1349: at once.
1350:
1351: If the just-in-time optimization feature is being used, it needs sepa-
1352: rate memory stack areas for each thread. See the pcrejit documentation
1353: for more details.
1354:
1355:
1356: SAVING PRECOMPILED PATTERNS FOR LATER USE
1357:
1358: The compiled form of a regular expression can be saved and re-used at a
1359: later time, possibly by a different program, and even on a host other
1360: than the one on which it was compiled. Details are given in the
1.1.1.2 ! misho 1361: pcreprecompile documentation, which includes a description of the
! 1362: pcre_pattern_to_host_byte_order() function. However, compiling a regu-
! 1363: lar expression with one version of PCRE for use with a different ver-
! 1364: sion is not guaranteed to work and may cause crashes.
1.1 misho 1365:
1366:
1367: CHECKING BUILD-TIME OPTIONS
1368:
1369: int pcre_config(int what, void *where);
1370:
1.1.1.2 ! misho 1371: The function pcre_config() makes it possible for a PCRE client to dis-
1.1 misho 1372: cover which optional features have been compiled into the PCRE library.
1.1.1.2 ! misho 1373: The pcrebuild documentation has more details about these optional fea-
1.1 misho 1374: tures.
1375:
1.1.1.2 ! misho 1376: The first argument for pcre_config() is an integer, specifying which
1.1 misho 1377: information is required; the second argument is a pointer to a variable
1.1.1.2 ! misho 1378: into which the information is placed. The returned value is zero on
! 1379: success, or the negative error code PCRE_ERROR_BADOPTION if the value
! 1380: in the first argument is not recognized. The following information is
1.1 misho 1381: available:
1382:
1383: PCRE_CONFIG_UTF8
1384:
1.1.1.2 ! misho 1385: The output is an integer that is set to one if UTF-8 support is avail-
! 1386: able; otherwise it is set to zero. If this option is given to the
! 1387: 16-bit version of this function, pcre16_config(), the result is
! 1388: PCRE_ERROR_BADOPTION.
! 1389:
! 1390: PCRE_CONFIG_UTF16
! 1391:
! 1392: The output is an integer that is set to one if UTF-16 support is avail-
! 1393: able; otherwise it is set to zero. This value should normally be given
! 1394: to the 16-bit version of this function, pcre16_config(). If it is given
! 1395: to the 8-bit version of this function, the result is PCRE_ERROR_BADOP-
! 1396: TION.
1.1 misho 1397:
1398: PCRE_CONFIG_UNICODE_PROPERTIES
1399:
1.1.1.2 ! misho 1400: The output is an integer that is set to one if support for Unicode
1.1 misho 1401: character properties is available; otherwise it is set to zero.
1402:
1403: PCRE_CONFIG_JIT
1404:
1405: The output is an integer that is set to one if support for just-in-time
1406: compiling is available; otherwise it is set to zero.
1407:
1.1.1.2 ! misho 1408: PCRE_CONFIG_JITTARGET
! 1409:
! 1410: The output is a pointer to a zero-terminated "const char *" string. If
! 1411: JIT support is available, the string contains the name of the architec-
! 1412: ture for which the JIT compiler is configured, for example "x86 32bit
! 1413: (little endian + unaligned)". If JIT support is not available, the
! 1414: result is NULL.
! 1415:
1.1 misho 1416: PCRE_CONFIG_NEWLINE
1417:
1.1.1.2 ! misho 1418: The output is an integer whose value specifies the default character
! 1419: sequence that is recognized as meaning "newline". The four values that
1.1 misho 1420: are supported are: 10 for LF, 13 for CR, 3338 for CRLF, -2 for ANYCRLF,
1.1.1.2 ! misho 1421: and -1 for ANY. Though they are derived from ASCII, the same values
1.1 misho 1422: are returned in EBCDIC environments. The default should normally corre-
1423: spond to the standard sequence for your operating system.
1424:
1425: PCRE_CONFIG_BSR
1426:
1427: The output is an integer whose value indicates what character sequences
1.1.1.2 ! misho 1428: the \R escape sequence matches by default. A value of 0 means that \R
! 1429: matches any Unicode line ending sequence; a value of 1 means that \R
1.1 misho 1430: matches only CR, LF, or CRLF. The default can be overridden when a pat-
1431: tern is compiled or matched.
1432:
1433: PCRE_CONFIG_LINK_SIZE
1434:
1.1.1.2 ! misho 1435: The output is an integer that contains the number of bytes used for
! 1436: internal linkage in compiled regular expressions. For the 8-bit
! 1437: library, the value can be 2, 3, or 4. For the 16-bit library, the value
! 1438: is either 2 or 4 and is still a number of bytes. The default value of 2
! 1439: is sufficient for all but the most massive patterns, since it allows
! 1440: the compiled pattern to be up to 64K in size. Larger values allow
! 1441: larger regular expressions to be compiled, at the expense of slower
! 1442: matching.
1.1 misho 1443:
1444: PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
1445:
1.1.1.2 ! misho 1446: The output is an integer that contains the threshold above which the
! 1447: POSIX interface uses malloc() for output vectors. Further details are
1.1 misho 1448: given in the pcreposix documentation.
1449:
1450: PCRE_CONFIG_MATCH_LIMIT
1451:
1.1.1.2 ! misho 1452: The output is a long integer that gives the default limit for the num-
! 1453: ber of internal matching function calls in a pcre_exec() execution.
1.1 misho 1454: Further details are given with pcre_exec() below.
1455:
1456: PCRE_CONFIG_MATCH_LIMIT_RECURSION
1457:
1458: The output is a long integer that gives the default limit for the depth
1.1.1.2 ! misho 1459: of recursion when calling the internal matching function in a
! 1460: pcre_exec() execution. Further details are given with pcre_exec()
1.1 misho 1461: below.
1462:
1463: PCRE_CONFIG_STACKRECURSE
1464:
1.1.1.2 ! misho 1465: The output is an integer that is set to one if internal recursion when
1.1 misho 1466: running pcre_exec() is implemented by recursive function calls that use
1.1.1.2 ! misho 1467: the stack to remember their state. This is the usual way that PCRE is
1.1 misho 1468: compiled. The output is zero if PCRE was compiled to use blocks of data
1.1.1.2 ! misho 1469: on the heap instead of recursive function calls. In this case,
! 1470: pcre_stack_malloc and pcre_stack_free are called to manage memory
1.1 misho 1471: blocks on the heap, thus avoiding the use of the stack.
1472:
1473:
1474: COMPILING A PATTERN
1475:
1476: pcre *pcre_compile(const char *pattern, int options,
1477: const char **errptr, int *erroffset,
1478: const unsigned char *tableptr);
1479:
1480: pcre *pcre_compile2(const char *pattern, int options,
1481: int *errorcodeptr,
1482: const char **errptr, int *erroffset,
1483: const unsigned char *tableptr);
1484:
1485: Either of the functions pcre_compile() or pcre_compile2() can be called
1486: to compile a pattern into an internal form. The only difference between
1.1.1.2 ! misho 1487: the two interfaces is that pcre_compile2() has an additional argument,
! 1488: errorcodeptr, via which a numerical error code can be returned. To
! 1489: avoid too much repetition, we refer just to pcre_compile() below, but
1.1 misho 1490: the information applies equally to pcre_compile2().
1491:
1492: The pattern is a C string terminated by a binary zero, and is passed in
1.1.1.2 ! misho 1493: the pattern argument. A pointer to a single block of memory that is
! 1494: obtained via pcre_malloc is returned. This contains the compiled code
1.1 misho 1495: and related data. The pcre type is defined for the returned block; this
1496: is a typedef for a structure whose contents are not externally defined.
1497: It is up to the caller to free the memory (via pcre_free) when it is no
1498: longer required.
1499:
1.1.1.2 ! misho 1500: Although the compiled code of a PCRE regex is relocatable, that is, it
1.1 misho 1501: does not depend on memory location, the complete pcre data block is not
1.1.1.2 ! misho 1502: fully relocatable, because it may contain a copy of the tableptr argu-
1.1 misho 1503: ment, which is an address (see below).
1504:
1505: The options argument contains various bit settings that affect the com-
1.1.1.2 ! misho 1506: pilation. It should be zero if no options are required. The available
! 1507: options are described below. Some of them (in particular, those that
! 1508: are compatible with Perl, but some others as well) can also be set and
! 1509: unset from within the pattern (see the detailed description in the
! 1510: pcrepattern documentation). For those options that can be different in
! 1511: different parts of the pattern, the contents of the options argument
1.1 misho 1512: specifies their settings at the start of compilation and execution. The
1.1.1.2 ! misho 1513: PCRE_ANCHORED, PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK, and
1.1 misho 1514: PCRE_NO_START_OPT options can be set at the time of matching as well as
1515: at compile time.
1516:
1517: If errptr is NULL, pcre_compile() returns NULL immediately. Otherwise,
1.1.1.2 ! misho 1518: if compilation of a pattern fails, pcre_compile() returns NULL, and
1.1 misho 1519: sets the variable pointed to by errptr to point to a textual error mes-
1520: sage. This is a static string that is part of the library. You must not
1.1.1.2 ! misho 1521: try to free it. Normally, the offset from the start of the pattern to
! 1522: the byte that was being processed when the error was discovered is
! 1523: placed in the variable pointed to by erroffset, which must not be NULL
! 1524: (if it is, an immediate error is given). However, for an invalid UTF-8
! 1525: string, the offset is that of the first byte of the failing character.
1.1 misho 1526:
1.1.1.2 ! misho 1527: Some errors are not detected until the whole pattern has been scanned;
! 1528: in these cases, the offset passed back is the length of the pattern.
1.1 misho 1529: Note that the offset is in bytes, not characters, even in UTF-8 mode.
1530: It may sometimes point into the middle of a UTF-8 character.
1531:
1532: If pcre_compile2() is used instead of pcre_compile(), and the error-
1533: codeptr argument is not NULL, a non-zero error code number is returned
1534: via this argument in the event of an error. This is in addition to the
1535: textual error message. Error codes and messages are listed below.
1536:
1537: If the final argument, tableptr, is NULL, PCRE uses a default set of
1538: character tables that are built when PCRE is compiled, using the
1539: default C locale. Otherwise, tableptr must be an address that is the
1540: result of a call to pcre_maketables(). This value is stored with the
1541: compiled pattern, and used again by pcre_exec(), unless another table
1542: pointer is passed to it. For more discussion, see the section on locale
1543: support below.
1544:
1545: This code fragment shows a typical straightforward call to pcre_com-
1546: pile():
1547:
1548: pcre *re;
1549: const char *error;
1550: int erroffset;
1551: re = pcre_compile(
1552: "^A.*Z", /* the pattern */
1553: 0, /* default options */
1554: &error, /* for error message */
1555: &erroffset, /* for error offset */
1556: NULL); /* use default character tables */
1557:
1558: The following names for option bits are defined in the pcre.h header
1559: file:
1560:
1561: PCRE_ANCHORED
1562:
1563: If this bit is set, the pattern is forced to be "anchored", that is, it
1564: is constrained to match only at the first matching point in the string
1565: that is being searched (the "subject string"). This effect can also be
1566: achieved by appropriate constructs in the pattern itself, which is the
1567: only way to do it in Perl.
1568:
1569: PCRE_AUTO_CALLOUT
1570:
1571: If this bit is set, pcre_compile() automatically inserts callout items,
1572: all with number 255, before each pattern item. For discussion of the
1573: callout facility, see the pcrecallout documentation.
1574:
1575: PCRE_BSR_ANYCRLF
1576: PCRE_BSR_UNICODE
1577:
1578: These options (which are mutually exclusive) control what the \R escape
1579: sequence matches. The choice is either to match only CR, LF, or CRLF,
1580: or to match any Unicode newline sequence. The default is specified when
1581: PCRE is built. It can be overridden from within the pattern, or by set-
1582: ting an option when a compiled pattern is matched.
1583:
1584: PCRE_CASELESS
1585:
1586: If this bit is set, letters in the pattern match both upper and lower
1587: case letters. It is equivalent to Perl's /i option, and it can be
1588: changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE
1589: always understands the concept of case for characters whose values are
1590: less than 128, so caseless matching is always possible. For characters
1591: with higher values, the concept of case is supported if PCRE is com-
1592: piled with Unicode property support, but not otherwise. If you want to
1593: use caseless matching for characters 128 and above, you must ensure
1594: that PCRE is compiled with Unicode property support as well as with
1595: UTF-8 support.
1596:
1597: PCRE_DOLLAR_ENDONLY
1598:
1599: If this bit is set, a dollar metacharacter in the pattern matches only
1600: at the end of the subject string. Without this option, a dollar also
1601: matches immediately before a newline at the end of the string (but not
1602: before any other newlines). The PCRE_DOLLAR_ENDONLY option is ignored
1603: if PCRE_MULTILINE is set. There is no equivalent to this option in
1604: Perl, and no way to set it within a pattern.
1605:
1606: PCRE_DOTALL
1607:
1608: If this bit is set, a dot metacharacter in the pattern matches a char-
1609: acter of any value, including one that indicates a newline. However, it
1610: only ever matches one character, even if newlines are coded as CRLF.
1611: Without this option, a dot does not match when the current position is
1612: at a newline. This option is equivalent to Perl's /s option, and it can
1613: be changed within a pattern by a (?s) option setting. A negative class
1614: such as [^a] always matches newline characters, independent of the set-
1615: ting of this option.
1616:
1617: PCRE_DUPNAMES
1618:
1619: If this bit is set, names used to identify capturing subpatterns need
1620: not be unique. This can be helpful for certain types of pattern when it
1621: is known that only one instance of the named subpattern can ever be
1622: matched. There are more details of named subpatterns below; see also
1623: the pcrepattern documentation.
1624:
1625: PCRE_EXTENDED
1626:
1627: If this bit is set, whitespace data characters in the pattern are
1628: totally ignored except when escaped or inside a character class. White-
1629: space does not include the VT character (code 11). In addition, charac-
1630: ters between an unescaped # outside a character class and the next new-
1631: line, inclusive, are also ignored. This is equivalent to Perl's /x
1632: option, and it can be changed within a pattern by a (?x) option set-
1633: ting.
1634:
1635: Which characters are interpreted as newlines is controlled by the
1636: options passed to pcre_compile() or by a special sequence at the start
1637: of the pattern, as described in the section entitled "Newline conven-
1638: tions" in the pcrepattern documentation. Note that the end of this type
1639: of comment is a literal newline sequence in the pattern; escape
1640: sequences that happen to represent a newline do not count.
1641:
1642: This option makes it possible to include comments inside complicated
1643: patterns. Note, however, that this applies only to data characters.
1644: Whitespace characters may never appear within special character
1645: sequences in a pattern, for example within the sequence (?( that intro-
1646: duces a conditional subpattern.
1647:
1648: PCRE_EXTRA
1649:
1650: This option was invented in order to turn on additional functionality
1651: of PCRE that is incompatible with Perl, but it is currently of very
1652: little use. When set, any backslash in a pattern that is followed by a
1653: letter that has no special meaning causes an error, thus reserving
1654: these combinations for future expansion. By default, as in Perl, a
1655: backslash followed by a letter with no special meaning is treated as a
1656: literal. (Perl can, however, be persuaded to give an error for this, by
1657: running it with the -w option.) There are at present no other features
1658: controlled by this option. It can also be set by a (?X) option setting
1659: within a pattern.
1660:
1661: PCRE_FIRSTLINE
1662:
1663: If this option is set, an unanchored pattern is required to match
1664: before or at the first newline in the subject string, though the
1665: matched text may continue over the newline.
1666:
1667: PCRE_JAVASCRIPT_COMPAT
1668:
1669: If this option is set, PCRE's behaviour is changed in some ways so that
1670: it is compatible with JavaScript rather than Perl. The changes are as
1671: follows:
1672:
1673: (1) A lone closing square bracket in a pattern causes a compile-time
1674: error, because this is illegal in JavaScript (by default it is treated
1675: as a data character). Thus, the pattern AB]CD becomes illegal when this
1676: option is set.
1677:
1678: (2) At run time, a back reference to an unset subpattern group matches
1679: an empty string (by default this causes the current matching alterna-
1680: tive to fail). A pattern such as (\1)(a) succeeds when this option is
1681: set (assuming it can find an "a" in the subject), whereas it fails by
1682: default, for Perl compatibility.
1683:
1684: (3) \U matches an upper case "U" character; by default \U causes a com-
1685: pile time error (Perl uses \U to upper case subsequent characters).
1686:
1687: (4) \u matches a lower case "u" character unless it is followed by four
1688: hexadecimal digits, in which case the hexadecimal number defines the
1689: code point to match. By default, \u causes a compile time error (Perl
1690: uses it to upper case the following character).
1691:
1692: (5) \x matches a lower case "x" character unless it is followed by two
1693: hexadecimal digits, in which case the hexadecimal number defines the
1694: code point to match. By default, as in Perl, a hexadecimal number is
1695: always expected after \x, but it may have zero, one, or two digits (so,
1696: for example, \xz matches a binary zero character followed by z).
1697:
1698: PCRE_MULTILINE
1699:
1700: By default, PCRE treats the subject string as consisting of a single
1701: line of characters (even if it actually contains newlines). The "start
1702: of line" metacharacter (^) matches only at the start of the string,
1703: while the "end of line" metacharacter ($) matches only at the end of
1704: the string, or before a terminating newline (unless PCRE_DOLLAR_ENDONLY
1705: is set). This is the same as Perl.
1706:
1707: When PCRE_MULTILINE it is set, the "start of line" and "end of line"
1708: constructs match immediately following or immediately before internal
1709: newlines in the subject string, respectively, as well as at the very
1710: start and end. This is equivalent to Perl's /m option, and it can be
1711: changed within a pattern by a (?m) option setting. If there are no new-
1712: lines in a subject string, or no occurrences of ^ or $ in a pattern,
1713: setting PCRE_MULTILINE has no effect.
1714:
1715: PCRE_NEWLINE_CR
1716: PCRE_NEWLINE_LF
1717: PCRE_NEWLINE_CRLF
1718: PCRE_NEWLINE_ANYCRLF
1719: PCRE_NEWLINE_ANY
1720:
1721: These options override the default newline definition that was chosen
1722: when PCRE was built. Setting the first or the second specifies that a
1723: newline is indicated by a single character (CR or LF, respectively).
1724: Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by the
1725: two-character CRLF sequence. Setting PCRE_NEWLINE_ANYCRLF specifies
1726: that any of the three preceding sequences should be recognized. Setting
1727: PCRE_NEWLINE_ANY specifies that any Unicode newline sequence should be
1728: recognized. The Unicode newline sequences are the three just mentioned,
1729: plus the single characters VT (vertical tab, U+000B), FF (formfeed,
1730: U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS
1.1.1.2 ! misho 1731: (paragraph separator, U+2029). For the 8-bit library, the last two are
! 1732: recognized only in UTF-8 mode.
1.1 misho 1733:
1734: The newline setting in the options word uses three bits that are
1735: treated as a number, giving eight possibilities. Currently only six are
1736: used (default plus the five values above). This means that if you set
1737: more than one newline option, the combination may or may not be sensi-
1738: ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
1739: PCRE_NEWLINE_CRLF, but other combinations may yield unused numbers and
1740: cause an error.
1741:
1742: The only time that a line break in a pattern is specially recognized
1743: when compiling is when PCRE_EXTENDED is set. CR and LF are whitespace
1744: characters, and so are ignored in this mode. Also, an unescaped # out-
1745: side a character class indicates a comment that lasts until after the
1746: next line break sequence. In other circumstances, line break sequences
1747: in patterns are treated as literal data.
1748:
1749: The newline option that is set at compile time becomes the default that
1750: is used for pcre_exec() and pcre_dfa_exec(), but it can be overridden.
1751:
1752: PCRE_NO_AUTO_CAPTURE
1753:
1754: If this option is set, it disables the use of numbered capturing paren-
1755: theses in the pattern. Any opening parenthesis that is not followed by
1756: ? behaves as if it were followed by ?: but named parentheses can still
1757: be used for capturing (and they acquire numbers in the usual way).
1758: There is no equivalent of this option in Perl.
1759:
1760: NO_START_OPTIMIZE
1761:
1762: This is an option that acts at matching time; that is, it is really an
1763: option for pcre_exec() or pcre_dfa_exec(). If it is set at compile
1764: time, it is remembered with the compiled pattern and assumed at match-
1765: ing time. For details see the discussion of PCRE_NO_START_OPTIMIZE
1766: below.
1767:
1768: PCRE_UCP
1769:
1770: This option changes the way PCRE processes \B, \b, \D, \d, \S, \s, \W,
1771: \w, and some of the POSIX character classes. By default, only ASCII
1772: characters are recognized, but if PCRE_UCP is set, Unicode properties
1773: are used instead to classify characters. More details are given in the
1774: section on generic character types in the pcrepattern page. If you set
1775: PCRE_UCP, matching one of the items it affects takes much longer. The
1776: option is available only if PCRE has been compiled with Unicode prop-
1777: erty support.
1778:
1779: PCRE_UNGREEDY
1780:
1781: This option inverts the "greediness" of the quantifiers so that they
1782: are not greedy by default, but become greedy if followed by "?". It is
1783: not compatible with Perl. It can also be set by a (?U) option setting
1784: within the pattern.
1785:
1786: PCRE_UTF8
1787:
1788: This option causes PCRE to regard both the pattern and the subject as
1.1.1.2 ! misho 1789: strings of UTF-8 characters instead of single-byte strings. However, it
! 1790: is available only when PCRE is built to include UTF support. If not,
! 1791: the use of this option provokes an error. Details of how this option
! 1792: changes the behaviour of PCRE are given in the pcreunicode page.
1.1 misho 1793:
1794: PCRE_NO_UTF8_CHECK
1795:
1796: When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
1.1.1.2 ! misho 1797: automatically checked. There is a discussion about the validity of
! 1798: UTF-8 strings in the pcreunicode page. If an invalid UTF-8 sequence is
! 1799: found, pcre_compile() returns an error. If you already know that your
! 1800: pattern is valid, and you want to skip this check for performance rea-
! 1801: sons, you can set the PCRE_NO_UTF8_CHECK option. When it is set, the
! 1802: effect of passing an invalid UTF-8 string as a pattern is undefined. It
! 1803: may cause your program to crash. Note that this option can also be
! 1804: passed to pcre_exec() and pcre_dfa_exec(), to suppress the validity
! 1805: checking of subject strings.
1.1 misho 1806:
1807:
1808: COMPILATION ERROR CODES
1809:
1.1.1.2 ! misho 1810: The following table lists the error codes than may be returned by
! 1811: pcre_compile2(), along with the error messages that may be returned by
! 1812: both compiling functions. Note that error messages are always 8-bit
! 1813: ASCII strings, even in 16-bit mode. As PCRE has developed, some error
! 1814: codes have fallen out of use. To avoid confusion, they have not been
! 1815: re-used.
1.1 misho 1816:
1817: 0 no error
1818: 1 \ at end of pattern
1819: 2 \c at end of pattern
1820: 3 unrecognized character follows \
1821: 4 numbers out of order in {} quantifier
1822: 5 number too big in {} quantifier
1823: 6 missing terminating ] for character class
1824: 7 invalid escape sequence in character class
1825: 8 range out of order in character class
1826: 9 nothing to repeat
1827: 10 [this code is not in use]
1828: 11 internal error: unexpected repeat
1829: 12 unrecognized character after (? or (?-
1830: 13 POSIX named classes are supported only within a class
1831: 14 missing )
1832: 15 reference to non-existent subpattern
1833: 16 erroffset passed as NULL
1834: 17 unknown option bit(s) set
1835: 18 missing ) after comment
1836: 19 [this code is not in use]
1837: 20 regular expression is too large
1838: 21 failed to get memory
1839: 22 unmatched parentheses
1840: 23 internal error: code overflow
1841: 24 unrecognized character after (?<
1842: 25 lookbehind assertion is not fixed length
1843: 26 malformed number or name after (?(
1844: 27 conditional group contains more than two branches
1845: 28 assertion expected after (?(
1846: 29 (?R or (?[+-]digits must be followed by )
1847: 30 unknown POSIX class name
1848: 31 POSIX collating elements are not supported
1.1.1.2 ! misho 1849: 32 this version of PCRE is compiled without UTF support
1.1 misho 1850: 33 [this code is not in use]
1851: 34 character value in \x{...} sequence is too large
1852: 35 invalid condition (?(0)
1853: 36 \C not allowed in lookbehind assertion
1854: 37 PCRE does not support \L, \l, \N{name}, \U, or \u
1855: 38 number after (?C is > 255
1856: 39 closing ) for (?C expected
1857: 40 recursive call could loop indefinitely
1858: 41 unrecognized character after (?P
1859: 42 syntax error in subpattern name (missing terminator)
1860: 43 two named subpatterns have the same name
1.1.1.2 ! misho 1861: 44 invalid UTF-8 string (specifically UTF-8)
1.1 misho 1862: 45 support for \P, \p, and \X has not been compiled
1863: 46 malformed \P or \p sequence
1864: 47 unknown property name after \P or \p
1865: 48 subpattern name is too long (maximum 32 characters)
1866: 49 too many named subpatterns (maximum 10000)
1867: 50 [this code is not in use]
1.1.1.2 ! misho 1868: 51 octal value is greater than \377 in 8-bit non-UTF-8 mode
1.1 misho 1869: 52 internal error: overran compiling workspace
1870: 53 internal error: previously-checked referenced subpattern
1871: not found
1872: 54 DEFINE group contains more than one branch
1873: 55 repeating a DEFINE group is not allowed
1874: 56 inconsistent NEWLINE options
1875: 57 \g is not followed by a braced, angle-bracketed, or quoted
1876: name/number or by a plain number
1877: 58 a numbered reference must not be zero
1878: 59 an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)
1879: 60 (*VERB) not recognized
1880: 61 number is too big
1881: 62 subpattern name expected
1882: 63 digit expected after (?+
1883: 64 ] is an invalid data character in JavaScript compatibility mode
1884: 65 different names for subpatterns of the same number are
1885: not allowed
1886: 66 (*MARK) must have an argument
1.1.1.2 ! misho 1887: 67 this version of PCRE is not compiled with Unicode property
! 1888: support
1.1 misho 1889: 68 \c must be followed by an ASCII character
1890: 69 \k is not followed by a braced, angle-bracketed, or quoted name
1.1.1.2 ! misho 1891: 70 internal error: unknown opcode in find_fixedlength()
! 1892: 71 \N is not supported in a class
! 1893: 72 too many forward references
! 1894: 73 disallowed Unicode code point (>= 0xd800 && <= 0xdfff)
! 1895: 74 invalid UTF-16 string (specifically UTF-16)
1.1 misho 1896:
1.1.1.2 ! misho 1897: The numbers 32 and 10000 in errors 48 and 49 are defaults; different
1.1 misho 1898: values may be used if the limits were changed when PCRE was built.
1899:
1900:
1901: STUDYING A PATTERN
1902:
1903: pcre_extra *pcre_study(const pcre *code, int options
1904: const char **errptr);
1905:
1.1.1.2 ! misho 1906: If a compiled pattern is going to be used several times, it is worth
1.1 misho 1907: spending more time analyzing it in order to speed up the time taken for
1.1.1.2 ! misho 1908: matching. The function pcre_study() takes a pointer to a compiled pat-
1.1 misho 1909: tern as its first argument. If studying the pattern produces additional
1.1.1.2 ! misho 1910: information that will help speed up matching, pcre_study() returns a
! 1911: pointer to a pcre_extra block, in which the study_data field points to
1.1 misho 1912: the results of the study.
1913:
1914: The returned value from pcre_study() can be passed directly to
1.1.1.2 ! misho 1915: pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block also con-
! 1916: tains other fields that can be set by the caller before the block is
1.1 misho 1917: passed; these are described below in the section on matching a pattern.
1918:
1.1.1.2 ! misho 1919: If studying the pattern does not produce any useful information,
1.1 misho 1920: pcre_study() returns NULL. In that circumstance, if the calling program
1.1.1.2 ! misho 1921: wants to pass any of the other fields to pcre_exec() or
1.1 misho 1922: pcre_dfa_exec(), it must set up its own pcre_extra block.
1923:
1924: The second argument of pcre_study() contains option bits. There is only
1.1.1.2 ! misho 1925: one option: PCRE_STUDY_JIT_COMPILE. If this is set, and the just-in-
! 1926: time compiler is available, the pattern is further compiled into
! 1927: machine code that executes much faster than the pcre_exec() matching
1.1 misho 1928: function. If the just-in-time compiler is not available, this option is
1929: ignored. All other bits in the options argument must be zero.
1930:
1.1.1.2 ! misho 1931: JIT compilation is a heavyweight optimization. It can take some time
! 1932: for patterns to be analyzed, and for one-off matches and simple pat-
! 1933: terns the benefit of faster execution might be offset by a much slower
1.1 misho 1934: study time. Not all patterns can be optimized by the JIT compiler. For
1.1.1.2 ! misho 1935: those that cannot be handled, matching automatically falls back to the
! 1936: pcre_exec() interpreter. For more details, see the pcrejit documenta-
1.1 misho 1937: tion.
1938:
1.1.1.2 ! misho 1939: The third argument for pcre_study() is a pointer for an error message.
! 1940: If studying succeeds (even if no data is returned), the variable it
! 1941: points to is set to NULL. Otherwise it is set to point to a textual
1.1 misho 1942: error message. This is a static string that is part of the library. You
1.1.1.2 ! misho 1943: must not try to free it. You should test the error pointer for NULL
1.1 misho 1944: after calling pcre_study(), to be sure that it has run successfully.
1945:
1.1.1.2 ! misho 1946: When you are finished with a pattern, you can free the memory used for
1.1 misho 1947: the study data by calling pcre_free_study(). This function was added to
1.1.1.2 ! misho 1948: the API for release 8.20. For earlier versions, the memory could be
! 1949: freed with pcre_free(), just like the pattern itself. This will still
! 1950: work in cases where PCRE_STUDY_JIT_COMPILE is not used, but it is
1.1 misho 1951: advisable to change to the new function when convenient.
1952:
1.1.1.2 ! misho 1953: This is a typical way in which pcre_study() is used (except that in a
1.1 misho 1954: real application there should be tests for errors):
1955:
1956: int rc;
1957: pcre *re;
1958: pcre_extra *sd;
1959: re = pcre_compile("pattern", 0, &error, &erroroffset, NULL);
1960: sd = pcre_study(
1961: re, /* result of pcre_compile() */
1962: 0, /* no options */
1963: &error); /* set to NULL or points to a message */
1964: rc = pcre_exec( /* see below for details of pcre_exec() options */
1965: re, sd, "subject", 7, 0, 0, ovector, 30);
1966: ...
1967: pcre_free_study(sd);
1968: pcre_free(re);
1969:
1970: Studying a pattern does two things: first, a lower bound for the length
1971: of subject string that is needed to match the pattern is computed. This
1972: does not mean that there are any strings of that length that match, but
1.1.1.2 ! misho 1973: it does guarantee that no shorter strings match. The value is used by
! 1974: pcre_exec() and pcre_dfa_exec() to avoid wasting time by trying to
! 1975: match strings that are shorter than the lower bound. You can find out
1.1 misho 1976: the value in a calling program via the pcre_fullinfo() function.
1977:
1978: Studying a pattern is also useful for non-anchored patterns that do not
1.1.1.2 ! misho 1979: have a single fixed starting character. A bitmap of possible starting
! 1980: bytes is created. This speeds up finding a position in the subject at
! 1981: which to start matching. (In 16-bit mode, the bitmap is used for 16-bit
! 1982: values less than 256.)
1.1 misho 1983:
1984: These two optimizations apply to both pcre_exec() and pcre_dfa_exec().
1985: However, they are not used by pcre_exec() if pcre_study() is called
1986: with the PCRE_STUDY_JIT_COMPILE option, and just-in-time compiling is
1987: successful. The optimizations can be disabled by setting the
1988: PCRE_NO_START_OPTIMIZE option when calling pcre_exec() or
1989: pcre_dfa_exec(). You might want to do this if your pattern contains
1990: callouts or (*MARK) (which cannot be handled by the JIT compiler), and
1991: you want to make use of these facilities in cases where matching fails.
1992: See the discussion of PCRE_NO_START_OPTIMIZE below.
1993:
1994:
1995: LOCALE SUPPORT
1996:
1997: PCRE handles caseless matching, and determines whether characters are
1998: letters, digits, or whatever, by reference to a set of tables, indexed
1999: by character value. When running in UTF-8 mode, this applies only to
2000: characters with codes less than 128. By default, higher-valued codes
2001: never match escapes such as \w or \d, but they can be tested with \p if
2002: PCRE is built with Unicode character property support. Alternatively,
2003: the PCRE_UCP option can be set at compile time; this causes \w and
2004: friends to use Unicode property support instead of built-in tables. The
2005: use of locales with Unicode is discouraged. If you are handling charac-
2006: ters with codes greater than 128, you should either use UTF-8 and Uni-
2007: code, or use locales, but not try to mix the two.
2008:
2009: PCRE contains an internal set of tables that are used when the final
2010: argument of pcre_compile() is NULL. These are sufficient for many
2011: applications. Normally, the internal tables recognize only ASCII char-
2012: acters. However, when PCRE is built, it is possible to cause the inter-
2013: nal tables to be rebuilt in the default "C" locale of the local system,
2014: which may cause them to be different.
2015:
2016: The internal tables can always be overridden by tables supplied by the
2017: application that calls PCRE. These may be created in a different locale
2018: from the default. As more and more applications change to using Uni-
2019: code, the need for this locale support is expected to die away.
2020:
2021: External tables are built by calling the pcre_maketables() function,
2022: which has no arguments, in the relevant locale. The result can then be
2023: passed to pcre_compile() or pcre_exec() as often as necessary. For
2024: example, to build and use tables that are appropriate for the French
2025: locale (where accented characters with values greater than 128 are
2026: treated as letters), the following code could be used:
2027:
2028: setlocale(LC_CTYPE, "fr_FR");
2029: tables = pcre_maketables();
2030: re = pcre_compile(..., tables);
2031:
2032: The locale name "fr_FR" is used on Linux and other Unix-like systems;
2033: if you are using Windows, the name for the French locale is "french".
2034:
2035: When pcre_maketables() runs, the tables are built in memory that is
2036: obtained via pcre_malloc. It is the caller's responsibility to ensure
2037: that the memory containing the tables remains available for as long as
2038: it is needed.
2039:
2040: The pointer that is passed to pcre_compile() is saved with the compiled
2041: pattern, and the same tables are used via this pointer by pcre_study()
2042: and normally also by pcre_exec(). Thus, by default, for any single pat-
2043: tern, compilation, studying and matching all happen in the same locale,
2044: but different patterns can be compiled in different locales.
2045:
2046: It is possible to pass a table pointer or NULL (indicating the use of
2047: the internal tables) to pcre_exec(). Although not intended for this
2048: purpose, this facility could be used to match a pattern in a different
2049: locale from the one in which it was compiled. Passing table pointers at
2050: run time is discussed below in the section on matching a pattern.
2051:
2052:
2053: INFORMATION ABOUT A PATTERN
2054:
2055: int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
2056: int what, void *where);
2057:
2058: The pcre_fullinfo() function returns information about a compiled pat-
1.1.1.2 ! misho 2059: tern. It replaces the pcre_info() function, which was removed from the
! 2060: library at version 8.30, after more than 10 years of obsolescence.
1.1 misho 2061:
2062: The first argument for pcre_fullinfo() is a pointer to the compiled
2063: pattern. The second argument is the result of pcre_study(), or NULL if
2064: the pattern was not studied. The third argument specifies which piece
2065: of information is required, and the fourth argument is a pointer to a
2066: variable to receive the data. The yield of the function is zero for
2067: success, or one of the following negative numbers:
2068:
1.1.1.2 ! misho 2069: PCRE_ERROR_NULL the argument code was NULL
! 2070: the argument where was NULL
! 2071: PCRE_ERROR_BADMAGIC the "magic number" was not found
! 2072: PCRE_ERROR_BADENDIANNESS the pattern was compiled with different
! 2073: endianness
! 2074: PCRE_ERROR_BADOPTION the value of what was invalid
1.1 misho 2075:
2076: The "magic number" is placed at the start of each compiled pattern as
1.1.1.2 ! misho 2077: an simple check against passing an arbitrary memory pointer. The endi-
! 2078: anness error can occur if a compiled pattern is saved and reloaded on a
! 2079: different host. Here is a typical call of pcre_fullinfo(), to obtain
! 2080: the length of the compiled pattern:
1.1 misho 2081:
2082: int rc;
2083: size_t length;
2084: rc = pcre_fullinfo(
2085: re, /* result of pcre_compile() */
2086: sd, /* result of pcre_study(), or NULL */
2087: PCRE_INFO_SIZE, /* what is required */
2088: &length); /* where to put the data */
2089:
1.1.1.2 ! misho 2090: The possible values for the third argument are defined in pcre.h, and
1.1 misho 2091: are as follows:
2092:
2093: PCRE_INFO_BACKREFMAX
2094:
1.1.1.2 ! misho 2095: Return the number of the highest back reference in the pattern. The
! 2096: fourth argument should point to an int variable. Zero is returned if
1.1 misho 2097: there are no back references.
2098:
2099: PCRE_INFO_CAPTURECOUNT
2100:
1.1.1.2 ! misho 2101: Return the number of capturing subpatterns in the pattern. The fourth
1.1 misho 2102: argument should point to an int variable.
2103:
2104: PCRE_INFO_DEFAULT_TABLES
2105:
1.1.1.2 ! misho 2106: Return a pointer to the internal default character tables within PCRE.
! 2107: The fourth argument should point to an unsigned char * variable. This
1.1 misho 2108: information call is provided for internal use by the pcre_study() func-
1.1.1.2 ! misho 2109: tion. External callers can cause PCRE to use its internal tables by
1.1 misho 2110: passing a NULL table pointer.
2111:
2112: PCRE_INFO_FIRSTBYTE
2113:
1.1.1.2 ! misho 2114: Return information about the first data unit of any matched string, for
! 2115: a non-anchored pattern. (The name of this option refers to the 8-bit
! 2116: library, where data units are bytes.) The fourth argument should point
! 2117: to an int variable.
! 2118:
! 2119: If there is a fixed first value, for example, the letter "c" from a
! 2120: pattern such as (cat|cow|coyote), its value is returned. In the 8-bit
! 2121: library, the value is always less than 256; in the 16-bit library the
! 2122: value can be up to 0xffff.
1.1 misho 2123:
1.1.1.2 ! misho 2124: If there is no fixed first value, and if either
1.1 misho 2125:
1.1.1.2 ! misho 2126: (a) the pattern was compiled with the PCRE_MULTILINE option, and every
1.1 misho 2127: branch starts with "^", or
2128:
2129: (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
2130: set (if it were set, the pattern would be anchored),
2131:
1.1.1.2 ! misho 2132: -1 is returned, indicating that the pattern matches only at the start
! 2133: of a subject string or after any newline within the string. Otherwise
1.1 misho 2134: -2 is returned. For anchored patterns, -2 is returned.
2135:
2136: PCRE_INFO_FIRSTTABLE
2137:
1.1.1.2 ! misho 2138: If the pattern was studied, and this resulted in the construction of a
! 2139: 256-bit table indicating a fixed set of values for the first data unit
! 2140: in any matching string, a pointer to the table is returned. Otherwise
! 2141: NULL is returned. The fourth argument should point to an unsigned char
! 2142: * variable.
1.1 misho 2143:
2144: PCRE_INFO_HASCRORLF
2145:
1.1.1.2 ! misho 2146: Return 1 if the pattern contains any explicit matches for CR or LF
! 2147: characters, otherwise 0. The fourth argument should point to an int
! 2148: variable. An explicit match is either a literal CR or LF character, or
1.1 misho 2149: \r or \n.
2150:
2151: PCRE_INFO_JCHANGED
2152:
1.1.1.2 ! misho 2153: Return 1 if the (?J) or (?-J) option setting is used in the pattern,
! 2154: otherwise 0. The fourth argument should point to an int variable. (?J)
1.1 misho 2155: and (?-J) set and unset the local PCRE_DUPNAMES option, respectively.
2156:
2157: PCRE_INFO_JIT
2158:
1.1.1.2 ! misho 2159: Return 1 if the pattern was studied with the PCRE_STUDY_JIT_COMPILE
! 2160: option, and just-in-time compiling was successful. The fourth argument
! 2161: should point to an int variable. A return value of 0 means that JIT
! 2162: support is not available in this version of PCRE, or that the pattern
1.1 misho 2163: was not studied with the PCRE_STUDY_JIT_COMPILE option, or that the JIT
2164: compiler could not handle this particular pattern. See the pcrejit doc-
2165: umentation for details of what can and cannot be handled.
2166:
2167: PCRE_INFO_JITSIZE
2168:
2169: If the pattern was successfully studied with the PCRE_STUDY_JIT_COMPILE
1.1.1.2 ! misho 2170: option, return the size of the JIT compiled code, otherwise return
1.1 misho 2171: zero. The fourth argument should point to a size_t variable.
2172:
2173: PCRE_INFO_LASTLITERAL
2174:
1.1.1.2 ! misho 2175: Return the value of the rightmost literal data unit that must exist in
! 2176: any matched string, other than at its start, if such a value has been
1.1 misho 2177: recorded. The fourth argument should point to an int variable. If there
1.1.1.2 ! misho 2178: is no such value, -1 is returned. For anchored patterns, a last literal
! 2179: value is recorded only if it follows something of variable length. For
1.1 misho 2180: example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
2181: /^a\dz\d/ the returned value is -1.
2182:
2183: PCRE_INFO_MINLENGTH
2184:
1.1.1.2 ! misho 2185: If the pattern was studied and a minimum length for matching subject
! 2186: strings was computed, its value is returned. Otherwise the returned
! 2187: value is -1. The value is a number of characters, which in UTF-8 mode
! 2188: may be different from the number of bytes. The fourth argument should
! 2189: point to an int variable. A non-negative value is a lower bound to the
! 2190: length of any matching string. There may not be any strings of that
! 2191: length that do actually match, but every string that does match is at
! 2192: least that long.
1.1 misho 2193:
2194: PCRE_INFO_NAMECOUNT
2195: PCRE_INFO_NAMEENTRYSIZE
2196: PCRE_INFO_NAMETABLE
2197:
2198: PCRE supports the use of named as well as numbered capturing parenthe-
2199: ses. The names are just an additional way of identifying the parenthe-
2200: ses, which still acquire numbers. Several convenience functions such as
2201: pcre_get_named_substring() are provided for extracting captured sub-
2202: strings by name. It is also possible to extract the data directly, by
2203: first converting the name to a number in order to access the correct
2204: pointers in the output vector (described with pcre_exec() below). To do
2205: the conversion, you need to use the name-to-number map, which is
2206: described by these three values.
2207:
2208: The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
2209: gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
2210: of each entry; both of these return an int value. The entry size
2211: depends on the length of the longest name. PCRE_INFO_NAMETABLE returns
1.1.1.2 ! misho 2212: a pointer to the first entry of the table. This is a pointer to char in
! 2213: the 8-bit library, where the first two bytes of each entry are the num-
! 2214: ber of the capturing parenthesis, most significant byte first. In the
! 2215: 16-bit library, the pointer points to 16-bit data units, the first of
! 2216: which contains the parenthesis number. The rest of the entry is the
! 2217: corresponding name, zero terminated.
1.1 misho 2218:
2219: The names are in alphabetical order. Duplicate names may appear if (?|
2220: is used to create multiple groups with the same number, as described in
2221: the section on duplicate subpattern numbers in the pcrepattern page.
2222: Duplicate names for subpatterns with different numbers are permitted
2223: only if PCRE_DUPNAMES is set. In all cases of duplicate names, they
2224: appear in the table in the order in which they were found in the pat-
2225: tern. In the absence of (?| this is the order of increasing number;
2226: when (?| is used this is not necessarily the case because later subpat-
2227: terns may have lower numbers.
2228:
2229: As a simple example of the name/number table, consider the following
1.1.1.2 ! misho 2230: pattern after compilation by the 8-bit library (assume PCRE_EXTENDED is
! 2231: set, so white space - including newlines - is ignored):
1.1 misho 2232:
2233: (?<date> (?<year>(\d\d)?\d\d) -
2234: (?<month>\d\d) - (?<day>\d\d) )
2235:
2236: There are four named subpatterns, so the table has four entries, and
2237: each entry in the table is eight bytes long. The table is as follows,
2238: with non-printing bytes shows in hexadecimal, and undefined bytes shown
2239: as ??:
2240:
2241: 00 01 d a t e 00 ??
2242: 00 05 d a y 00 ?? ??
2243: 00 04 m o n t h 00
2244: 00 02 y e a r 00 ??
2245:
2246: When writing code to extract data from named subpatterns using the
2247: name-to-number map, remember that the length of the entries is likely
2248: to be different for each compiled pattern.
2249:
2250: PCRE_INFO_OKPARTIAL
2251:
2252: Return 1 if the pattern can be used for partial matching with
2253: pcre_exec(), otherwise 0. The fourth argument should point to an int
2254: variable. From release 8.00, this always returns 1, because the
2255: restrictions that previously applied to partial matching have been
2256: lifted. The pcrepartial documentation gives details of partial match-
2257: ing.
2258:
2259: PCRE_INFO_OPTIONS
2260:
2261: Return a copy of the options with which the pattern was compiled. The
2262: fourth argument should point to an unsigned long int variable. These
2263: option bits are those specified in the call to pcre_compile(), modified
2264: by any top-level option settings at the start of the pattern itself. In
2265: other words, they are the options that will be in force when matching
2266: starts. For example, if the pattern /(?im)abc(?-i)d/ is compiled with
2267: the PCRE_EXTENDED option, the result is PCRE_CASELESS, PCRE_MULTILINE,
2268: and PCRE_EXTENDED.
2269:
2270: A pattern is automatically anchored by PCRE if all of its top-level
2271: alternatives begin with one of the following:
2272:
2273: ^ unless PCRE_MULTILINE is set
2274: \A always
2275: \G always
2276: .* if PCRE_DOTALL is set and there are no back
2277: references to the subpattern in which .* appears
2278:
2279: For such patterns, the PCRE_ANCHORED bit is set in the options returned
2280: by pcre_fullinfo().
2281:
2282: PCRE_INFO_SIZE
2283:
1.1.1.2 ! misho 2284: Return the size of the compiled pattern in bytes (for both libraries).
! 2285: The fourth argument should point to a size_t variable. This value does
! 2286: not include the size of the pcre structure that is returned by
! 2287: pcre_compile(). The value that is passed as the argument to pcre_mal-
! 2288: loc() when pcre_compile() is getting memory in which to place the com-
! 2289: piled data is the value returned by this option plus the size of the
! 2290: pcre structure. Studying a compiled pattern, with or without JIT, does
! 2291: not alter the value returned by this option.
1.1 misho 2292:
2293: PCRE_INFO_STUDYSIZE
2294:
1.1.1.2 ! misho 2295: Return the size in bytes of the data block pointed to by the study_data
! 2296: field in a pcre_extra block. If pcre_extra is NULL, or there is no
! 2297: study data, zero is returned. The fourth argument should point to a
! 2298: size_t variable. The study_data field is set by pcre_study() to record
! 2299: information that will speed up matching (see the section entitled
! 2300: "Studying a pattern" above). The format of the study_data block is pri-
! 2301: vate, but its length is made available via this option so that it can
! 2302: be saved and restored (see the pcreprecompile documentation for
! 2303: details).
1.1 misho 2304:
2305:
2306: REFERENCE COUNTS
2307:
2308: int pcre_refcount(pcre *code, int adjust);
2309:
1.1.1.2 ! misho 2310: The pcre_refcount() function is used to maintain a reference count in
1.1 misho 2311: the data block that contains a compiled pattern. It is provided for the
1.1.1.2 ! misho 2312: benefit of applications that operate in an object-oriented manner,
1.1 misho 2313: where different parts of the application may be using the same compiled
2314: pattern, but you want to free the block when they are all done.
2315:
2316: When a pattern is compiled, the reference count field is initialized to
1.1.1.2 ! misho 2317: zero. It is changed only by calling this function, whose action is to
! 2318: add the adjust value (which may be positive or negative) to it. The
1.1 misho 2319: yield of the function is the new value. However, the value of the count
1.1.1.2 ! misho 2320: is constrained to lie between 0 and 65535, inclusive. If the new value
1.1 misho 2321: is outside these limits, it is forced to the appropriate limit value.
2322:
1.1.1.2 ! misho 2323: Except when it is zero, the reference count is not correctly preserved
! 2324: if a pattern is compiled on one host and then transferred to a host
1.1 misho 2325: whose byte-order is different. (This seems a highly unlikely scenario.)
2326:
2327:
2328: MATCHING A PATTERN: THE TRADITIONAL FUNCTION
2329:
2330: int pcre_exec(const pcre *code, const pcre_extra *extra,
2331: const char *subject, int length, int startoffset,
2332: int options, int *ovector, int ovecsize);
2333:
1.1.1.2 ! misho 2334: The function pcre_exec() is called to match a subject string against a
! 2335: compiled pattern, which is passed in the code argument. If the pattern
! 2336: was studied, the result of the study should be passed in the extra
! 2337: argument. You can call pcre_exec() with the same code and extra argu-
! 2338: ments as many times as you like, in order to match different subject
1.1 misho 2339: strings with the same pattern.
2340:
1.1.1.2 ! misho 2341: This function is the main matching facility of the library, and it
! 2342: operates in a Perl-like manner. For specialist use there is also an
! 2343: alternative matching function, which is described below in the section
1.1 misho 2344: about the pcre_dfa_exec() function.
2345:
1.1.1.2 ! misho 2346: In most applications, the pattern will have been compiled (and option-
! 2347: ally studied) in the same process that calls pcre_exec(). However, it
1.1 misho 2348: is possible to save compiled patterns and study data, and then use them
1.1.1.2 ! misho 2349: later in different processes, possibly even on different hosts. For a
1.1 misho 2350: discussion about this, see the pcreprecompile documentation.
2351:
2352: Here is an example of a simple call to pcre_exec():
2353:
2354: int rc;
2355: int ovector[30];
2356: rc = pcre_exec(
2357: re, /* result of pcre_compile() */
2358: NULL, /* we didn't study the pattern */
2359: "some string", /* the subject string */
2360: 11, /* the length of the subject string */
2361: 0, /* start at offset 0 in the subject */
2362: 0, /* default options */
2363: ovector, /* vector of integers for substring information */
2364: 30); /* number of elements (NOT size in bytes) */
2365:
2366: Extra data for pcre_exec()
2367:
1.1.1.2 ! misho 2368: If the extra argument is not NULL, it must point to a pcre_extra data
! 2369: block. The pcre_study() function returns such a block (when it doesn't
! 2370: return NULL), but you can also create one for yourself, and pass addi-
! 2371: tional information in it. The pcre_extra block contains the following
1.1 misho 2372: fields (not necessarily in this order):
2373:
2374: unsigned long int flags;
2375: void *study_data;
2376: void *executable_jit;
2377: unsigned long int match_limit;
2378: unsigned long int match_limit_recursion;
2379: void *callout_data;
2380: const unsigned char *tables;
2381: unsigned char **mark;
2382:
1.1.1.2 ! misho 2383: In the 16-bit version of this structure, the mark field has type
! 2384: "PCRE_UCHAR16 **".
! 2385:
1.1 misho 2386: The flags field is a bitmap that specifies which of the other fields
2387: are set. The flag bits are:
2388:
2389: PCRE_EXTRA_STUDY_DATA
2390: PCRE_EXTRA_EXECUTABLE_JIT
2391: PCRE_EXTRA_MATCH_LIMIT
2392: PCRE_EXTRA_MATCH_LIMIT_RECURSION
2393: PCRE_EXTRA_CALLOUT_DATA
2394: PCRE_EXTRA_TABLES
2395: PCRE_EXTRA_MARK
2396:
2397: Other flag bits should be set to zero. The study_data field and some-
2398: times the executable_jit field are set in the pcre_extra block that is
2399: returned by pcre_study(), together with the appropriate flag bits. You
2400: should not set these yourself, but you may add to the block by setting
2401: the other fields and their corresponding flag bits.
2402:
2403: The match_limit field provides a means of preventing PCRE from using up
2404: a vast amount of resources when running patterns that are not going to
2405: match, but which have a very large number of possibilities in their
2406: search trees. The classic example is a pattern that uses nested unlim-
2407: ited repeats.
2408:
2409: Internally, pcre_exec() uses a function called match(), which it calls
2410: repeatedly (sometimes recursively). The limit set by match_limit is
2411: imposed on the number of times this function is called during a match,
2412: which has the effect of limiting the amount of backtracking that can
2413: take place. For patterns that are not anchored, the count restarts from
2414: zero for each position in the subject string.
2415:
2416: When pcre_exec() is called with a pattern that was successfully studied
2417: with the PCRE_STUDY_JIT_COMPILE option, the way that the matching is
2418: executed is entirely different. However, there is still the possibility
2419: of runaway matching that goes on for a very long time, and so the
2420: match_limit value is also used in this case (but in a different way) to
2421: limit how long the matching can continue.
2422:
2423: The default value for the limit can be set when PCRE is built; the
2424: default default is 10 million, which handles all but the most extreme
2425: cases. You can override the default by suppling pcre_exec() with a
2426: pcre_extra block in which match_limit is set, and
2427: PCRE_EXTRA_MATCH_LIMIT is set in the flags field. If the limit is
2428: exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT.
2429:
2430: The match_limit_recursion field is similar to match_limit, but instead
2431: of limiting the total number of times that match() is called, it limits
2432: the depth of recursion. The recursion depth is a smaller number than
2433: the total number of calls, because not all calls to match() are recur-
2434: sive. This limit is of use only if it is set smaller than match_limit.
2435:
2436: Limiting the recursion depth limits the amount of machine stack that
2437: can be used, or, when PCRE has been compiled to use memory on the heap
2438: instead of the stack, the amount of heap memory that can be used. This
2439: limit is not relevant, and is ignored, if the pattern was successfully
2440: studied with PCRE_STUDY_JIT_COMPILE.
2441:
2442: The default value for match_limit_recursion can be set when PCRE is
2443: built; the default default is the same value as the default for
2444: match_limit. You can override the default by suppling pcre_exec() with
2445: a pcre_extra block in which match_limit_recursion is set, and
2446: PCRE_EXTRA_MATCH_LIMIT_RECURSION is set in the flags field. If the
2447: limit is exceeded, pcre_exec() returns PCRE_ERROR_RECURSIONLIMIT.
2448:
2449: The callout_data field is used in conjunction with the "callout" fea-
2450: ture, and is described in the pcrecallout documentation.
2451:
2452: The tables field is used to pass a character tables pointer to
2453: pcre_exec(); this overrides the value that is stored with the compiled
2454: pattern. A non-NULL value is stored with the compiled pattern only if
2455: custom tables were supplied to pcre_compile() via its tableptr argu-
2456: ment. If NULL is passed to pcre_exec() using this mechanism, it forces
2457: PCRE's internal tables to be used. This facility is helpful when re-
2458: using patterns that have been saved after compiling with an external
2459: set of tables, because the external tables might be at a different
2460: address when pcre_exec() is called. See the pcreprecompile documenta-
2461: tion for a discussion of saving compiled patterns for later use.
2462:
2463: If PCRE_EXTRA_MARK is set in the flags field, the mark field must be
1.1.1.2 ! misho 2464: set to point to a suitable variable. If the pattern contains any back-
1.1 misho 2465: tracking control verbs such as (*MARK:NAME), and the execution ends up
2466: with a name to pass back, a pointer to the name string (zero termi-
2467: nated) is placed in the variable pointed to by the mark field. The
2468: names are within the compiled pattern; if you wish to retain such a
2469: name you must copy it before freeing the memory of a compiled pattern.
2470: If there is no name to pass back, the variable pointed to by the mark
1.1.1.2 ! misho 2471: field is set to NULL. For details of the backtracking control verbs,
! 2472: see the section entitled "Backtracking control" in the pcrepattern doc-
! 2473: umentation.
1.1 misho 2474:
2475: Option bits for pcre_exec()
2476:
2477: The unused bits of the options argument for pcre_exec() must be zero.
2478: The only bits that may be set are PCRE_ANCHORED, PCRE_NEWLINE_xxx,
2479: PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART,
2480: PCRE_NO_START_OPTIMIZE, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_SOFT, and
2481: PCRE_PARTIAL_HARD.
2482:
2483: If the pattern was successfully studied with the PCRE_STUDY_JIT_COMPILE
2484: option, the only supported options for JIT execution are
2485: PCRE_NO_UTF8_CHECK, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and
2486: PCRE_NOTEMPTY_ATSTART. Note in particular that partial matching is not
2487: supported. If an unsupported option is used, JIT execution is disabled
2488: and the normal interpretive code in pcre_exec() is run.
2489:
2490: PCRE_ANCHORED
2491:
2492: The PCRE_ANCHORED option limits pcre_exec() to matching at the first
2493: matching position. If a pattern was compiled with PCRE_ANCHORED, or
2494: turned out to be anchored by virtue of its contents, it cannot be made
2495: unachored at matching time.
2496:
2497: PCRE_BSR_ANYCRLF
2498: PCRE_BSR_UNICODE
2499:
2500: These options (which are mutually exclusive) control what the \R escape
2501: sequence matches. The choice is either to match only CR, LF, or CRLF,
2502: or to match any Unicode newline sequence. These options override the
2503: choice that was made or defaulted when the pattern was compiled.
2504:
2505: PCRE_NEWLINE_CR
2506: PCRE_NEWLINE_LF
2507: PCRE_NEWLINE_CRLF
2508: PCRE_NEWLINE_ANYCRLF
2509: PCRE_NEWLINE_ANY
2510:
2511: These options override the newline definition that was chosen or
2512: defaulted when the pattern was compiled. For details, see the descrip-
2513: tion of pcre_compile() above. During matching, the newline choice
2514: affects the behaviour of the dot, circumflex, and dollar metacharac-
2515: ters. It may also alter the way the match position is advanced after a
2516: match failure for an unanchored pattern.
2517:
2518: When PCRE_NEWLINE_CRLF, PCRE_NEWLINE_ANYCRLF, or PCRE_NEWLINE_ANY is
2519: set, and a match attempt for an unanchored pattern fails when the cur-
2520: rent position is at a CRLF sequence, and the pattern contains no
2521: explicit matches for CR or LF characters, the match position is
2522: advanced by two characters instead of one, in other words, to after the
2523: CRLF.
2524:
2525: The above rule is a compromise that makes the most common cases work as
2526: expected. For example, if the pattern is .+A (and the PCRE_DOTALL
2527: option is not set), it does not match the string "\r\nA" because, after
2528: failing at the start, it skips both the CR and the LF before retrying.
2529: However, the pattern [\r\n]A does match that string, because it con-
2530: tains an explicit CR or LF reference, and so advances only by one char-
2531: acter after the first failure.
2532:
2533: An explicit match for CR of LF is either a literal appearance of one of
2534: those characters, or one of the \r or \n escape sequences. Implicit
2535: matches such as [^X] do not count, nor does \s (which includes CR and
2536: LF in the characters that it matches).
2537:
2538: Notwithstanding the above, anomalous effects may still occur when CRLF
2539: is a valid newline sequence and explicit \r or \n escapes appear in the
2540: pattern.
2541:
2542: PCRE_NOTBOL
2543:
2544: This option specifies that first character of the subject string is not
2545: the beginning of a line, so the circumflex metacharacter should not
2546: match before it. Setting this without PCRE_MULTILINE (at compile time)
2547: causes circumflex never to match. This option affects only the behav-
2548: iour of the circumflex metacharacter. It does not affect \A.
2549:
2550: PCRE_NOTEOL
2551:
2552: This option specifies that the end of the subject string is not the end
2553: of a line, so the dollar metacharacter should not match it nor (except
2554: in multiline mode) a newline immediately before it. Setting this with-
2555: out PCRE_MULTILINE (at compile time) causes dollar never to match. This
2556: option affects only the behaviour of the dollar metacharacter. It does
2557: not affect \Z or \z.
2558:
2559: PCRE_NOTEMPTY
2560:
2561: An empty string is not considered to be a valid match if this option is
2562: set. If there are alternatives in the pattern, they are tried. If all
2563: the alternatives match the empty string, the entire match fails. For
2564: example, if the pattern
2565:
2566: a?b?
2567:
2568: is applied to a string not beginning with "a" or "b", it matches an
2569: empty string at the start of the subject. With PCRE_NOTEMPTY set, this
2570: match is not valid, so PCRE searches further into the string for occur-
2571: rences of "a" or "b".
2572:
2573: PCRE_NOTEMPTY_ATSTART
2574:
2575: This is like PCRE_NOTEMPTY, except that an empty string match that is
2576: not at the start of the subject is permitted. If the pattern is
2577: anchored, such a match can occur only if the pattern contains \K.
2578:
2579: Perl has no direct equivalent of PCRE_NOTEMPTY or
2580: PCRE_NOTEMPTY_ATSTART, but it does make a special case of a pattern
2581: match of the empty string within its split() function, and when using
2582: the /g modifier. It is possible to emulate Perl's behaviour after
2583: matching a null string by first trying the match again at the same off-
2584: set with PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED, and then if that
2585: fails, by advancing the starting offset (see below) and trying an ordi-
2586: nary match again. There is some code that demonstrates how to do this
2587: in the pcredemo sample program. In the most general case, you have to
2588: check to see if the newline convention recognizes CRLF as a newline,
2589: and if so, and the current character is CR followed by LF, advance the
2590: starting offset by two characters instead of one.
2591:
2592: PCRE_NO_START_OPTIMIZE
2593:
2594: There are a number of optimizations that pcre_exec() uses at the start
2595: of a match, in order to speed up the process. For example, if it is
2596: known that an unanchored match must start with a specific character, it
2597: searches the subject for that character, and fails immediately if it
2598: cannot find it, without actually running the main matching function.
2599: This means that a special item such as (*COMMIT) at the start of a pat-
2600: tern is not considered until after a suitable starting point for the
2601: match has been found. When callouts or (*MARK) items are in use, these
2602: "start-up" optimizations can cause them to be skipped if the pattern is
2603: never actually used. The start-up optimizations are in effect a pre-
2604: scan of the subject that takes place before the pattern is run.
2605:
2606: The PCRE_NO_START_OPTIMIZE option disables the start-up optimizations,
2607: possibly causing performance to suffer, but ensuring that in cases
2608: where the result is "no match", the callouts do occur, and that items
2609: such as (*COMMIT) and (*MARK) are considered at every possible starting
2610: position in the subject string. If PCRE_NO_START_OPTIMIZE is set at
2611: compile time, it cannot be unset at matching time.
2612:
2613: Setting PCRE_NO_START_OPTIMIZE can change the outcome of a matching
2614: operation. Consider the pattern
2615:
2616: (*COMMIT)ABC
2617:
2618: When this is compiled, PCRE records the fact that a match must start
2619: with the character "A". Suppose the subject string is "DEFABC". The
2620: start-up optimization scans along the subject, finds "A" and runs the
2621: first match attempt from there. The (*COMMIT) item means that the pat-
2622: tern must match the current starting position, which in this case, it
2623: does. However, if the same match is run with PCRE_NO_START_OPTIMIZE
2624: set, the initial scan along the subject string does not happen. The
2625: first match attempt is run starting from "D" and when this fails,
2626: (*COMMIT) prevents any further matches being tried, so the overall
2627: result is "no match". If the pattern is studied, more start-up opti-
2628: mizations may be used. For example, a minimum length for the subject
2629: may be recorded. Consider the pattern
2630:
2631: (*MARK:A)(X|Y)
2632:
2633: The minimum length for a match is one character. If the subject is
2634: "ABC", there will be attempts to match "ABC", "BC", "C", and then
2635: finally an empty string. If the pattern is studied, the final attempt
2636: does not take place, because PCRE knows that the subject is too short,
2637: and so the (*MARK) is never encountered. In this case, studying the
2638: pattern does not affect the overall match result, which is still "no
2639: match", but it does affect the auxiliary information that is returned.
2640:
2641: PCRE_NO_UTF8_CHECK
2642:
2643: When PCRE_UTF8 is set at compile time, the validity of the subject as a
2644: UTF-8 string is automatically checked when pcre_exec() is subsequently
2645: called. The value of startoffset is also checked to ensure that it
2646: points to the start of a UTF-8 character. There is a discussion about
1.1.1.2 ! misho 2647: the validity of UTF-8 strings in the pcreunicode page. If an invalid
! 2648: sequence of bytes is found, pcre_exec() returns the error
! 2649: PCRE_ERROR_BADUTF8 or, if PCRE_PARTIAL_HARD is set and the problem is a
! 2650: truncated character at the end of the subject, PCRE_ERROR_SHORTUTF8. In
! 2651: both cases, information about the precise nature of the error may also
! 2652: be returned (see the descriptions of these errors in the section enti-
! 2653: tled Error return values from pcre_exec() below). If startoffset con-
! 2654: tains a value that does not point to the start of a UTF-8 character (or
! 2655: to the end of the subject), PCRE_ERROR_BADUTF8_OFFSET is returned.
! 2656:
! 2657: If you already know that your subject is valid, and you want to skip
! 2658: these checks for performance reasons, you can set the
! 2659: PCRE_NO_UTF8_CHECK option when calling pcre_exec(). You might want to
! 2660: do this for the second and subsequent calls to pcre_exec() if you are
! 2661: making repeated calls to find all the matches in a single subject
! 2662: string. However, you should be sure that the value of startoffset
! 2663: points to the start of a character (or the end of the subject). When
! 2664: PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid string as a
! 2665: subject or an invalid value of startoffset is undefined. Your program
! 2666: may crash.
1.1 misho 2667:
2668: PCRE_PARTIAL_HARD
2669: PCRE_PARTIAL_SOFT
2670:
1.1.1.2 ! misho 2671: These options turn on the partial matching feature. For backwards com-
! 2672: patibility, PCRE_PARTIAL is a synonym for PCRE_PARTIAL_SOFT. A partial
! 2673: match occurs if the end of the subject string is reached successfully,
! 2674: but there are not enough subject characters to complete the match. If
1.1 misho 2675: this happens when PCRE_PARTIAL_SOFT (but not PCRE_PARTIAL_HARD) is set,
1.1.1.2 ! misho 2676: matching continues by testing any remaining alternatives. Only if no
! 2677: complete match can be found is PCRE_ERROR_PARTIAL returned instead of
! 2678: PCRE_ERROR_NOMATCH. In other words, PCRE_PARTIAL_SOFT says that the
! 2679: caller is prepared to handle a partial match, but only if no complete
1.1 misho 2680: match can be found.
2681:
1.1.1.2 ! misho 2682: If PCRE_PARTIAL_HARD is set, it overrides PCRE_PARTIAL_SOFT. In this
! 2683: case, if a partial match is found, pcre_exec() immediately returns
! 2684: PCRE_ERROR_PARTIAL, without considering any other alternatives. In
! 2685: other words, when PCRE_PARTIAL_HARD is set, a partial match is consid-
1.1 misho 2686: ered to be more important that an alternative complete match.
2687:
1.1.1.2 ! misho 2688: In both cases, the portion of the string that was inspected when the
1.1 misho 2689: partial match was found is set as the first matching string. There is a
1.1.1.2 ! misho 2690: more detailed discussion of partial and multi-segment matching, with
1.1 misho 2691: examples, in the pcrepartial documentation.
2692:
2693: The string to be matched by pcre_exec()
2694:
1.1.1.2 ! misho 2695: The subject string is passed to pcre_exec() as a pointer in subject, a
! 2696: length in bytes in length, and a starting byte offset in startoffset.
! 2697: If this is negative or greater than the length of the subject,
! 2698: pcre_exec() returns PCRE_ERROR_BADOFFSET. When the starting offset is
! 2699: zero, the search for a match starts at the beginning of the subject,
1.1 misho 2700: and this is by far the most common case. In UTF-8 mode, the byte offset
1.1.1.2 ! misho 2701: must point to the start of a UTF-8 character (or the end of the sub-
! 2702: ject). Unlike the pattern string, the subject may contain binary zero
1.1 misho 2703: bytes.
2704:
1.1.1.2 ! misho 2705: A non-zero starting offset is useful when searching for another match
! 2706: in the same subject by calling pcre_exec() again after a previous suc-
! 2707: cess. Setting startoffset differs from just passing over a shortened
! 2708: string and setting PCRE_NOTBOL in the case of a pattern that begins
1.1 misho 2709: with any kind of lookbehind. For example, consider the pattern
2710:
2711: \Biss\B
2712:
1.1.1.2 ! misho 2713: which finds occurrences of "iss" in the middle of words. (\B matches
! 2714: only if the current position in the subject is not a word boundary.)
! 2715: When applied to the string "Mississipi" the first call to pcre_exec()
! 2716: finds the first occurrence. If pcre_exec() is called again with just
! 2717: the remainder of the subject, namely "issipi", it does not match,
1.1 misho 2718: because \B is always false at the start of the subject, which is deemed
1.1.1.2 ! misho 2719: to be a word boundary. However, if pcre_exec() is passed the entire
1.1 misho 2720: string again, but with startoffset set to 4, it finds the second occur-
1.1.1.2 ! misho 2721: rence of "iss" because it is able to look behind the starting point to
1.1 misho 2722: discover that it is preceded by a letter.
2723:
1.1.1.2 ! misho 2724: Finding all the matches in a subject is tricky when the pattern can
1.1 misho 2725: match an empty string. It is possible to emulate Perl's /g behaviour by
1.1.1.2 ! misho 2726: first trying the match again at the same offset, with the
! 2727: PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED options, and then if that
! 2728: fails, advancing the starting offset and trying an ordinary match
1.1 misho 2729: again. There is some code that demonstrates how to do this in the pcre-
2730: demo sample program. In the most general case, you have to check to see
1.1.1.2 ! misho 2731: if the newline convention recognizes CRLF as a newline, and if so, and
1.1 misho 2732: the current character is CR followed by LF, advance the starting offset
2733: by two characters instead of one.
2734:
1.1.1.2 ! misho 2735: If a non-zero starting offset is passed when the pattern is anchored,
1.1 misho 2736: one attempt to match at the given offset is made. This can only succeed
1.1.1.2 ! misho 2737: if the pattern does not require the match to be at the start of the
1.1 misho 2738: subject.
2739:
2740: How pcre_exec() returns captured substrings
2741:
1.1.1.2 ! misho 2742: In general, a pattern matches a certain portion of the subject, and in
! 2743: addition, further substrings from the subject may be picked out by
! 2744: parts of the pattern. Following the usage in Jeffrey Friedl's book,
! 2745: this is called "capturing" in what follows, and the phrase "capturing
! 2746: subpattern" is used for a fragment of a pattern that picks out a sub-
! 2747: string. PCRE supports several other kinds of parenthesized subpattern
1.1 misho 2748: that do not cause substrings to be captured.
2749:
2750: Captured substrings are returned to the caller via a vector of integers
1.1.1.2 ! misho 2751: whose address is passed in ovector. The number of elements in the vec-
! 2752: tor is passed in ovecsize, which must be a non-negative number. Note:
1.1 misho 2753: this argument is NOT the size of ovector in bytes.
2754:
1.1.1.2 ! misho 2755: The first two-thirds of the vector is used to pass back captured sub-
! 2756: strings, each substring using a pair of integers. The remaining third
! 2757: of the vector is used as workspace by pcre_exec() while matching cap-
! 2758: turing subpatterns, and is not available for passing back information.
! 2759: The number passed in ovecsize should always be a multiple of three. If
1.1 misho 2760: it is not, it is rounded down.
2761:
1.1.1.2 ! misho 2762: When a match is successful, information about captured substrings is
! 2763: returned in pairs of integers, starting at the beginning of ovector,
! 2764: and continuing up to two-thirds of its length at the most. The first
! 2765: element of each pair is set to the byte offset of the first character
! 2766: in a substring, and the second is set to the byte offset of the first
! 2767: character after the end of a substring. Note: these values are always
1.1 misho 2768: byte offsets, even in UTF-8 mode. They are not character counts.
2769:
1.1.1.2 ! misho 2770: The first pair of integers, ovector[0] and ovector[1], identify the
! 2771: portion of the subject string matched by the entire pattern. The next
! 2772: pair is used for the first capturing subpattern, and so on. The value
1.1 misho 2773: returned by pcre_exec() is one more than the highest numbered pair that
1.1.1.2 ! misho 2774: has been set. For example, if two substrings have been captured, the
! 2775: returned value is 3. If there are no capturing subpatterns, the return
1.1 misho 2776: value from a successful match is 1, indicating that just the first pair
2777: of offsets has been set.
2778:
2779: If a capturing subpattern is matched repeatedly, it is the last portion
2780: of the string that it matched that is returned.
2781:
1.1.1.2 ! misho 2782: If the vector is too small to hold all the captured substring offsets,
1.1 misho 2783: it is used as far as possible (up to two-thirds of its length), and the
1.1.1.2 ! misho 2784: function returns a value of zero. If neither the actual string matched
! 2785: not any captured substrings are of interest, pcre_exec() may be called
! 2786: with ovector passed as NULL and ovecsize as zero. However, if the pat-
! 2787: tern contains back references and the ovector is not big enough to
! 2788: remember the related substrings, PCRE has to get additional memory for
! 2789: use during matching. Thus it is usually advisable to supply an ovector
1.1 misho 2790: of reasonable size.
2791:
1.1.1.2 ! misho 2792: There are some cases where zero is returned (indicating vector over-
! 2793: flow) when in fact the vector is exactly the right size for the final
1.1 misho 2794: match. For example, consider the pattern
2795:
2796: (a)(?:(b)c|bd)
2797:
1.1.1.2 ! misho 2798: If a vector of 6 elements (allowing for only 1 captured substring) is
1.1 misho 2799: given with subject string "abd", pcre_exec() will try to set the second
2800: captured string, thereby recording a vector overflow, before failing to
1.1.1.2 ! misho 2801: match "c" and backing up to try the second alternative. The zero
! 2802: return, however, does correctly indicate that the maximum number of
1.1 misho 2803: slots (namely 2) have been filled. In similar cases where there is tem-
1.1.1.2 ! misho 2804: porary overflow, but the final number of used slots is actually less
1.1 misho 2805: than the maximum, a non-zero value is returned.
2806:
2807: The pcre_fullinfo() function can be used to find out how many capturing
1.1.1.2 ! misho 2808: subpatterns there are in a compiled pattern. The smallest size for
! 2809: ovector that will allow for n captured substrings, in addition to the
1.1 misho 2810: offsets of the substring matched by the whole pattern, is (n+1)*3.
2811:
1.1.1.2 ! misho 2812: It is possible for capturing subpattern number n+1 to match some part
1.1 misho 2813: of the subject when subpattern n has not been used at all. For example,
1.1.1.2 ! misho 2814: if the string "abc" is matched against the pattern (a|(z))(bc) the
1.1 misho 2815: return from the function is 4, and subpatterns 1 and 3 are matched, but
1.1.1.2 ! misho 2816: 2 is not. When this happens, both values in the offset pairs corre-
1.1 misho 2817: sponding to unused subpatterns are set to -1.
2818:
1.1.1.2 ! misho 2819: Offset values that correspond to unused subpatterns at the end of the
! 2820: expression are also set to -1. For example, if the string "abc" is
! 2821: matched against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are not
! 2822: matched. The return from the function is 2, because the highest used
! 2823: capturing subpattern number is 1, and the offsets for for the second
! 2824: and third capturing subpatterns (assuming the vector is large enough,
1.1 misho 2825: of course) are set to -1.
2826:
1.1.1.2 ! misho 2827: Note: Elements in the first two-thirds of ovector that do not corre-
! 2828: spond to capturing parentheses in the pattern are never changed. That
! 2829: is, if a pattern contains n capturing parentheses, no more than ovec-
! 2830: tor[0] to ovector[2n+1] are set by pcre_exec(). The other elements (in
1.1 misho 2831: the first two-thirds) retain whatever values they previously had.
2832:
1.1.1.2 ! misho 2833: Some convenience functions are provided for extracting the captured
1.1 misho 2834: substrings as separate strings. These are described below.
2835:
2836: Error return values from pcre_exec()
2837:
1.1.1.2 ! misho 2838: If pcre_exec() fails, it returns a negative number. The following are
1.1 misho 2839: defined in the header file:
2840:
2841: PCRE_ERROR_NOMATCH (-1)
2842:
2843: The subject string did not match the pattern.
2844:
2845: PCRE_ERROR_NULL (-2)
2846:
1.1.1.2 ! misho 2847: Either code or subject was passed as NULL, or ovector was NULL and
1.1 misho 2848: ovecsize was not zero.
2849:
2850: PCRE_ERROR_BADOPTION (-3)
2851:
2852: An unrecognized bit was set in the options argument.
2853:
2854: PCRE_ERROR_BADMAGIC (-4)
2855:
1.1.1.2 ! misho 2856: PCRE stores a 4-byte "magic number" at the start of the compiled code,
1.1 misho 2857: to catch the case when it is passed a junk pointer and to detect when a
2858: pattern that was compiled in an environment of one endianness is run in
1.1.1.2 ! misho 2859: an environment with the other endianness. This is the error that PCRE
1.1 misho 2860: gives when the magic number is not present.
2861:
2862: PCRE_ERROR_UNKNOWN_OPCODE (-5)
2863:
2864: While running the pattern match, an unknown item was encountered in the
1.1.1.2 ! misho 2865: compiled pattern. This error could be caused by a bug in PCRE or by
1.1 misho 2866: overwriting of the compiled pattern.
2867:
2868: PCRE_ERROR_NOMEMORY (-6)
2869:
1.1.1.2 ! misho 2870: If a pattern contains back references, but the ovector that is passed
1.1 misho 2871: to pcre_exec() is not big enough to remember the referenced substrings,
1.1.1.2 ! misho 2872: PCRE gets a block of memory at the start of matching to use for this
! 2873: purpose. If the call via pcre_malloc() fails, this error is given. The
1.1 misho 2874: memory is automatically freed at the end of matching.
2875:
1.1.1.2 ! misho 2876: This error is also given if pcre_stack_malloc() fails in pcre_exec().
! 2877: This can happen only when PCRE has been compiled with --disable-stack-
1.1 misho 2878: for-recursion.
2879:
2880: PCRE_ERROR_NOSUBSTRING (-7)
2881:
1.1.1.2 ! misho 2882: This error is used by the pcre_copy_substring(), pcre_get_substring(),
1.1 misho 2883: and pcre_get_substring_list() functions (see below). It is never
2884: returned by pcre_exec().
2885:
2886: PCRE_ERROR_MATCHLIMIT (-8)
2887:
1.1.1.2 ! misho 2888: The backtracking limit, as specified by the match_limit field in a
! 2889: pcre_extra structure (or defaulted) was reached. See the description
1.1 misho 2890: above.
2891:
2892: PCRE_ERROR_CALLOUT (-9)
2893:
2894: This error is never generated by pcre_exec() itself. It is provided for
1.1.1.2 ! misho 2895: use by callout functions that want to yield a distinctive error code.
1.1 misho 2896: See the pcrecallout documentation for details.
2897:
2898: PCRE_ERROR_BADUTF8 (-10)
2899:
1.1.1.2 ! misho 2900: A string that contains an invalid UTF-8 byte sequence was passed as a
! 2901: subject, and the PCRE_NO_UTF8_CHECK option was not set. If the size of
! 2902: the output vector (ovecsize) is at least 2, the byte offset to the
! 2903: start of the the invalid UTF-8 character is placed in the first ele-
! 2904: ment, and a reason code is placed in the second element. The reason
1.1 misho 2905: codes are listed in the following section. For backward compatibility,
1.1.1.2 ! misho 2906: if PCRE_PARTIAL_HARD is set and the problem is a truncated UTF-8 char-
! 2907: acter at the end of the subject (reason codes 1 to 5),
1.1 misho 2908: PCRE_ERROR_SHORTUTF8 is returned instead of PCRE_ERROR_BADUTF8.
2909:
2910: PCRE_ERROR_BADUTF8_OFFSET (-11)
2911:
1.1.1.2 ! misho 2912: The UTF-8 byte sequence that was passed as a subject was checked and
! 2913: found to be valid (the PCRE_NO_UTF8_CHECK option was not set), but the
! 2914: value of startoffset did not point to the beginning of a UTF-8 charac-
1.1 misho 2915: ter or the end of the subject.
2916:
2917: PCRE_ERROR_PARTIAL (-12)
2918:
1.1.1.2 ! misho 2919: The subject string did not match, but it did match partially. See the
1.1 misho 2920: pcrepartial documentation for details of partial matching.
2921:
2922: PCRE_ERROR_BADPARTIAL (-13)
2923:
1.1.1.2 ! misho 2924: This code is no longer in use. It was formerly returned when the
! 2925: PCRE_PARTIAL option was used with a compiled pattern containing items
! 2926: that were not supported for partial matching. From release 8.00
1.1 misho 2927: onwards, there are no restrictions on partial matching.
2928:
2929: PCRE_ERROR_INTERNAL (-14)
2930:
1.1.1.2 ! misho 2931: An unexpected internal error has occurred. This error could be caused
1.1 misho 2932: by a bug in PCRE or by overwriting of the compiled pattern.
2933:
2934: PCRE_ERROR_BADCOUNT (-15)
2935:
2936: This error is given if the value of the ovecsize argument is negative.
2937:
2938: PCRE_ERROR_RECURSIONLIMIT (-21)
2939:
2940: The internal recursion limit, as specified by the match_limit_recursion
1.1.1.2 ! misho 2941: field in a pcre_extra structure (or defaulted) was reached. See the
1.1 misho 2942: description above.
2943:
2944: PCRE_ERROR_BADNEWLINE (-23)
2945:
2946: An invalid combination of PCRE_NEWLINE_xxx options was given.
2947:
2948: PCRE_ERROR_BADOFFSET (-24)
2949:
2950: The value of startoffset was negative or greater than the length of the
2951: subject, that is, the value in length.
2952:
2953: PCRE_ERROR_SHORTUTF8 (-25)
2954:
1.1.1.2 ! misho 2955: This error is returned instead of PCRE_ERROR_BADUTF8 when the subject
! 2956: string ends with a truncated UTF-8 character and the PCRE_PARTIAL_HARD
! 2957: option is set. Information about the failure is returned as for
! 2958: PCRE_ERROR_BADUTF8. It is in fact sufficient to detect this case, but
! 2959: this special error code for PCRE_PARTIAL_HARD precedes the implementa-
! 2960: tion of returned information; it is retained for backwards compatibil-
1.1 misho 2961: ity.
2962:
2963: PCRE_ERROR_RECURSELOOP (-26)
2964:
2965: This error is returned when pcre_exec() detects a recursion loop within
1.1.1.2 ! misho 2966: the pattern. Specifically, it means that either the whole pattern or a
! 2967: subpattern has been called recursively for the second time at the same
1.1 misho 2968: position in the subject string. Some simple patterns that might do this
1.1.1.2 ! misho 2969: are detected and faulted at compile time, but more complicated cases,
1.1 misho 2970: in particular mutual recursions between two different subpatterns, can-
2971: not be detected until run time.
2972:
2973: PCRE_ERROR_JIT_STACKLIMIT (-27)
2974:
1.1.1.2 ! misho 2975: This error is returned when a pattern that was successfully studied
! 2976: using the PCRE_STUDY_JIT_COMPILE option is being matched, but the mem-
! 2977: ory available for the just-in-time processing stack is not large
1.1 misho 2978: enough. See the pcrejit documentation for more details.
2979:
1.1.1.2 ! misho 2980: PCRE_ERROR_BADMODE (-28)
! 2981:
! 2982: This error is given if a pattern that was compiled by the 8-bit library
! 2983: is passed to a 16-bit library function, or vice versa.
! 2984:
! 2985: PCRE_ERROR_BADENDIANNESS (-29)
! 2986:
! 2987: This error is given if a pattern that was compiled and saved is
! 2988: reloaded on a host with different endianness. The utility function
! 2989: pcre_pattern_to_host_byte_order() can be used to convert such a pattern
! 2990: so that it runs on the new host.
! 2991:
1.1 misho 2992: Error numbers -16 to -20 and -22 are not used by pcre_exec().
2993:
2994: Reason codes for invalid UTF-8 strings
2995:
1.1.1.2 ! misho 2996: This section applies only to the 8-bit library. The corresponding
! 2997: information for the 16-bit library is given in the pcre16 page.
! 2998:
1.1 misho 2999: When pcre_exec() returns either PCRE_ERROR_BADUTF8 or PCRE_ERROR_SHORT-
3000: UTF8, and the size of the output vector (ovecsize) is at least 2, the
3001: offset of the start of the invalid UTF-8 character is placed in the
3002: first output vector element (ovector[0]) and a reason code is placed in
3003: the second element (ovector[1]). The reason codes are given names in
3004: the pcre.h header file:
3005:
3006: PCRE_UTF8_ERR1
3007: PCRE_UTF8_ERR2
3008: PCRE_UTF8_ERR3
3009: PCRE_UTF8_ERR4
3010: PCRE_UTF8_ERR5
3011:
3012: The string ends with a truncated UTF-8 character; the code specifies
3013: how many bytes are missing (1 to 5). Although RFC 3629 restricts UTF-8
3014: characters to be no longer than 4 bytes, the encoding scheme (origi-
3015: nally defined by RFC 2279) allows for up to 6 bytes, and this is
3016: checked first; hence the possibility of 4 or 5 missing bytes.
3017:
3018: PCRE_UTF8_ERR6
3019: PCRE_UTF8_ERR7
3020: PCRE_UTF8_ERR8
3021: PCRE_UTF8_ERR9
3022: PCRE_UTF8_ERR10
3023:
3024: The two most significant bits of the 2nd, 3rd, 4th, 5th, or 6th byte of
3025: the character do not have the binary value 0b10 (that is, either the
3026: most significant bit is 0, or the next bit is 1).
3027:
3028: PCRE_UTF8_ERR11
3029: PCRE_UTF8_ERR12
3030:
3031: A character that is valid by the RFC 2279 rules is either 5 or 6 bytes
3032: long; these code points are excluded by RFC 3629.
3033:
3034: PCRE_UTF8_ERR13
3035:
3036: A 4-byte character has a value greater than 0x10fff; these code points
3037: are excluded by RFC 3629.
3038:
3039: PCRE_UTF8_ERR14
3040:
3041: A 3-byte character has a value in the range 0xd800 to 0xdfff; this
3042: range of code points are reserved by RFC 3629 for use with UTF-16, and
3043: so are excluded from UTF-8.
3044:
3045: PCRE_UTF8_ERR15
3046: PCRE_UTF8_ERR16
3047: PCRE_UTF8_ERR17
3048: PCRE_UTF8_ERR18
3049: PCRE_UTF8_ERR19
3050:
3051: A 2-, 3-, 4-, 5-, or 6-byte character is "overlong", that is, it codes
3052: for a value that can be represented by fewer bytes, which is invalid.
3053: For example, the two bytes 0xc0, 0xae give the value 0x2e, whose cor-
3054: rect coding uses just one byte.
3055:
3056: PCRE_UTF8_ERR20
3057:
3058: The two most significant bits of the first byte of a character have the
3059: binary value 0b10 (that is, the most significant bit is 1 and the sec-
3060: ond is 0). Such a byte can only validly occur as the second or subse-
3061: quent byte of a multi-byte character.
3062:
3063: PCRE_UTF8_ERR21
3064:
3065: The first byte of a character has the value 0xfe or 0xff. These values
3066: can never occur in a valid UTF-8 string.
3067:
3068:
3069: EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
3070:
3071: int pcre_copy_substring(const char *subject, int *ovector,
3072: int stringcount, int stringnumber, char *buffer,
3073: int buffersize);
3074:
3075: int pcre_get_substring(const char *subject, int *ovector,
3076: int stringcount, int stringnumber,
3077: const char **stringptr);
3078:
3079: int pcre_get_substring_list(const char *subject,
3080: int *ovector, int stringcount, const char ***listptr);
3081:
3082: Captured substrings can be accessed directly by using the offsets
3083: returned by pcre_exec() in ovector. For convenience, the functions
3084: pcre_copy_substring(), pcre_get_substring(), and pcre_get_sub-
3085: string_list() are provided for extracting captured substrings as new,
3086: separate, zero-terminated strings. These functions identify substrings
3087: by number. The next section describes functions for extracting named
3088: substrings.
3089:
3090: A substring that contains a binary zero is correctly extracted and has
3091: a further zero added on the end, but the result is not, of course, a C
3092: string. However, you can process such a string by referring to the
3093: length that is returned by pcre_copy_substring() and pcre_get_sub-
3094: string(). Unfortunately, the interface to pcre_get_substring_list() is
3095: not adequate for handling strings containing binary zeros, because the
3096: end of the final string is not independently indicated.
3097:
3098: The first three arguments are the same for all three of these func-
3099: tions: subject is the subject string that has just been successfully
3100: matched, ovector is a pointer to the vector of integer offsets that was
3101: passed to pcre_exec(), and stringcount is the number of substrings that
3102: were captured by the match, including the substring that matched the
3103: entire regular expression. This is the value returned by pcre_exec() if
3104: it is greater than zero. If pcre_exec() returned zero, indicating that
3105: it ran out of space in ovector, the value passed as stringcount should
3106: be the number of elements in the vector divided by three.
3107:
3108: The functions pcre_copy_substring() and pcre_get_substring() extract a
3109: single substring, whose number is given as stringnumber. A value of
3110: zero extracts the substring that matched the entire pattern, whereas
3111: higher values extract the captured substrings. For pcre_copy_sub-
3112: string(), the string is placed in buffer, whose length is given by
3113: buffersize, while for pcre_get_substring() a new block of memory is
3114: obtained via pcre_malloc, and its address is returned via stringptr.
3115: The yield of the function is the length of the string, not including
3116: the terminating zero, or one of these error codes:
3117:
3118: PCRE_ERROR_NOMEMORY (-6)
3119:
3120: The buffer was too small for pcre_copy_substring(), or the attempt to
3121: get memory failed for pcre_get_substring().
3122:
3123: PCRE_ERROR_NOSUBSTRING (-7)
3124:
3125: There is no substring whose number is stringnumber.
3126:
3127: The pcre_get_substring_list() function extracts all available sub-
3128: strings and builds a list of pointers to them. All this is done in a
3129: single block of memory that is obtained via pcre_malloc. The address of
3130: the memory block is returned via listptr, which is also the start of
3131: the list of string pointers. The end of the list is marked by a NULL
3132: pointer. The yield of the function is zero if all went well, or the
3133: error code
3134:
3135: PCRE_ERROR_NOMEMORY (-6)
3136:
3137: if the attempt to get the memory block failed.
3138:
3139: When any of these functions encounter a substring that is unset, which
3140: can happen when capturing subpattern number n+1 matches some part of
3141: the subject, but subpattern n has not been used at all, they return an
3142: empty string. This can be distinguished from a genuine zero-length sub-
3143: string by inspecting the appropriate offset in ovector, which is nega-
3144: tive for unset substrings.
3145:
3146: The two convenience functions pcre_free_substring() and pcre_free_sub-
3147: string_list() can be used to free the memory returned by a previous
3148: call of pcre_get_substring() or pcre_get_substring_list(), respec-
3149: tively. They do nothing more than call the function pointed to by
3150: pcre_free, which of course could be called directly from a C program.
3151: However, PCRE is used in some situations where it is linked via a spe-
3152: cial interface to another programming language that cannot use
3153: pcre_free directly; it is for these cases that the functions are pro-
3154: vided.
3155:
3156:
3157: EXTRACTING CAPTURED SUBSTRINGS BY NAME
3158:
3159: int pcre_get_stringnumber(const pcre *code,
3160: const char *name);
3161:
3162: int pcre_copy_named_substring(const pcre *code,
3163: const char *subject, int *ovector,
3164: int stringcount, const char *stringname,
3165: char *buffer, int buffersize);
3166:
3167: int pcre_get_named_substring(const pcre *code,
3168: const char *subject, int *ovector,
3169: int stringcount, const char *stringname,
3170: const char **stringptr);
3171:
3172: To extract a substring by name, you first have to find associated num-
3173: ber. For example, for this pattern
3174:
3175: (a+)b(?<xxx>\d+)...
3176:
3177: the number of the subpattern called "xxx" is 2. If the name is known to
3178: be unique (PCRE_DUPNAMES was not set), you can find the number from the
3179: name by calling pcre_get_stringnumber(). The first argument is the com-
3180: piled pattern, and the second is the name. The yield of the function is
3181: the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if there is no
3182: subpattern of that name.
3183:
3184: Given the number, you can extract the substring directly, or use one of
3185: the functions described in the previous section. For convenience, there
3186: are also two functions that do the whole job.
3187:
3188: Most of the arguments of pcre_copy_named_substring() and
3189: pcre_get_named_substring() are the same as those for the similarly
3190: named functions that extract by number. As these are described in the
3191: previous section, they are not re-described here. There are just two
3192: differences:
3193:
3194: First, instead of a substring number, a substring name is given. Sec-
3195: ond, there is an extra argument, given at the start, which is a pointer
3196: to the compiled pattern. This is needed in order to gain access to the
3197: name-to-number translation table.
3198:
3199: These functions call pcre_get_stringnumber(), and if it succeeds, they
3200: then call pcre_copy_substring() or pcre_get_substring(), as appropri-
3201: ate. NOTE: If PCRE_DUPNAMES is set and there are duplicate names, the
3202: behaviour may not be what you want (see the next section).
3203:
3204: Warning: If the pattern uses the (?| feature to set up multiple subpat-
3205: terns with the same number, as described in the section on duplicate
3206: subpattern numbers in the pcrepattern page, you cannot use names to
3207: distinguish the different subpatterns, because names are not included
3208: in the compiled code. The matching process uses only numbers. For this
3209: reason, the use of different names for subpatterns of the same number
3210: causes an error at compile time.
3211:
3212:
3213: DUPLICATE SUBPATTERN NAMES
3214:
3215: int pcre_get_stringtable_entries(const pcre *code,
3216: const char *name, char **first, char **last);
3217:
3218: When a pattern is compiled with the PCRE_DUPNAMES option, names for
3219: subpatterns are not required to be unique. (Duplicate names are always
3220: allowed for subpatterns with the same number, created by using the (?|
3221: feature. Indeed, if such subpatterns are named, they are required to
3222: use the same names.)
3223:
3224: Normally, patterns with duplicate names are such that in any one match,
3225: only one of the named subpatterns participates. An example is shown in
3226: the pcrepattern documentation.
3227:
3228: When duplicates are present, pcre_copy_named_substring() and
3229: pcre_get_named_substring() return the first substring corresponding to
3230: the given name that is set. If none are set, PCRE_ERROR_NOSUBSTRING
3231: (-7) is returned; no data is returned. The pcre_get_stringnumber()
3232: function returns one of the numbers that are associated with the name,
3233: but it is not defined which it is.
3234:
3235: If you want to get full details of all captured substrings for a given
3236: name, you must use the pcre_get_stringtable_entries() function. The
3237: first argument is the compiled pattern, and the second is the name. The
3238: third and fourth are pointers to variables which are updated by the
3239: function. After it has run, they point to the first and last entries in
3240: the name-to-number table for the given name. The function itself
3241: returns the length of each entry, or PCRE_ERROR_NOSUBSTRING (-7) if
3242: there are none. The format of the table is described above in the sec-
3243: tion entitled Information about a pattern above. Given all the rele-
3244: vant entries for the name, you can extract each of their numbers, and
3245: hence the captured data, if any.
3246:
3247:
3248: FINDING ALL POSSIBLE MATCHES
3249:
3250: The traditional matching function uses a similar algorithm to Perl,
3251: which stops when it finds the first match, starting at a given point in
3252: the subject. If you want to find all possible matches, or the longest
3253: possible match, consider using the alternative matching function (see
3254: below) instead. If you cannot use the alternative function, but still
3255: need to find all possible matches, you can kludge it up by making use
3256: of the callout facility, which is described in the pcrecallout documen-
3257: tation.
3258:
3259: What you have to do is to insert a callout right at the end of the pat-
3260: tern. When your callout function is called, extract and save the cur-
3261: rent matched substring. Then return 1, which forces pcre_exec() to
3262: backtrack and try other alternatives. Ultimately, when it runs out of
3263: matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
3264:
3265:
1.1.1.2 ! misho 3266: OBTAINING AN ESTIMATE OF STACK USAGE
! 3267:
! 3268: Matching certain patterns using pcre_exec() can use a lot of process
! 3269: stack, which in certain environments can be rather limited in size.
! 3270: Some users find it helpful to have an estimate of the amount of stack
! 3271: that is used by pcre_exec(), to help them set recursion limits, as
! 3272: described in the pcrestack documentation. The estimate that is output
! 3273: by pcretest when called with the -m and -C options is obtained by call-
! 3274: ing pcre_exec with the values NULL, NULL, NULL, -999, and -999 for its
! 3275: first five arguments.
! 3276:
! 3277: Normally, if its first argument is NULL, pcre_exec() immediately
! 3278: returns the negative error code PCRE_ERROR_NULL, but with this special
! 3279: combination of arguments, it returns instead a negative number whose
! 3280: absolute value is the approximate stack frame size in bytes. (A nega-
! 3281: tive number is used so that it is clear that no match has happened.)
! 3282: The value is approximate because in some cases, recursive calls to
! 3283: pcre_exec() occur when there are one or two additional variables on the
! 3284: stack.
! 3285:
! 3286: If PCRE has been compiled to use the heap instead of the stack for
! 3287: recursion, the value returned is the size of each block that is
! 3288: obtained from the heap.
! 3289:
! 3290:
1.1 misho 3291: MATCHING A PATTERN: THE ALTERNATIVE FUNCTION
3292:
3293: int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
3294: const char *subject, int length, int startoffset,
3295: int options, int *ovector, int ovecsize,
3296: int *workspace, int wscount);
3297:
3298: The function pcre_dfa_exec() is called to match a subject string
3299: against a compiled pattern, using a matching algorithm that scans the
3300: subject string just once, and does not backtrack. This has different
3301: characteristics to the normal algorithm, and is not compatible with
3302: Perl. Some of the features of PCRE patterns are not supported. Never-
3303: theless, there are times when this kind of matching can be useful. For
3304: a discussion of the two matching algorithms, and a list of features
3305: that pcre_dfa_exec() does not support, see the pcrematching documenta-
3306: tion.
3307:
3308: The arguments for the pcre_dfa_exec() function are the same as for
3309: pcre_exec(), plus two extras. The ovector argument is used in a differ-
3310: ent way, and this is described below. The other common arguments are
3311: used in the same way as for pcre_exec(), so their description is not
3312: repeated here.
3313:
3314: The two additional arguments provide workspace for the function. The
3315: workspace vector should contain at least 20 elements. It is used for
3316: keeping track of multiple paths through the pattern tree. More
3317: workspace will be needed for patterns and subjects where there are a
3318: lot of potential matches.
3319:
3320: Here is an example of a simple call to pcre_dfa_exec():
3321:
3322: int rc;
3323: int ovector[10];
3324: int wspace[20];
3325: rc = pcre_dfa_exec(
3326: re, /* result of pcre_compile() */
3327: NULL, /* we didn't study the pattern */
3328: "some string", /* the subject string */
3329: 11, /* the length of the subject string */
3330: 0, /* start at offset 0 in the subject */
3331: 0, /* default options */
3332: ovector, /* vector of integers for substring information */
3333: 10, /* number of elements (NOT size in bytes) */
3334: wspace, /* working space vector */
3335: 20); /* number of elements (NOT size in bytes) */
3336:
3337: Option bits for pcre_dfa_exec()
3338:
3339: The unused bits of the options argument for pcre_dfa_exec() must be
3340: zero. The only bits that may be set are PCRE_ANCHORED, PCRE_NEW-
3341: LINE_xxx, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY,
3342: PCRE_NOTEMPTY_ATSTART, PCRE_NO_UTF8_CHECK, PCRE_BSR_ANYCRLF,
3343: PCRE_BSR_UNICODE, PCRE_NO_START_OPTIMIZE, PCRE_PARTIAL_HARD, PCRE_PAR-
3344: TIAL_SOFT, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART. All but the last
3345: four of these are exactly the same as for pcre_exec(), so their
3346: description is not repeated here.
3347:
3348: PCRE_PARTIAL_HARD
3349: PCRE_PARTIAL_SOFT
3350:
3351: These have the same general effect as they do for pcre_exec(), but the
3352: details are slightly different. When PCRE_PARTIAL_HARD is set for
3353: pcre_dfa_exec(), it returns PCRE_ERROR_PARTIAL if the end of the sub-
3354: ject is reached and there is still at least one matching possibility
3355: that requires additional characters. This happens even if some complete
3356: matches have also been found. When PCRE_PARTIAL_SOFT is set, the return
3357: code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if the end
3358: of the subject is reached, there have been no complete matches, but
3359: there is still at least one matching possibility. The portion of the
3360: string that was inspected when the longest partial match was found is
3361: set as the first matching string in both cases. There is a more
3362: detailed discussion of partial and multi-segment matching, with exam-
3363: ples, in the pcrepartial documentation.
3364:
3365: PCRE_DFA_SHORTEST
3366:
3367: Setting the PCRE_DFA_SHORTEST option causes the matching algorithm to
3368: stop as soon as it has found one match. Because of the way the alterna-
3369: tive algorithm works, this is necessarily the shortest possible match
3370: at the first possible matching point in the subject string.
3371:
3372: PCRE_DFA_RESTART
3373:
3374: When pcre_dfa_exec() returns a partial match, it is possible to call it
3375: again, with additional subject characters, and have it continue with
3376: the same match. The PCRE_DFA_RESTART option requests this action; when
3377: it is set, the workspace and wscount options must reference the same
3378: vector as before because data about the match so far is left in them
3379: after a partial match. There is more discussion of this facility in the
3380: pcrepartial documentation.
3381:
3382: Successful returns from pcre_dfa_exec()
3383:
3384: When pcre_dfa_exec() succeeds, it may have matched more than one sub-
3385: string in the subject. Note, however, that all the matches from one run
3386: of the function start at the same point in the subject. The shorter
3387: matches are all initial substrings of the longer matches. For example,
3388: if the pattern
3389:
3390: <.*>
3391:
3392: is matched against the string
3393:
3394: This is <something> <something else> <something further> no more
3395:
3396: the three matched strings are
3397:
3398: <something>
3399: <something> <something else>
3400: <something> <something else> <something further>
3401:
3402: On success, the yield of the function is a number greater than zero,
3403: which is the number of matched substrings. The substrings themselves
3404: are returned in ovector. Each string uses two elements; the first is
3405: the offset to the start, and the second is the offset to the end. In
3406: fact, all the strings have the same start offset. (Space could have
3407: been saved by giving this only once, but it was decided to retain some
3408: compatibility with the way pcre_exec() returns data, even though the
3409: meaning of the strings is different.)
3410:
3411: The strings are returned in reverse order of length; that is, the long-
3412: est matching string is given first. If there were too many matches to
3413: fit into ovector, the yield of the function is zero, and the vector is
3414: filled with the longest matches. Unlike pcre_exec(), pcre_dfa_exec()
3415: can use the entire ovector for returning matched strings.
3416:
3417: Error returns from pcre_dfa_exec()
3418:
3419: The pcre_dfa_exec() function returns a negative number when it fails.
3420: Many of the errors are the same as for pcre_exec(), and these are
3421: described above. There are in addition the following errors that are
3422: specific to pcre_dfa_exec():
3423:
3424: PCRE_ERROR_DFA_UITEM (-16)
3425:
3426: This return is given if pcre_dfa_exec() encounters an item in the pat-
3427: tern that it does not support, for instance, the use of \C or a back
3428: reference.
3429:
3430: PCRE_ERROR_DFA_UCOND (-17)
3431:
3432: This return is given if pcre_dfa_exec() encounters a condition item
3433: that uses a back reference for the condition, or a test for recursion
3434: in a specific group. These are not supported.
3435:
3436: PCRE_ERROR_DFA_UMLIMIT (-18)
3437:
3438: This return is given if pcre_dfa_exec() is called with an extra block
3439: that contains a setting of the match_limit or match_limit_recursion
3440: fields. This is not supported (these fields are meaningless for DFA
3441: matching).
3442:
3443: PCRE_ERROR_DFA_WSSIZE (-19)
3444:
3445: This return is given if pcre_dfa_exec() runs out of space in the
3446: workspace vector.
3447:
3448: PCRE_ERROR_DFA_RECURSE (-20)
3449:
3450: When a recursive subpattern is processed, the matching function calls
3451: itself recursively, using private vectors for ovector and workspace.
3452: This error is given if the output vector is not large enough. This
3453: should be extremely rare, as a vector of size 1000 is used.
3454:
3455:
3456: SEE ALSO
3457:
1.1.1.2 ! misho 3458: pcre16(3), pcrebuild(3), pcrecallout(3), pcrecpp(3)(3), pcrematch-
! 3459: ing(3), pcrepartial(3), pcreposix(3), pcreprecompile(3), pcresample(3),
! 3460: pcrestack(3).
1.1 misho 3461:
3462:
3463: AUTHOR
3464:
3465: Philip Hazel
3466: University Computing Service
3467: Cambridge CB2 3QH, England.
3468:
3469:
3470: REVISION
3471:
1.1.1.2 ! misho 3472: Last updated: 21 January 2012
! 3473: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 3474: ------------------------------------------------------------------------------
3475:
3476:
3477: PCRECALLOUT(3) PCRECALLOUT(3)
3478:
3479:
3480: NAME
3481: PCRE - Perl-compatible regular expressions
3482:
3483:
3484: PCRE CALLOUTS
3485:
3486: int (*pcre_callout)(pcre_callout_block *);
3487:
1.1.1.2 ! misho 3488: int (*pcre16_callout)(pcre16_callout_block *);
! 3489:
1.1 misho 3490: PCRE provides a feature called "callout", which is a means of temporar-
3491: ily passing control to the caller of PCRE in the middle of pattern
3492: matching. The caller of PCRE provides an external function by putting
1.1.1.2 ! misho 3493: its entry point in the global variable pcre_callout (pcre16_callout for
! 3494: the 16-bit library). By default, this variable contains NULL, which
! 3495: disables all calling out.
1.1 misho 3496:
1.1.1.2 ! misho 3497: Within a regular expression, (?C) indicates the points at which the
! 3498: external function is to be called. Different callout points can be
! 3499: identified by putting a number less than 256 after the letter C. The
! 3500: default value is zero. For example, this pattern has two callout
1.1 misho 3501: points:
3502:
3503: (?C1)abc(?C2)def
3504:
1.1.1.2 ! misho 3505: If the PCRE_AUTO_CALLOUT option bit is set when a pattern is compiled,
! 3506: PCRE automatically inserts callouts, all with number 255, before each
! 3507: item in the pattern. For example, if PCRE_AUTO_CALLOUT is used with the
! 3508: pattern
1.1 misho 3509:
3510: A(\d{2}|--)
3511:
3512: it is processed as if it were
3513:
3514: (?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
3515:
1.1.1.2 ! misho 3516: Notice that there is a callout before and after each parenthesis and
! 3517: alternation bar. Automatic callouts can be used for tracking the
! 3518: progress of pattern matching. The pcretest command has an option that
! 3519: sets automatic callouts; when it is used, the output indicates how the
! 3520: pattern is matched. This is useful information when you are trying to
1.1 misho 3521: optimize the performance of a particular pattern.
3522:
1.1.1.2 ! misho 3523: The use of callouts in a pattern makes it ineligible for optimization
1.1 misho 3524: by the just-in-time compiler. Studying such a pattern with the
3525: PCRE_STUDY_JIT_COMPILE option always fails.
3526:
3527:
3528: MISSING CALLOUTS
3529:
1.1.1.2 ! misho 3530: You should be aware that, because of optimizations in the way PCRE
! 3531: matches patterns by default, callouts sometimes do not happen. For
1.1 misho 3532: example, if the pattern is
3533:
3534: ab(?C4)cd
3535:
3536: PCRE knows that any matching string must contain the letter "d". If the
1.1.1.2 ! misho 3537: subject string is "abyz", the lack of "d" means that matching doesn't
! 3538: ever start, and the callout is never reached. However, with "abyd",
1.1 misho 3539: though the result is still no match, the callout is obeyed.
3540:
1.1.1.2 ! misho 3541: If the pattern is studied, PCRE knows the minimum length of a matching
! 3542: string, and will immediately give a "no match" return without actually
! 3543: running a match if the subject is not long enough, or, for unanchored
1.1 misho 3544: patterns, if it has been scanned far enough.
3545:
1.1.1.2 ! misho 3546: You can disable these optimizations by passing the PCRE_NO_START_OPTI-
! 3547: MIZE option to the matching function, or by starting the pattern with
! 3548: (*NO_START_OPT). This slows down the matching process, but does ensure
! 3549: that callouts such as the example above are obeyed.
1.1 misho 3550:
3551:
3552: THE CALLOUT INTERFACE
3553:
3554: During matching, when PCRE reaches a callout point, the external func-
1.1.1.2 ! misho 3555: tion defined by pcre_callout or pcre16_callout is called (if it is
! 3556: set). This applies to both normal and DFA matching. The only argument
! 3557: to the callout function is a pointer to a pcre_callout or pcre16_call-
! 3558: out block. These structures contains the following fields:
! 3559:
! 3560: int version;
! 3561: int callout_number;
! 3562: int *offset_vector;
! 3563: const char *subject; (8-bit version)
! 3564: PCRE_SPTR16 subject; (16-bit version)
! 3565: int subject_length;
! 3566: int start_match;
! 3567: int current_position;
! 3568: int capture_top;
! 3569: int capture_last;
! 3570: void *callout_data;
! 3571: int pattern_position;
! 3572: int next_item_length;
! 3573: const unsigned char *mark; (8-bit version)
! 3574: const PCRE_UCHAR16 *mark; (16-bit version)
1.1 misho 3575:
3576: The version field is an integer containing the version number of the
3577: block format. The initial version was 0; the current version is 2. The
3578: version number will change again in future if additional fields are
3579: added, but the intention is never to remove any of the existing fields.
3580:
3581: The callout_number field contains the number of the callout, as com-
3582: piled into the pattern (that is, the number after ?C for manual call-
3583: outs, and 255 for automatically generated callouts).
3584:
3585: The offset_vector field is a pointer to the vector of offsets that was
1.1.1.2 ! misho 3586: passed by the caller to the matching function. When pcre_exec() or
! 3587: pcre16_exec() is used, the contents can be inspected, in order to
! 3588: extract substrings that have been matched so far, in the same way as
! 3589: for extracting substrings after a match has completed. For the DFA
! 3590: matching functions, this field is not useful.
1.1 misho 3591:
3592: The subject and subject_length fields contain copies of the values that
1.1.1.2 ! misho 3593: were passed to the matching function.
1.1 misho 3594:
3595: The start_match field normally contains the offset within the subject
3596: at which the current match attempt started. However, if the escape
3597: sequence \K has been encountered, this value is changed to reflect the
3598: modified starting point. If the pattern is not anchored, the callout
3599: function may be called several times from the same point in the pattern
3600: for different starting points in the subject.
3601:
3602: The current_position field contains the offset within the subject of
3603: the current match pointer.
3604:
1.1.1.2 ! misho 3605: When the pcre_exec() or pcre16_exec() is used, the capture_top field
! 3606: contains one more than the number of the highest numbered captured sub-
! 3607: string so far. If no substrings have been captured, the value of cap-
! 3608: ture_top is one. This is always the case when the DFA functions are
! 3609: used, because they do not support captured substrings.
1.1 misho 3610:
3611: The capture_last field contains the number of the most recently cap-
3612: tured substring. If no substrings have been captured, its value is -1.
1.1.1.2 ! misho 3613: This is always the case for the DFA matching functions.
1.1 misho 3614:
1.1.1.2 ! misho 3615: The callout_data field contains a value that is passed to a matching
! 3616: function specifically so that it can be passed back in callouts. It is
! 3617: passed in the callout_data field of a pcre_extra or pcre16_extra data
1.1 misho 3618: structure. If no such data was passed, the value of callout_data in a
1.1.1.2 ! misho 3619: callout block is NULL. There is a description of the pcre_extra struc-
! 3620: ture in the pcreapi documentation.
1.1 misho 3621:
1.1.1.2 ! misho 3622: The pattern_position field is present from version 1 of the callout
! 3623: structure. It contains the offset to the next item to be matched in the
! 3624: pattern string.
! 3625:
! 3626: The next_item_length field is present from version 1 of the callout
! 3627: structure. It contains the length of the next item to be matched in the
! 3628: pattern string. When the callout immediately precedes an alternation
! 3629: bar, a closing parenthesis, or the end of the pattern, the length is
! 3630: zero. When the callout precedes an opening parenthesis, the length is
! 3631: that of the entire subpattern.
1.1 misho 3632:
3633: The pattern_position and next_item_length fields are intended to help
3634: in distinguishing between different automatic callouts, which all have
3635: the same callout number. However, they are set for all callouts.
3636:
1.1.1.2 ! misho 3637: The mark field is present from version 2 of the callout structure. In
! 3638: callouts from pcre_exec() or pcre16_exec() it contains a pointer to the
! 3639: zero-terminated name of the most recently passed (*MARK), (*PRUNE), or
! 3640: (*THEN) item in the match, or NULL if no such items have been passed.
! 3641: Instances of (*PRUNE) or (*THEN) without a name do not obliterate a
! 3642: previous (*MARK). In callouts from the DFA matching functions this
! 3643: field always contains NULL.
1.1 misho 3644:
3645:
3646: RETURN VALUES
3647:
3648: The external callout function returns an integer to PCRE. If the value
3649: is zero, matching proceeds as normal. If the value is greater than
3650: zero, matching fails at the current point, but the testing of other
3651: matching possibilities goes ahead, just as if a lookahead assertion had
1.1.1.2 ! misho 3652: failed. If the value is less than zero, the match is abandoned, the
! 3653: matching function returns the negative value.
1.1 misho 3654:
3655: Negative values should normally be chosen from the set of
3656: PCRE_ERROR_xxx values. In particular, PCRE_ERROR_NOMATCH forces a stan-
3657: dard "no match" failure. The error number PCRE_ERROR_CALLOUT is
3658: reserved for use by callout functions; it will never be used by PCRE
3659: itself.
3660:
3661:
3662: AUTHOR
3663:
3664: Philip Hazel
3665: University Computing Service
3666: Cambridge CB2 3QH, England.
3667:
3668:
3669: REVISION
3670:
1.1.1.2 ! misho 3671: Last updated: 08 Janurary 2012
! 3672: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 3673: ------------------------------------------------------------------------------
3674:
3675:
3676: PCRECOMPAT(3) PCRECOMPAT(3)
3677:
3678:
3679: NAME
3680: PCRE - Perl-compatible regular expressions
3681:
3682:
3683: DIFFERENCES BETWEEN PCRE AND PERL
3684:
3685: This document describes the differences in the ways that PCRE and Perl
3686: handle regular expressions. The differences described here are with
3687: respect to Perl versions 5.10 and above.
3688:
1.1.1.2 ! misho 3689: 1. PCRE has only a subset of Perl's Unicode support. Details of what it
! 3690: does have are given in the pcreunicode page.
1.1 misho 3691:
3692: 2. PCRE allows repeat quantifiers only on parenthesized assertions, but
3693: they do not mean what you might think. For example, (?!a){3} does not
3694: assert that the next three characters are not "a". It just asserts that
3695: the next character is not "a" three times (in principle: PCRE optimizes
3696: this to run the assertion just once). Perl allows repeat quantifiers on
3697: other assertions such as \b, but these do not seem to have any use.
3698:
3699: 3. Capturing subpatterns that occur inside negative lookahead asser-
3700: tions are counted, but their entries in the offsets vector are never
3701: set. Perl sets its numerical variables from any such patterns that are
3702: matched before the assertion fails to match something (thereby succeed-
3703: ing), but only if the negative lookahead assertion contains just one
3704: branch.
3705:
3706: 4. Though binary zero characters are supported in the subject string,
3707: they are not allowed in a pattern string because it is passed as a nor-
3708: mal C string, terminated by zero. The escape sequence \0 can be used in
3709: the pattern to represent a binary zero.
3710:
3711: 5. The following Perl escape sequences are not supported: \l, \u, \L,
3712: \U, and \N when followed by a character name or Unicode value. (\N on
3713: its own, matching a non-newline character, is supported.) In fact these
3714: are implemented by Perl's general string-handling and are not part of
3715: its pattern matching engine. If any of these are encountered by PCRE,
3716: an error is generated by default. However, if the PCRE_JAVASCRIPT_COM-
3717: PAT option is set, \U and \u are interpreted as JavaScript interprets
3718: them.
3719:
3720: 6. The Perl escape sequences \p, \P, and \X are supported only if PCRE
3721: is built with Unicode character property support. The properties that
3722: can be tested with \p and \P are limited to the general category prop-
3723: erties such as Lu and Nd, script names such as Greek or Han, and the
3724: derived properties Any and L&. PCRE does support the Cs (surrogate)
3725: property, which Perl does not; the Perl documentation says "Because
3726: Perl hides the need for the user to understand the internal representa-
3727: tion of Unicode characters, there is no need to implement the somewhat
3728: messy concept of surrogates."
3729:
3730: 7. PCRE implements a simpler version of \X than Perl, which changed to
3731: make \X match what Unicode calls an "extended grapheme cluster". This
3732: is more complicated than an extended Unicode sequence, which is what
3733: PCRE matches.
3734:
3735: 8. PCRE does support the \Q...\E escape for quoting substrings. Charac-
3736: ters in between are treated as literals. This is slightly different
3737: from Perl in that $ and @ are also handled as literals inside the
3738: quotes. In Perl, they cause variable interpolation (but of course PCRE
3739: does not have variables). Note the following examples:
3740:
3741: Pattern PCRE matches Perl matches
3742:
3743: \Qabc$xyz\E abc$xyz abc followed by the
3744: contents of $xyz
3745: \Qabc\$xyz\E abc\$xyz abc\$xyz
3746: \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
3747:
3748: The \Q...\E sequence is recognized both inside and outside character
3749: classes.
3750:
3751: 9. Fairly obviously, PCRE does not support the (?{code}) and (??{code})
3752: constructions. However, there is support for recursive patterns. This
3753: is not available in Perl 5.8, but it is in Perl 5.10. Also, the PCRE
3754: "callout" feature allows an external function to be called during pat-
3755: tern matching. See the pcrecallout documentation for details.
3756:
3757: 10. Subpatterns that are called as subroutines (whether or not recur-
3758: sively) are always treated as atomic groups in PCRE. This is like
3759: Python, but unlike Perl. Captured values that are set outside a sub-
3760: routine call can be reference from inside in PCRE, but not in Perl.
3761: There is a discussion that explains these differences in more detail in
3762: the section on recursion differences from Perl in the pcrepattern page.
3763:
3764: 11. If (*THEN) is present in a group that is called as a subroutine,
3765: its action is limited to that group, even if the group does not contain
3766: any | characters.
3767:
3768: 12. There are some differences that are concerned with the settings of
3769: captured strings when part of a pattern is repeated. For example,
3770: matching "aba" against the pattern /^(a(b)?)+$/ in Perl leaves $2
3771: unset, but in PCRE it is set to "b".
3772:
3773: 13. PCRE's handling of duplicate subpattern numbers and duplicate sub-
3774: pattern names is not as general as Perl's. This is a consequence of the
3775: fact the PCRE works internally just with numbers, using an external ta-
3776: ble to translate between numbers and names. In particular, a pattern
3777: such as (?|(?<a>A)|(?<b)B), where the two capturing parentheses have
3778: the same number but different names, is not supported, and causes an
3779: error at compile time. If it were allowed, it would not be possible to
3780: distinguish which parentheses matched, because both names map to cap-
3781: turing subpattern number 1. To avoid this confusing situation, an error
3782: is given at compile time.
3783:
3784: 14. Perl recognizes comments in some places that PCRE does not, for
3785: example, between the ( and ? at the start of a subpattern. If the /x
3786: modifier is set, Perl allows whitespace between ( and ? but PCRE never
3787: does, even if the PCRE_EXTENDED option is set.
3788:
3789: 15. PCRE provides some extensions to the Perl regular expression facil-
3790: ities. Perl 5.10 includes new features that are not in earlier ver-
3791: sions of Perl, some of which (such as named parentheses) have been in
3792: PCRE for some time. This list is with respect to Perl 5.10:
3793:
3794: (a) Although lookbehind assertions in PCRE must match fixed length
3795: strings, each alternative branch of a lookbehind assertion can match a
3796: different length of string. Perl requires them all to have the same
3797: length.
3798:
3799: (b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
3800: meta-character matches only at the very end of the string.
3801:
3802: (c) If PCRE_EXTRA is set, a backslash followed by a letter with no spe-
3803: cial meaning is faulted. Otherwise, like Perl, the backslash is quietly
3804: ignored. (Perl can be made to issue a warning.)
3805:
3806: (d) If PCRE_UNGREEDY is set, the greediness of the repetition quanti-
3807: fiers is inverted, that is, by default they are not greedy, but if fol-
3808: lowed by a question mark they are.
3809:
3810: (e) PCRE_ANCHORED can be used at matching time to force a pattern to be
3811: tried only at the first matching position in the subject string.
3812:
3813: (f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART,
3814: and PCRE_NO_AUTO_CAPTURE options for pcre_exec() have no Perl equiva-
3815: lents.
3816:
3817: (g) The \R escape sequence can be restricted to match only CR, LF, or
3818: CRLF by the PCRE_BSR_ANYCRLF option.
3819:
3820: (h) The callout facility is PCRE-specific.
3821:
3822: (i) The partial matching facility is PCRE-specific.
3823:
3824: (j) Patterns compiled by PCRE can be saved and re-used at a later time,
3825: even on different hosts that have the other endianness. However, this
3826: does not apply to optimized data created by the just-in-time compiler.
3827:
1.1.1.2 ! misho 3828: (k) The alternative matching functions (pcre_dfa_exec() and
! 3829: pcre16_dfa_exec()) match in a different way and are not Perl-compati-
! 3830: ble.
1.1 misho 3831:
1.1.1.2 ! misho 3832: (l) PCRE recognizes some special sequences such as (*CR) at the start
1.1 misho 3833: of a pattern that set overall options that cannot be changed within the
3834: pattern.
3835:
3836:
3837: AUTHOR
3838:
3839: Philip Hazel
3840: University Computing Service
3841: Cambridge CB2 3QH, England.
3842:
3843:
3844: REVISION
3845:
1.1.1.2 ! misho 3846: Last updated: 08 Januray 2012
! 3847: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 3848: ------------------------------------------------------------------------------
3849:
3850:
3851: PCREPATTERN(3) PCREPATTERN(3)
3852:
3853:
3854: NAME
3855: PCRE - Perl-compatible regular expressions
3856:
3857:
3858: PCRE REGULAR EXPRESSION DETAILS
3859:
3860: The syntax and semantics of the regular expressions that are supported
3861: by PCRE are described in detail below. There is a quick-reference syn-
3862: tax summary in the pcresyntax page. PCRE tries to match Perl syntax and
3863: semantics as closely as it can. PCRE also supports some alternative
3864: regular expression syntax (which does not conflict with the Perl syn-
3865: tax) in order to provide some compatibility with regular expressions in
3866: Python, .NET, and Oniguruma.
3867:
3868: Perl's regular expressions are described in its own documentation, and
3869: regular expressions in general are covered in a number of books, some
3870: of which have copious examples. Jeffrey Friedl's "Mastering Regular
3871: Expressions", published by O'Reilly, covers regular expressions in
3872: great detail. This description of PCRE's regular expressions is
3873: intended as reference material.
3874:
3875: The original operation of PCRE was on strings of one-byte characters.
1.1.1.2 ! misho 3876: However, there is now also support for UTF-8 strings in the original
! 3877: library, and a second library that supports 16-bit and UTF-16 character
! 3878: strings. To use these features, PCRE must be built to include appropri-
! 3879: ate support. When using UTF strings you must either call the compiling
! 3880: function with the PCRE_UTF8 or PCRE_UTF16 option, or the pattern must
! 3881: start with one of these special sequences:
1.1 misho 3882:
3883: (*UTF8)
1.1.1.2 ! misho 3884: (*UTF16)
1.1 misho 3885:
1.1.1.2 ! misho 3886: Starting a pattern with such a sequence is equivalent to setting the
! 3887: relevant option. This feature is not Perl-compatible. How setting a UTF
! 3888: mode affects pattern matching is mentioned in several places below.
! 3889: There is also a summary of features in the pcreunicode page.
1.1 misho 3890:
1.1.1.2 ! misho 3891: Another special sequence that may appear at the start of a pattern or
! 3892: in combination with (*UTF8) or (*UTF16) is:
1.1 misho 3893:
3894: (*UCP)
3895:
1.1.1.2 ! misho 3896: This has the same effect as setting the PCRE_UCP option: it causes
! 3897: sequences such as \d and \w to use Unicode properties to determine
1.1 misho 3898: character types, instead of recognizing only characters with codes less
3899: than 128 via a lookup table.
3900:
1.1.1.2 ! misho 3901: If a pattern starts with (*NO_START_OPT), it has the same effect as
1.1 misho 3902: setting the PCRE_NO_START_OPTIMIZE option either at compile or matching
3903: time. There are also some more of these special sequences that are con-
3904: cerned with the handling of newlines; they are described below.
3905:
1.1.1.2 ! misho 3906: The remainder of this document discusses the patterns that are sup-
! 3907: ported by PCRE when one its main matching functions, pcre_exec()
! 3908: (8-bit) or pcre16_exec() (16-bit), is used. PCRE also has alternative
! 3909: matching functions, pcre_dfa_exec() and pcre16_dfa_exec(), which match
! 3910: using a different algorithm that is not Perl-compatible. Some of the
! 3911: features discussed below are not available when DFA matching is used.
! 3912: The advantages and disadvantages of the alternative functions, and how
! 3913: they differ from the normal functions, are discussed in the pcrematch-
! 3914: ing page.
1.1 misho 3915:
3916:
3917: NEWLINE CONVENTIONS
3918:
3919: PCRE supports five different conventions for indicating line breaks in
3920: strings: a single CR (carriage return) character, a single LF (line-
3921: feed) character, the two-character sequence CRLF, any of the three pre-
3922: ceding, or any Unicode newline sequence. The pcreapi page has further
3923: discussion about newlines, and shows how to set the newline convention
3924: in the options arguments for the compiling and matching functions.
3925:
3926: It is also possible to specify a newline convention by starting a pat-
3927: tern string with one of the following five sequences:
3928:
3929: (*CR) carriage return
3930: (*LF) linefeed
3931: (*CRLF) carriage return, followed by linefeed
3932: (*ANYCRLF) any of the three above
3933: (*ANY) all Unicode newline sequences
3934:
1.1.1.2 ! misho 3935: These override the default and the options given to the compiling func-
! 3936: tion. For example, on a Unix system where LF is the default newline
! 3937: sequence, the pattern
1.1 misho 3938:
3939: (*CR)a.b
3940:
3941: changes the convention to CR. That pattern matches "a\nb" because LF is
3942: no longer a newline. Note that these special settings, which are not
3943: Perl-compatible, are recognized only at the very start of a pattern,
3944: and that they must be in upper case. If more than one of them is
3945: present, the last one is used.
3946:
3947: The newline convention affects the interpretation of the dot metachar-
3948: acter when PCRE_DOTALL is not set, and also the behaviour of \N. How-
3949: ever, it does not affect what the \R escape sequence matches. By
3950: default, this is any Unicode newline sequence, for Perl compatibility.
3951: However, this can be changed; see the description of \R in the section
3952: entitled "Newline sequences" below. A change of \R setting can be com-
3953: bined with a change of newline convention.
3954:
3955:
3956: CHARACTERS AND METACHARACTERS
3957:
3958: A regular expression is a pattern that is matched against a subject
3959: string from left to right. Most characters stand for themselves in a
3960: pattern, and match the corresponding characters in the subject. As a
3961: trivial example, the pattern
3962:
3963: The quick brown fox
3964:
3965: matches a portion of a subject string that is identical to itself. When
3966: caseless matching is specified (the PCRE_CASELESS option), letters are
1.1.1.2 ! misho 3967: matched independently of case. In a UTF mode, PCRE always understands
1.1 misho 3968: the concept of case for characters whose values are less than 128, so
3969: caseless matching is always possible. For characters with higher val-
3970: ues, the concept of case is supported if PCRE is compiled with Unicode
3971: property support, but not otherwise. If you want to use caseless
3972: matching for characters 128 and above, you must ensure that PCRE is
1.1.1.2 ! misho 3973: compiled with Unicode property support as well as with UTF support.
1.1 misho 3974:
3975: The power of regular expressions comes from the ability to include
3976: alternatives and repetitions in the pattern. These are encoded in the
3977: pattern by the use of metacharacters, which do not stand for themselves
3978: but instead are interpreted in some special way.
3979:
3980: There are two different sets of metacharacters: those that are recog-
3981: nized anywhere in the pattern except within square brackets, and those
3982: that are recognized within square brackets. Outside square brackets,
3983: the metacharacters are as follows:
3984:
3985: \ general escape character with several uses
3986: ^ assert start of string (or line, in multiline mode)
3987: $ assert end of string (or line, in multiline mode)
3988: . match any character except newline (by default)
3989: [ start character class definition
3990: | start of alternative branch
3991: ( start subpattern
3992: ) end subpattern
3993: ? extends the meaning of (
3994: also 0 or 1 quantifier
3995: also quantifier minimizer
3996: * 0 or more quantifier
3997: + 1 or more quantifier
3998: also "possessive quantifier"
3999: { start min/max quantifier
4000:
4001: Part of a pattern that is in square brackets is called a "character
4002: class". In a character class the only metacharacters are:
4003:
4004: \ general escape character
4005: ^ negate the class, but only if the first character
4006: - indicates character range
4007: [ POSIX character class (only if followed by POSIX
4008: syntax)
4009: ] terminates the character class
4010:
4011: The following sections describe the use of each of the metacharacters.
4012:
4013:
4014: BACKSLASH
4015:
4016: The backslash character has several uses. Firstly, if it is followed by
4017: a character that is not a number or a letter, it takes away any special
4018: meaning that character may have. This use of backslash as an escape
4019: character applies both inside and outside character classes.
4020:
4021: For example, if you want to match a * character, you write \* in the
4022: pattern. This escaping action applies whether or not the following
4023: character would otherwise be interpreted as a metacharacter, so it is
4024: always safe to precede a non-alphanumeric with backslash to specify
4025: that it stands for itself. In particular, if you want to match a back-
4026: slash, you write \\.
4027:
1.1.1.2 ! misho 4028: In a UTF mode, only ASCII numbers and letters have any special meaning
1.1 misho 4029: after a backslash. All other characters (in particular, those whose
4030: codepoints are greater than 127) are treated as literals.
4031:
4032: If a pattern is compiled with the PCRE_EXTENDED option, whitespace in
4033: the pattern (other than in a character class) and characters between a
4034: # outside a character class and the next newline are ignored. An escap-
4035: ing backslash can be used to include a whitespace or # character as
4036: part of the pattern.
4037:
4038: If you want to remove the special meaning from a sequence of charac-
4039: ters, you can do so by putting them between \Q and \E. This is differ-
4040: ent from Perl in that $ and @ are handled as literals in \Q...\E
4041: sequences in PCRE, whereas in Perl, $ and @ cause variable interpola-
4042: tion. Note the following examples:
4043:
4044: Pattern PCRE matches Perl matches
4045:
4046: \Qabc$xyz\E abc$xyz abc followed by the
4047: contents of $xyz
4048: \Qabc\$xyz\E abc\$xyz abc\$xyz
4049: \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
4050:
4051: The \Q...\E sequence is recognized both inside and outside character
4052: classes. An isolated \E that is not preceded by \Q is ignored. If \Q
4053: is not followed by \E later in the pattern, the literal interpretation
4054: continues to the end of the pattern (that is, \E is assumed at the
4055: end). If the isolated \Q is inside a character class, this causes an
4056: error, because the character class is not terminated.
4057:
4058: Non-printing characters
4059:
4060: A second use of backslash provides a way of encoding non-printing char-
4061: acters in patterns in a visible manner. There is no restriction on the
4062: appearance of non-printing characters, apart from the binary zero that
4063: terminates a pattern, but when a pattern is being prepared by text
4064: editing, it is often easier to use one of the following escape
4065: sequences than the binary character it represents:
4066:
4067: \a alarm, that is, the BEL character (hex 07)
4068: \cx "control-x", where x is any ASCII character
4069: \e escape (hex 1B)
4070: \f formfeed (hex 0C)
4071: \n linefeed (hex 0A)
4072: \r carriage return (hex 0D)
4073: \t tab (hex 09)
4074: \ddd character with octal code ddd, or back reference
4075: \xhh character with hex code hh
4076: \x{hhh..} character with hex code hhh.. (non-JavaScript mode)
4077: \uhhhh character with hex code hhhh (JavaScript mode only)
4078:
4079: The precise effect of \cx is as follows: if x is a lower case letter,
4080: it is converted to upper case. Then bit 6 of the character (hex 40) is
4081: inverted. Thus \cz becomes hex 1A (z is 7A), but \c{ becomes hex 3B ({
4082: is 7B), while \c; becomes hex 7B (; is 3B). If the byte following \c
4083: has a value greater than 127, a compile-time error occurs. This locks
1.1.1.2 ! misho 4084: out non-ASCII characters in all modes. (When PCRE is compiled in EBCDIC
! 4085: mode, all byte values are valid. A lower case letter is converted to
! 4086: upper case, and then the 0xc0 bits are flipped.)
1.1 misho 4087:
4088: By default, after \x, from zero to two hexadecimal digits are read
4089: (letters can be in upper or lower case). Any number of hexadecimal dig-
1.1.1.2 ! misho 4090: its may appear between \x{ and }, but the character code is constrained
! 4091: as follows:
! 4092:
! 4093: 8-bit non-UTF mode less than 0x100
! 4094: 8-bit UTF-8 mode less than 0x10ffff and a valid codepoint
! 4095: 16-bit non-UTF mode less than 0x10000
! 4096: 16-bit UTF-16 mode less than 0x10ffff and a valid codepoint
1.1 misho 4097:
1.1.1.2 ! misho 4098: Invalid Unicode codepoints are the range 0xd800 to 0xdfff (the so-
! 4099: called "surrogate" codepoints).
! 4100:
! 4101: If characters other than hexadecimal digits appear between \x{ and },
1.1 misho 4102: or if there is no terminating }, this form of escape is not recognized.
1.1.1.2 ! misho 4103: Instead, the initial \x will be interpreted as a basic hexadecimal
! 4104: escape, with no following digits, giving a character whose value is
1.1 misho 4105: zero.
4106:
1.1.1.2 ! misho 4107: If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x
! 4108: is as just described only when it is followed by two hexadecimal dig-
! 4109: its. Otherwise, it matches a literal "x" character. In JavaScript
1.1 misho 4110: mode, support for code points greater than 256 is provided by \u, which
1.1.1.2 ! misho 4111: must be followed by four hexadecimal digits; otherwise it matches a
1.1 misho 4112: literal "u" character.
4113:
4114: Characters whose value is less than 256 can be defined by either of the
1.1.1.2 ! misho 4115: two syntaxes for \x (or by \u in JavaScript mode). There is no differ-
1.1 misho 4116: ence in the way they are handled. For example, \xdc is exactly the same
4117: as \x{dc} (or \u00dc in JavaScript mode).
4118:
1.1.1.2 ! misho 4119: After \0 up to two further octal digits are read. If there are fewer
! 4120: than two digits, just those that are present are used. Thus the
1.1 misho 4121: sequence \0\x\07 specifies two binary zeros followed by a BEL character
1.1.1.2 ! misho 4122: (code value 7). Make sure you supply two digits after the initial zero
1.1 misho 4123: if the pattern character that follows is itself an octal digit.
4124:
4125: The handling of a backslash followed by a digit other than 0 is compli-
4126: cated. Outside a character class, PCRE reads it and any following dig-
1.1.1.2 ! misho 4127: its as a decimal number. If the number is less than 10, or if there
1.1 misho 4128: have been at least that many previous capturing left parentheses in the
1.1.1.2 ! misho 4129: expression, the entire sequence is taken as a back reference. A
! 4130: description of how this works is given later, following the discussion
1.1 misho 4131: of parenthesized subpatterns.
4132:
1.1.1.2 ! misho 4133: Inside a character class, or if the decimal number is greater than 9
! 4134: and there have not been that many capturing subpatterns, PCRE re-reads
1.1 misho 4135: up to three octal digits following the backslash, and uses them to gen-
1.1.1.2 ! misho 4136: erate a data character. Any subsequent digits stand for themselves. The
! 4137: value of the character is constrained in the same way as characters
! 4138: specified in hexadecimal. For example:
1.1 misho 4139:
4140: \040 is another way of writing a space
4141: \40 is the same, provided there are fewer than 40
4142: previous capturing subpatterns
4143: \7 is always a back reference
4144: \11 might be a back reference, or another way of
4145: writing a tab
4146: \011 is always a tab
4147: \0113 is a tab followed by the character "3"
4148: \113 might be a back reference, otherwise the
4149: character with octal code 113
4150: \377 might be a back reference, otherwise
1.1.1.2 ! misho 4151: the value 255 (decimal)
1.1 misho 4152: \81 is either a back reference, or a binary zero
4153: followed by the two characters "8" and "1"
4154:
4155: Note that octal values of 100 or greater must not be introduced by a
4156: leading zero, because no more than three octal digits are ever read.
4157:
4158: All the sequences that define a single character value can be used both
4159: inside and outside character classes. In addition, inside a character
4160: class, \b is interpreted as the backspace character (hex 08).
4161:
4162: \N is not allowed in a character class. \B, \R, and \X are not special
4163: inside a character class. Like other unrecognized escape sequences,
4164: they are treated as the literal characters "B", "R", and "X" by
4165: default, but cause an error if the PCRE_EXTRA option is set. Outside a
4166: character class, these sequences have different meanings.
4167:
4168: Unsupported escape sequences
4169:
4170: In Perl, the sequences \l, \L, \u, and \U are recognized by its string
4171: handler and used to modify the case of following characters. By
4172: default, PCRE does not support these escape sequences. However, if the
4173: PCRE_JAVASCRIPT_COMPAT option is set, \U matches a "U" character, and
4174: \u can be used to define a character by code point, as described in the
4175: previous section.
4176:
4177: Absolute and relative back references
4178:
4179: The sequence \g followed by an unsigned or a negative number, option-
4180: ally enclosed in braces, is an absolute or relative back reference. A
4181: named back reference can be coded as \g{name}. Back references are dis-
4182: cussed later, following the discussion of parenthesized subpatterns.
4183:
4184: Absolute and relative subroutine calls
4185:
4186: For compatibility with Oniguruma, the non-Perl syntax \g followed by a
4187: name or a number enclosed either in angle brackets or single quotes, is
4188: an alternative syntax for referencing a subpattern as a "subroutine".
4189: Details are discussed later. Note that \g{...} (Perl syntax) and
4190: \g<...> (Oniguruma syntax) are not synonymous. The former is a back
4191: reference; the latter is a subroutine call.
4192:
4193: Generic character types
4194:
4195: Another use of backslash is for specifying generic character types:
4196:
4197: \d any decimal digit
4198: \D any character that is not a decimal digit
4199: \h any horizontal whitespace character
4200: \H any character that is not a horizontal whitespace character
4201: \s any whitespace character
4202: \S any character that is not a whitespace character
4203: \v any vertical whitespace character
4204: \V any character that is not a vertical whitespace character
4205: \w any "word" character
4206: \W any "non-word" character
4207:
4208: There is also the single sequence \N, which matches a non-newline char-
4209: acter. This is the same as the "." metacharacter when PCRE_DOTALL is
4210: not set. Perl also uses \N to match characters by name; PCRE does not
4211: support this.
4212:
4213: Each pair of lower and upper case escape sequences partitions the com-
4214: plete set of characters into two disjoint sets. Any given character
4215: matches one, and only one, of each pair. The sequences can appear both
4216: inside and outside character classes. They each match one character of
4217: the appropriate type. If the current matching point is at the end of
4218: the subject string, all of them fail, because there is no character to
4219: match.
4220:
4221: For compatibility with Perl, \s does not match the VT character (code
4222: 11). This makes it different from the the POSIX "space" class. The \s
4223: characters are HT (9), LF (10), FF (12), CR (13), and space (32). If
4224: "use locale;" is included in a Perl script, \s may match the VT charac-
4225: ter. In PCRE, it never does.
4226:
4227: A "word" character is an underscore or any character that is a letter
4228: or digit. By default, the definition of letters and digits is con-
4229: trolled by PCRE's low-valued character tables, and may vary if locale-
4230: specific matching is taking place (see "Locale support" in the pcreapi
4231: page). For example, in a French locale such as "fr_FR" in Unix-like
4232: systems, or "french" in Windows, some character codes greater than 128
4233: are used for accented letters, and these are then matched by \w. The
4234: use of locales with Unicode is discouraged.
4235:
1.1.1.2 ! misho 4236: By default, in a UTF mode, characters with values greater than 128
1.1 misho 4237: never match \d, \s, or \w, and always match \D, \S, and \W. These
1.1.1.2 ! misho 4238: sequences retain their original meanings from before UTF support was
1.1 misho 4239: available, mainly for efficiency reasons. However, if PCRE is compiled
4240: with Unicode property support, and the PCRE_UCP option is set, the be-
4241: haviour is changed so that Unicode properties are used to determine
4242: character types, as follows:
4243:
4244: \d any character that \p{Nd} matches (decimal digit)
4245: \s any character that \p{Z} matches, plus HT, LF, FF, CR
4246: \w any character that \p{L} or \p{N} matches, plus underscore
4247:
4248: The upper case escapes match the inverse sets of characters. Note that
4249: \d matches only decimal digits, whereas \w matches any Unicode digit,
4250: as well as any Unicode letter, and underscore. Note also that PCRE_UCP
4251: affects \b, and \B because they are defined in terms of \w and \W.
4252: Matching these sequences is noticeably slower when PCRE_UCP is set.
4253:
4254: The sequences \h, \H, \v, and \V are features that were added to Perl
4255: at release 5.10. In contrast to the other sequences, which match only
4256: ASCII characters by default, these always match certain high-valued
1.1.1.2 ! misho 4257: codepoints, whether or not PCRE_UCP is set. The horizontal space char-
! 4258: acters are:
1.1 misho 4259:
4260: U+0009 Horizontal tab
4261: U+0020 Space
4262: U+00A0 Non-break space
4263: U+1680 Ogham space mark
4264: U+180E Mongolian vowel separator
4265: U+2000 En quad
4266: U+2001 Em quad
4267: U+2002 En space
4268: U+2003 Em space
4269: U+2004 Three-per-em space
4270: U+2005 Four-per-em space
4271: U+2006 Six-per-em space
4272: U+2007 Figure space
4273: U+2008 Punctuation space
4274: U+2009 Thin space
4275: U+200A Hair space
4276: U+202F Narrow no-break space
4277: U+205F Medium mathematical space
4278: U+3000 Ideographic space
4279:
4280: The vertical space characters are:
4281:
4282: U+000A Linefeed
4283: U+000B Vertical tab
4284: U+000C Formfeed
4285: U+000D Carriage return
4286: U+0085 Next line
4287: U+2028 Line separator
4288: U+2029 Paragraph separator
4289:
1.1.1.2 ! misho 4290: In 8-bit, non-UTF-8 mode, only the characters with codepoints less than
! 4291: 256 are relevant.
! 4292:
1.1 misho 4293: Newline sequences
4294:
1.1.1.2 ! misho 4295: Outside a character class, by default, the escape sequence \R matches
! 4296: any Unicode newline sequence. In 8-bit non-UTF-8 mode \R is equivalent
! 4297: to the following:
1.1 misho 4298:
4299: (?>\r\n|\n|\x0b|\f|\r|\x85)
4300:
1.1.1.2 ! misho 4301: This is an example of an "atomic group", details of which are given
1.1 misho 4302: below. This particular group matches either the two-character sequence
1.1.1.2 ! misho 4303: CR followed by LF, or one of the single characters LF (linefeed,
1.1 misho 4304: U+000A), VT (vertical tab, U+000B), FF (formfeed, U+000C), CR (carriage
4305: return, U+000D), or NEL (next line, U+0085). The two-character sequence
4306: is treated as a single unit that cannot be split.
4307:
1.1.1.2 ! misho 4308: In other modes, two additional characters whose codepoints are greater
1.1 misho 4309: than 255 are added: LS (line separator, U+2028) and PS (paragraph sepa-
1.1.1.2 ! misho 4310: rator, U+2029). Unicode character property support is not needed for
1.1 misho 4311: these characters to be recognized.
4312:
4313: It is possible to restrict \R to match only CR, LF, or CRLF (instead of
1.1.1.2 ! misho 4314: the complete set of Unicode line endings) by setting the option
1.1 misho 4315: PCRE_BSR_ANYCRLF either at compile time or when the pattern is matched.
4316: (BSR is an abbrevation for "backslash R".) This can be made the default
1.1.1.2 ! misho 4317: when PCRE is built; if this is the case, the other behaviour can be
! 4318: requested via the PCRE_BSR_UNICODE option. It is also possible to
! 4319: specify these settings by starting a pattern string with one of the
1.1 misho 4320: following sequences:
4321:
4322: (*BSR_ANYCRLF) CR, LF, or CRLF only
4323: (*BSR_UNICODE) any Unicode newline sequence
4324:
1.1.1.2 ! misho 4325: These override the default and the options given to the compiling func-
! 4326: tion, but they can themselves be overridden by options given to a
! 4327: matching function. Note that these special settings, which are not
! 4328: Perl-compatible, are recognized only at the very start of a pattern,
! 4329: and that they must be in upper case. If more than one of them is
! 4330: present, the last one is used. They can be combined with a change of
1.1 misho 4331: newline convention; for example, a pattern can start with:
4332:
4333: (*ANY)(*BSR_ANYCRLF)
4334:
1.1.1.2 ! misho 4335: They can also be combined with the (*UTF8), (*UTF16), or (*UCP) special
! 4336: sequences. Inside a character class, \R is treated as an unrecognized
! 4337: escape sequence, and so matches the letter "R" by default, but causes
! 4338: an error if PCRE_EXTRA is set.
1.1 misho 4339:
4340: Unicode character properties
4341:
4342: When PCRE is built with Unicode character property support, three addi-
1.1.1.2 ! misho 4343: tional escape sequences that match characters with specific properties
! 4344: are available. When in 8-bit non-UTF-8 mode, these sequences are of
! 4345: course limited to testing characters whose codepoints are less than
! 4346: 256, but they do work in this mode. The extra escape sequences are:
1.1 misho 4347:
4348: \p{xx} a character with the xx property
4349: \P{xx} a character without the xx property
4350: \X an extended Unicode sequence
4351:
1.1.1.2 ! misho 4352: The property names represented by xx above are limited to the Unicode
1.1 misho 4353: script names, the general category properties, "Any", which matches any
1.1.1.2 ! misho 4354: character (including newline), and some special PCRE properties
! 4355: (described in the next section). Other Perl properties such as "InMu-
! 4356: sicalSymbols" are not currently supported by PCRE. Note that \P{Any}
1.1 misho 4357: does not match any characters, so always causes a match failure.
4358:
4359: Sets of Unicode characters are defined as belonging to certain scripts.
1.1.1.2 ! misho 4360: A character from one of these sets can be matched using a script name.
1.1 misho 4361: For example:
4362:
4363: \p{Greek}
4364: \P{Han}
4365:
1.1.1.2 ! misho 4366: Those that are not part of an identified script are lumped together as
1.1 misho 4367: "Common". The current list of scripts is:
4368:
4369: Arabic, Armenian, Avestan, Balinese, Bamum, Bengali, Bopomofo, Braille,
1.1.1.2 ! misho 4370: Buginese, Buhid, Canadian_Aboriginal, Carian, Cham, Cherokee, Common,
! 4371: Coptic, Cuneiform, Cypriot, Cyrillic, Deseret, Devanagari, Egyp-
! 4372: tian_Hieroglyphs, Ethiopic, Georgian, Glagolitic, Gothic, Greek,
! 4373: Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew, Hiragana, Impe-
1.1 misho 4374: rial_Aramaic, Inherited, Inscriptional_Pahlavi, Inscriptional_Parthian,
1.1.1.2 ! misho 4375: Javanese, Kaithi, Kannada, Katakana, Kayah_Li, Kharoshthi, Khmer, Lao,
1.1 misho 4376: Latin, Lepcha, Limbu, Linear_B, Lisu, Lycian, Lydian, Malayalam,
1.1.1.2 ! misho 4377: Meetei_Mayek, Mongolian, Myanmar, New_Tai_Lue, Nko, Ogham, Old_Italic,
! 4378: Old_Persian, Old_South_Arabian, Old_Turkic, Ol_Chiki, Oriya, Osmanya,
! 4379: Phags_Pa, Phoenician, Rejang, Runic, Samaritan, Saurashtra, Shavian,
! 4380: Sinhala, Sundanese, Syloti_Nagri, Syriac, Tagalog, Tagbanwa, Tai_Le,
! 4381: Tai_Tham, Tai_Viet, Tamil, Telugu, Thaana, Thai, Tibetan, Tifinagh,
1.1 misho 4382: Ugaritic, Vai, Yi.
4383:
4384: Each character has exactly one Unicode general category property, spec-
1.1.1.2 ! misho 4385: ified by a two-letter abbreviation. For compatibility with Perl, nega-
! 4386: tion can be specified by including a circumflex between the opening
! 4387: brace and the property name. For example, \p{^Lu} is the same as
1.1 misho 4388: \P{Lu}.
4389:
4390: If only one letter is specified with \p or \P, it includes all the gen-
1.1.1.2 ! misho 4391: eral category properties that start with that letter. In this case, in
! 4392: the absence of negation, the curly brackets in the escape sequence are
1.1 misho 4393: optional; these two examples have the same effect:
4394:
4395: \p{L}
4396: \pL
4397:
4398: The following general category property codes are supported:
4399:
4400: C Other
4401: Cc Control
4402: Cf Format
4403: Cn Unassigned
4404: Co Private use
4405: Cs Surrogate
4406:
4407: L Letter
4408: Ll Lower case letter
4409: Lm Modifier letter
4410: Lo Other letter
4411: Lt Title case letter
4412: Lu Upper case letter
4413:
4414: M Mark
4415: Mc Spacing mark
4416: Me Enclosing mark
4417: Mn Non-spacing mark
4418:
4419: N Number
4420: Nd Decimal number
4421: Nl Letter number
4422: No Other number
4423:
4424: P Punctuation
4425: Pc Connector punctuation
4426: Pd Dash punctuation
4427: Pe Close punctuation
4428: Pf Final punctuation
4429: Pi Initial punctuation
4430: Po Other punctuation
4431: Ps Open punctuation
4432:
4433: S Symbol
4434: Sc Currency symbol
4435: Sk Modifier symbol
4436: Sm Mathematical symbol
4437: So Other symbol
4438:
4439: Z Separator
4440: Zl Line separator
4441: Zp Paragraph separator
4442: Zs Space separator
4443:
1.1.1.2 ! misho 4444: The special property L& is also supported: it matches a character that
! 4445: has the Lu, Ll, or Lt property, in other words, a letter that is not
1.1 misho 4446: classified as a modifier or "other".
4447:
1.1.1.2 ! misho 4448: The Cs (Surrogate) property applies only to characters in the range
! 4449: U+D800 to U+DFFF. Such characters are not valid in Unicode strings and
! 4450: so cannot be tested by PCRE, unless UTF validity checking has been
! 4451: turned off (see the discussion of PCRE_NO_UTF8_CHECK and
! 4452: PCRE_NO_UTF16_CHECK in the pcreapi page). Perl does not support the Cs
! 4453: property.
1.1 misho 4454:
4455: The long synonyms for property names that Perl supports (such as
4456: \p{Letter}) are not supported by PCRE, nor is it permitted to prefix
4457: any of these properties with "Is".
4458:
4459: No character that is in the Unicode table has the Cn (unassigned) prop-
4460: erty. Instead, this property is assumed for any code point that is not
4461: in the Unicode table.
4462:
4463: Specifying caseless matching does not affect these escape sequences.
4464: For example, \p{Lu} always matches only upper case letters.
4465:
4466: The \X escape matches any number of Unicode characters that form an
4467: extended Unicode sequence. \X is equivalent to
4468:
4469: (?>\PM\pM*)
4470:
4471: That is, it matches a character without the "mark" property, followed
4472: by zero or more characters with the "mark" property, and treats the
4473: sequence as an atomic group (see below). Characters with the "mark"
4474: property are typically accents that affect the preceding character.
1.1.1.2 ! misho 4475: None of them have codepoints less than 256, so in 8-bit non-UTF-8 mode
! 4476: \X matches any one character.
1.1 misho 4477:
4478: Note that recent versions of Perl have changed \X to match what Unicode
4479: calls an "extended grapheme cluster", which has a more complicated def-
4480: inition.
4481:
4482: Matching characters by Unicode property is not fast, because PCRE has
4483: to search a structure that contains data for over fifteen thousand
4484: characters. That is why the traditional escape sequences such as \d and
4485: \w do not use Unicode properties in PCRE by default, though you can
1.1.1.2 ! misho 4486: make them do so by setting the PCRE_UCP option or by starting the pat-
! 4487: tern with (*UCP).
1.1 misho 4488:
4489: PCRE's additional properties
4490:
4491: As well as the standard Unicode properties described in the previous
4492: section, PCRE supports four more that make it possible to convert tra-
4493: ditional escape sequences such as \w and \s and POSIX character classes
4494: to use Unicode properties. PCRE uses these non-standard, non-Perl prop-
4495: erties internally when PCRE_UCP is set. They are:
4496:
4497: Xan Any alphanumeric character
4498: Xps Any POSIX space character
4499: Xsp Any Perl space character
4500: Xwd Any Perl "word" character
4501:
4502: Xan matches characters that have either the L (letter) or the N (num-
4503: ber) property. Xps matches the characters tab, linefeed, vertical tab,
4504: formfeed, or carriage return, and any other character that has the Z
4505: (separator) property. Xsp is the same as Xps, except that vertical tab
4506: is excluded. Xwd matches the same characters as Xan, plus underscore.
4507:
4508: Resetting the match start
4509:
4510: The escape sequence \K causes any previously matched characters not to
4511: be included in the final matched sequence. For example, the pattern:
4512:
4513: foo\Kbar
4514:
4515: matches "foobar", but reports that it has matched "bar". This feature
4516: is similar to a lookbehind assertion (described below). However, in
4517: this case, the part of the subject before the real match does not have
4518: to be of fixed length, as lookbehind assertions do. The use of \K does
4519: not interfere with the setting of captured substrings. For example,
4520: when the pattern
4521:
4522: (foo)\Kbar
4523:
4524: matches "foobar", the first substring is still set to "foo".
4525:
4526: Perl documents that the use of \K within assertions is "not well
4527: defined". In PCRE, \K is acted upon when it occurs inside positive
4528: assertions, but is ignored in negative assertions.
4529:
4530: Simple assertions
4531:
4532: The final use of backslash is for certain simple assertions. An asser-
4533: tion specifies a condition that has to be met at a particular point in
4534: a match, without consuming any characters from the subject string. The
4535: use of subpatterns for more complicated assertions is described below.
4536: The backslashed assertions are:
4537:
4538: \b matches at a word boundary
4539: \B matches when not at a word boundary
4540: \A matches at the start of the subject
4541: \Z matches at the end of the subject
4542: also matches before a newline at the end of the subject
4543: \z matches only at the end of the subject
4544: \G matches at the first matching position in the subject
4545:
4546: Inside a character class, \b has a different meaning; it matches the
4547: backspace character. If any other of these assertions appears in a
4548: character class, by default it matches the corresponding literal char-
4549: acter (for example, \B matches the letter B). However, if the
4550: PCRE_EXTRA option is set, an "invalid escape sequence" error is gener-
4551: ated instead.
4552:
4553: A word boundary is a position in the subject string where the current
4554: character and the previous character do not both match \w or \W (i.e.
4555: one matches \w and the other matches \W), or the start or end of the
1.1.1.2 ! misho 4556: string if the first or last character matches \w, respectively. In a
! 4557: UTF mode, the meanings of \w and \W can be changed by setting the
1.1 misho 4558: PCRE_UCP option. When this is done, it also affects \b and \B. Neither
4559: PCRE nor Perl has a separate "start of word" or "end of word" metase-
4560: quence. However, whatever follows \b normally determines which it is.
4561: For example, the fragment \ba matches "a" at the start of a word.
4562:
4563: The \A, \Z, and \z assertions differ from the traditional circumflex
4564: and dollar (described in the next section) in that they only ever match
4565: at the very start and end of the subject string, whatever options are
4566: set. Thus, they are independent of multiline mode. These three asser-
4567: tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
4568: affect only the behaviour of the circumflex and dollar metacharacters.
4569: However, if the startoffset argument of pcre_exec() is non-zero, indi-
4570: cating that matching is to start at a point other than the beginning of
4571: the subject, \A can never match. The difference between \Z and \z is
4572: that \Z matches before a newline at the end of the string as well as at
4573: the very end, whereas \z matches only at the end.
4574:
4575: The \G assertion is true only when the current matching position is at
4576: the start point of the match, as specified by the startoffset argument
4577: of pcre_exec(). It differs from \A when the value of startoffset is
4578: non-zero. By calling pcre_exec() multiple times with appropriate argu-
4579: ments, you can mimic Perl's /g option, and it is in this kind of imple-
4580: mentation where \G can be useful.
4581:
4582: Note, however, that PCRE's interpretation of \G, as the start of the
4583: current match, is subtly different from Perl's, which defines it as the
4584: end of the previous match. In Perl, these can be different when the
4585: previously matched string was empty. Because PCRE does just one match
4586: at a time, it cannot reproduce this behaviour.
4587:
4588: If all the alternatives of a pattern begin with \G, the expression is
4589: anchored to the starting match position, and the "anchored" flag is set
4590: in the compiled regular expression.
4591:
4592:
4593: CIRCUMFLEX AND DOLLAR
4594:
4595: Outside a character class, in the default matching mode, the circumflex
4596: character is an assertion that is true only if the current matching
4597: point is at the start of the subject string. If the startoffset argu-
4598: ment of pcre_exec() is non-zero, circumflex can never match if the
4599: PCRE_MULTILINE option is unset. Inside a character class, circumflex
4600: has an entirely different meaning (see below).
4601:
4602: Circumflex need not be the first character of the pattern if a number
4603: of alternatives are involved, but it should be the first thing in each
4604: alternative in which it appears if the pattern is ever to match that
4605: branch. If all possible alternatives start with a circumflex, that is,
4606: if the pattern is constrained to match only at the start of the sub-
4607: ject, it is said to be an "anchored" pattern. (There are also other
4608: constructs that can cause a pattern to be anchored.)
4609:
4610: A dollar character is an assertion that is true only if the current
4611: matching point is at the end of the subject string, or immediately
4612: before a newline at the end of the string (by default). Dollar need not
4613: be the last character of the pattern if a number of alternatives are
4614: involved, but it should be the last item in any branch in which it
4615: appears. Dollar has no special meaning in a character class.
4616:
4617: The meaning of dollar can be changed so that it matches only at the
4618: very end of the string, by setting the PCRE_DOLLAR_ENDONLY option at
4619: compile time. This does not affect the \Z assertion.
4620:
4621: The meanings of the circumflex and dollar characters are changed if the
4622: PCRE_MULTILINE option is set. When this is the case, a circumflex
4623: matches immediately after internal newlines as well as at the start of
4624: the subject string. It does not match after a newline that ends the
4625: string. A dollar matches before any newlines in the string, as well as
4626: at the very end, when PCRE_MULTILINE is set. When newline is specified
4627: as the two-character sequence CRLF, isolated CR and LF characters do
4628: not indicate newlines.
4629:
4630: For example, the pattern /^abc$/ matches the subject string "def\nabc"
4631: (where \n represents a newline) in multiline mode, but not otherwise.
4632: Consequently, patterns that are anchored in single line mode because
4633: all branches start with ^ are not anchored in multiline mode, and a
4634: match for circumflex is possible when the startoffset argument of
4635: pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if
4636: PCRE_MULTILINE is set.
4637:
4638: Note that the sequences \A, \Z, and \z can be used to match the start
4639: and end of the subject in both modes, and if all branches of a pattern
4640: start with \A it is always anchored, whether or not PCRE_MULTILINE is
4641: set.
4642:
4643:
4644: FULL STOP (PERIOD, DOT) AND \N
4645:
4646: Outside a character class, a dot in the pattern matches any one charac-
4647: ter in the subject string except (by default) a character that signi-
1.1.1.2 ! misho 4648: fies the end of a line.
1.1 misho 4649:
1.1.1.2 ! misho 4650: When a line ending is defined as a single character, dot never matches
! 4651: that character; when the two-character sequence CRLF is used, dot does
! 4652: not match CR if it is immediately followed by LF, but otherwise it
! 4653: matches all characters (including isolated CRs and LFs). When any Uni-
! 4654: code line endings are being recognized, dot does not match CR or LF or
1.1 misho 4655: any of the other line ending characters.
4656:
1.1.1.2 ! misho 4657: The behaviour of dot with regard to newlines can be changed. If the
! 4658: PCRE_DOTALL option is set, a dot matches any one character, without
1.1 misho 4659: exception. If the two-character sequence CRLF is present in the subject
4660: string, it takes two dots to match it.
4661:
1.1.1.2 ! misho 4662: The handling of dot is entirely independent of the handling of circum-
! 4663: flex and dollar, the only relationship being that they both involve
1.1 misho 4664: newlines. Dot has no special meaning in a character class.
4665:
1.1.1.2 ! misho 4666: The escape sequence \N behaves like a dot, except that it is not
! 4667: affected by the PCRE_DOTALL option. In other words, it matches any
! 4668: character except one that signifies the end of a line. Perl also uses
1.1 misho 4669: \N to match characters by name; PCRE does not support this.
4670:
4671:
1.1.1.2 ! misho 4672: MATCHING A SINGLE DATA UNIT
1.1 misho 4673:
1.1.1.2 ! misho 4674: Outside a character class, the escape sequence \C matches any one data
! 4675: unit, whether or not a UTF mode is set. In the 8-bit library, one data
! 4676: unit is one byte; in the 16-bit library it is a 16-bit unit. Unlike a
! 4677: dot, \C always matches line-ending characters. The feature is provided
! 4678: in Perl in order to match individual bytes in UTF-8 mode, but it is
! 4679: unclear how it can usefully be used. Because \C breaks up characters
! 4680: into individual data units, matching one unit with \C in a UTF mode
! 4681: means that the rest of the string may start with a malformed UTF char-
! 4682: acter. This has undefined results, because PCRE assumes that it is
! 4683: dealing with valid UTF strings (and by default it checks this at the
! 4684: start of processing unless the PCRE_NO_UTF8_CHECK option is used).
1.1 misho 4685:
4686: PCRE does not allow \C to appear in lookbehind assertions (described
1.1.1.2 ! misho 4687: below) in a UTF mode, because this would make it impossible to calcu-
1.1 misho 4688: late the length of the lookbehind.
4689:
1.1.1.2 ! misho 4690: In general, the \C escape sequence is best avoided. However, one way of
! 4691: using it that avoids the problem of malformed UTF characters is to use
! 4692: a lookahead to check the length of the next character, as in this pat-
! 4693: tern, which could be used with a UTF-8 string (ignore white space and
! 4694: line breaks):
1.1 misho 4695:
4696: (?| (?=[\x00-\x7f])(\C) |
4697: (?=[\x80-\x{7ff}])(\C)(\C) |
4698: (?=[\x{800}-\x{ffff}])(\C)(\C)(\C) |
4699: (?=[\x{10000}-\x{1fffff}])(\C)(\C)(\C)(\C))
4700:
1.1.1.2 ! misho 4701: A group that starts with (?| resets the capturing parentheses numbers
! 4702: in each alternative (see "Duplicate Subpattern Numbers" below). The
! 4703: assertions at the start of each branch check the next UTF-8 character
! 4704: for values whose encoding uses 1, 2, 3, or 4 bytes, respectively. The
! 4705: character's individual bytes are then captured by the appropriate num-
1.1 misho 4706: ber of groups.
4707:
4708:
4709: SQUARE BRACKETS AND CHARACTER CLASSES
4710:
4711: An opening square bracket introduces a character class, terminated by a
4712: closing square bracket. A closing square bracket on its own is not spe-
4713: cial by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set,
4714: a lone closing square bracket causes a compile-time error. If a closing
1.1.1.2 ! misho 4715: square bracket is required as a member of the class, it should be the
! 4716: first data character in the class (after an initial circumflex, if
1.1 misho 4717: present) or escaped with a backslash.
4718:
1.1.1.2 ! misho 4719: A character class matches a single character in the subject. In a UTF
! 4720: mode, the character may be more than one data unit long. A matched
! 4721: character must be in the set of characters defined by the class, unless
! 4722: the first character in the class definition is a circumflex, in which
! 4723: case the subject character must not be in the set defined by the class.
! 4724: If a circumflex is actually required as a member of the class, ensure
! 4725: it is not the first character, or escape it with a backslash.
1.1 misho 4726:
1.1.1.2 ! misho 4727: For example, the character class [aeiou] matches any lower case vowel,
! 4728: while [^aeiou] matches any character that is not a lower case vowel.
1.1 misho 4729: Note that a circumflex is just a convenient notation for specifying the
1.1.1.2 ! misho 4730: characters that are in the class by enumerating those that are not. A
! 4731: class that starts with a circumflex is not an assertion; it still con-
! 4732: sumes a character from the subject string, and therefore it fails if
1.1 misho 4733: the current pointer is at the end of the string.
4734:
1.1.1.2 ! misho 4735: In UTF-8 (UTF-16) mode, characters with values greater than 255
! 4736: (0xffff) can be included in a class as a literal string of data units,
! 4737: or by using the \x{ escaping mechanism.
! 4738:
! 4739: When caseless matching is set, any letters in a class represent both
! 4740: their upper case and lower case versions, so for example, a caseless
! 4741: [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
! 4742: match "A", whereas a caseful version would. In a UTF mode, PCRE always
! 4743: understands the concept of case for characters whose values are less
! 4744: than 128, so caseless matching is always possible. For characters with
! 4745: higher values, the concept of case is supported if PCRE is compiled
! 4746: with Unicode property support, but not otherwise. If you want to use
! 4747: caseless matching in a UTF mode for characters 128 and above, you must
! 4748: ensure that PCRE is compiled with Unicode property support as well as
! 4749: with UTF support.
! 4750:
! 4751: Characters that might indicate line breaks are never treated in any
! 4752: special way when matching character classes, whatever line-ending
! 4753: sequence is in use, and whatever setting of the PCRE_DOTALL and
1.1 misho 4754: PCRE_MULTILINE options is used. A class such as [^a] always matches one
4755: of these characters.
4756:
1.1.1.2 ! misho 4757: The minus (hyphen) character can be used to specify a range of charac-
! 4758: ters in a character class. For example, [d-m] matches any letter
! 4759: between d and m, inclusive. If a minus character is required in a
! 4760: class, it must be escaped with a backslash or appear in a position
! 4761: where it cannot be interpreted as indicating a range, typically as the
1.1 misho 4762: first or last character in the class.
4763:
4764: It is not possible to have the literal character "]" as the end charac-
1.1.1.2 ! misho 4765: ter of a range. A pattern such as [W-]46] is interpreted as a class of
! 4766: two characters ("W" and "-") followed by a literal string "46]", so it
! 4767: would match "W46]" or "-46]". However, if the "]" is escaped with a
! 4768: backslash it is interpreted as the end of range, so [W-\]46] is inter-
! 4769: preted as a class containing a range followed by two other characters.
! 4770: The octal or hexadecimal representation of "]" can also be used to end
1.1 misho 4771: a range.
4772:
1.1.1.2 ! misho 4773: Ranges operate in the collating sequence of character values. They can
! 4774: also be used for characters specified numerically, for example
! 4775: [\000-\037]. Ranges can include any characters that are valid for the
! 4776: current mode.
1.1 misho 4777:
4778: If a range that includes letters is used when caseless matching is set,
4779: it matches the letters in either case. For example, [W-c] is equivalent
1.1.1.2 ! misho 4780: to [][\\^_`wxyzabc], matched caselessly, and in a non-UTF mode, if
! 4781: character tables for a French locale are in use, [\xc8-\xcb] matches
! 4782: accented E characters in both cases. In UTF modes, PCRE supports the
! 4783: concept of case for characters with values greater than 128 only when
1.1 misho 4784: it is compiled with Unicode property support.
4785:
1.1.1.2 ! misho 4786: The character escape sequences \d, \D, \h, \H, \p, \P, \s, \S, \v, \V,
1.1 misho 4787: \w, and \W may appear in a character class, and add the characters that
1.1.1.2 ! misho 4788: they match to the class. For example, [\dABCDEF] matches any hexadeci-
! 4789: mal digit. In UTF modes, the PCRE_UCP option affects the meanings of
! 4790: \d, \s, \w and their upper case partners, just as it does when they
! 4791: appear outside a character class, as described in the section entitled
1.1 misho 4792: "Generic character types" above. The escape sequence \b has a different
1.1.1.2 ! misho 4793: meaning inside a character class; it matches the backspace character.
! 4794: The sequences \B, \N, \R, and \X are not special inside a character
! 4795: class. Like any other unrecognized escape sequences, they are treated
! 4796: as the literal characters "B", "N", "R", and "X" by default, but cause
1.1 misho 4797: an error if the PCRE_EXTRA option is set.
4798:
1.1.1.2 ! misho 4799: A circumflex can conveniently be used with the upper case character
! 4800: types to specify a more restricted set of characters than the matching
! 4801: lower case type. For example, the class [^\W_] matches any letter or
1.1 misho 4802: digit, but not underscore, whereas [\w] includes underscore. A positive
4803: character class should be read as "something OR something OR ..." and a
4804: negative class as "NOT something AND NOT something AND NOT ...".
4805:
1.1.1.2 ! misho 4806: The only metacharacters that are recognized in character classes are
! 4807: backslash, hyphen (only where it can be interpreted as specifying a
! 4808: range), circumflex (only at the start), opening square bracket (only
! 4809: when it can be interpreted as introducing a POSIX class name - see the
! 4810: next section), and the terminating closing square bracket. However,
1.1 misho 4811: escaping other non-alphanumeric characters does no harm.
4812:
4813:
4814: POSIX CHARACTER CLASSES
4815:
4816: Perl supports the POSIX notation for character classes. This uses names
1.1.1.2 ! misho 4817: enclosed by [: and :] within the enclosing square brackets. PCRE also
1.1 misho 4818: supports this notation. For example,
4819:
4820: [01[:alpha:]%]
4821:
4822: matches "0", "1", any alphabetic character, or "%". The supported class
4823: names are:
4824:
4825: alnum letters and digits
4826: alpha letters
4827: ascii character codes 0 - 127
4828: blank space or tab only
4829: cntrl control characters
4830: digit decimal digits (same as \d)
4831: graph printing characters, excluding space
4832: lower lower case letters
4833: print printing characters, including space
4834: punct printing characters, excluding letters and digits and space
4835: space white space (not quite the same as \s)
4836: upper upper case letters
4837: word "word" characters (same as \w)
4838: xdigit hexadecimal digits
4839:
1.1.1.2 ! misho 4840: The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
! 4841: and space (32). Notice that this list includes the VT character (code
1.1 misho 4842: 11). This makes "space" different to \s, which does not include VT (for
4843: Perl compatibility).
4844:
1.1.1.2 ! misho 4845: The name "word" is a Perl extension, and "blank" is a GNU extension
! 4846: from Perl 5.8. Another Perl extension is negation, which is indicated
1.1 misho 4847: by a ^ character after the colon. For example,
4848:
4849: [12[:^digit:]]
4850:
1.1.1.2 ! misho 4851: matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the
1.1 misho 4852: POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
4853: these are not supported, and an error is given if they are encountered.
4854:
1.1.1.2 ! misho 4855: By default, in UTF modes, characters with values greater than 128 do
! 4856: not match any of the POSIX character classes. However, if the PCRE_UCP
! 4857: option is passed to pcre_compile(), some of the classes are changed so
1.1 misho 4858: that Unicode character properties are used. This is achieved by replac-
4859: ing the POSIX classes by other sequences, as follows:
4860:
4861: [:alnum:] becomes \p{Xan}
4862: [:alpha:] becomes \p{L}
4863: [:blank:] becomes \h
4864: [:digit:] becomes \p{Nd}
4865: [:lower:] becomes \p{Ll}
4866: [:space:] becomes \p{Xps}
4867: [:upper:] becomes \p{Lu}
4868: [:word:] becomes \p{Xwd}
4869:
1.1.1.2 ! misho 4870: Negated versions, such as [:^alpha:] use \P instead of \p. The other
1.1 misho 4871: POSIX classes are unchanged, and match only characters with code points
4872: less than 128.
4873:
4874:
4875: VERTICAL BAR
4876:
1.1.1.2 ! misho 4877: Vertical bar characters are used to separate alternative patterns. For
1.1 misho 4878: example, the pattern
4879:
4880: gilbert|sullivan
4881:
1.1.1.2 ! misho 4882: matches either "gilbert" or "sullivan". Any number of alternatives may
! 4883: appear, and an empty alternative is permitted (matching the empty
1.1 misho 4884: string). The matching process tries each alternative in turn, from left
1.1.1.2 ! misho 4885: to right, and the first one that succeeds is used. If the alternatives
! 4886: are within a subpattern (defined below), "succeeds" means matching the
1.1 misho 4887: rest of the main pattern as well as the alternative in the subpattern.
4888:
4889:
4890: INTERNAL OPTION SETTING
4891:
1.1.1.2 ! misho 4892: The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
! 4893: PCRE_EXTENDED options (which are Perl-compatible) can be changed from
! 4894: within the pattern by a sequence of Perl option letters enclosed
1.1 misho 4895: between "(?" and ")". The option letters are
4896:
4897: i for PCRE_CASELESS
4898: m for PCRE_MULTILINE
4899: s for PCRE_DOTALL
4900: x for PCRE_EXTENDED
4901:
4902: For example, (?im) sets caseless, multiline matching. It is also possi-
4903: ble to unset these options by preceding the letter with a hyphen, and a
1.1.1.2 ! misho 4904: combined setting and unsetting such as (?im-sx), which sets PCRE_CASE-
! 4905: LESS and PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED,
! 4906: is also permitted. If a letter appears both before and after the
1.1 misho 4907: hyphen, the option is unset.
4908:
1.1.1.2 ! misho 4909: The PCRE-specific options PCRE_DUPNAMES, PCRE_UNGREEDY, and PCRE_EXTRA
! 4910: can be changed in the same way as the Perl-compatible options by using
1.1 misho 4911: the characters J, U and X respectively.
4912:
1.1.1.2 ! misho 4913: When one of these option changes occurs at top level (that is, not
! 4914: inside subpattern parentheses), the change applies to the remainder of
1.1 misho 4915: the pattern that follows. If the change is placed right at the start of
4916: a pattern, PCRE extracts it into the global options (and it will there-
4917: fore show up in data extracted by the pcre_fullinfo() function).
4918:
1.1.1.2 ! misho 4919: An option change within a subpattern (see below for a description of
! 4920: subpatterns) affects only that part of the subpattern that follows it,
1.1 misho 4921: so
4922:
4923: (a(?i)b)c
4924:
4925: matches abc and aBc and no other strings (assuming PCRE_CASELESS is not
1.1.1.2 ! misho 4926: used). By this means, options can be made to have different settings
! 4927: in different parts of the pattern. Any changes made in one alternative
! 4928: do carry on into subsequent branches within the same subpattern. For
1.1 misho 4929: example,
4930:
4931: (a(?i)b|c)
4932:
1.1.1.2 ! misho 4933: matches "ab", "aB", "c", and "C", even though when matching "C" the
! 4934: first branch is abandoned before the option setting. This is because
! 4935: the effects of option settings happen at compile time. There would be
1.1 misho 4936: some very weird behaviour otherwise.
4937:
1.1.1.2 ! misho 4938: Note: There are other PCRE-specific options that can be set by the
! 4939: application when the compiling or matching functions are called. In
! 4940: some cases the pattern can contain special leading sequences such as
! 4941: (*CRLF) to override what the application has set or what has been
! 4942: defaulted. Details are given in the section entitled "Newline
! 4943: sequences" above. There are also the (*UTF8), (*UTF16), and (*UCP)
! 4944: leading sequences that can be used to set UTF and Unicode property
! 4945: modes; they are equivalent to setting the PCRE_UTF8, PCRE_UTF16, and
! 4946: the PCRE_UCP options, respectively.
1.1 misho 4947:
4948:
4949: SUBPATTERNS
4950:
4951: Subpatterns are delimited by parentheses (round brackets), which can be
4952: nested. Turning part of a pattern into a subpattern does two things:
4953:
4954: 1. It localizes a set of alternatives. For example, the pattern
4955:
4956: cat(aract|erpillar|)
4957:
4958: matches "cataract", "caterpillar", or "cat". Without the parentheses,
4959: it would match "cataract", "erpillar" or an empty string.
4960:
4961: 2. It sets up the subpattern as a capturing subpattern. This means
4962: that, when the whole pattern matches, that portion of the subject
4963: string that matched the subpattern is passed back to the caller via the
1.1.1.2 ! misho 4964: ovector argument of the matching function. (This applies only to the
! 4965: traditional matching functions; the DFA matching functions do not sup-
! 4966: port capturing.)
! 4967:
! 4968: Opening parentheses are counted from left to right (starting from 1) to
! 4969: obtain numbers for the capturing subpatterns. For example, if the
! 4970: string "the red king" is matched against the pattern
1.1 misho 4971:
4972: the ((red|white) (king|queen))
4973:
4974: the captured substrings are "red king", "red", and "king", and are num-
4975: bered 1, 2, and 3, respectively.
4976:
1.1.1.2 ! misho 4977: The fact that plain parentheses fulfil two functions is not always
! 4978: helpful. There are often times when a grouping subpattern is required
! 4979: without a capturing requirement. If an opening parenthesis is followed
! 4980: by a question mark and a colon, the subpattern does not do any captur-
! 4981: ing, and is not counted when computing the number of any subsequent
! 4982: capturing subpatterns. For example, if the string "the white queen" is
1.1 misho 4983: matched against the pattern
4984:
4985: the ((?:red|white) (king|queen))
4986:
4987: the captured substrings are "white queen" and "queen", and are numbered
4988: 1 and 2. The maximum number of capturing subpatterns is 65535.
4989:
1.1.1.2 ! misho 4990: As a convenient shorthand, if any option settings are required at the
! 4991: start of a non-capturing subpattern, the option letters may appear
1.1 misho 4992: between the "?" and the ":". Thus the two patterns
4993:
4994: (?i:saturday|sunday)
4995: (?:(?i)saturday|sunday)
4996:
4997: match exactly the same set of strings. Because alternative branches are
1.1.1.2 ! misho 4998: tried from left to right, and options are not reset until the end of
! 4999: the subpattern is reached, an option setting in one branch does affect
! 5000: subsequent branches, so the above patterns match "SUNDAY" as well as
1.1 misho 5001: "Saturday".
5002:
5003:
5004: DUPLICATE SUBPATTERN NUMBERS
5005:
5006: Perl 5.10 introduced a feature whereby each alternative in a subpattern
1.1.1.2 ! misho 5007: uses the same numbers for its capturing parentheses. Such a subpattern
! 5008: starts with (?| and is itself a non-capturing subpattern. For example,
1.1 misho 5009: consider this pattern:
5010:
5011: (?|(Sat)ur|(Sun))day
5012:
1.1.1.2 ! misho 5013: Because the two alternatives are inside a (?| group, both sets of cap-
! 5014: turing parentheses are numbered one. Thus, when the pattern matches,
! 5015: you can look at captured substring number one, whichever alternative
! 5016: matched. This construct is useful when you want to capture part, but
1.1 misho 5017: not all, of one of a number of alternatives. Inside a (?| group, paren-
1.1.1.2 ! misho 5018: theses are numbered as usual, but the number is reset at the start of
! 5019: each branch. The numbers of any capturing parentheses that follow the
! 5020: subpattern start after the highest number used in any branch. The fol-
1.1 misho 5021: lowing example is taken from the Perl documentation. The numbers under-
5022: neath show in which buffer the captured content will be stored.
5023:
5024: # before ---------------branch-reset----------- after
5025: / ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
5026: # 1 2 2 3 2 3 4
5027:
1.1.1.2 ! misho 5028: A back reference to a numbered subpattern uses the most recent value
! 5029: that is set for that number by any subpattern. The following pattern
1.1 misho 5030: matches "abcabc" or "defdef":
5031:
5032: /(?|(abc)|(def))\1/
5033:
1.1.1.2 ! misho 5034: In contrast, a subroutine call to a numbered subpattern always refers
! 5035: to the first one in the pattern with the given number. The following
1.1 misho 5036: pattern matches "abcabc" or "defabc":
5037:
5038: /(?|(abc)|(def))(?1)/
5039:
1.1.1.2 ! misho 5040: If a condition test for a subpattern's having matched refers to a non-
! 5041: unique number, the test is true if any of the subpatterns of that num-
1.1 misho 5042: ber have matched.
5043:
1.1.1.2 ! misho 5044: An alternative approach to using this "branch reset" feature is to use
1.1 misho 5045: duplicate named subpatterns, as described in the next section.
5046:
5047:
5048: NAMED SUBPATTERNS
5049:
1.1.1.2 ! misho 5050: Identifying capturing parentheses by number is simple, but it can be
! 5051: very hard to keep track of the numbers in complicated regular expres-
! 5052: sions. Furthermore, if an expression is modified, the numbers may
! 5053: change. To help with this difficulty, PCRE supports the naming of sub-
1.1 misho 5054: patterns. This feature was not added to Perl until release 5.10. Python
1.1.1.2 ! misho 5055: had the feature earlier, and PCRE introduced it at release 4.0, using
! 5056: the Python syntax. PCRE now supports both the Perl and the Python syn-
! 5057: tax. Perl allows identically numbered subpatterns to have different
1.1 misho 5058: names, but PCRE does not.
5059:
1.1.1.2 ! misho 5060: In PCRE, a subpattern can be named in one of three ways: (?<name>...)
! 5061: or (?'name'...) as in Perl, or (?P<name>...) as in Python. References
! 5062: to capturing parentheses from other parts of the pattern, such as back
! 5063: references, recursion, and conditions, can be made by name as well as
1.1 misho 5064: by number.
5065:
1.1.1.2 ! misho 5066: Names consist of up to 32 alphanumeric characters and underscores.
! 5067: Named capturing parentheses are still allocated numbers as well as
! 5068: names, exactly as if the names were not present. The PCRE API provides
1.1 misho 5069: function calls for extracting the name-to-number translation table from
5070: a compiled pattern. There is also a convenience function for extracting
5071: a captured substring by name.
5072:
1.1.1.2 ! misho 5073: By default, a name must be unique within a pattern, but it is possible
1.1 misho 5074: to relax this constraint by setting the PCRE_DUPNAMES option at compile
1.1.1.2 ! misho 5075: time. (Duplicate names are also always permitted for subpatterns with
! 5076: the same number, set up as described in the previous section.) Dupli-
! 5077: cate names can be useful for patterns where only one instance of the
! 5078: named parentheses can match. Suppose you want to match the name of a
! 5079: weekday, either as a 3-letter abbreviation or as the full name, and in
1.1 misho 5080: both cases you want to extract the abbreviation. This pattern (ignoring
5081: the line breaks) does the job:
5082:
5083: (?<DN>Mon|Fri|Sun)(?:day)?|
5084: (?<DN>Tue)(?:sday)?|
5085: (?<DN>Wed)(?:nesday)?|
5086: (?<DN>Thu)(?:rsday)?|
5087: (?<DN>Sat)(?:urday)?
5088:
1.1.1.2 ! misho 5089: There are five capturing substrings, but only one is ever set after a
1.1 misho 5090: match. (An alternative way of solving this problem is to use a "branch
5091: reset" subpattern, as described in the previous section.)
5092:
1.1.1.2 ! misho 5093: The convenience function for extracting the data by name returns the
! 5094: substring for the first (and in this example, the only) subpattern of
! 5095: that name that matched. This saves searching to find which numbered
1.1 misho 5096: subpattern it was.
5097:
1.1.1.2 ! misho 5098: If you make a back reference to a non-unique named subpattern from
! 5099: elsewhere in the pattern, the one that corresponds to the first occur-
1.1 misho 5100: rence of the name is used. In the absence of duplicate numbers (see the
1.1.1.2 ! misho 5101: previous section) this is the one with the lowest number. If you use a
! 5102: named reference in a condition test (see the section about conditions
! 5103: below), either to check whether a subpattern has matched, or to check
! 5104: for recursion, all subpatterns with the same name are tested. If the
! 5105: condition is true for any one of them, the overall condition is true.
1.1 misho 5106: This is the same behaviour as testing by number. For further details of
5107: the interfaces for handling named subpatterns, see the pcreapi documen-
5108: tation.
5109:
5110: Warning: You cannot use different names to distinguish between two sub-
1.1.1.2 ! misho 5111: patterns with the same number because PCRE uses only the numbers when
1.1 misho 5112: matching. For this reason, an error is given at compile time if differ-
1.1.1.2 ! misho 5113: ent names are given to subpatterns with the same number. However, you
! 5114: can give the same name to subpatterns with the same number, even when
1.1 misho 5115: PCRE_DUPNAMES is not set.
5116:
5117:
5118: REPETITION
5119:
1.1.1.2 ! misho 5120: Repetition is specified by quantifiers, which can follow any of the
1.1 misho 5121: following items:
5122:
5123: a literal data character
5124: the dot metacharacter
5125: the \C escape sequence
1.1.1.2 ! misho 5126: the \X escape sequence
1.1 misho 5127: the \R escape sequence
5128: an escape such as \d or \pL that matches a single character
5129: a character class
5130: a back reference (see next section)
5131: a parenthesized subpattern (including assertions)
5132: a subroutine call to a subpattern (recursive or otherwise)
5133:
1.1.1.2 ! misho 5134: The general repetition quantifier specifies a minimum and maximum num-
! 5135: ber of permitted matches, by giving the two numbers in curly brackets
! 5136: (braces), separated by a comma. The numbers must be less than 65536,
1.1 misho 5137: and the first must be less than or equal to the second. For example:
5138:
5139: z{2,4}
5140:
1.1.1.2 ! misho 5141: matches "zz", "zzz", or "zzzz". A closing brace on its own is not a
! 5142: special character. If the second number is omitted, but the comma is
! 5143: present, there is no upper limit; if the second number and the comma
! 5144: are both omitted, the quantifier specifies an exact number of required
1.1 misho 5145: matches. Thus
5146:
5147: [aeiou]{3,}
5148:
5149: matches at least 3 successive vowels, but may match many more, while
5150:
5151: \d{8}
5152:
1.1.1.2 ! misho 5153: matches exactly 8 digits. An opening curly bracket that appears in a
! 5154: position where a quantifier is not allowed, or one that does not match
! 5155: the syntax of a quantifier, is taken as a literal character. For exam-
1.1 misho 5156: ple, {,6} is not a quantifier, but a literal string of four characters.
5157:
1.1.1.2 ! misho 5158: In UTF modes, quantifiers apply to characters rather than to individual
! 5159: data units. Thus, for example, \x{100}{2} matches two characters, each
! 5160: of which is represented by a two-byte sequence in a UTF-8 string. Simi-
! 5161: larly, \X{3} matches three Unicode extended sequences, each of which
! 5162: may be several data units long (and they may be of different lengths).
1.1 misho 5163:
5164: The quantifier {0} is permitted, causing the expression to behave as if
5165: the previous item and the quantifier were not present. This may be use-
5166: ful for subpatterns that are referenced as subroutines from elsewhere
5167: in the pattern (but see also the section entitled "Defining subpatterns
5168: for use by reference only" below). Items other than subpatterns that
5169: have a {0} quantifier are omitted from the compiled pattern.
5170:
5171: For convenience, the three most common quantifiers have single-charac-
5172: ter abbreviations:
5173:
5174: * is equivalent to {0,}
5175: + is equivalent to {1,}
5176: ? is equivalent to {0,1}
5177:
5178: It is possible to construct infinite loops by following a subpattern
5179: that can match no characters with a quantifier that has no upper limit,
5180: for example:
5181:
5182: (a?)*
5183:
5184: Earlier versions of Perl and PCRE used to give an error at compile time
5185: for such patterns. However, because there are cases where this can be
5186: useful, such patterns are now accepted, but if any repetition of the
5187: subpattern does in fact match no characters, the loop is forcibly bro-
5188: ken.
5189:
5190: By default, the quantifiers are "greedy", that is, they match as much
5191: as possible (up to the maximum number of permitted times), without
5192: causing the rest of the pattern to fail. The classic example of where
5193: this gives problems is in trying to match comments in C programs. These
5194: appear between /* and */ and within the comment, individual * and /
5195: characters may appear. An attempt to match C comments by applying the
5196: pattern
5197:
5198: /\*.*\*/
5199:
5200: to the string
5201:
5202: /* first comment */ not comment /* second comment */
5203:
5204: fails, because it matches the entire string owing to the greediness of
5205: the .* item.
5206:
5207: However, if a quantifier is followed by a question mark, it ceases to
5208: be greedy, and instead matches the minimum number of times possible, so
5209: the pattern
5210:
5211: /\*.*?\*/
5212:
5213: does the right thing with the C comments. The meaning of the various
5214: quantifiers is not otherwise changed, just the preferred number of
5215: matches. Do not confuse this use of question mark with its use as a
5216: quantifier in its own right. Because it has two uses, it can sometimes
5217: appear doubled, as in
5218:
5219: \d??\d
5220:
5221: which matches one digit by preference, but can match two if that is the
5222: only way the rest of the pattern matches.
5223:
5224: If the PCRE_UNGREEDY option is set (an option that is not available in
5225: Perl), the quantifiers are not greedy by default, but individual ones
5226: can be made greedy by following them with a question mark. In other
5227: words, it inverts the default behaviour.
5228:
5229: When a parenthesized subpattern is quantified with a minimum repeat
5230: count that is greater than 1 or with a limited maximum, more memory is
5231: required for the compiled pattern, in proportion to the size of the
5232: minimum or maximum.
5233:
5234: If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equiv-
5235: alent to Perl's /s) is set, thus allowing the dot to match newlines,
5236: the pattern is implicitly anchored, because whatever follows will be
5237: tried against every character position in the subject string, so there
5238: is no point in retrying the overall match at any position after the
5239: first. PCRE normally treats such a pattern as though it were preceded
5240: by \A.
5241:
5242: In cases where it is known that the subject string contains no new-
5243: lines, it is worth setting PCRE_DOTALL in order to obtain this opti-
5244: mization, or alternatively using ^ to indicate anchoring explicitly.
5245:
5246: However, there is one situation where the optimization cannot be used.
5247: When .* is inside capturing parentheses that are the subject of a back
5248: reference elsewhere in the pattern, a match at the start may fail where
5249: a later one succeeds. Consider, for example:
5250:
5251: (.*)abc\1
5252:
5253: If the subject is "xyz123abc123" the match point is the fourth charac-
5254: ter. For this reason, such a pattern is not implicitly anchored.
5255:
5256: When a capturing subpattern is repeated, the value captured is the sub-
5257: string that matched the final iteration. For example, after
5258:
5259: (tweedle[dume]{3}\s*)+
5260:
5261: has matched "tweedledum tweedledee" the value of the captured substring
5262: is "tweedledee". However, if there are nested capturing subpatterns,
5263: the corresponding captured values may have been set in previous itera-
5264: tions. For example, after
5265:
5266: /(a|(b))+/
5267:
5268: matches "aba" the value of the second captured substring is "b".
5269:
5270:
5271: ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS
5272:
5273: With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
5274: repetition, failure of what follows normally causes the repeated item
5275: to be re-evaluated to see if a different number of repeats allows the
5276: rest of the pattern to match. Sometimes it is useful to prevent this,
5277: either to change the nature of the match, or to cause it fail earlier
5278: than it otherwise might, when the author of the pattern knows there is
5279: no point in carrying on.
5280:
5281: Consider, for example, the pattern \d+foo when applied to the subject
5282: line
5283:
5284: 123456bar
5285:
5286: After matching all 6 digits and then failing to match "foo", the normal
5287: action of the matcher is to try again with only 5 digits matching the
5288: \d+ item, and then with 4, and so on, before ultimately failing.
5289: "Atomic grouping" (a term taken from Jeffrey Friedl's book) provides
5290: the means for specifying that once a subpattern has matched, it is not
5291: to be re-evaluated in this way.
5292:
5293: If we use atomic grouping for the previous example, the matcher gives
5294: up immediately on failing to match "foo" the first time. The notation
5295: is a kind of special parenthesis, starting with (?> as in this example:
5296:
5297: (?>\d+)foo
5298:
5299: This kind of parenthesis "locks up" the part of the pattern it con-
5300: tains once it has matched, and a failure further into the pattern is
5301: prevented from backtracking into it. Backtracking past it to previous
5302: items, however, works as normal.
5303:
5304: An alternative description is that a subpattern of this type matches
5305: the string of characters that an identical standalone pattern would
5306: match, if anchored at the current point in the subject string.
5307:
5308: Atomic grouping subpatterns are not capturing subpatterns. Simple cases
5309: such as the above example can be thought of as a maximizing repeat that
5310: must swallow everything it can. So, while both \d+ and \d+? are pre-
5311: pared to adjust the number of digits they match in order to make the
5312: rest of the pattern match, (?>\d+) can only match an entire sequence of
5313: digits.
5314:
5315: Atomic groups in general can of course contain arbitrarily complicated
5316: subpatterns, and can be nested. However, when the subpattern for an
5317: atomic group is just a single repeated item, as in the example above, a
5318: simpler notation, called a "possessive quantifier" can be used. This
5319: consists of an additional + character following a quantifier. Using
5320: this notation, the previous example can be rewritten as
5321:
5322: \d++foo
5323:
5324: Note that a possessive quantifier can be used with an entire group, for
5325: example:
5326:
5327: (abc|xyz){2,3}+
5328:
5329: Possessive quantifiers are always greedy; the setting of the
5330: PCRE_UNGREEDY option is ignored. They are a convenient notation for the
5331: simpler forms of atomic group. However, there is no difference in the
5332: meaning of a possessive quantifier and the equivalent atomic group,
5333: though there may be a performance difference; possessive quantifiers
5334: should be slightly faster.
5335:
5336: The possessive quantifier syntax is an extension to the Perl 5.8 syn-
5337: tax. Jeffrey Friedl originated the idea (and the name) in the first
5338: edition of his book. Mike McCloskey liked it, so implemented it when he
5339: built Sun's Java package, and PCRE copied it from there. It ultimately
5340: found its way into Perl at release 5.10.
5341:
5342: PCRE has an optimization that automatically "possessifies" certain sim-
5343: ple pattern constructs. For example, the sequence A+B is treated as
5344: A++B because there is no point in backtracking into a sequence of A's
5345: when B must follow.
5346:
5347: When a pattern contains an unlimited repeat inside a subpattern that
5348: can itself be repeated an unlimited number of times, the use of an
5349: atomic group is the only way to avoid some failing matches taking a
5350: very long time indeed. The pattern
5351:
5352: (\D+|<\d+>)*[!?]
5353:
5354: matches an unlimited number of substrings that either consist of non-
5355: digits, or digits enclosed in <>, followed by either ! or ?. When it
5356: matches, it runs quickly. However, if it is applied to
5357:
5358: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
5359:
5360: it takes a long time before reporting failure. This is because the
5361: string can be divided between the internal \D+ repeat and the external
5362: * repeat in a large number of ways, and all have to be tried. (The
5363: example uses [!?] rather than a single character at the end, because
5364: both PCRE and Perl have an optimization that allows for fast failure
5365: when a single character is used. They remember the last single charac-
5366: ter that is required for a match, and fail early if it is not present
5367: in the string.) If the pattern is changed so that it uses an atomic
5368: group, like this:
5369:
5370: ((?>\D+)|<\d+>)*[!?]
5371:
5372: sequences of non-digits cannot be broken, and failure happens quickly.
5373:
5374:
5375: BACK REFERENCES
5376:
5377: Outside a character class, a backslash followed by a digit greater than
5378: 0 (and possibly further digits) is a back reference to a capturing sub-
5379: pattern earlier (that is, to its left) in the pattern, provided there
5380: have been that many previous capturing left parentheses.
5381:
5382: However, if the decimal number following the backslash is less than 10,
5383: it is always taken as a back reference, and causes an error only if
5384: there are not that many capturing left parentheses in the entire pat-
5385: tern. In other words, the parentheses that are referenced need not be
5386: to the left of the reference for numbers less than 10. A "forward back
5387: reference" of this type can make sense when a repetition is involved
5388: and the subpattern to the right has participated in an earlier itera-
5389: tion.
5390:
5391: It is not possible to have a numerical "forward back reference" to a
5392: subpattern whose number is 10 or more using this syntax because a
5393: sequence such as \50 is interpreted as a character defined in octal.
5394: See the subsection entitled "Non-printing characters" above for further
5395: details of the handling of digits following a backslash. There is no
5396: such problem when named parentheses are used. A back reference to any
5397: subpattern is possible using named parentheses (see below).
5398:
5399: Another way of avoiding the ambiguity inherent in the use of digits
5400: following a backslash is to use the \g escape sequence. This escape
5401: must be followed by an unsigned number or a negative number, optionally
5402: enclosed in braces. These examples are all identical:
5403:
5404: (ring), \1
5405: (ring), \g1
5406: (ring), \g{1}
5407:
5408: An unsigned number specifies an absolute reference without the ambigu-
5409: ity that is present in the older syntax. It is also useful when literal
5410: digits follow the reference. A negative number is a relative reference.
5411: Consider this example:
5412:
5413: (abc(def)ghi)\g{-1}
5414:
5415: The sequence \g{-1} is a reference to the most recently started captur-
5416: ing subpattern before \g, that is, is it equivalent to \2 in this exam-
5417: ple. Similarly, \g{-2} would be equivalent to \1. The use of relative
5418: references can be helpful in long patterns, and also in patterns that
5419: are created by joining together fragments that contain references
5420: within themselves.
5421:
5422: A back reference matches whatever actually matched the capturing sub-
5423: pattern in the current subject string, rather than anything matching
5424: the subpattern itself (see "Subpatterns as subroutines" below for a way
5425: of doing that). So the pattern
5426:
5427: (sens|respons)e and \1ibility
5428:
5429: matches "sense and sensibility" and "response and responsibility", but
5430: not "sense and responsibility". If caseful matching is in force at the
5431: time of the back reference, the case of letters is relevant. For exam-
5432: ple,
5433:
5434: ((?i)rah)\s+\1
5435:
5436: matches "rah rah" and "RAH RAH", but not "RAH rah", even though the
5437: original capturing subpattern is matched caselessly.
5438:
5439: There are several different ways of writing back references to named
5440: subpatterns. The .NET syntax \k{name} and the Perl syntax \k<name> or
5441: \k'name' are supported, as is the Python syntax (?P=name). Perl 5.10's
5442: unified back reference syntax, in which \g can be used for both numeric
5443: and named references, is also supported. We could rewrite the above
5444: example in any of the following ways:
5445:
5446: (?<p1>(?i)rah)\s+\k<p1>
5447: (?'p1'(?i)rah)\s+\k{p1}
5448: (?P<p1>(?i)rah)\s+(?P=p1)
5449: (?<p1>(?i)rah)\s+\g{p1}
5450:
5451: A subpattern that is referenced by name may appear in the pattern
5452: before or after the reference.
5453:
5454: There may be more than one back reference to the same subpattern. If a
5455: subpattern has not actually been used in a particular match, any back
5456: references to it always fail by default. For example, the pattern
5457:
5458: (a|(bc))\2
5459:
5460: always fails if it starts to match "a" rather than "bc". However, if
5461: the PCRE_JAVASCRIPT_COMPAT option is set at compile time, a back refer-
5462: ence to an unset value matches an empty string.
5463:
5464: Because there may be many capturing parentheses in a pattern, all dig-
5465: its following a backslash are taken as part of a potential back refer-
5466: ence number. If the pattern continues with a digit character, some
5467: delimiter must be used to terminate the back reference. If the
5468: PCRE_EXTENDED option is set, this can be whitespace. Otherwise, the \g{
5469: syntax or an empty comment (see "Comments" below) can be used.
5470:
5471: Recursive back references
5472:
5473: A back reference that occurs inside the parentheses to which it refers
5474: fails when the subpattern is first used, so, for example, (a\1) never
5475: matches. However, such references can be useful inside repeated sub-
5476: patterns. For example, the pattern
5477:
5478: (a|b\1)+
5479:
5480: matches any number of "a"s and also "aba", "ababbaa" etc. At each iter-
5481: ation of the subpattern, the back reference matches the character
5482: string corresponding to the previous iteration. In order for this to
5483: work, the pattern must be such that the first iteration does not need
5484: to match the back reference. This can be done using alternation, as in
5485: the example above, or by a quantifier with a minimum of zero.
5486:
5487: Back references of this type cause the group that they reference to be
5488: treated as an atomic group. Once the whole group has been matched, a
5489: subsequent matching failure cannot cause backtracking into the middle
5490: of the group.
5491:
5492:
5493: ASSERTIONS
5494:
5495: An assertion is a test on the characters following or preceding the
5496: current matching point that does not actually consume any characters.
5497: The simple assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are
5498: described above.
5499:
5500: More complicated assertions are coded as subpatterns. There are two
5501: kinds: those that look ahead of the current position in the subject
5502: string, and those that look behind it. An assertion subpattern is
5503: matched in the normal way, except that it does not cause the current
5504: matching position to be changed.
5505:
5506: Assertion subpatterns are not capturing subpatterns. If such an asser-
5507: tion contains capturing subpatterns within it, these are counted for
5508: the purposes of numbering the capturing subpatterns in the whole pat-
5509: tern. However, substring capturing is carried out only for positive
5510: assertions, because it does not make sense for negative assertions.
5511:
5512: For compatibility with Perl, assertion subpatterns may be repeated;
5513: though it makes no sense to assert the same thing several times, the
5514: side effect of capturing parentheses may occasionally be useful. In
5515: practice, there only three cases:
5516:
5517: (1) If the quantifier is {0}, the assertion is never obeyed during
5518: matching. However, it may contain internal capturing parenthesized
5519: groups that are called from elsewhere via the subroutine mechanism.
5520:
5521: (2) If quantifier is {0,n} where n is greater than zero, it is treated
5522: as if it were {0,1}. At run time, the rest of the pattern match is
5523: tried with and without the assertion, the order depending on the greed-
5524: iness of the quantifier.
5525:
5526: (3) If the minimum repetition is greater than zero, the quantifier is
5527: ignored. The assertion is obeyed just once when encountered during
5528: matching.
5529:
5530: Lookahead assertions
5531:
5532: Lookahead assertions start with (?= for positive assertions and (?! for
5533: negative assertions. For example,
5534:
5535: \w+(?=;)
5536:
5537: matches a word followed by a semicolon, but does not include the semi-
5538: colon in the match, and
5539:
5540: foo(?!bar)
5541:
5542: matches any occurrence of "foo" that is not followed by "bar". Note
5543: that the apparently similar pattern
5544:
5545: (?!foo)bar
5546:
5547: does not find an occurrence of "bar" that is preceded by something
5548: other than "foo"; it finds any occurrence of "bar" whatsoever, because
5549: the assertion (?!foo) is always true when the next three characters are
5550: "bar". A lookbehind assertion is needed to achieve the other effect.
5551:
5552: If you want to force a matching failure at some point in a pattern, the
5553: most convenient way to do it is with (?!) because an empty string
5554: always matches, so an assertion that requires there not to be an empty
5555: string must always fail. The backtracking control verb (*FAIL) or (*F)
5556: is a synonym for (?!).
5557:
5558: Lookbehind assertions
5559:
5560: Lookbehind assertions start with (?<= for positive assertions and (?<!
5561: for negative assertions. For example,
5562:
5563: (?<!foo)bar
5564:
5565: does find an occurrence of "bar" that is not preceded by "foo". The
5566: contents of a lookbehind assertion are restricted such that all the
5567: strings it matches must have a fixed length. However, if there are sev-
5568: eral top-level alternatives, they do not all have to have the same
5569: fixed length. Thus
5570:
5571: (?<=bullock|donkey)
5572:
5573: is permitted, but
5574:
5575: (?<!dogs?|cats?)
5576:
5577: causes an error at compile time. Branches that match different length
5578: strings are permitted only at the top level of a lookbehind assertion.
5579: This is an extension compared with Perl, which requires all branches to
5580: match the same length of string. An assertion such as
5581:
5582: (?<=ab(c|de))
5583:
5584: is not permitted, because its single top-level branch can match two
5585: different lengths, but it is acceptable to PCRE if rewritten to use two
5586: top-level branches:
5587:
5588: (?<=abc|abde)
5589:
5590: In some cases, the escape sequence \K (see above) can be used instead
5591: of a lookbehind assertion to get round the fixed-length restriction.
5592:
5593: The implementation of lookbehind assertions is, for each alternative,
5594: to temporarily move the current position back by the fixed length and
5595: then try to match. If there are insufficient characters before the cur-
5596: rent position, the assertion fails.
5597:
1.1.1.2 ! misho 5598: In a UTF mode, PCRE does not allow the \C escape (which matches a sin-
! 5599: gle data unit even in a UTF mode) to appear in lookbehind assertions,
1.1 misho 5600: because it makes it impossible to calculate the length of the lookbe-
1.1.1.2 ! misho 5601: hind. The \X and \R escapes, which can match different numbers of data
! 5602: units, are also not permitted.
1.1 misho 5603:
5604: "Subroutine" calls (see below) such as (?2) or (?&X) are permitted in
5605: lookbehinds, as long as the subpattern matches a fixed-length string.
5606: Recursion, however, is not supported.
5607:
5608: Possessive quantifiers can be used in conjunction with lookbehind
5609: assertions to specify efficient matching of fixed-length strings at the
5610: end of subject strings. Consider a simple pattern such as
5611:
5612: abcd$
5613:
5614: when applied to a long string that does not match. Because matching
5615: proceeds from left to right, PCRE will look for each "a" in the subject
5616: and then see if what follows matches the rest of the pattern. If the
5617: pattern is specified as
5618:
5619: ^.*abcd$
5620:
5621: the initial .* matches the entire string at first, but when this fails
5622: (because there is no following "a"), it backtracks to match all but the
5623: last character, then all but the last two characters, and so on. Once
5624: again the search for "a" covers the entire string, from right to left,
5625: so we are no better off. However, if the pattern is written as
5626:
5627: ^.*+(?<=abcd)
5628:
5629: there can be no backtracking for the .*+ item; it can match only the
5630: entire string. The subsequent lookbehind assertion does a single test
5631: on the last four characters. If it fails, the match fails immediately.
5632: For long strings, this approach makes a significant difference to the
5633: processing time.
5634:
5635: Using multiple assertions
5636:
5637: Several assertions (of any sort) may occur in succession. For example,
5638:
5639: (?<=\d{3})(?<!999)foo
5640:
5641: matches "foo" preceded by three digits that are not "999". Notice that
5642: each of the assertions is applied independently at the same point in
5643: the subject string. First there is a check that the previous three
5644: characters are all digits, and then there is a check that the same
5645: three characters are not "999". This pattern does not match "foo" pre-
5646: ceded by six characters, the first of which are digits and the last
5647: three of which are not "999". For example, it doesn't match "123abc-
5648: foo". A pattern to do that is
5649:
5650: (?<=\d{3}...)(?<!999)foo
5651:
5652: This time the first assertion looks at the preceding six characters,
5653: checking that the first three are digits, and then the second assertion
5654: checks that the preceding three characters are not "999".
5655:
5656: Assertions can be nested in any combination. For example,
5657:
5658: (?<=(?<!foo)bar)baz
5659:
5660: matches an occurrence of "baz" that is preceded by "bar" which in turn
5661: is not preceded by "foo", while
5662:
5663: (?<=\d{3}(?!999)...)foo
5664:
5665: is another pattern that matches "foo" preceded by three digits and any
5666: three characters that are not "999".
5667:
5668:
5669: CONDITIONAL SUBPATTERNS
5670:
5671: It is possible to cause the matching process to obey a subpattern con-
5672: ditionally or to choose between two alternative subpatterns, depending
5673: on the result of an assertion, or whether a specific capturing subpat-
5674: tern has already been matched. The two possible forms of conditional
5675: subpattern are:
5676:
5677: (?(condition)yes-pattern)
5678: (?(condition)yes-pattern|no-pattern)
5679:
5680: If the condition is satisfied, the yes-pattern is used; otherwise the
5681: no-pattern (if present) is used. If there are more than two alterna-
5682: tives in the subpattern, a compile-time error occurs. Each of the two
5683: alternatives may itself contain nested subpatterns of any form, includ-
5684: ing conditional subpatterns; the restriction to two alternatives
5685: applies only at the level of the condition. This pattern fragment is an
5686: example where the alternatives are complex:
5687:
5688: (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
5689:
5690:
5691: There are four kinds of condition: references to subpatterns, refer-
5692: ences to recursion, a pseudo-condition called DEFINE, and assertions.
5693:
5694: Checking for a used subpattern by number
5695:
5696: If the text between the parentheses consists of a sequence of digits,
5697: the condition is true if a capturing subpattern of that number has pre-
5698: viously matched. If there is more than one capturing subpattern with
5699: the same number (see the earlier section about duplicate subpattern
5700: numbers), the condition is true if any of them have matched. An alter-
5701: native notation is to precede the digits with a plus or minus sign. In
5702: this case, the subpattern number is relative rather than absolute. The
5703: most recently opened parentheses can be referenced by (?(-1), the next
5704: most recent by (?(-2), and so on. Inside loops it can also make sense
5705: to refer to subsequent groups. The next parentheses to be opened can be
5706: referenced as (?(+1), and so on. (The value zero in any of these forms
5707: is not used; it provokes a compile-time error.)
5708:
5709: Consider the following pattern, which contains non-significant white
5710: space to make it more readable (assume the PCRE_EXTENDED option) and to
5711: divide it into three parts for ease of discussion:
5712:
5713: ( \( )? [^()]+ (?(1) \) )
5714:
5715: The first part matches an optional opening parenthesis, and if that
5716: character is present, sets it as the first captured substring. The sec-
5717: ond part matches one or more characters that are not parentheses. The
5718: third part is a conditional subpattern that tests whether or not the
5719: first set of parentheses matched. If they did, that is, if subject
5720: started with an opening parenthesis, the condition is true, and so the
5721: yes-pattern is executed and a closing parenthesis is required. Other-
5722: wise, since no-pattern is not present, the subpattern matches nothing.
5723: In other words, this pattern matches a sequence of non-parentheses,
5724: optionally enclosed in parentheses.
5725:
5726: If you were embedding this pattern in a larger one, you could use a
5727: relative reference:
5728:
5729: ...other stuff... ( \( )? [^()]+ (?(-1) \) ) ...
5730:
5731: This makes the fragment independent of the parentheses in the larger
5732: pattern.
5733:
5734: Checking for a used subpattern by name
5735:
5736: Perl uses the syntax (?(<name>)...) or (?('name')...) to test for a
5737: used subpattern by name. For compatibility with earlier versions of
5738: PCRE, which had this facility before Perl, the syntax (?(name)...) is
5739: also recognized. However, there is a possible ambiguity with this syn-
5740: tax, because subpattern names may consist entirely of digits. PCRE
5741: looks first for a named subpattern; if it cannot find one and the name
5742: consists entirely of digits, PCRE looks for a subpattern of that num-
5743: ber, which must be greater than zero. Using subpattern names that con-
5744: sist entirely of digits is not recommended.
5745:
5746: Rewriting the above example to use a named subpattern gives this:
5747:
5748: (?<OPEN> \( )? [^()]+ (?(<OPEN>) \) )
5749:
5750: If the name used in a condition of this kind is a duplicate, the test
5751: is applied to all subpatterns of the same name, and is true if any one
5752: of them has matched.
5753:
5754: Checking for pattern recursion
5755:
5756: If the condition is the string (R), and there is no subpattern with the
5757: name R, the condition is true if a recursive call to the whole pattern
5758: or any subpattern has been made. If digits or a name preceded by amper-
5759: sand follow the letter R, for example:
5760:
5761: (?(R3)...) or (?(R&name)...)
5762:
5763: the condition is true if the most recent recursion is into a subpattern
5764: whose number or name is given. This condition does not check the entire
5765: recursion stack. If the name used in a condition of this kind is a
5766: duplicate, the test is applied to all subpatterns of the same name, and
5767: is true if any one of them is the most recent recursion.
5768:
5769: At "top level", all these recursion test conditions are false. The
5770: syntax for recursive patterns is described below.
5771:
5772: Defining subpatterns for use by reference only
5773:
5774: If the condition is the string (DEFINE), and there is no subpattern
5775: with the name DEFINE, the condition is always false. In this case,
5776: there may be only one alternative in the subpattern. It is always
5777: skipped if control reaches this point in the pattern; the idea of
5778: DEFINE is that it can be used to define subroutines that can be refer-
5779: enced from elsewhere. (The use of subroutines is described below.) For
5780: example, a pattern to match an IPv4 address such as "192.168.23.245"
5781: could be written like this (ignore whitespace and line breaks):
5782:
5783: (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
5784: \b (?&byte) (\.(?&byte)){3} \b
5785:
5786: The first part of the pattern is a DEFINE group inside which a another
5787: group named "byte" is defined. This matches an individual component of
5788: an IPv4 address (a number less than 256). When matching takes place,
5789: this part of the pattern is skipped because DEFINE acts like a false
5790: condition. The rest of the pattern uses references to the named group
5791: to match the four dot-separated components of an IPv4 address, insist-
5792: ing on a word boundary at each end.
5793:
5794: Assertion conditions
5795:
5796: If the condition is not in any of the above formats, it must be an
5797: assertion. This may be a positive or negative lookahead or lookbehind
5798: assertion. Consider this pattern, again containing non-significant
5799: white space, and with the two alternatives on the second line:
5800:
5801: (?(?=[^a-z]*[a-z])
5802: \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
5803:
5804: The condition is a positive lookahead assertion that matches an
5805: optional sequence of non-letters followed by a letter. In other words,
5806: it tests for the presence of at least one letter in the subject. If a
5807: letter is found, the subject is matched against the first alternative;
5808: otherwise it is matched against the second. This pattern matches
5809: strings in one of the two forms dd-aaa-dd or dd-dd-dd, where aaa are
5810: letters and dd are digits.
5811:
5812:
5813: COMMENTS
5814:
5815: There are two ways of including comments in patterns that are processed
5816: by PCRE. In both cases, the start of the comment must not be in a char-
5817: acter class, nor in the middle of any other sequence of related charac-
5818: ters such as (?: or a subpattern name or number. The characters that
5819: make up a comment play no part in the pattern matching.
5820:
5821: The sequence (?# marks the start of a comment that continues up to the
5822: next closing parenthesis. Nested parentheses are not permitted. If the
5823: PCRE_EXTENDED option is set, an unescaped # character also introduces a
5824: comment, which in this case continues to immediately after the next
5825: newline character or character sequence in the pattern. Which charac-
5826: ters are interpreted as newlines is controlled by the options passed to
1.1.1.2 ! misho 5827: a compiling function or by a special sequence at the start of the pat-
! 5828: tern, as described in the section entitled "Newline conventions" above.
! 5829: Note that the end of this type of comment is a literal newline sequence
! 5830: in the pattern; escape sequences that happen to represent a newline do
! 5831: not count. For example, consider this pattern when PCRE_EXTENDED is
! 5832: set, and the default newline convention is in force:
1.1 misho 5833:
5834: abc #comment \n still comment
5835:
5836: On encountering the # character, pcre_compile() skips along, looking
5837: for a newline in the pattern. The sequence \n is still literal at this
5838: stage, so it does not terminate the comment. Only an actual character
5839: with the code value 0x0a (the default newline) does so.
5840:
5841:
5842: RECURSIVE PATTERNS
5843:
5844: Consider the problem of matching a string in parentheses, allowing for
5845: unlimited nested parentheses. Without the use of recursion, the best
5846: that can be done is to use a pattern that matches up to some fixed
5847: depth of nesting. It is not possible to handle an arbitrary nesting
5848: depth.
5849:
5850: For some time, Perl has provided a facility that allows regular expres-
5851: sions to recurse (amongst other things). It does this by interpolating
5852: Perl code in the expression at run time, and the code can refer to the
5853: expression itself. A Perl pattern using code interpolation to solve the
5854: parentheses problem can be created like this:
5855:
5856: $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
5857:
5858: The (?p{...}) item interpolates Perl code at run time, and in this case
5859: refers recursively to the pattern in which it appears.
5860:
5861: Obviously, PCRE cannot support the interpolation of Perl code. Instead,
5862: it supports special syntax for recursion of the entire pattern, and
5863: also for individual subpattern recursion. After its introduction in
5864: PCRE and Python, this kind of recursion was subsequently introduced
5865: into Perl at release 5.10.
5866:
5867: A special item that consists of (? followed by a number greater than
5868: zero and a closing parenthesis is a recursive subroutine call of the
5869: subpattern of the given number, provided that it occurs inside that
5870: subpattern. (If not, it is a non-recursive subroutine call, which is
5871: described in the next section.) The special item (?R) or (?0) is a
5872: recursive call of the entire regular expression.
5873:
5874: This PCRE pattern solves the nested parentheses problem (assume the
5875: PCRE_EXTENDED option is set so that white space is ignored):
5876:
5877: \( ( [^()]++ | (?R) )* \)
5878:
5879: First it matches an opening parenthesis. Then it matches any number of
5880: substrings which can either be a sequence of non-parentheses, or a
5881: recursive match of the pattern itself (that is, a correctly parenthe-
5882: sized substring). Finally there is a closing parenthesis. Note the use
5883: of a possessive quantifier to avoid backtracking into sequences of non-
5884: parentheses.
5885:
5886: If this were part of a larger pattern, you would not want to recurse
5887: the entire pattern, so instead you could use this:
5888:
5889: ( \( ( [^()]++ | (?1) )* \) )
5890:
5891: We have put the pattern into parentheses, and caused the recursion to
5892: refer to them instead of the whole pattern.
5893:
5894: In a larger pattern, keeping track of parenthesis numbers can be
5895: tricky. This is made easier by the use of relative references. Instead
5896: of (?1) in the pattern above you can write (?-2) to refer to the second
5897: most recently opened parentheses preceding the recursion. In other
5898: words, a negative number counts capturing parentheses leftwards from
5899: the point at which it is encountered.
5900:
5901: It is also possible to refer to subsequently opened parentheses, by
5902: writing references such as (?+2). However, these cannot be recursive
5903: because the reference is not inside the parentheses that are refer-
5904: enced. They are always non-recursive subroutine calls, as described in
5905: the next section.
5906:
5907: An alternative approach is to use named parentheses instead. The Perl
5908: syntax for this is (?&name); PCRE's earlier syntax (?P>name) is also
5909: supported. We could rewrite the above example as follows:
5910:
5911: (?<pn> \( ( [^()]++ | (?&pn) )* \) )
5912:
5913: If there is more than one subpattern with the same name, the earliest
5914: one is used.
5915:
5916: This particular example pattern that we have been looking at contains
5917: nested unlimited repeats, and so the use of a possessive quantifier for
5918: matching strings of non-parentheses is important when applying the pat-
5919: tern to strings that do not match. For example, when this pattern is
5920: applied to
5921:
5922: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
5923:
5924: it yields "no match" quickly. However, if a possessive quantifier is
5925: not used, the match runs for a very long time indeed because there are
5926: so many different ways the + and * repeats can carve up the subject,
5927: and all have to be tested before failure can be reported.
5928:
5929: At the end of a match, the values of capturing parentheses are those
5930: from the outermost level. If you want to obtain intermediate values, a
5931: callout function can be used (see below and the pcrecallout documenta-
5932: tion). If the pattern above is matched against
5933:
5934: (ab(cd)ef)
5935:
5936: the value for the inner capturing parentheses (numbered 2) is "ef",
5937: which is the last value taken on at the top level. If a capturing sub-
5938: pattern is not matched at the top level, its final captured value is
5939: unset, even if it was (temporarily) set at a deeper level during the
5940: matching process.
5941:
5942: If there are more than 15 capturing parentheses in a pattern, PCRE has
5943: to obtain extra memory to store data during a recursion, which it does
5944: by using pcre_malloc, freeing it via pcre_free afterwards. If no memory
5945: can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
5946:
5947: Do not confuse the (?R) item with the condition (R), which tests for
5948: recursion. Consider this pattern, which matches text in angle brack-
5949: ets, allowing for arbitrary nesting. Only digits are allowed in nested
5950: brackets (that is, when recursing), whereas any characters are permit-
5951: ted at the outer level.
5952:
5953: < (?: (?(R) \d++ | [^<>]*+) | (?R)) * >
5954:
5955: In this pattern, (?(R) is the start of a conditional subpattern, with
5956: two different alternatives for the recursive and non-recursive cases.
5957: The (?R) item is the actual recursive call.
5958:
5959: Differences in recursion processing between PCRE and Perl
5960:
5961: Recursion processing in PCRE differs from Perl in two important ways.
5962: In PCRE (like Python, but unlike Perl), a recursive subpattern call is
5963: always treated as an atomic group. That is, once it has matched some of
5964: the subject string, it is never re-entered, even if it contains untried
5965: alternatives and there is a subsequent matching failure. This can be
5966: illustrated by the following pattern, which purports to match a palin-
5967: dromic string that contains an odd number of characters (for example,
5968: "a", "aba", "abcba", "abcdcba"):
5969:
5970: ^(.|(.)(?1)\2)$
5971:
5972: The idea is that it either matches a single character, or two identical
5973: characters surrounding a sub-palindrome. In Perl, this pattern works;
5974: in PCRE it does not if the pattern is longer than three characters.
5975: Consider the subject string "abcba":
5976:
5977: At the top level, the first character is matched, but as it is not at
5978: the end of the string, the first alternative fails; the second alterna-
5979: tive is taken and the recursion kicks in. The recursive call to subpat-
5980: tern 1 successfully matches the next character ("b"). (Note that the
5981: beginning and end of line tests are not part of the recursion).
5982:
5983: Back at the top level, the next character ("c") is compared with what
5984: subpattern 2 matched, which was "a". This fails. Because the recursion
5985: is treated as an atomic group, there are now no backtracking points,
5986: and so the entire match fails. (Perl is able, at this point, to re-
5987: enter the recursion and try the second alternative.) However, if the
5988: pattern is written with the alternatives in the other order, things are
5989: different:
5990:
5991: ^((.)(?1)\2|.)$
5992:
5993: This time, the recursing alternative is tried first, and continues to
5994: recurse until it runs out of characters, at which point the recursion
5995: fails. But this time we do have another alternative to try at the
5996: higher level. That is the big difference: in the previous case the
5997: remaining alternative is at a deeper recursion level, which PCRE cannot
5998: use.
5999:
6000: To change the pattern so that it matches all palindromic strings, not
6001: just those with an odd number of characters, it is tempting to change
6002: the pattern to this:
6003:
6004: ^((.)(?1)\2|.?)$
6005:
6006: Again, this works in Perl, but not in PCRE, and for the same reason.
6007: When a deeper recursion has matched a single character, it cannot be
6008: entered again in order to match an empty string. The solution is to
6009: separate the two cases, and write out the odd and even cases as alter-
6010: natives at the higher level:
6011:
6012: ^(?:((.)(?1)\2|)|((.)(?3)\4|.))
6013:
6014: If you want to match typical palindromic phrases, the pattern has to
6015: ignore all non-word characters, which can be done like this:
6016:
6017: ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$
6018:
6019: If run with the PCRE_CASELESS option, this pattern matches phrases such
6020: as "A man, a plan, a canal: Panama!" and it works well in both PCRE and
6021: Perl. Note the use of the possessive quantifier *+ to avoid backtrack-
6022: ing into sequences of non-word characters. Without this, PCRE takes a
6023: great deal longer (ten times or more) to match typical phrases, and
6024: Perl takes so long that you think it has gone into a loop.
6025:
6026: WARNING: The palindrome-matching patterns above work only if the sub-
6027: ject string does not start with a palindrome that is shorter than the
6028: entire string. For example, although "abcba" is correctly matched, if
6029: the subject is "ababa", PCRE finds the palindrome "aba" at the start,
6030: then fails at top level because the end of the string does not follow.
6031: Once again, it cannot jump back into the recursion to try other alter-
6032: natives, so the entire match fails.
6033:
6034: The second way in which PCRE and Perl differ in their recursion pro-
6035: cessing is in the handling of captured values. In Perl, when a subpat-
6036: tern is called recursively or as a subpattern (see the next section),
6037: it has no access to any values that were captured outside the recur-
6038: sion, whereas in PCRE these values can be referenced. Consider this
6039: pattern:
6040:
6041: ^(.)(\1|a(?2))
6042:
6043: In PCRE, this pattern matches "bab". The first capturing parentheses
6044: match "b", then in the second group, when the back reference \1 fails
6045: to match "b", the second alternative matches "a" and then recurses. In
6046: the recursion, \1 does now match "b" and so the whole match succeeds.
6047: In Perl, the pattern fails to match because inside the recursive call
6048: \1 cannot access the externally set value.
6049:
6050:
6051: SUBPATTERNS AS SUBROUTINES
6052:
6053: If the syntax for a recursive subpattern call (either by number or by
6054: name) is used outside the parentheses to which it refers, it operates
6055: like a subroutine in a programming language. The called subpattern may
6056: be defined before or after the reference. A numbered reference can be
6057: absolute or relative, as in these examples:
6058:
6059: (...(absolute)...)...(?2)...
6060: (...(relative)...)...(?-1)...
6061: (...(?+1)...(relative)...
6062:
6063: An earlier example pointed out that the pattern
6064:
6065: (sens|respons)e and \1ibility
6066:
6067: matches "sense and sensibility" and "response and responsibility", but
6068: not "sense and responsibility". If instead the pattern
6069:
6070: (sens|respons)e and (?1)ibility
6071:
6072: is used, it does match "sense and responsibility" as well as the other
6073: two strings. Another example is given in the discussion of DEFINE
6074: above.
6075:
6076: All subroutine calls, whether recursive or not, are always treated as
6077: atomic groups. That is, once a subroutine has matched some of the sub-
6078: ject string, it is never re-entered, even if it contains untried alter-
6079: natives and there is a subsequent matching failure. Any capturing
6080: parentheses that are set during the subroutine call revert to their
6081: previous values afterwards.
6082:
6083: Processing options such as case-independence are fixed when a subpat-
6084: tern is defined, so if it is used as a subroutine, such options cannot
6085: be changed for different calls. For example, consider this pattern:
6086:
6087: (abc)(?i:(?-1))
6088:
6089: It matches "abcabc". It does not match "abcABC" because the change of
6090: processing option does not affect the called subpattern.
6091:
6092:
6093: ONIGURUMA SUBROUTINE SYNTAX
6094:
6095: For compatibility with Oniguruma, the non-Perl syntax \g followed by a
6096: name or a number enclosed either in angle brackets or single quotes, is
6097: an alternative syntax for referencing a subpattern as a subroutine,
6098: possibly recursively. Here are two of the examples used above, rewrit-
6099: ten using this syntax:
6100:
6101: (?<pn> \( ( (?>[^()]+) | \g<pn> )* \) )
6102: (sens|respons)e and \g'1'ibility
6103:
6104: PCRE supports an extension to Oniguruma: if a number is preceded by a
6105: plus or a minus sign it is taken as a relative reference. For example:
6106:
6107: (abc)(?i:\g<-1>)
6108:
6109: Note that \g{...} (Perl syntax) and \g<...> (Oniguruma syntax) are not
6110: synonymous. The former is a back reference; the latter is a subroutine
6111: call.
6112:
6113:
6114: CALLOUTS
6115:
6116: Perl has a feature whereby using the sequence (?{...}) causes arbitrary
6117: Perl code to be obeyed in the middle of matching a regular expression.
6118: This makes it possible, amongst other things, to extract different sub-
6119: strings that match the same pair of parentheses when there is a repeti-
6120: tion.
6121:
6122: PCRE provides a similar feature, but of course it cannot obey arbitrary
6123: Perl code. The feature is called "callout". The caller of PCRE provides
6124: an external function by putting its entry point in the global variable
1.1.1.2 ! misho 6125: pcre_callout (8-bit library) or pcre16_callout (16-bit library). By
! 6126: default, this variable contains NULL, which disables all calling out.
1.1 misho 6127:
6128: Within a regular expression, (?C) indicates the points at which the
6129: external function is to be called. If you want to identify different
6130: callout points, you can put a number less than 256 after the letter C.
6131: The default value is zero. For example, this pattern has two callout
6132: points:
6133:
6134: (?C1)abc(?C2)def
6135:
1.1.1.2 ! misho 6136: If the PCRE_AUTO_CALLOUT flag is passed to a compiling function, call-
! 6137: outs are automatically installed before each item in the pattern. They
! 6138: are all numbered 255.
! 6139:
! 6140: During matching, when PCRE reaches a callout point, the external func-
! 6141: tion is called. It is provided with the number of the callout, the
! 6142: position in the pattern, and, optionally, one item of data originally
! 6143: supplied by the caller of the matching function. The callout function
! 6144: may cause matching to proceed, to backtrack, or to fail altogether. A
! 6145: complete description of the interface to the callout function is given
! 6146: in the pcrecallout documentation.
1.1 misho 6147:
6148:
6149: BACKTRACKING CONTROL
6150:
6151: Perl 5.10 introduced a number of "Special Backtracking Control Verbs",
6152: which are described in the Perl documentation as "experimental and sub-
6153: ject to change or removal in a future version of Perl". It goes on to
6154: say: "Their usage in production code should be noted to avoid problems
6155: during upgrades." The same remarks apply to the PCRE features described
6156: in this section.
6157:
6158: Since these verbs are specifically related to backtracking, most of
1.1.1.2 ! misho 6159: them can be used only when the pattern is to be matched using one of
! 6160: the traditional matching functions, which use a backtracking algorithm.
! 6161: With the exception of (*FAIL), which behaves like a failing negative
! 6162: assertion, they cause an error if encountered by a DFA matching func-
! 6163: tion.
1.1 misho 6164:
1.1.1.2 ! misho 6165: If any of these verbs are used in an assertion or in a subpattern that
1.1 misho 6166: is called as a subroutine (whether or not recursively), their effect is
6167: confined to that subpattern; it does not extend to the surrounding pat-
6168: tern, with one exception: the name from a *(MARK), (*PRUNE), or (*THEN)
1.1.1.2 ! misho 6169: that is encountered in a successful positive assertion is passed back
! 6170: when a match succeeds (compare capturing parentheses in assertions).
1.1 misho 6171: Note that such subpatterns are processed as anchored at the point where
6172: they are tested. Note also that Perl's treatment of subroutines is dif-
6173: ferent in some cases.
6174:
1.1.1.2 ! misho 6175: The new verbs make use of what was previously invalid syntax: an open-
1.1 misho 6176: ing parenthesis followed by an asterisk. They are generally of the form
1.1.1.2 ! misho 6177: (*VERB) or (*VERB:NAME). Some may take either form, with differing be-
! 6178: haviour, depending on whether or not an argument is present. A name is
1.1 misho 6179: any sequence of characters that does not include a closing parenthesis.
1.1.1.2 ! misho 6180: If the name is empty, that is, if the closing parenthesis immediately
! 6181: follows the colon, the effect is as if the colon were not there. Any
1.1 misho 6182: number of these verbs may occur in a pattern.
6183:
1.1.1.2 ! misho 6184: PCRE contains some optimizations that are used to speed up matching by
1.1 misho 6185: running some checks at the start of each match attempt. For example, it
1.1.1.2 ! misho 6186: may know the minimum length of matching subject, or that a particular
! 6187: character must be present. When one of these optimizations suppresses
! 6188: the running of a match, any included backtracking verbs will not, of
1.1 misho 6189: course, be processed. You can suppress the start-of-match optimizations
1.1.1.2 ! misho 6190: by setting the PCRE_NO_START_OPTIMIZE option when calling pcre_com-
1.1 misho 6191: pile() or pcre_exec(), or by starting the pattern with (*NO_START_OPT).
6192:
1.1.1.2 ! misho 6193: Experiments with Perl suggest that it too has similar optimizations,
1.1 misho 6194: sometimes leading to anomalous results.
6195:
6196: Verbs that act immediately
6197:
1.1.1.2 ! misho 6198: The following verbs act as soon as they are encountered. They may not
1.1 misho 6199: be followed by a name.
6200:
6201: (*ACCEPT)
6202:
1.1.1.2 ! misho 6203: This verb causes the match to end successfully, skipping the remainder
! 6204: of the pattern. However, when it is inside a subpattern that is called
! 6205: as a subroutine, only that subpattern is ended successfully. Matching
! 6206: then continues at the outer level. If (*ACCEPT) is inside capturing
1.1 misho 6207: parentheses, the data so far is captured. For example:
6208:
6209: A((?:A|B(*ACCEPT)|C)D)
6210:
1.1.1.2 ! misho 6211: This matches "AB", "AAD", or "ACD"; when it matches "AB", "B" is cap-
1.1 misho 6212: tured by the outer parentheses.
6213:
6214: (*FAIL) or (*F)
6215:
1.1.1.2 ! misho 6216: This verb causes a matching failure, forcing backtracking to occur. It
! 6217: is equivalent to (?!) but easier to read. The Perl documentation notes
! 6218: that it is probably useful only when combined with (?{}) or (??{}).
! 6219: Those are, of course, Perl features that are not present in PCRE. The
! 6220: nearest equivalent is the callout feature, as for example in this pat-
1.1 misho 6221: tern:
6222:
6223: a+(?C)(*FAIL)
6224:
1.1.1.2 ! misho 6225: A match with the string "aaaa" always fails, but the callout is taken
1.1 misho 6226: before each backtrack happens (in this example, 10 times).
6227:
6228: Recording which path was taken
6229:
1.1.1.2 ! misho 6230: There is one verb whose main purpose is to track how a match was
! 6231: arrived at, though it also has a secondary use in conjunction with
1.1 misho 6232: advancing the match starting point (see (*SKIP) below).
6233:
6234: (*MARK:NAME) or (*:NAME)
6235:
1.1.1.2 ! misho 6236: A name is always required with this verb. There may be as many
! 6237: instances of (*MARK) as you like in a pattern, and their names do not
1.1 misho 6238: have to be unique.
6239:
1.1.1.2 ! misho 6240: When a match succeeds, the name of the last-encountered (*MARK) on the
! 6241: matching path is passed back to the caller as described in the section
! 6242: entitled "Extra data for pcre_exec()" in the pcreapi documentation.
! 6243: Here is an example of pcretest output, where the /K modifier requests
! 6244: the retrieval and outputting of (*MARK) data:
1.1 misho 6245:
6246: re> /X(*MARK:A)Y|X(*MARK:B)Z/K
6247: data> XY
6248: 0: XY
6249: MK: A
6250: XZ
6251: 0: XZ
6252: MK: B
6253:
6254: The (*MARK) name is tagged with "MK:" in this output, and in this exam-
1.1.1.2 ! misho 6255: ple it indicates which of the two alternatives matched. This is a more
! 6256: efficient way of obtaining this information than putting each alterna-
1.1 misho 6257: tive in its own capturing parentheses.
6258:
6259: If (*MARK) is encountered in a positive assertion, its name is recorded
6260: and passed back if it is the last-encountered. This does not happen for
6261: negative assertions.
6262:
1.1.1.2 ! misho 6263: After a partial match or a failed match, the name of the last encoun-
1.1 misho 6264: tered (*MARK) in the entire match process is returned. For example:
6265:
6266: re> /X(*MARK:A)Y|X(*MARK:B)Z/K
6267: data> XP
6268: No match, mark = B
6269:
1.1.1.2 ! misho 6270: Note that in this unanchored example the mark is retained from the
1.1 misho 6271: match attempt that started at the letter "X". Subsequent match attempts
1.1.1.2 ! misho 6272: starting at "P" and then with an empty string do not get as far as the
1.1 misho 6273: (*MARK) item, but nevertheless do not reset it.
6274:
6275: Verbs that act after backtracking
6276:
6277: The following verbs do nothing when they are encountered. Matching con-
1.1.1.2 ! misho 6278: tinues with what follows, but if there is no subsequent match, causing
! 6279: a backtrack to the verb, a failure is forced. That is, backtracking
! 6280: cannot pass to the left of the verb. However, when one of these verbs
! 6281: appears inside an atomic group, its effect is confined to that group,
! 6282: because once the group has been matched, there is never any backtrack-
! 6283: ing into it. In this situation, backtracking can "jump back" to the
! 6284: left of the entire atomic group. (Remember also, as stated above, that
1.1 misho 6285: this localization also applies in subroutine calls and assertions.)
6286:
1.1.1.2 ! misho 6287: These verbs differ in exactly what kind of failure occurs when back-
1.1 misho 6288: tracking reaches them.
6289:
6290: (*COMMIT)
6291:
1.1.1.2 ! misho 6292: This verb, which may not be followed by a name, causes the whole match
1.1 misho 6293: to fail outright if the rest of the pattern does not match. Even if the
6294: pattern is unanchored, no further attempts to find a match by advancing
6295: the starting point take place. Once (*COMMIT) has been passed,
1.1.1.2 ! misho 6296: pcre_exec() is committed to finding a match at the current starting
1.1 misho 6297: point, or not at all. For example:
6298:
6299: a+(*COMMIT)b
6300:
1.1.1.2 ! misho 6301: This matches "xxaab" but not "aacaab". It can be thought of as a kind
1.1 misho 6302: of dynamic anchor, or "I've started, so I must finish." The name of the
1.1.1.2 ! misho 6303: most recently passed (*MARK) in the path is passed back when (*COMMIT)
1.1 misho 6304: forces a match failure.
6305:
1.1.1.2 ! misho 6306: Note that (*COMMIT) at the start of a pattern is not the same as an
! 6307: anchor, unless PCRE's start-of-match optimizations are turned off, as
1.1 misho 6308: shown in this pcretest example:
6309:
6310: re> /(*COMMIT)abc/
6311: data> xyzabc
6312: 0: abc
6313: xyzabc\Y
6314: No match
6315:
1.1.1.2 ! misho 6316: PCRE knows that any match must start with "a", so the optimization
! 6317: skips along the subject to "a" before running the first match attempt,
! 6318: which succeeds. When the optimization is disabled by the \Y escape in
1.1 misho 6319: the second subject, the match starts at "x" and so the (*COMMIT) causes
6320: it to fail without trying any other starting points.
6321:
6322: (*PRUNE) or (*PRUNE:NAME)
6323:
1.1.1.2 ! misho 6324: This verb causes the match to fail at the current starting position in
! 6325: the subject if the rest of the pattern does not match. If the pattern
! 6326: is unanchored, the normal "bumpalong" advance to the next starting
! 6327: character then happens. Backtracking can occur as usual to the left of
! 6328: (*PRUNE), before it is reached, or when matching to the right of
! 6329: (*PRUNE), but if there is no match to the right, backtracking cannot
! 6330: cross (*PRUNE). In simple cases, the use of (*PRUNE) is just an alter-
! 6331: native to an atomic group or possessive quantifier, but there are some
1.1 misho 6332: uses of (*PRUNE) that cannot be expressed in any other way. The behav-
1.1.1.2 ! misho 6333: iour of (*PRUNE:NAME) is the same as (*MARK:NAME)(*PRUNE). In an
1.1 misho 6334: anchored pattern (*PRUNE) has the same effect as (*COMMIT).
6335:
6336: (*SKIP)
6337:
1.1.1.2 ! misho 6338: This verb, when given without a name, is like (*PRUNE), except that if
! 6339: the pattern is unanchored, the "bumpalong" advance is not to the next
1.1 misho 6340: character, but to the position in the subject where (*SKIP) was encoun-
1.1.1.2 ! misho 6341: tered. (*SKIP) signifies that whatever text was matched leading up to
1.1 misho 6342: it cannot be part of a successful match. Consider:
6343:
6344: a+(*SKIP)b
6345:
1.1.1.2 ! misho 6346: If the subject is "aaaac...", after the first match attempt fails
! 6347: (starting at the first character in the string), the starting point
1.1 misho 6348: skips on to start the next attempt at "c". Note that a possessive quan-
1.1.1.2 ! misho 6349: tifer does not have the same effect as this example; although it would
! 6350: suppress backtracking during the first match attempt, the second
! 6351: attempt would start at the second character instead of skipping on to
1.1 misho 6352: "c".
6353:
6354: (*SKIP:NAME)
6355:
1.1.1.2 ! misho 6356: When (*SKIP) has an associated name, its behaviour is modified. If the
1.1 misho 6357: following pattern fails to match, the previous path through the pattern
1.1.1.2 ! misho 6358: is searched for the most recent (*MARK) that has the same name. If one
! 6359: is found, the "bumpalong" advance is to the subject position that cor-
! 6360: responds to that (*MARK) instead of to where (*SKIP) was encountered.
1.1 misho 6361: If no (*MARK) with a matching name is found, the (*SKIP) is ignored.
6362:
6363: (*THEN) or (*THEN:NAME)
6364:
1.1.1.2 ! misho 6365: This verb causes a skip to the next innermost alternative if the rest
! 6366: of the pattern does not match. That is, it cancels pending backtrack-
! 6367: ing, but only within the current alternative. Its name comes from the
1.1 misho 6368: observation that it can be used for a pattern-based if-then-else block:
6369:
6370: ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
6371:
1.1.1.2 ! misho 6372: If the COND1 pattern matches, FOO is tried (and possibly further items
! 6373: after the end of the group if FOO succeeds); on failure, the matcher
! 6374: skips to the second alternative and tries COND2, without backtracking
! 6375: into COND1. The behaviour of (*THEN:NAME) is exactly the same as
! 6376: (*MARK:NAME)(*THEN). If (*THEN) is not inside an alternation, it acts
1.1 misho 6377: like (*PRUNE).
6378:
1.1.1.2 ! misho 6379: Note that a subpattern that does not contain a | character is just a
! 6380: part of the enclosing alternative; it is not a nested alternation with
! 6381: only one alternative. The effect of (*THEN) extends beyond such a sub-
! 6382: pattern to the enclosing alternative. Consider this pattern, where A,
1.1 misho 6383: B, etc. are complex pattern fragments that do not contain any | charac-
6384: ters at this level:
6385:
6386: A (B(*THEN)C) | D
6387:
1.1.1.2 ! misho 6388: If A and B are matched, but there is a failure in C, matching does not
1.1 misho 6389: backtrack into A; instead it moves to the next alternative, that is, D.
1.1.1.2 ! misho 6390: However, if the subpattern containing (*THEN) is given an alternative,
1.1 misho 6391: it behaves differently:
6392:
6393: A (B(*THEN)C | (*FAIL)) | D
6394:
1.1.1.2 ! misho 6395: The effect of (*THEN) is now confined to the inner subpattern. After a
1.1 misho 6396: failure in C, matching moves to (*FAIL), which causes the whole subpat-
1.1.1.2 ! misho 6397: tern to fail because there are no more alternatives to try. In this
1.1 misho 6398: case, matching does now backtrack into A.
6399:
6400: Note also that a conditional subpattern is not considered as having two
1.1.1.2 ! misho 6401: alternatives, because only one is ever used. In other words, the |
1.1 misho 6402: character in a conditional subpattern has a different meaning. Ignoring
6403: white space, consider:
6404:
6405: ^.*? (?(?=a) a | b(*THEN)c )
6406:
1.1.1.2 ! misho 6407: If the subject is "ba", this pattern does not match. Because .*? is
! 6408: ungreedy, it initially matches zero characters. The condition (?=a)
! 6409: then fails, the character "b" is matched, but "c" is not. At this
! 6410: point, matching does not backtrack to .*? as might perhaps be expected
! 6411: from the presence of the | character. The conditional subpattern is
1.1 misho 6412: part of the single alternative that comprises the whole pattern, and so
1.1.1.2 ! misho 6413: the match fails. (If there was a backtrack into .*?, allowing it to
1.1 misho 6414: match "b", the match would succeed.)
6415:
1.1.1.2 ! misho 6416: The verbs just described provide four different "strengths" of control
1.1 misho 6417: when subsequent matching fails. (*THEN) is the weakest, carrying on the
1.1.1.2 ! misho 6418: match at the next alternative. (*PRUNE) comes next, failing the match
! 6419: at the current starting position, but allowing an advance to the next
! 6420: character (for an unanchored pattern). (*SKIP) is similar, except that
1.1 misho 6421: the advance may be more than one character. (*COMMIT) is the strongest,
6422: causing the entire match to fail.
6423:
6424: If more than one such verb is present in a pattern, the "strongest" one
6425: wins. For example, consider this pattern, where A, B, etc. are complex
6426: pattern fragments:
6427:
6428: (A(*COMMIT)B(*THEN)C|D)
6429:
1.1.1.2 ! misho 6430: Once A has matched, PCRE is committed to this match, at the current
! 6431: starting position. If subsequently B matches, but C does not, the nor-
1.1 misho 6432: mal (*THEN) action of trying the next alternative (that is, D) does not
6433: happen because (*COMMIT) overrides.
6434:
6435:
6436: SEE ALSO
6437:
1.1.1.2 ! misho 6438: pcreapi(3), pcrecallout(3), pcrematching(3), pcresyntax(3), pcre(3),
! 6439: pcre16(3).
1.1 misho 6440:
6441:
6442: AUTHOR
6443:
6444: Philip Hazel
6445: University Computing Service
6446: Cambridge CB2 3QH, England.
6447:
6448:
6449: REVISION
6450:
1.1.1.2 ! misho 6451: Last updated: 09 January 2012
! 6452: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 6453: ------------------------------------------------------------------------------
6454:
6455:
6456: PCRESYNTAX(3) PCRESYNTAX(3)
6457:
6458:
6459: NAME
6460: PCRE - Perl-compatible regular expressions
6461:
6462:
6463: PCRE REGULAR EXPRESSION SYNTAX SUMMARY
6464:
6465: The full syntax and semantics of the regular expressions that are sup-
6466: ported by PCRE are described in the pcrepattern documentation. This
1.1.1.2 ! misho 6467: document contains a quick-reference summary of the syntax.
1.1 misho 6468:
6469:
6470: QUOTING
6471:
6472: \x where x is non-alphanumeric is a literal x
6473: \Q...\E treat enclosed characters as literal
6474:
6475:
6476: CHARACTERS
6477:
6478: \a alarm, that is, the BEL character (hex 07)
6479: \cx "control-x", where x is any ASCII character
6480: \e escape (hex 1B)
6481: \f formfeed (hex 0C)
6482: \n newline (hex 0A)
6483: \r carriage return (hex 0D)
6484: \t tab (hex 09)
6485: \ddd character with octal code ddd, or backreference
6486: \xhh character with hex code hh
6487: \x{hhh..} character with hex code hhh..
6488:
6489:
6490: CHARACTER TYPES
6491:
6492: . any character except newline;
6493: in dotall mode, any character whatsoever
1.1.1.2 ! misho 6494: \C one data unit, even in UTF mode (best avoided)
1.1 misho 6495: \d a decimal digit
6496: \D a character that is not a decimal digit
6497: \h a horizontal whitespace character
6498: \H a character that is not a horizontal whitespace character
6499: \N a character that is not a newline
6500: \p{xx} a character with the xx property
6501: \P{xx} a character without the xx property
6502: \R a newline sequence
6503: \s a whitespace character
6504: \S a character that is not a whitespace character
6505: \v a vertical whitespace character
6506: \V a character that is not a vertical whitespace character
6507: \w a "word" character
6508: \W a "non-word" character
6509: \X an extended Unicode sequence
6510:
6511: In PCRE, by default, \d, \D, \s, \S, \w, and \W recognize only ASCII
1.1.1.2 ! misho 6512: characters, even in a UTF mode. However, this can be changed by setting
1.1 misho 6513: the PCRE_UCP option.
6514:
6515:
6516: GENERAL CATEGORY PROPERTIES FOR \p and \P
6517:
6518: C Other
6519: Cc Control
6520: Cf Format
6521: Cn Unassigned
6522: Co Private use
6523: Cs Surrogate
6524:
6525: L Letter
6526: Ll Lower case letter
6527: Lm Modifier letter
6528: Lo Other letter
6529: Lt Title case letter
6530: Lu Upper case letter
6531: L& Ll, Lu, or Lt
6532:
6533: M Mark
6534: Mc Spacing mark
6535: Me Enclosing mark
6536: Mn Non-spacing mark
6537:
6538: N Number
6539: Nd Decimal number
6540: Nl Letter number
6541: No Other number
6542:
6543: P Punctuation
6544: Pc Connector punctuation
6545: Pd Dash punctuation
6546: Pe Close punctuation
6547: Pf Final punctuation
6548: Pi Initial punctuation
6549: Po Other punctuation
6550: Ps Open punctuation
6551:
6552: S Symbol
6553: Sc Currency symbol
6554: Sk Modifier symbol
6555: Sm Mathematical symbol
6556: So Other symbol
6557:
6558: Z Separator
6559: Zl Line separator
6560: Zp Paragraph separator
6561: Zs Space separator
6562:
6563:
6564: PCRE SPECIAL CATEGORY PROPERTIES FOR \p and \P
6565:
6566: Xan Alphanumeric: union of properties L and N
6567: Xps POSIX space: property Z or tab, NL, VT, FF, CR
6568: Xsp Perl space: property Z or tab, NL, FF, CR
6569: Xwd Perl word: property Xan or underscore
6570:
6571:
6572: SCRIPT NAMES FOR \p AND \P
6573:
6574: Arabic, Armenian, Avestan, Balinese, Bamum, Bengali, Bopomofo, Braille,
6575: Buginese, Buhid, Canadian_Aboriginal, Carian, Cham, Cherokee, Common,
6576: Coptic, Cuneiform, Cypriot, Cyrillic, Deseret, Devanagari, Egyp-
6577: tian_Hieroglyphs, Ethiopic, Georgian, Glagolitic, Gothic, Greek,
6578: Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew, Hiragana, Impe-
6579: rial_Aramaic, Inherited, Inscriptional_Pahlavi, Inscriptional_Parthian,
6580: Javanese, Kaithi, Kannada, Katakana, Kayah_Li, Kharoshthi, Khmer, Lao,
6581: Latin, Lepcha, Limbu, Linear_B, Lisu, Lycian, Lydian, Malayalam,
6582: Meetei_Mayek, Mongolian, Myanmar, New_Tai_Lue, Nko, Ogham, Old_Italic,
6583: Old_Persian, Old_South_Arabian, Old_Turkic, Ol_Chiki, Oriya, Osmanya,
6584: Phags_Pa, Phoenician, Rejang, Runic, Samaritan, Saurashtra, Shavian,
6585: Sinhala, Sundanese, Syloti_Nagri, Syriac, Tagalog, Tagbanwa, Tai_Le,
6586: Tai_Tham, Tai_Viet, Tamil, Telugu, Thaana, Thai, Tibetan, Tifinagh,
6587: Ugaritic, Vai, Yi.
6588:
6589:
6590: CHARACTER CLASSES
6591:
6592: [...] positive character class
6593: [^...] negative character class
6594: [x-y] range (can be used for hex characters)
6595: [[:xxx:]] positive POSIX named set
6596: [[:^xxx:]] negative POSIX named set
6597:
6598: alnum alphanumeric
6599: alpha alphabetic
6600: ascii 0-127
6601: blank space or tab
6602: cntrl control character
6603: digit decimal digit
6604: graph printing, excluding space
6605: lower lower case letter
6606: print printing, including space
6607: punct printing, excluding alphanumeric
6608: space whitespace
6609: upper upper case letter
6610: word same as \w
6611: xdigit hexadecimal digit
6612:
6613: In PCRE, POSIX character set names recognize only ASCII characters by
6614: default, but some of them use Unicode properties if PCRE_UCP is set.
6615: You can use \Q...\E inside a character class.
6616:
6617:
6618: QUANTIFIERS
6619:
6620: ? 0 or 1, greedy
6621: ?+ 0 or 1, possessive
6622: ?? 0 or 1, lazy
6623: * 0 or more, greedy
6624: *+ 0 or more, possessive
6625: *? 0 or more, lazy
6626: + 1 or more, greedy
6627: ++ 1 or more, possessive
6628: +? 1 or more, lazy
6629: {n} exactly n
6630: {n,m} at least n, no more than m, greedy
6631: {n,m}+ at least n, no more than m, possessive
6632: {n,m}? at least n, no more than m, lazy
6633: {n,} n or more, greedy
6634: {n,}+ n or more, possessive
6635: {n,}? n or more, lazy
6636:
6637:
6638: ANCHORS AND SIMPLE ASSERTIONS
6639:
6640: \b word boundary
6641: \B not a word boundary
6642: ^ start of subject
6643: also after internal newline in multiline mode
6644: \A start of subject
6645: $ end of subject
6646: also before newline at end of subject
6647: also before internal newline in multiline mode
6648: \Z end of subject
6649: also before newline at end of subject
6650: \z end of subject
6651: \G first matching position in subject
6652:
6653:
6654: MATCH POINT RESET
6655:
6656: \K reset start of match
6657:
6658:
6659: ALTERNATION
6660:
6661: expr|expr|expr...
6662:
6663:
6664: CAPTURING
6665:
6666: (...) capturing group
6667: (?<name>...) named capturing group (Perl)
6668: (?'name'...) named capturing group (Perl)
6669: (?P<name>...) named capturing group (Python)
6670: (?:...) non-capturing group
6671: (?|...) non-capturing group; reset group numbers for
6672: capturing groups in each alternative
6673:
6674:
6675: ATOMIC GROUPS
6676:
6677: (?>...) atomic, non-capturing group
6678:
6679:
6680: COMMENT
6681:
6682: (?#....) comment (not nestable)
6683:
6684:
6685: OPTION SETTING
6686:
6687: (?i) caseless
6688: (?J) allow duplicate names
6689: (?m) multiline
6690: (?s) single line (dotall)
6691: (?U) default ungreedy (lazy)
6692: (?x) extended (ignore white space)
6693: (?-...) unset option(s)
6694:
6695: The following are recognized only at the start of a pattern or after
6696: one of the newline-setting options with similar syntax:
6697:
6698: (*NO_START_OPT) no start-match optimization (PCRE_NO_START_OPTIMIZE)
1.1.1.2 ! misho 6699: (*UTF8) set UTF-8 mode: 8-bit library (PCRE_UTF8)
! 6700: (*UTF16) set UTF-16 mode: 16-bit library (PCRE_UTF16)
1.1 misho 6701: (*UCP) set PCRE_UCP (use Unicode properties for \d etc)
6702:
6703:
6704: LOOKAHEAD AND LOOKBEHIND ASSERTIONS
6705:
6706: (?=...) positive look ahead
6707: (?!...) negative look ahead
6708: (?<=...) positive look behind
6709: (?<!...) negative look behind
6710:
6711: Each top-level branch of a look behind must be of a fixed length.
6712:
6713:
6714: BACKREFERENCES
6715:
6716: \n reference by number (can be ambiguous)
6717: \gn reference by number
6718: \g{n} reference by number
6719: \g{-n} relative reference by number
6720: \k<name> reference by name (Perl)
6721: \k'name' reference by name (Perl)
6722: \g{name} reference by name (Perl)
6723: \k{name} reference by name (.NET)
6724: (?P=name) reference by name (Python)
6725:
6726:
6727: SUBROUTINE REFERENCES (POSSIBLY RECURSIVE)
6728:
6729: (?R) recurse whole pattern
6730: (?n) call subpattern by absolute number
6731: (?+n) call subpattern by relative number
6732: (?-n) call subpattern by relative number
6733: (?&name) call subpattern by name (Perl)
6734: (?P>name) call subpattern by name (Python)
6735: \g<name> call subpattern by name (Oniguruma)
6736: \g'name' call subpattern by name (Oniguruma)
6737: \g<n> call subpattern by absolute number (Oniguruma)
6738: \g'n' call subpattern by absolute number (Oniguruma)
6739: \g<+n> call subpattern by relative number (PCRE extension)
6740: \g'+n' call subpattern by relative number (PCRE extension)
6741: \g<-n> call subpattern by relative number (PCRE extension)
6742: \g'-n' call subpattern by relative number (PCRE extension)
6743:
6744:
6745: CONDITIONAL PATTERNS
6746:
6747: (?(condition)yes-pattern)
6748: (?(condition)yes-pattern|no-pattern)
6749:
6750: (?(n)... absolute reference condition
6751: (?(+n)... relative reference condition
6752: (?(-n)... relative reference condition
6753: (?(<name>)... named reference condition (Perl)
6754: (?('name')... named reference condition (Perl)
6755: (?(name)... named reference condition (PCRE)
6756: (?(R)... overall recursion condition
6757: (?(Rn)... specific group recursion condition
6758: (?(R&name)... specific recursion condition
6759: (?(DEFINE)... define subpattern for reference
6760: (?(assert)... assertion condition
6761:
6762:
6763: BACKTRACKING CONTROL
6764:
6765: The following act immediately they are reached:
6766:
6767: (*ACCEPT) force successful match
6768: (*FAIL) force backtrack; synonym (*F)
1.1.1.2 ! misho 6769: (*MARK:NAME) set name to be passed back; synonym (*:NAME)
1.1 misho 6770:
6771: The following act only when a subsequent match failure causes a back-
6772: track to reach them. They all force a match failure, but they differ in
6773: what happens afterwards. Those that advance the start-of-match point do
6774: so only if the pattern is not anchored.
6775:
6776: (*COMMIT) overall failure, no advance of starting point
6777: (*PRUNE) advance to next starting character
1.1.1.2 ! misho 6778: (*PRUNE:NAME) equivalent to (*MARK:NAME)(*PRUNE)
! 6779: (*SKIP) advance to current matching position
! 6780: (*SKIP:NAME) advance to position corresponding to an earlier
! 6781: (*MARK:NAME); if not found, the (*SKIP) is ignored
1.1 misho 6782: (*THEN) local failure, backtrack to next alternation
1.1.1.2 ! misho 6783: (*THEN:NAME) equivalent to (*MARK:NAME)(*THEN)
1.1 misho 6784:
6785:
6786: NEWLINE CONVENTIONS
6787:
6788: These are recognized only at the very start of the pattern or after a
1.1.1.2 ! misho 6789: (*BSR_...), (*UTF8), (*UTF16) or (*UCP) option.
1.1 misho 6790:
6791: (*CR) carriage return only
6792: (*LF) linefeed only
6793: (*CRLF) carriage return followed by linefeed
6794: (*ANYCRLF) all three of the above
6795: (*ANY) any Unicode newline sequence
6796:
6797:
6798: WHAT \R MATCHES
6799:
6800: These are recognized only at the very start of the pattern or after a
1.1.1.2 ! misho 6801: (*...) option that sets the newline convention or a UTF or UCP mode.
1.1 misho 6802:
6803: (*BSR_ANYCRLF) CR, LF, or CRLF
6804: (*BSR_UNICODE) any Unicode newline sequence
6805:
6806:
6807: CALLOUTS
6808:
6809: (?C) callout
6810: (?Cn) callout with data n
6811:
6812:
6813: SEE ALSO
6814:
6815: pcrepattern(3), pcreapi(3), pcrecallout(3), pcrematching(3), pcre(3).
6816:
6817:
6818: AUTHOR
6819:
6820: Philip Hazel
6821: University Computing Service
6822: Cambridge CB2 3QH, England.
6823:
6824:
6825: REVISION
6826:
1.1.1.2 ! misho 6827: Last updated: 10 January 2012
! 6828: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 6829: ------------------------------------------------------------------------------
6830:
6831:
6832: PCREUNICODE(3) PCREUNICODE(3)
6833:
6834:
6835: NAME
6836: PCRE - Perl-compatible regular expressions
6837:
6838:
1.1.1.2 ! misho 6839: UTF-8, UTF-16, AND UNICODE PROPERTY SUPPORT
! 6840:
! 6841: From Release 8.30, in addition to its previous UTF-8 support, PCRE also
! 6842: supports UTF-16 by means of a separate 16-bit library. This can be
! 6843: built as well as, or instead of, the 8-bit library.
! 6844:
! 6845:
! 6846: UTF-8 SUPPORT
1.1 misho 6847:
1.1.1.2 ! misho 6848: In order process UTF-8 strings, you must build PCRE's 8-bit library
! 6849: with UTF support, and, in addition, you must call pcre_compile() with
! 6850: the PCRE_UTF8 option flag, or the pattern must start with the sequence
! 6851: (*UTF8). When either of these is the case, both the pattern and any
! 6852: subject strings that are matched against it are treated as UTF-8
! 6853: strings instead of strings of 1-byte characters.
1.1 misho 6854:
1.1.1.2 ! misho 6855:
! 6856: UTF-16 SUPPORT
! 6857:
! 6858: In order process UTF-16 strings, you must build PCRE's 16-bit library
! 6859: with UTF support, and, in addition, you must call pcre16_compile() with
! 6860: the PCRE_UTF16 option flag, or the pattern must start with the sequence
! 6861: (*UTF16). When either of these is the case, both the pattern and any
! 6862: subject strings that are matched against it are treated as UTF-16
! 6863: strings instead of strings of 16-bit characters.
! 6864:
! 6865:
! 6866: UTF SUPPORT OVERHEAD
! 6867:
! 6868: If you compile PCRE with UTF support, but do not use it at run time,
1.1 misho 6869: the library will be a bit bigger, but the additional run time overhead
1.1.1.2 ! misho 6870: is limited to testing the PCRE_UTF8/16 flag occasionally, so should not
! 6871: be very big.
! 6872:
! 6873:
! 6874: UNICODE PROPERTY SUPPORT
1.1 misho 6875:
6876: If PCRE is built with Unicode character property support (which implies
1.1.1.2 ! misho 6877: UTF support), the escape sequences \p{..}, \P{..}, and \X can be used.
! 6878: The available properties that can be tested are limited to the general
! 6879: category properties such as Lu for an upper case letter or Nd for a
! 6880: decimal number, the Unicode script names such as Arabic or Han, and the
! 6881: derived properties Any and L&. A full list is given in the pcrepattern
! 6882: documentation. Only the short names for properties are supported. For
! 6883: example, \p{L} matches a letter. Its Perl synonym, \p{Letter}, is not
! 6884: supported. Furthermore, in Perl, many properties may optionally be
! 6885: prefixed by "Is", for compatibility with Perl 5.6. PCRE does not sup-
! 6886: port this.
1.1 misho 6887:
6888: Validity of UTF-8 strings
6889:
1.1.1.2 ! misho 6890: When you set the PCRE_UTF8 flag, the byte strings passed as patterns
! 6891: and subjects are (by default) checked for validity on entry to the rel-
! 6892: evant functions. From release 7.3 of PCRE, the check is according the
! 6893: rules of RFC 3629, which are themselves derived from the Unicode speci-
! 6894: fication. Earlier releases of PCRE followed the rules of RFC 2279,
! 6895: which allows the full range of 31-bit values (0 to 0x7FFFFFFF). The
! 6896: current check allows only values in the range U+0 to U+10FFFF, exclud-
! 6897: ing U+D800 to U+DFFF.
! 6898:
! 6899: The excluded code points are the "Surrogate Area" of Unicode. They are
! 6900: reserved for use by UTF-16, where they are used in pairs to encode
! 6901: codepoints with values greater than 0xFFFF. The code points that are
! 6902: encoded by UTF-16 pairs are available independently in the UTF-8 encod-
! 6903: ing. (In other words, the whole surrogate thing is a fudge for UTF-16
! 6904: which unfortunately messes up UTF-8.)
1.1 misho 6905:
6906: If an invalid UTF-8 string is passed to PCRE, an error return is given.
6907: At compile time, the only additional information is the offset to the
6908: first byte of the failing character. The runtime functions pcre_exec()
6909: and pcre_dfa_exec() also pass back this information, as well as a more
6910: detailed reason code if the caller has provided memory in which to do
6911: this.
6912:
6913: In some situations, you may already know that your strings are valid,
6914: and therefore want to skip these checks in order to improve perfor-
6915: mance. If you set the PCRE_NO_UTF8_CHECK flag at compile time or at run
6916: time, PCRE assumes that the pattern or subject it is given (respec-
6917: tively) contains only valid UTF-8 codes. In this case, it does not
6918: diagnose an invalid UTF-8 string.
6919:
6920: If you pass an invalid UTF-8 string when PCRE_NO_UTF8_CHECK is set,
6921: what happens depends on why the string is invalid. If the string con-
6922: forms to the "old" definition of UTF-8 (RFC 2279), it is processed as a
6923: string of characters in the range 0 to 0x7FFFFFFF by pcre_dfa_exec()
6924: and the interpreted version of pcre_exec(). In other words, apart from
6925: the initial validity test, these functions (when in UTF-8 mode) handle
6926: strings according to the more liberal rules of RFC 2279. However, the
6927: just-in-time (JIT) optimization for pcre_exec() supports only RFC 3629.
6928: If you are using JIT optimization, or if the string does not even con-
6929: form to RFC 2279, the result is undefined. Your program may crash.
6930:
6931: If you want to process strings of values in the full range 0 to
6932: 0x7FFFFFFF, encoded in a UTF-8-like manner as per the old RFC, you can
6933: set PCRE_NO_UTF8_CHECK to bypass the more restrictive test. However, in
6934: this situation, you will have to apply your own validity check, and
6935: avoid the use of JIT optimization.
6936:
1.1.1.2 ! misho 6937: Validity of UTF-16 strings
1.1 misho 6938:
1.1.1.2 ! misho 6939: When you set the PCRE_UTF16 flag, the strings of 16-bit data units that
! 6940: are passed as patterns and subjects are (by default) checked for valid-
! 6941: ity on entry to the relevant functions. Values other than those in the
! 6942: surrogate range U+D800 to U+DFFF are independent code points. Values in
! 6943: the surrogate range must be used in pairs in the correct manner.
! 6944:
! 6945: If an invalid UTF-16 string is passed to PCRE, an error return is
! 6946: given. At compile time, the only additional information is the offset
! 6947: to the first data unit of the failing character. The runtime functions
! 6948: pcre16_exec() and pcre16_dfa_exec() also pass back this information, as
! 6949: well as a more detailed reason code if the caller has provided memory
! 6950: in which to do this.
! 6951:
! 6952: In some situations, you may already know that your strings are valid,
! 6953: and therefore want to skip these checks in order to improve perfor-
! 6954: mance. If you set the PCRE_NO_UTF16_CHECK flag at compile time or at
! 6955: run time, PCRE assumes that the pattern or subject it is given (respec-
! 6956: tively) contains only valid UTF-16 sequences. In this case, it does not
! 6957: diagnose an invalid UTF-16 string.
! 6958:
! 6959: General comments about UTF modes
! 6960:
! 6961: 1. Codepoints less than 256 can be specified by either braced or
! 6962: unbraced hexadecimal escape sequences (for example, \x{b3} or \xb3).
! 6963: Larger values have to use braced sequences.
! 6964:
! 6965: 2. Octal numbers up to \777 are recognized, and in UTF-8 mode, they
! 6966: match two-byte characters for values greater than \177.
! 6967:
! 6968: 3. Repeat quantifiers apply to complete UTF characters, not to individ-
! 6969: ual data units, for example: \x{100}{3}.
! 6970:
! 6971: 4. The dot metacharacter matches one UTF character instead of a single
! 6972: data unit.
! 6973:
! 6974: 5. The escape sequence \C can be used to match a single byte in UTF-8
! 6975: mode, or a single 16-bit data unit in UTF-16 mode, but its use can lead
! 6976: to some strange effects because it breaks up multi-unit characters (see
! 6977: the description of \C in the pcrepattern documentation). The use of \C
! 6978: is not supported in the alternative matching function
! 6979: pcre[16]_dfa_exec(), nor is it supported in UTF mode by the JIT opti-
! 6980: mization of pcre[16]_exec(). If JIT optimization is requested for a UTF
! 6981: pattern that contains \C, it will not succeed, and so the matching will
! 6982: be carried out by the normal interpretive function.
1.1 misho 6983:
6984: 6. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
6985: test characters of any code value, but, by default, the characters that
6986: PCRE recognizes as digits, spaces, or word characters remain the same
1.1.1.2 ! misho 6987: set as in non-UTF mode, all with values less than 256. This remains
! 6988: true even when PCRE is built to include Unicode property support,
! 6989: because to do otherwise would slow down PCRE in many common cases. Note
! 6990: in particular that this applies to \b and \B, because they are defined
! 6991: in terms of \w and \W. If you really want to test for a wider sense of,
! 6992: say, "digit", you can use explicit Unicode property tests such as
! 6993: \p{Nd}. Alternatively, if you set the PCRE_UCP option, the way that the
! 6994: character escapes work is changed so that Unicode properties are used
! 6995: to determine which characters match. There are more details in the sec-
! 6996: tion on generic character types in the pcrepattern documentation.
1.1 misho 6997:
6998: 7. Similarly, characters that match the POSIX named character classes
6999: are all low-valued characters, unless the PCRE_UCP option is set.
7000:
7001: 8. However, the horizontal and vertical whitespace matching escapes
7002: (\h, \H, \v, and \V) do match all the appropriate Unicode characters,
7003: whether or not PCRE_UCP is set.
7004:
7005: 9. Case-insensitive matching applies only to characters whose values
7006: are less than 128, unless PCRE is built with Unicode property support.
7007: Even when Unicode property support is available, PCRE still uses its
7008: own character tables when checking the case of low-valued characters,
7009: so as not to degrade performance. The Unicode property information is
7010: used only for characters with higher values. Furthermore, PCRE supports
7011: case-insensitive matching only when there is a one-to-one mapping
7012: between a letter's cases. There are a small number of many-to-one map-
7013: pings in Unicode; these are not supported by PCRE.
7014:
7015:
7016: AUTHOR
7017:
7018: Philip Hazel
7019: University Computing Service
7020: Cambridge CB2 3QH, England.
7021:
7022:
7023: REVISION
7024:
1.1.1.2 ! misho 7025: Last updated: 13 January 2012
! 7026: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 7027: ------------------------------------------------------------------------------
7028:
7029:
7030: PCREJIT(3) PCREJIT(3)
7031:
7032:
7033: NAME
7034: PCRE - Perl-compatible regular expressions
7035:
7036:
7037: PCRE JUST-IN-TIME COMPILER SUPPORT
7038:
7039: Just-in-time compiling is a heavyweight optimization that can greatly
7040: speed up pattern matching. However, it comes at the cost of extra pro-
7041: cessing before the match is performed. Therefore, it is of most benefit
7042: when the same pattern is going to be matched many times. This does not
1.1.1.2 ! misho 7043: necessarily mean many calls of a matching function; if the pattern is
! 7044: not anchored, matching attempts may take place many times at various
! 7045: positions in the subject, even for a single call. Therefore, if the
1.1 misho 7046: subject string is very long, it may still pay to use JIT for one-off
7047: matches.
7048:
1.1.1.2 ! misho 7049: JIT support applies only to the traditional Perl-compatible matching
! 7050: function. It does not apply when the DFA matching function is being
! 7051: used. The code for this support was written by Zoltan Herczeg.
! 7052:
! 7053:
! 7054: 8-BIT and 16-BIT SUPPORT
! 7055:
! 7056: JIT support is available for both the 8-bit and 16-bit PCRE libraries.
! 7057: To keep this documentation simple, only the 8-bit interface is
! 7058: described in what follows. If you are using the 16-bit library, substi-
! 7059: tute the 16-bit functions and 16-bit structures (for example,
! 7060: pcre16_jit_stack instead of pcre_jit_stack).
1.1 misho 7061:
7062:
7063: AVAILABILITY OF JIT SUPPORT
7064:
7065: JIT support is an optional feature of PCRE. The "configure" option
7066: --enable-jit (or equivalent CMake option) must be set when PCRE is
7067: built if you want to use JIT. The support is limited to the following
7068: hardware platforms:
7069:
7070: ARM v5, v7, and Thumb2
7071: Intel x86 32-bit and 64-bit
7072: MIPS 32-bit
1.1.1.2 ! misho 7073: Power PC 32-bit and 64-bit
1.1 misho 7074:
7075: The Power PC support is designated as experimental because it has not
7076: been fully tested. If --enable-jit is set on an unsupported platform,
7077: compilation fails.
7078:
7079: A program that is linked with PCRE 8.20 or later can tell if JIT sup-
7080: port is available by calling pcre_config() with the PCRE_CONFIG_JIT
7081: option. The result is 1 when JIT is available, and 0 otherwise. How-
7082: ever, a simple program does not need to check this in order to use JIT.
7083: The API is implemented in a way that falls back to the ordinary PCRE
7084: code if JIT is not available.
7085:
7086: If your program may sometimes be linked with versions of PCRE that are
7087: older than 8.20, but you want to use JIT when it is available, you can
7088: test the values of PCRE_MAJOR and PCRE_MINOR, or the existence of a JIT
7089: macro such as PCRE_CONFIG_JIT, for compile-time control of your code.
7090:
7091:
7092: SIMPLE USE OF JIT
7093:
7094: You have to do two things to make use of the JIT support in the sim-
7095: plest way:
7096:
7097: (1) Call pcre_study() with the PCRE_STUDY_JIT_COMPILE option for
7098: each compiled pattern, and pass the resulting pcre_extra block to
7099: pcre_exec().
7100:
7101: (2) Use pcre_free_study() to free the pcre_extra block when it is
7102: no longer needed instead of just freeing it yourself. This
7103: ensures that any JIT data is also freed.
7104:
7105: For a program that may be linked with pre-8.20 versions of PCRE, you
7106: can insert
7107:
7108: #ifndef PCRE_STUDY_JIT_COMPILE
7109: #define PCRE_STUDY_JIT_COMPILE 0
7110: #endif
7111:
7112: so that no option is passed to pcre_study(), and then use something
7113: like this to free the study data:
7114:
7115: #ifdef PCRE_CONFIG_JIT
7116: pcre_free_study(study_ptr);
7117: #else
7118: pcre_free(study_ptr);
7119: #endif
7120:
7121: In some circumstances you may need to call additional functions. These
7122: are described in the section entitled "Controlling the JIT stack"
7123: below.
7124:
7125: If JIT support is not available, PCRE_STUDY_JIT_COMPILE is ignored, and
7126: no JIT data is set up. Otherwise, the compiled pattern is passed to the
7127: JIT compiler, which turns it into machine code that executes much
7128: faster than the normal interpretive code. When pcre_exec() is passed a
7129: pcre_extra block containing a pointer to JIT code, it obeys that
7130: instead of the normal code. The result is identical, but the code runs
7131: much faster.
7132:
7133: There are some pcre_exec() options that are not supported for JIT exe-
7134: cution. There are also some pattern items that JIT cannot handle.
7135: Details are given below. In both cases, execution automatically falls
7136: back to the interpretive code.
7137:
7138: If the JIT compiler finds an unsupported item, no JIT data is gener-
7139: ated. You can find out if JIT execution is available after studying a
7140: pattern by calling pcre_fullinfo() with the PCRE_INFO_JIT option. A
7141: result of 1 means that JIT compilation was successful. A result of 0
7142: means that JIT support is not available, or the pattern was not studied
7143: with PCRE_STUDY_JIT_COMPILE, or the JIT compiler was not able to handle
7144: the pattern.
7145:
7146: Once a pattern has been studied, with or without JIT, it can be used as
7147: many times as you like for matching different subject strings.
7148:
7149:
7150: UNSUPPORTED OPTIONS AND PATTERN ITEMS
7151:
7152: The only pcre_exec() options that are supported for JIT execution are
7153: PCRE_NO_UTF8_CHECK, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and
7154: PCRE_NOTEMPTY_ATSTART. Note in particular that partial matching is not
7155: supported.
7156:
7157: The unsupported pattern items are:
7158:
7159: \C match a single byte; not supported in UTF-8 mode
7160: (?Cn) callouts
7161: (*COMMIT) )
7162: (*MARK) )
7163: (*PRUNE) ) the backtracking control verbs
7164: (*SKIP) )
7165: (*THEN) )
7166:
7167: Support for some of these may be added in future.
7168:
7169:
7170: RETURN VALUES FROM JIT EXECUTION
7171:
7172: When a pattern is matched using JIT execution, the return values are
7173: the same as those given by the interpretive pcre_exec() code, with the
7174: addition of one new error code: PCRE_ERROR_JIT_STACKLIMIT. This means
7175: that the memory used for the JIT stack was insufficient. See "Control-
7176: ling the JIT stack" below for a discussion of JIT stack usage. For com-
7177: patibility with the interpretive pcre_exec() code, no more than two-
7178: thirds of the ovector argument is used for passing back captured sub-
7179: strings.
7180:
7181: The error code PCRE_ERROR_MATCHLIMIT is returned by the JIT code if
7182: searching a very large pattern tree goes on for too long, as it is in
7183: the same circumstance when JIT is not used, but the details of exactly
7184: what is counted are not the same. The PCRE_ERROR_RECURSIONLIMIT error
7185: code is never returned by JIT execution.
7186:
7187:
7188: SAVING AND RESTORING COMPILED PATTERNS
7189:
7190: The code that is generated by the JIT compiler is architecture-spe-
7191: cific, and is also position dependent. For those reasons it cannot be
7192: saved (in a file or database) and restored later like the bytecode and
7193: other data of a compiled pattern. Saving and restoring compiled pat-
7194: terns is not something many people do. More detail about this facility
7195: is given in the pcreprecompile documentation. It should be possible to
7196: run pcre_study() on a saved and restored pattern, and thereby recreate
7197: the JIT data, but because JIT compilation uses significant resources,
7198: it is probably not worth doing this; you might as well recompile the
7199: original pattern.
7200:
7201:
7202: CONTROLLING THE JIT STACK
7203:
7204: When the compiled JIT code runs, it needs a block of memory to use as a
7205: stack. By default, it uses 32K on the machine stack. However, some
7206: large or complicated patterns need more than this. The error
7207: PCRE_ERROR_JIT_STACKLIMIT is given when there is not enough stack.
7208: Three functions are provided for managing blocks of memory for use as
7209: JIT stacks. There is further discussion about the use of JIT stacks in
7210: the section entitled "JIT stack FAQ" below.
7211:
7212: The pcre_jit_stack_alloc() function creates a JIT stack. Its arguments
7213: are a starting size and a maximum size, and it returns a pointer to an
7214: opaque structure of type pcre_jit_stack, or NULL if there is an error.
7215: The pcre_jit_stack_free() function can be used to free a stack that is
7216: no longer needed. (For the technically minded: the address space is
7217: allocated by mmap or VirtualAlloc.)
7218:
7219: JIT uses far less memory for recursion than the interpretive code, and
7220: a maximum stack size of 512K to 1M should be more than enough for any
7221: pattern.
7222:
7223: The pcre_assign_jit_stack() function specifies which stack JIT code
7224: should use. Its arguments are as follows:
7225:
7226: pcre_extra *extra
7227: pcre_jit_callback callback
7228: void *data
7229:
7230: The extra argument must be the result of studying a pattern with
7231: PCRE_STUDY_JIT_COMPILE. There are three cases for the values of the
7232: other two options:
7233:
7234: (1) If callback is NULL and data is NULL, an internal 32K block
7235: on the machine stack is used.
7236:
7237: (2) If callback is NULL and data is not NULL, data must be
7238: a valid JIT stack, the result of calling pcre_jit_stack_alloc().
7239:
7240: (3) If callback not NULL, it must point to a function that is called
7241: with data as an argument at the start of matching, in order to
7242: set up a JIT stack. If the result is NULL, the internal 32K stack
7243: is used; otherwise the return value must be a valid JIT stack,
7244: the result of calling pcre_jit_stack_alloc().
7245:
7246: You may safely assign the same JIT stack to more than one pattern, as
7247: long as they are all matched sequentially in the same thread. In a mul-
7248: tithread application, each thread must use its own JIT stack.
7249:
7250: Strictly speaking, even more is allowed. You can assign the same stack
7251: to any number of patterns as long as they are not used for matching by
7252: multiple threads at the same time. For example, you can assign the same
7253: stack to all compiled patterns, and use a global mutex in the callback
7254: to wait until the stack is available for use. However, this is an inef-
7255: ficient solution, and not recommended.
7256:
7257: This is a suggestion for how a typical multithreaded program might
7258: operate:
7259:
7260: During thread initalization
7261: thread_local_var = pcre_jit_stack_alloc(...)
7262:
7263: During thread exit
7264: pcre_jit_stack_free(thread_local_var)
7265:
7266: Use a one-line callback function
7267: return thread_local_var
7268:
7269: All the functions described in this section do nothing if JIT is not
7270: available, and pcre_assign_jit_stack() does nothing unless the extra
7271: argument is non-NULL and points to a pcre_extra block that is the
7272: result of a successful study with PCRE_STUDY_JIT_COMPILE.
7273:
7274:
7275: JIT STACK FAQ
7276:
7277: (1) Why do we need JIT stacks?
7278:
7279: PCRE (and JIT) is a recursive, depth-first engine, so it needs a stack
7280: where the local data of the current node is pushed before checking its
7281: child nodes. Allocating real machine stack on some platforms is diffi-
7282: cult. For example, the stack chain needs to be updated every time if we
7283: extend the stack on PowerPC. Although it is possible, its updating
7284: time overhead decreases performance. So we do the recursion in memory.
7285:
7286: (2) Why don't we simply allocate blocks of memory with malloc()?
7287:
7288: Modern operating systems have a nice feature: they can reserve an
7289: address space instead of allocating memory. We can safely allocate mem-
7290: ory pages inside this address space, so the stack could grow without
7291: moving memory data (this is important because of pointers). Thus we can
7292: allocate 1M address space, and use only a single memory page (usually
7293: 4K) if that is enough. However, we can still grow up to 1M anytime if
7294: needed.
7295:
7296: (3) Who "owns" a JIT stack?
7297:
7298: The owner of the stack is the user program, not the JIT studied pattern
7299: or anything else. The user program must ensure that if a stack is used
7300: by pcre_exec(), (that is, it is assigned to the pattern currently run-
7301: ning), that stack must not be used by any other threads (to avoid over-
7302: writing the same memory area). The best practice for multithreaded pro-
7303: grams is to allocate a stack for each thread, and return this stack
7304: through the JIT callback function.
7305:
7306: (4) When should a JIT stack be freed?
7307:
7308: You can free a JIT stack at any time, as long as it will not be used by
7309: pcre_exec() again. When you assign the stack to a pattern, only a
7310: pointer is set. There is no reference counting or any other magic. You
7311: can free the patterns and stacks in any order, anytime. Just do not
7312: call pcre_exec() with a pattern pointing to an already freed stack, as
7313: that will cause SEGFAULT. (Also, do not free a stack currently used by
7314: pcre_exec() in another thread). You can also replace the stack for a
7315: pattern at any time. You can even free the previous stack before
7316: assigning a replacement.
7317:
7318: (5) Should I allocate/free a stack every time before/after calling
7319: pcre_exec()?
7320:
7321: No, because this is too costly in terms of resources. However, you
7322: could implement some clever idea which release the stack if it is not
7323: used in let's say two minutes. The JIT callback can help to achive this
7324: without keeping a list of the currently JIT studied patterns.
7325:
7326: (6) OK, the stack is for long term memory allocation. But what happens
7327: if a pattern causes stack overflow with a stack of 1M? Is that 1M kept
7328: until the stack is freed?
7329:
7330: Especially on embedded sytems, it might be a good idea to release mem-
7331: ory sometimes without freeing the stack. There is no API for this at
7332: the moment. Probably a function call which returns with the currently
7333: allocated memory for any stack and another which allows releasing mem-
7334: ory (shrinking the stack) would be a good idea if someone needs this.
7335:
7336: (7) This is too much of a headache. Isn't there any better solution for
7337: JIT stack handling?
7338:
7339: No, thanks to Windows. If POSIX threads were used everywhere, we could
7340: throw out this complicated API.
7341:
7342:
7343: EXAMPLE CODE
7344:
7345: This is a single-threaded example that specifies a JIT stack without
7346: using a callback.
7347:
7348: int rc;
7349: int ovector[30];
7350: pcre *re;
7351: pcre_extra *extra;
7352: pcre_jit_stack *jit_stack;
7353:
7354: re = pcre_compile(pattern, 0, &error, &erroffset, NULL);
7355: /* Check for errors */
7356: extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
7357: jit_stack = pcre_jit_stack_alloc(32*1024, 512*1024);
7358: /* Check for error (NULL) */
7359: pcre_assign_jit_stack(extra, NULL, jit_stack);
7360: rc = pcre_exec(re, extra, subject, length, 0, 0, ovector, 30);
7361: /* Check results */
7362: pcre_free(re);
7363: pcre_free_study(extra);
7364: pcre_jit_stack_free(jit_stack);
7365:
7366:
7367: SEE ALSO
7368:
7369: pcreapi(3)
7370:
7371:
7372: AUTHOR
7373:
7374: Philip Hazel (FAQ by Zoltan Herczeg)
7375: University Computing Service
7376: Cambridge CB2 3QH, England.
7377:
7378:
7379: REVISION
7380:
1.1.1.2 ! misho 7381: Last updated: 08 January 2012
! 7382: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 7383: ------------------------------------------------------------------------------
7384:
7385:
7386: PCREPARTIAL(3) PCREPARTIAL(3)
7387:
7388:
7389: NAME
7390: PCRE - Perl-compatible regular expressions
7391:
7392:
7393: PARTIAL MATCHING IN PCRE
7394:
1.1.1.2 ! misho 7395: In normal use of PCRE, if the subject string that is passed to a match-
! 7396: ing function matches as far as it goes, but is too short to match the
! 7397: entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances
! 7398: where it might be helpful to distinguish this case from other cases in
! 7399: which there is no match.
1.1 misho 7400:
7401: Consider, for example, an application where a human is required to type
7402: in data for a field with specific formatting requirements. An example
7403: might be a date in the form ddmmmyy, defined by this pattern:
7404:
7405: ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
7406:
7407: If the application sees the user's keystrokes one by one, and can check
7408: that what has been typed so far is potentially valid, it is able to
7409: raise an error as soon as a mistake is made, by beeping and not
7410: reflecting the character that has been typed, for example. This immedi-
7411: ate feedback is likely to be a better user interface than a check that
7412: is delayed until the entire string has been entered. Partial matching
7413: can also be useful when the subject string is very long and is not all
7414: available at once.
7415:
7416: PCRE supports partial matching by means of the PCRE_PARTIAL_SOFT and
1.1.1.2 ! misho 7417: PCRE_PARTIAL_HARD options, which can be set when calling any of the
! 7418: matching functions. For backwards compatibility, PCRE_PARTIAL is a syn-
! 7419: onym for PCRE_PARTIAL_SOFT. The essential difference between the two
! 7420: options is whether or not a partial match is preferred to an alterna-
! 7421: tive complete match, though the details differ between the two types of
! 7422: matching function. If both options are set, PCRE_PARTIAL_HARD takes
! 7423: precedence.
! 7424:
! 7425: Setting a partial matching option disables the use of any just-in-time
! 7426: code that was set up by studying the compiled pattern with the
! 7427: PCRE_STUDY_JIT_COMPILE option. It also disables two of PCRE's standard
! 7428: optimizations. PCRE remembers the last literal data unit in a pattern,
! 7429: and abandons matching immediately if it is not present in the subject
! 7430: string. This optimization cannot be used for a subject string that
! 7431: might match only partially. If the pattern was studied, PCRE knows the
! 7432: minimum length of a matching string, and does not bother to run the
! 7433: matching function on shorter strings. This optimization is also dis-
1.1 misho 7434: abled for partial matching.
7435:
7436:
1.1.1.2 ! misho 7437: PARTIAL MATCHING USING pcre_exec() OR pcre16_exec()
1.1 misho 7438:
1.1.1.2 ! misho 7439: A partial match occurs during a call to pcre_exec() or pcre16_exec()
! 7440: when the end of the subject string is reached successfully, but match-
! 7441: ing cannot continue because more characters are needed. However, at
! 7442: least one character in the subject must have been inspected. This char-
! 7443: acter need not form part of the final matched string; lookbehind asser-
! 7444: tions and the \K escape sequence provide ways of inspecting characters
! 7445: before the start of a matched substring. The requirement for inspecting
! 7446: at least one character exists because an empty string can always be
! 7447: matched; without such a restriction there would always be a partial
! 7448: match of an empty string at the end of the subject.
! 7449:
! 7450: If there are at least two slots in the offsets vector when a partial
! 7451: match is returned, the first slot is set to the offset of the earliest
! 7452: character that was inspected. For convenience, the second offset points
! 7453: to the end of the subject so that a substring can easily be identified.
1.1 misho 7454:
7455: For the majority of patterns, the first offset identifies the start of
7456: the partially matched string. However, for patterns that contain look-
7457: behind assertions, or \K, or begin with \b or \B, earlier characters
7458: have been inspected while carrying out the match. For example:
7459:
7460: /(?<=abc)123/
7461:
7462: This pattern matches "123", but only if it is preceded by "abc". If the
7463: subject string is "xyzabc12", the offsets after a partial match are for
7464: the substring "abc12", because all these characters are needed if
7465: another match is tried with extra characters added to the subject.
7466:
7467: What happens when a partial match is identified depends on which of the
7468: two partial matching options are set.
7469:
1.1.1.2 ! misho 7470: PCRE_PARTIAL_SOFT WITH pcre_exec() OR pcre16_exec()
1.1 misho 7471:
1.1.1.2 ! misho 7472: If PCRE_PARTIAL_SOFT is set when pcre_exec() or pcre16_exec() identi-
! 7473: fies a partial match, the partial match is remembered, but matching
! 7474: continues as normal, and other alternatives in the pattern are tried.
! 7475: If no complete match can be found, PCRE_ERROR_PARTIAL is returned
! 7476: instead of PCRE_ERROR_NOMATCH.
1.1 misho 7477:
7478: This option is "soft" because it prefers a complete match over a par-
7479: tial match. All the various matching items in a pattern behave as if
7480: the subject string is potentially complete. For example, \z, \Z, and $
7481: match at the end of the subject, as normal, and for \b and \B the end
7482: of the subject is treated as a non-alphanumeric.
7483:
7484: If there is more than one partial match, the first one that was found
7485: provides the data that is returned. Consider this pattern:
7486:
7487: /123\w+X|dogY/
7488:
7489: If this is matched against the subject string "abc123dog", both alter-
7490: natives fail to match, but the end of the subject is reached during
7491: matching, so PCRE_ERROR_PARTIAL is returned. The offsets are set to 3
7492: and 9, identifying "123dog" as the first partial match that was found.
7493: (In this example, there are two partial matches, because "dog" on its
7494: own partially matches the second alternative.)
7495:
1.1.1.2 ! misho 7496: PCRE_PARTIAL_HARD WITH pcre_exec() OR pcre16_exec()
1.1 misho 7497:
1.1.1.2 ! misho 7498: If PCRE_PARTIAL_HARD is set for pcre_exec() or pcre16_exec(),
! 7499: PCRE_ERROR_PARTIAL is returned as soon as a partial match is found,
! 7500: without continuing to search for possible complete matches. This option
! 7501: is "hard" because it prefers an earlier partial match over a later com-
! 7502: plete match. For this reason, the assumption is made that the end of
! 7503: the supplied subject string may not be the true end of the available
! 7504: data, and so, if \z, \Z, \b, \B, or $ are encountered at the end of the
! 7505: subject, the result is PCRE_ERROR_PARTIAL, provided that at least one
! 7506: character in the subject has been inspected.
! 7507:
! 7508: Setting PCRE_PARTIAL_HARD also affects the way UTF-8 and UTF-16 subject
! 7509: strings are checked for validity. Normally, an invalid sequence causes
! 7510: the error PCRE_ERROR_BADUTF8 or PCRE_ERROR_BADUTF16. However, in the
! 7511: special case of a truncated character at the end of the subject,
! 7512: PCRE_ERROR_SHORTUTF8 or PCRE_ERROR_SHORTUTF16 is returned when
! 7513: PCRE_PARTIAL_HARD is set.
1.1 misho 7514:
7515: Comparing hard and soft partial matching
7516:
7517: The difference between the two partial matching options can be illus-
7518: trated by a pattern such as:
7519:
7520: /dog(sbody)?/
7521:
7522: This matches either "dog" or "dogsbody", greedily (that is, it prefers
7523: the longer string if possible). If it is matched against the string
7524: "dog" with PCRE_PARTIAL_SOFT, it yields a complete match for "dog".
7525: However, if PCRE_PARTIAL_HARD is set, the result is PCRE_ERROR_PARTIAL.
7526: On the other hand, if the pattern is made ungreedy the result is dif-
7527: ferent:
7528:
7529: /dog(sbody)??/
7530:
1.1.1.2 ! misho 7531: In this case the result is always a complete match because that is
! 7532: found first, and matching never continues after finding a complete
! 7533: match. It might be easier to follow this explanation by thinking of the
! 7534: two patterns like this:
1.1 misho 7535:
7536: /dog(sbody)?/ is the same as /dogsbody|dog/
7537: /dog(sbody)??/ is the same as /dog|dogsbody/
7538:
1.1.1.2 ! misho 7539: The second pattern will never match "dogsbody", because it will always
! 7540: find the shorter match first.
1.1 misho 7541:
7542:
1.1.1.2 ! misho 7543: PARTIAL MATCHING USING pcre_dfa_exec() OR pcre16_dfa_exec()
1.1 misho 7544:
1.1.1.2 ! misho 7545: The DFA functions move along the subject string character by character,
! 7546: without backtracking, searching for all possible matches simultane-
! 7547: ously. If the end of the subject is reached before the end of the pat-
! 7548: tern, there is the possibility of a partial match, again provided that
! 7549: at least one character has been inspected.
1.1 misho 7550:
7551: When PCRE_PARTIAL_SOFT is set, PCRE_ERROR_PARTIAL is returned only if
7552: there have been no complete matches. Otherwise, the complete matches
7553: are returned. However, if PCRE_PARTIAL_HARD is set, a partial match
7554: takes precedence over any complete matches. The portion of the string
7555: that was inspected when the longest partial match was found is set as
7556: the first matching string, provided there are at least two slots in the
7557: offsets vector.
7558:
1.1.1.2 ! misho 7559: Because the DFA functions always search for all possible matches, and
! 7560: there is no difference between greedy and ungreedy repetition, their
! 7561: behaviour is different from the standard functions when PCRE_PAR-
! 7562: TIAL_HARD is set. Consider the string "dog" matched against the
! 7563: ungreedy pattern shown above:
1.1 misho 7564:
7565: /dog(sbody)??/
7566:
1.1.1.2 ! misho 7567: Whereas the standard functions stop as soon as they find the complete
! 7568: match for "dog", the DFA functions also find the partial match for
! 7569: "dogsbody", and so return that when PCRE_PARTIAL_HARD is set.
1.1 misho 7570:
7571:
7572: PARTIAL MATCHING AND WORD BOUNDARIES
7573:
7574: If a pattern ends with one of sequences \b or \B, which test for word
7575: boundaries, partial matching with PCRE_PARTIAL_SOFT can give counter-
7576: intuitive results. Consider this pattern:
7577:
7578: /\bcat\b/
7579:
7580: This matches "cat", provided there is a word boundary at either end. If
7581: the subject string is "the cat", the comparison of the final "t" with a
7582: following character cannot take place, so a partial match is found.
1.1.1.2 ! misho 7583: However, normal matching carries on, and \b matches at the end of the
! 7584: subject when the last character is a letter, so a complete match is
! 7585: found. The result, therefore, is not PCRE_ERROR_PARTIAL. Using
! 7586: PCRE_PARTIAL_HARD in this case does yield PCRE_ERROR_PARTIAL, because
! 7587: then the partial match takes precedence.
1.1 misho 7588:
7589:
7590: FORMERLY RESTRICTED PATTERNS
7591:
7592: For releases of PCRE prior to 8.00, because of the way certain internal
1.1.1.2 ! misho 7593: optimizations were implemented in the pcre_exec() function, the
! 7594: PCRE_PARTIAL option (predecessor of PCRE_PARTIAL_SOFT) could not be
! 7595: used with all patterns. From release 8.00 onwards, the restrictions no
! 7596: longer apply, and partial matching with can be requested for any pat-
! 7597: tern.
1.1 misho 7598:
7599: Items that were formerly restricted were repeated single characters and
1.1.1.2 ! misho 7600: repeated metasequences. If PCRE_PARTIAL was set for a pattern that did
! 7601: not conform to the restrictions, pcre_exec() returned the error code
! 7602: PCRE_ERROR_BADPARTIAL (-13). This error code is no longer in use. The
! 7603: PCRE_INFO_OKPARTIAL call to pcre_fullinfo() to find out if a compiled
1.1 misho 7604: pattern can be used for partial matching now always returns 1.
7605:
7606:
7607: EXAMPLE OF PARTIAL MATCHING USING PCRETEST
7608:
1.1.1.2 ! misho 7609: If the escape sequence \P is present in a pcretest data line, the
! 7610: PCRE_PARTIAL_SOFT option is used for the match. Here is a run of
1.1 misho 7611: pcretest that uses the date example quoted above:
7612:
7613: re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
7614: data> 25jun04\P
7615: 0: 25jun04
7616: 1: jun
7617: data> 25dec3\P
7618: Partial match: 23dec3
7619: data> 3ju\P
7620: Partial match: 3ju
7621: data> 3juj\P
7622: No match
7623: data> j\P
7624: No match
7625:
1.1.1.2 ! misho 7626: The first data string is matched completely, so pcretest shows the
! 7627: matched substrings. The remaining four strings do not match the com-
1.1 misho 7628: plete pattern, but the first two are partial matches. Similar output is
1.1.1.2 ! misho 7629: obtained if DFA matching is used.
1.1 misho 7630:
1.1.1.2 ! misho 7631: If the escape sequence \P is present more than once in a pcretest data
1.1 misho 7632: line, the PCRE_PARTIAL_HARD option is set for the match.
7633:
7634:
1.1.1.2 ! misho 7635: MULTI-SEGMENT MATCHING WITH pcre_dfa_exec() OR pcre16_dfa_exec()
1.1 misho 7636:
1.1.1.2 ! misho 7637: When a partial match has been found using a DFA matching function, it
! 7638: is possible to continue the match by providing additional subject data
! 7639: and calling the function again with the same compiled regular expres-
! 7640: sion, this time setting the PCRE_DFA_RESTART option. You must pass the
1.1 misho 7641: same working space as before, because this is where details of the pre-
1.1.1.2 ! misho 7642: vious partial match are stored. Here is an example using pcretest,
! 7643: using the \R escape sequence to set the PCRE_DFA_RESTART option (\D
! 7644: specifies the use of the DFA matching function):
1.1 misho 7645:
7646: re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
7647: data> 23ja\P\D
7648: Partial match: 23ja
7649: data> n05\R\D
7650: 0: n05
7651:
1.1.1.2 ! misho 7652: The first call has "23ja" as the subject, and requests partial match-
! 7653: ing; the second call has "n05" as the subject for the continued
! 7654: (restarted) match. Notice that when the match is complete, only the
! 7655: last part is shown; PCRE does not retain the previously partially-
! 7656: matched string. It is up to the calling program to do that if it needs
1.1 misho 7657: to.
7658:
1.1.1.2 ! misho 7659: You can set the PCRE_PARTIAL_SOFT or PCRE_PARTIAL_HARD options with
! 7660: PCRE_DFA_RESTART to continue partial matching over multiple segments.
! 7661: This facility can be used to pass very long subject strings to the DFA
! 7662: matching functions.
! 7663:
! 7664:
! 7665: MULTI-SEGMENT MATCHING WITH pcre_exec() OR pcre16_exec()
! 7666:
! 7667: From release 8.00, the standard matching functions can also be used to
! 7668: do multi-segment matching. Unlike the DFA functions, it is not possible
! 7669: to restart the previous match with a new segment of data. Instead, new
! 7670: data must be added to the previous subject string, and the entire match
! 7671: re-run, starting from the point where the partial match occurred. Ear-
! 7672: lier data can be discarded.
! 7673:
! 7674: It is best to use PCRE_PARTIAL_HARD in this situation, because it does
! 7675: not treat the end of a segment as the end of the subject when matching
! 7676: \z, \Z, \b, \B, and $. Consider an unanchored pattern that matches
! 7677: dates:
1.1 misho 7678:
7679: re> /\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d/
7680: data> The date is 23ja\P\P
7681: Partial match: 23ja
7682:
1.1.1.2 ! misho 7683: At this stage, an application could discard the text preceding "23ja",
! 7684: add on text from the next segment, and call the matching function
! 7685: again. Unlike the DFA matching functions the entire matching string
! 7686: must always be available, and the complete matching process occurs for
! 7687: each call, so more memory and more processing time is needed.
! 7688:
! 7689: Note: If the pattern contains lookbehind assertions, or \K, or starts
! 7690: with \b or \B, the string that is returned for a partial match includes
! 7691: characters that precede the partially matched string itself, because
! 7692: these must be retained when adding on more characters for a subsequent
! 7693: matching attempt.
1.1 misho 7694:
7695:
7696: ISSUES WITH MULTI-SEGMENT MATCHING
7697:
7698: Certain types of pattern may give problems with multi-segment matching,
7699: whichever matching function is used.
7700:
7701: 1. If the pattern contains a test for the beginning of a line, you need
1.1.1.2 ! misho 7702: to pass the PCRE_NOTBOL option when the subject string for any call
! 7703: does start at the beginning of a line. There is also a PCRE_NOTEOL
1.1 misho 7704: option, but in practice when doing multi-segment matching you should be
7705: using PCRE_PARTIAL_HARD, which includes the effect of PCRE_NOTEOL.
7706:
1.1.1.2 ! misho 7707: 2. Lookbehind assertions at the start of a pattern are catered for in
! 7708: the offsets that are returned for a partial match. However, in theory,
! 7709: a lookbehind assertion later in the pattern could require even earlier
! 7710: characters to be inspected, and it might not have been reached when a
! 7711: partial match occurs. This is probably an extremely unlikely case; you
! 7712: could guard against it to a certain extent by always including extra
1.1 misho 7713: characters at the start.
7714:
1.1.1.2 ! misho 7715: 3. Matching a subject string that is split into multiple segments may
! 7716: not always produce exactly the same result as matching over one single
! 7717: long string, especially when PCRE_PARTIAL_SOFT is used. The section
! 7718: "Partial Matching and Word Boundaries" above describes an issue that
! 7719: arises if the pattern ends with \b or \B. Another kind of difference
! 7720: may occur when there are multiple matching possibilities, because (for
! 7721: PCRE_PARTIAL_SOFT) a partial match result is given only when there are
1.1 misho 7722: no completed matches. This means that as soon as the shortest match has
1.1.1.2 ! misho 7723: been found, continuation to a new subject segment is no longer possi-
1.1 misho 7724: ble. Consider again this pcretest example:
7725:
7726: re> /dog(sbody)?/
7727: data> dogsb\P
7728: 0: dog
7729: data> do\P\D
7730: Partial match: do
7731: data> gsb\R\P\D
7732: 0: g
7733: data> dogsbody\D
7734: 0: dogsbody
7735: 1: dog
7736:
1.1.1.2 ! misho 7737: The first data line passes the string "dogsb" to a standard matching
! 7738: function, setting the PCRE_PARTIAL_SOFT option. Although the string is
! 7739: a partial match for "dogsbody", the result is not PCRE_ERROR_PARTIAL,
! 7740: because the shorter string "dog" is a complete match. Similarly, when
! 7741: the subject is presented to a DFA matching function in several parts
! 7742: ("do" and "gsb" being the first two) the match stops when "dog" has
! 7743: been found, and it is not possible to continue. On the other hand, if
! 7744: "dogsbody" is presented as a single string, a DFA matching function
! 7745: finds both matches.
1.1 misho 7746:
7747: Because of these problems, it is best to use PCRE_PARTIAL_HARD when
7748: matching multi-segment data. The example above then behaves differ-
7749: ently:
7750:
7751: re> /dog(sbody)?/
7752: data> dogsb\P\P
7753: Partial match: dogsb
7754: data> do\P\D
7755: Partial match: do
7756: data> gsb\R\P\P\D
7757: Partial match: gsb
7758:
7759: 4. Patterns that contain alternatives at the top level which do not all
7760: start with the same pattern item may not work as expected when
1.1.1.2 ! misho 7761: PCRE_DFA_RESTART is used. For example, consider this pattern:
1.1 misho 7762:
7763: 1234|3789
7764:
1.1.1.2 ! misho 7765: If the first part of the subject is "ABC123", a partial match of the
! 7766: first alternative is found at offset 3. There is no partial match for
1.1 misho 7767: the second alternative, because such a match does not start at the same
1.1.1.2 ! misho 7768: point in the subject string. Attempting to continue with the string
! 7769: "7890" does not yield a match because only those alternatives that
! 7770: match at one point in the subject are remembered. The problem arises
! 7771: because the start of the second alternative matches within the first
! 7772: alternative. There is no problem with anchored patterns or patterns
1.1 misho 7773: such as:
7774:
7775: 1234|ABCD
7776:
1.1.1.2 ! misho 7777: where no string can be a partial match for both alternatives. This is
! 7778: not a problem if a standard matching function is used, because the
! 7779: entire match has to be rerun each time:
1.1 misho 7780:
7781: re> /1234|3789/
7782: data> ABC123\P\P
7783: Partial match: 123
7784: data> 1237890
7785: 0: 3789
7786:
7787: Of course, instead of using PCRE_DFA_RESTART, the same technique of re-
1.1.1.2 ! misho 7788: running the entire match can also be used with the DFA matching func-
! 7789: tions. Another possibility is to work with two buffers. If a partial
! 7790: match at offset n in the first buffer is followed by "no match" when
! 7791: PCRE_DFA_RESTART is used on the second buffer, you can then try a new
! 7792: match starting at offset n+1 in the first buffer.
1.1 misho 7793:
7794:
7795: AUTHOR
7796:
7797: Philip Hazel
7798: University Computing Service
7799: Cambridge CB2 3QH, England.
7800:
7801:
7802: REVISION
7803:
1.1.1.2 ! misho 7804: Last updated: 21 January 2012
! 7805: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 7806: ------------------------------------------------------------------------------
7807:
7808:
7809: PCREPRECOMPILE(3) PCREPRECOMPILE(3)
7810:
7811:
7812: NAME
7813: PCRE - Perl-compatible regular expressions
7814:
7815:
7816: SAVING AND RE-USING PRECOMPILED PCRE PATTERNS
7817:
7818: If you are running an application that uses a large number of regular
7819: expression patterns, it may be useful to store them in a precompiled
7820: form instead of having to compile them every time the application is
7821: run. If you are not using any private character tables (see the
7822: pcre_maketables() documentation), this is relatively straightforward.
7823: If you are using private tables, it is a little bit more complicated.
1.1.1.2 ! misho 7824: However, if you are using the just-in-time optimization feature, it is
! 7825: not possible to save and reload the JIT data.
1.1 misho 7826:
7827: If you save compiled patterns to a file, you can copy them to a differ-
1.1.1.2 ! misho 7828: ent host and run them there. If the two hosts have different endianness
! 7829: (byte order), you should run the pcre[16]_pattern_to_host_byte_order()
! 7830: function on the new host before trying to match the pattern. The match-
! 7831: ing functions return PCRE_ERROR_BADENDIANNESS if they detect a pattern
! 7832: with the wrong endianness.
! 7833:
! 7834: Compiling regular expressions with one version of PCRE for use with a
! 7835: different version is not guaranteed to work and may cause crashes, and
! 7836: saving and restoring a compiled pattern loses any JIT optimization
! 7837: data.
1.1 misho 7838:
7839:
7840: SAVING A COMPILED PATTERN
7841:
1.1.1.2 ! misho 7842: The value returned by pcre[16]_compile() points to a single block of
! 7843: memory that holds the compiled pattern and associated data. You can
! 7844: find the length of this block in bytes by calling pcre[16]_fullinfo()
! 7845: with an argument of PCRE_INFO_SIZE. You can then save the data in any
! 7846: appropriate manner. Here is sample code for the 8-bit library that com-
! 7847: piles a pattern and writes it to a file. It assumes that the variable
! 7848: fd refers to a file that is open for output:
1.1 misho 7849:
7850: int erroroffset, rc, size;
7851: char *error;
7852: pcre *re;
7853:
7854: re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
7855: if (re == NULL) { ... handle errors ... }
7856: rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
7857: if (rc < 0) { ... handle errors ... }
7858: rc = fwrite(re, 1, size, fd);
7859: if (rc != size) { ... handle errors ... }
7860:
1.1.1.2 ! misho 7861: In this example, the bytes that comprise the compiled pattern are
! 7862: copied exactly. Note that this is binary data that may contain any of
! 7863: the 256 possible byte values. On systems that make a distinction
1.1 misho 7864: between binary and non-binary data, be sure that the file is opened for
7865: binary output.
7866:
1.1.1.2 ! misho 7867: If you want to write more than one pattern to a file, you will have to
! 7868: devise a way of separating them. For binary data, preceding each pat-
! 7869: tern with its length is probably the most straightforward approach.
! 7870: Another possibility is to write out the data in hexadecimal instead of
1.1 misho 7871: binary, one pattern to a line.
7872:
1.1.1.2 ! misho 7873: Saving compiled patterns in a file is only one possible way of storing
! 7874: them for later use. They could equally well be saved in a database, or
! 7875: in the memory of some daemon process that passes them via sockets to
1.1 misho 7876: the processes that want them.
7877:
7878: If the pattern has been studied, it is also possible to save the normal
7879: study data in a similar way to the compiled pattern itself. However, if
7880: the PCRE_STUDY_JIT_COMPILE was used, the just-in-time data that is cre-
1.1.1.2 ! misho 7881: ated cannot be saved because it is too dependent on the current envi-
! 7882: ronment. When studying generates additional information,
! 7883: pcre[16]_study() returns a pointer to a pcre[16]_extra data block. Its
! 7884: format is defined in the section on matching a pattern in the pcreapi
! 7885: documentation. The study_data field points to the binary study data,
! 7886: and this is what you must save (not the pcre[16]_extra block itself).
! 7887: The length of the study data can be obtained by calling
! 7888: pcre[16]_fullinfo() with an argument of PCRE_INFO_STUDYSIZE. Remember
! 7889: to check that pcre[16]_study() did return a non-NULL value before try-
! 7890: ing to save the study data.
1.1 misho 7891:
7892:
7893: RE-USING A PRECOMPILED PATTERN
7894:
7895: Re-using a precompiled pattern is straightforward. Having reloaded it
1.1.1.2 ! misho 7896: into main memory, called pcre[16]_pattern_to_host_byte_order() if nec-
! 7897: essary, you pass its pointer to pcre[16]_exec() or pcre[16]_dfa_exec()
! 7898: in the usual way.
! 7899:
! 7900: However, if you passed a pointer to custom character tables when the
! 7901: pattern was compiled (the tableptr argument of pcre[16]_compile()), you
! 7902: must now pass a similar pointer to pcre[16]_exec() or
! 7903: pcre[16]_dfa_exec(), because the value saved with the compiled pattern
! 7904: will obviously be nonsense. A field in a pcre[16]_extra() block is used
! 7905: to pass this data, as described in the section on matching a pattern in
! 7906: the pcreapi documentation.
! 7907:
! 7908: If you did not provide custom character tables when the pattern was
! 7909: compiled, the pointer in the compiled pattern is NULL, which causes the
! 7910: matching functions to use PCRE's internal tables. Thus, you do not need
! 7911: to take any special action at run time in this case.
! 7912:
! 7913: If you saved study data with the compiled pattern, you need to create
! 7914: your own pcre[16]_extra data block and set the study_data field to
! 7915: point to the reloaded study data. You must also set the
! 7916: PCRE_EXTRA_STUDY_DATA bit in the flags field to indicate that study
! 7917: data is present. Then pass the pcre[16]_extra block to the matching
! 7918: function in the usual way. If the pattern was studied for just-in-time
! 7919: optimization, that data cannot be saved, and so is lost by a
! 7920: save/restore cycle.
1.1 misho 7921:
7922:
7923: COMPATIBILITY WITH DIFFERENT PCRE RELEASES
7924:
7925: In general, it is safest to recompile all saved patterns when you
7926: update to a new PCRE release, though not all updates actually require
7927: this.
7928:
7929:
7930: AUTHOR
7931:
7932: Philip Hazel
7933: University Computing Service
7934: Cambridge CB2 3QH, England.
7935:
7936:
7937: REVISION
7938:
1.1.1.2 ! misho 7939: Last updated: 10 January 2012
! 7940: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 7941: ------------------------------------------------------------------------------
7942:
7943:
7944: PCREPERFORM(3) PCREPERFORM(3)
7945:
7946:
7947: NAME
7948: PCRE - Perl-compatible regular expressions
7949:
7950:
7951: PCRE PERFORMANCE
7952:
7953: Two aspects of performance are discussed below: memory usage and pro-
7954: cessing time. The way you express your pattern as a regular expression
7955: can affect both of them.
7956:
7957:
7958: COMPILED PATTERN MEMORY USAGE
7959:
1.1.1.2 ! misho 7960: Patterns are compiled by PCRE into a reasonably efficient interpretive
! 7961: code, so that most simple patterns do not use much memory. However,
! 7962: there is one case where the memory usage of a compiled pattern can be
! 7963: unexpectedly large. If a parenthesized subpattern has a quantifier with
! 7964: a minimum greater than 1 and/or a limited maximum, the whole subpattern
! 7965: is repeated in the compiled code. For example, the pattern
1.1 misho 7966:
7967: (abc|def){2,4}
7968:
7969: is compiled as if it were
7970:
7971: (abc|def)(abc|def)((abc|def)(abc|def)?)?
7972:
7973: (Technical aside: It is done this way so that backtrack points within
7974: each of the repetitions can be independently maintained.)
7975:
7976: For regular expressions whose quantifiers use only small numbers, this
7977: is not usually a problem. However, if the numbers are large, and par-
7978: ticularly if such repetitions are nested, the memory usage can become
7979: an embarrassment. For example, the very simple pattern
7980:
7981: ((ab){1,1000}c){1,3}
7982:
1.1.1.2 ! misho 7983: uses 51K bytes when compiled using the 8-bit library. When PCRE is com-
! 7984: piled with its default internal pointer size of two bytes, the size
! 7985: limit on a compiled pattern is 64K data units, and this is reached with
! 7986: the above pattern if the outer repetition is increased from 3 to 4.
! 7987: PCRE can be compiled to use larger internal pointers and thus handle
! 7988: larger compiled patterns, but it is better to try to rewrite your pat-
! 7989: tern to use less memory if you can.
1.1 misho 7990:
1.1.1.2 ! misho 7991: One way of reducing the memory usage for such patterns is to make use
1.1 misho 7992: of PCRE's "subroutine" facility. Re-writing the above pattern as
7993:
7994: ((ab)(?2){0,999}c)(?1){0,2}
7995:
7996: reduces the memory requirements to 18K, and indeed it remains under 20K
1.1.1.2 ! misho 7997: even with the outer repetition increased to 100. However, this pattern
! 7998: is not exactly equivalent, because the "subroutine" calls are treated
! 7999: as atomic groups into which there can be no backtracking if there is a
! 8000: subsequent matching failure. Therefore, PCRE cannot do this kind of
! 8001: rewriting automatically. Furthermore, there is a noticeable loss of
! 8002: speed when executing the modified pattern. Nevertheless, if the atomic
! 8003: grouping is not a problem and the loss of speed is acceptable, this
! 8004: kind of rewriting will allow you to process patterns that PCRE cannot
1.1 misho 8005: otherwise handle.
8006:
8007:
8008: STACK USAGE AT RUN TIME
8009:
1.1.1.2 ! misho 8010: When pcre_exec() or pcre16_exec() is used for matching, certain kinds
! 8011: of pattern can cause it to use large amounts of the process stack. In
! 8012: some environments the default process stack is quite small, and if it
! 8013: runs out the result is often SIGSEGV. This issue is probably the most
! 8014: frequently raised problem with PCRE. Rewriting your pattern can often
! 8015: help. The pcrestack documentation discusses this issue in detail.
1.1 misho 8016:
8017:
8018: PROCESSING TIME
8019:
1.1.1.2 ! misho 8020: Certain items in regular expression patterns are processed more effi-
1.1 misho 8021: ciently than others. It is more efficient to use a character class like
1.1.1.2 ! misho 8022: [aeiou] than a set of single-character alternatives such as
! 8023: (a|e|i|o|u). In general, the simplest construction that provides the
1.1 misho 8024: required behaviour is usually the most efficient. Jeffrey Friedl's book
1.1.1.2 ! misho 8025: contains a lot of useful general discussion about optimizing regular
! 8026: expressions for efficient performance. This document contains a few
1.1 misho 8027: observations about PCRE.
8028:
1.1.1.2 ! misho 8029: Using Unicode character properties (the \p, \P, and \X escapes) is
! 8030: slow, because PCRE has to scan a structure that contains data for over
! 8031: fifteen thousand characters whenever it needs a character's property.
! 8032: If you can find an alternative pattern that does not use character
1.1 misho 8033: properties, it will probably be faster.
8034:
1.1.1.2 ! misho 8035: By default, the escape sequences \b, \d, \s, and \w, and the POSIX
! 8036: character classes such as [:alpha:] do not use Unicode properties,
1.1 misho 8037: partly for backwards compatibility, and partly for performance reasons.
1.1.1.2 ! misho 8038: However, you can set PCRE_UCP if you want Unicode character properties
! 8039: to be used. This can double the matching time for items such as \d,
! 8040: when matched with a traditional matching function; the performance loss
! 8041: is less with a DFA matching function, and in both cases there is not
! 8042: much difference for \b.
1.1 misho 8043:
8044: When a pattern begins with .* not in parentheses, or in parentheses
8045: that are not the subject of a backreference, and the PCRE_DOTALL option
8046: is set, the pattern is implicitly anchored by PCRE, since it can match
8047: only at the start of a subject string. However, if PCRE_DOTALL is not
8048: set, PCRE cannot make this optimization, because the . metacharacter
8049: does not then match a newline, and if the subject string contains new-
8050: lines, the pattern may match from the character immediately following
8051: one of them instead of from the very start. For example, the pattern
8052:
8053: .*second
8054:
8055: matches the subject "first\nand second" (where \n stands for a newline
8056: character), with the match starting at the seventh character. In order
8057: to do this, PCRE has to retry the match starting after every newline in
8058: the subject.
8059:
8060: If you are using such a pattern with subject strings that do not con-
8061: tain newlines, the best performance is obtained by setting PCRE_DOTALL,
8062: or starting the pattern with ^.* or ^.*? to indicate explicit anchor-
8063: ing. That saves PCRE from having to scan along the subject looking for
8064: a newline to restart at.
8065:
8066: Beware of patterns that contain nested indefinite repeats. These can
8067: take a long time to run when applied to a string that does not match.
8068: Consider the pattern fragment
8069:
8070: ^(a+)*
8071:
8072: This can match "aaaa" in 16 different ways, and this number increases
8073: very rapidly as the string gets longer. (The * repeat can match 0, 1,
8074: 2, 3, or 4 times, and for each of those cases other than 0 or 4, the +
8075: repeats can match different numbers of times.) When the remainder of
8076: the pattern is such that the entire match is going to fail, PCRE has in
8077: principle to try every possible variation, and this can take an
8078: extremely long time, even for relatively short strings.
8079:
8080: An optimization catches some of the more simple cases such as
8081:
8082: (a+)*b
8083:
8084: where a literal character follows. Before embarking on the standard
8085: matching procedure, PCRE checks that there is a "b" later in the sub-
8086: ject string, and if there is not, it fails the match immediately. How-
8087: ever, when there is no following literal this optimization cannot be
8088: used. You can see the difference by comparing the behaviour of
8089:
8090: (a+)*\d
8091:
8092: with the pattern above. The former gives a failure almost instantly
8093: when applied to a whole line of "a" characters, whereas the latter
8094: takes an appreciable time with strings longer than about 20 characters.
8095:
8096: In many cases, the solution to this kind of performance issue is to use
8097: an atomic group or a possessive quantifier.
8098:
8099:
8100: AUTHOR
8101:
8102: Philip Hazel
8103: University Computing Service
8104: Cambridge CB2 3QH, England.
8105:
8106:
8107: REVISION
8108:
1.1.1.2 ! misho 8109: Last updated: 09 January 2012
! 8110: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 8111: ------------------------------------------------------------------------------
8112:
8113:
8114: PCREPOSIX(3) PCREPOSIX(3)
8115:
8116:
8117: NAME
8118: PCRE - Perl-compatible regular expressions.
8119:
8120:
8121: SYNOPSIS OF POSIX API
8122:
8123: #include <pcreposix.h>
8124:
8125: int regcomp(regex_t *preg, const char *pattern,
8126: int cflags);
8127:
8128: int regexec(regex_t *preg, const char *string,
8129: size_t nmatch, regmatch_t pmatch[], int eflags);
8130:
8131: size_t regerror(int errcode, const regex_t *preg,
8132: char *errbuf, size_t errbuf_size);
8133:
8134: void regfree(regex_t *preg);
8135:
8136:
8137: DESCRIPTION
8138:
1.1.1.2 ! misho 8139: This set of functions provides a POSIX-style API for the PCRE regular
! 8140: expression 8-bit library. See the pcreapi documentation for a descrip-
! 8141: tion of PCRE's native API, which contains much additional functional-
! 8142: ity. There is no POSIX-style wrapper for PCRE's 16-bit library.
1.1 misho 8143:
8144: The functions described here are just wrapper functions that ultimately
8145: call the PCRE native API. Their prototypes are defined in the
1.1.1.2 ! misho 8146: pcreposix.h header file, and on Unix systems the library itself is
! 8147: called pcreposix.a, so can be accessed by adding -lpcreposix to the
! 8148: command for linking an application that uses them. Because the POSIX
1.1 misho 8149: functions call the native ones, it is also necessary to add -lpcre.
8150:
1.1.1.2 ! misho 8151: I have implemented only those POSIX option bits that can be reasonably
! 8152: mapped to PCRE native options. In addition, the option REG_EXTENDED is
! 8153: defined with the value zero. This has no effect, but since programs
! 8154: that are written to the POSIX interface often use it, this makes it
! 8155: easier to slot in PCRE as a replacement library. Other POSIX options
1.1 misho 8156: are not even defined.
8157:
1.1.1.2 ! misho 8158: There are also some other options that are not defined by POSIX. These
1.1 misho 8159: have been added at the request of users who want to make use of certain
8160: PCRE-specific features via the POSIX calling interface.
8161:
1.1.1.2 ! misho 8162: When PCRE is called via these functions, it is only the API that is
! 8163: POSIX-like in style. The syntax and semantics of the regular expres-
! 8164: sions themselves are still those of Perl, subject to the setting of
! 8165: various PCRE options, as described below. "POSIX-like in style" means
! 8166: that the API approximates to the POSIX definition; it is not fully
! 8167: POSIX-compatible, and in multi-byte encoding domains it is probably
1.1 misho 8168: even less compatible.
8169:
1.1.1.2 ! misho 8170: The header for these functions is supplied as pcreposix.h to avoid any
! 8171: potential clash with other POSIX libraries. It can, of course, be
1.1 misho 8172: renamed or aliased as regex.h, which is the "correct" name. It provides
1.1.1.2 ! misho 8173: two structure types, regex_t for compiled internal forms, and reg-
! 8174: match_t for returning captured substrings. It also defines some con-
! 8175: stants whose names start with "REG_"; these are used for setting
1.1 misho 8176: options and identifying error codes.
8177:
8178:
8179: COMPILING A PATTERN
8180:
1.1.1.2 ! misho 8181: The function regcomp() is called to compile a pattern into an internal
! 8182: form. The pattern is a C string terminated by a binary zero, and is
! 8183: passed in the argument pattern. The preg argument is a pointer to a
! 8184: regex_t structure that is used as a base for storing information about
1.1 misho 8185: the compiled regular expression.
8186:
8187: The argument cflags is either zero, or contains one or more of the bits
8188: defined by the following macros:
8189:
8190: REG_DOTALL
8191:
8192: The PCRE_DOTALL option is set when the regular expression is passed for
8193: compilation to the native function. Note that REG_DOTALL is not part of
8194: the POSIX standard.
8195:
8196: REG_ICASE
8197:
1.1.1.2 ! misho 8198: The PCRE_CASELESS option is set when the regular expression is passed
1.1 misho 8199: for compilation to the native function.
8200:
8201: REG_NEWLINE
8202:
1.1.1.2 ! misho 8203: The PCRE_MULTILINE option is set when the regular expression is passed
! 8204: for compilation to the native function. Note that this does not mimic
! 8205: the defined POSIX behaviour for REG_NEWLINE (see the following sec-
1.1 misho 8206: tion).
8207:
8208: REG_NOSUB
8209:
1.1.1.2 ! misho 8210: The PCRE_NO_AUTO_CAPTURE option is set when the regular expression is
1.1 misho 8211: passed for compilation to the native function. In addition, when a pat-
1.1.1.2 ! misho 8212: tern that is compiled with this flag is passed to regexec() for match-
! 8213: ing, the nmatch and pmatch arguments are ignored, and no captured
1.1 misho 8214: strings are returned.
8215:
8216: REG_UCP
8217:
1.1.1.2 ! misho 8218: The PCRE_UCP option is set when the regular expression is passed for
! 8219: compilation to the native function. This causes PCRE to use Unicode
! 8220: properties when matchine \d, \w, etc., instead of just recognizing
1.1 misho 8221: ASCII values. Note that REG_UTF8 is not part of the POSIX standard.
8222:
8223: REG_UNGREEDY
8224:
1.1.1.2 ! misho 8225: The PCRE_UNGREEDY option is set when the regular expression is passed
! 8226: for compilation to the native function. Note that REG_UNGREEDY is not
1.1 misho 8227: part of the POSIX standard.
8228:
8229: REG_UTF8
8230:
1.1.1.2 ! misho 8231: The PCRE_UTF8 option is set when the regular expression is passed for
! 8232: compilation to the native function. This causes the pattern itself and
! 8233: all data strings used for matching it to be treated as UTF-8 strings.
1.1 misho 8234: Note that REG_UTF8 is not part of the POSIX standard.
8235:
1.1.1.2 ! misho 8236: In the absence of these flags, no options are passed to the native
! 8237: function. This means the the regex is compiled with PCRE default
! 8238: semantics. In particular, the way it handles newline characters in the
! 8239: subject string is the Perl way, not the POSIX way. Note that setting
! 8240: PCRE_MULTILINE has only some of the effects specified for REG_NEWLINE.
! 8241: It does not affect the way newlines are matched by . (they are not) or
1.1 misho 8242: by a negative class such as [^a] (they are).
8243:
1.1.1.2 ! misho 8244: The yield of regcomp() is zero on success, and non-zero otherwise. The
1.1 misho 8245: preg structure is filled in on success, and one member of the structure
1.1.1.2 ! misho 8246: is public: re_nsub contains the number of capturing subpatterns in the
1.1 misho 8247: regular expression. Various error codes are defined in the header file.
8248:
1.1.1.2 ! misho 8249: NOTE: If the yield of regcomp() is non-zero, you must not attempt to
1.1 misho 8250: use the contents of the preg structure. If, for example, you pass it to
8251: regexec(), the result is undefined and your program is likely to crash.
8252:
8253:
8254: MATCHING NEWLINE CHARACTERS
8255:
8256: This area is not simple, because POSIX and Perl take different views of
1.1.1.2 ! misho 8257: things. It is not possible to get PCRE to obey POSIX semantics, but
! 8258: then PCRE was never intended to be a POSIX engine. The following table
! 8259: lists the different possibilities for matching newline characters in
1.1 misho 8260: PCRE:
8261:
8262: Default Change with
8263:
8264: . matches newline no PCRE_DOTALL
8265: newline matches [^a] yes not changeable
8266: $ matches \n at end yes PCRE_DOLLARENDONLY
8267: $ matches \n in middle no PCRE_MULTILINE
8268: ^ matches \n in middle no PCRE_MULTILINE
8269:
8270: This is the equivalent table for POSIX:
8271:
8272: Default Change with
8273:
8274: . matches newline yes REG_NEWLINE
8275: newline matches [^a] yes REG_NEWLINE
8276: $ matches \n at end no REG_NEWLINE
8277: $ matches \n in middle no REG_NEWLINE
8278: ^ matches \n in middle no REG_NEWLINE
8279:
8280: PCRE's behaviour is the same as Perl's, except that there is no equiva-
1.1.1.2 ! misho 8281: lent for PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is
1.1 misho 8282: no way to stop newline from matching [^a].
8283:
1.1.1.2 ! misho 8284: The default POSIX newline handling can be obtained by setting
! 8285: PCRE_DOTALL and PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE
1.1 misho 8286: behave exactly as for the REG_NEWLINE action.
8287:
8288:
8289: MATCHING A PATTERN
8290:
1.1.1.2 ! misho 8291: The function regexec() is called to match a compiled pattern preg
! 8292: against a given string, which is by default terminated by a zero byte
! 8293: (but see REG_STARTEND below), subject to the options in eflags. These
1.1 misho 8294: can be:
8295:
8296: REG_NOTBOL
8297:
8298: The PCRE_NOTBOL option is set when calling the underlying PCRE matching
8299: function.
8300:
8301: REG_NOTEMPTY
8302:
8303: The PCRE_NOTEMPTY option is set when calling the underlying PCRE match-
8304: ing function. Note that REG_NOTEMPTY is not part of the POSIX standard.
8305: However, setting this option can give more POSIX-like behaviour in some
8306: situations.
8307:
8308: REG_NOTEOL
8309:
8310: The PCRE_NOTEOL option is set when calling the underlying PCRE matching
8311: function.
8312:
8313: REG_STARTEND
8314:
1.1.1.2 ! misho 8315: The string is considered to start at string + pmatch[0].rm_so and to
! 8316: have a terminating NUL located at string + pmatch[0].rm_eo (there need
! 8317: not actually be a NUL at that location), regardless of the value of
! 8318: nmatch. This is a BSD extension, compatible with but not specified by
! 8319: IEEE Standard 1003.2 (POSIX.2), and should be used with caution in
1.1 misho 8320: software intended to be portable to other systems. Note that a non-zero
8321: rm_so does not imply REG_NOTBOL; REG_STARTEND affects only the location
8322: of the string, not how it is matched.
8323:
1.1.1.2 ! misho 8324: If the pattern was compiled with the REG_NOSUB flag, no data about any
! 8325: matched strings is returned. The nmatch and pmatch arguments of
1.1 misho 8326: regexec() are ignored.
8327:
8328: If the value of nmatch is zero, or if the value pmatch is NULL, no data
8329: about any matched strings is returned.
8330:
8331: Otherwise,the portion of the string that was matched, and also any cap-
8332: tured substrings, are returned via the pmatch argument, which points to
1.1.1.2 ! misho 8333: an array of nmatch structures of type regmatch_t, containing the mem-
! 8334: bers rm_so and rm_eo. These contain the offset to the first character
! 8335: of each substring and the offset to the first character after the end
! 8336: of each substring, respectively. The 0th element of the vector relates
! 8337: to the entire portion of string that was matched; subsequent elements
! 8338: relate to the capturing subpatterns of the regular expression. Unused
1.1 misho 8339: entries in the array have both structure members set to -1.
8340:
1.1.1.2 ! misho 8341: A successful match yields a zero return; various error codes are
! 8342: defined in the header file, of which REG_NOMATCH is the "expected"
1.1 misho 8343: failure code.
8344:
8345:
8346: ERROR MESSAGES
8347:
8348: The regerror() function maps a non-zero errorcode from either regcomp()
1.1.1.2 ! misho 8349: or regexec() to a printable message. If preg is not NULL, the error
1.1 misho 8350: should have arisen from the use of that structure. A message terminated
1.1.1.2 ! misho 8351: by a binary zero is placed in errbuf. The length of the message,
! 8352: including the zero, is limited to errbuf_size. The yield of the func-
1.1 misho 8353: tion is the size of buffer needed to hold the whole message.
8354:
8355:
8356: MEMORY USAGE
8357:
1.1.1.2 ! misho 8358: Compiling a regular expression causes memory to be allocated and asso-
! 8359: ciated with the preg structure. The function regfree() frees all such
! 8360: memory, after which preg may no longer be used as a compiled expres-
1.1 misho 8361: sion.
8362:
8363:
8364: AUTHOR
8365:
8366: Philip Hazel
8367: University Computing Service
8368: Cambridge CB2 3QH, England.
8369:
8370:
8371: REVISION
8372:
1.1.1.2 ! misho 8373: Last updated: 09 January 2012
! 8374: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 8375: ------------------------------------------------------------------------------
8376:
8377:
8378: PCRECPP(3) PCRECPP(3)
8379:
8380:
8381: NAME
8382: PCRE - Perl-compatible regular expressions.
8383:
8384:
8385: SYNOPSIS OF C++ WRAPPER
8386:
8387: #include <pcrecpp.h>
8388:
8389:
8390: DESCRIPTION
8391:
8392: The C++ wrapper for PCRE was provided by Google Inc. Some additional
8393: functionality was added by Giuseppe Maxia. This brief man page was con-
8394: structed from the notes in the pcrecpp.h file, which should be con-
1.1.1.2 ! misho 8395: sulted for further details. Note that the C++ wrapper supports only the
! 8396: original 8-bit PCRE library. There is no 16-bit support at present.
1.1 misho 8397:
8398:
8399: MATCHING INTERFACE
8400:
1.1.1.2 ! misho 8401: The "FullMatch" operation checks that supplied text matches a supplied
! 8402: pattern exactly. If pointer arguments are supplied, it copies matched
1.1 misho 8403: sub-strings that match sub-patterns into them.
8404:
8405: Example: successful match
8406: pcrecpp::RE re("h.*o");
8407: re.FullMatch("hello");
8408:
8409: Example: unsuccessful match (requires full match):
8410: pcrecpp::RE re("e");
8411: !re.FullMatch("hello");
8412:
8413: Example: creating a temporary RE object:
8414: pcrecpp::RE("h.*o").FullMatch("hello");
8415:
1.1.1.2 ! misho 8416: You can pass in a "const char*" or a "string" for "text". The examples
! 8417: below tend to use a const char*. You can, as in the different examples
! 8418: above, store the RE object explicitly in a variable or use a temporary
! 8419: RE object. The examples below use one mode or the other arbitrarily.
1.1 misho 8420: Either could correctly be used for any of these examples.
8421:
8422: You must supply extra pointer arguments to extract matched subpieces.
8423:
8424: Example: extracts "ruby" into "s" and 1234 into "i"
8425: int i;
8426: string s;
8427: pcrecpp::RE re("(\\w+):(\\d+)");
8428: re.FullMatch("ruby:1234", &s, &i);
8429:
8430: Example: does not try to extract any extra sub-patterns
8431: re.FullMatch("ruby:1234", &s);
8432:
8433: Example: does not try to extract into NULL
8434: re.FullMatch("ruby:1234", NULL, &i);
8435:
8436: Example: integer overflow causes failure
8437: !re.FullMatch("ruby:1234567891234", NULL, &i);
8438:
8439: Example: fails because there aren't enough sub-patterns:
8440: !pcrecpp::RE("\\w+:\\d+").FullMatch("ruby:1234", &s);
8441:
8442: Example: fails because string cannot be stored in integer
8443: !pcrecpp::RE("(.*)").FullMatch("ruby", &i);
8444:
1.1.1.2 ! misho 8445: The provided pointer arguments can be pointers to any scalar numeric
1.1 misho 8446: type, or one of:
8447:
8448: string (matched piece is copied to string)
8449: StringPiece (StringPiece is mutated to point to matched piece)
8450: T (where "bool T::ParseFrom(const char*, int)" exists)
8451: NULL (the corresponding matched sub-pattern is not copied)
8452:
1.1.1.2 ! misho 8453: The function returns true iff all of the following conditions are sat-
1.1 misho 8454: isfied:
8455:
8456: a. "text" matches "pattern" exactly;
8457:
8458: b. The number of matched sub-patterns is >= number of supplied
8459: pointers;
8460:
8461: c. The "i"th argument has a suitable type for holding the
8462: string captured as the "i"th sub-pattern. If you pass in
8463: void * NULL for the "i"th argument, or a non-void * NULL
8464: of the correct type, or pass fewer arguments than the
8465: number of sub-patterns, "i"th captured sub-pattern is
8466: ignored.
8467:
1.1.1.2 ! misho 8468: CAVEAT: An optional sub-pattern that does not exist in the matched
! 8469: string is assigned the empty string. Therefore, the following will
1.1 misho 8470: return false (because the empty string is not a valid number):
8471:
8472: int number;
8473: pcrecpp::RE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
8474:
1.1.1.2 ! misho 8475: The matching interface supports at most 16 arguments per call. If you
! 8476: need more, consider using the more general interface
1.1 misho 8477: pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.
8478:
1.1.1.2 ! misho 8479: NOTE: Do not use no_arg, which is used internally to mark the end of a
! 8480: list of optional arguments, as a placeholder for missing arguments, as
1.1 misho 8481: this can lead to segfaults.
8482:
8483:
8484: QUOTING METACHARACTERS
8485:
1.1.1.2 ! misho 8486: You can use the "QuoteMeta" operation to insert backslashes before all
! 8487: potentially meaningful characters in a string. The returned string,
1.1 misho 8488: used as a regular expression, will exactly match the original string.
8489:
8490: Example:
8491: string quoted = RE::QuoteMeta(unquoted);
8492:
1.1.1.2 ! misho 8493: Note that it's legal to escape a character even if it has no special
! 8494: meaning in a regular expression -- so this function does that. (This
! 8495: also makes it identical to the perl function of the same name; see
! 8496: "perldoc -f quotemeta".) For example, "1.5-2.0?" becomes
1.1 misho 8497: "1\.5\-2\.0\?".
8498:
8499:
8500: PARTIAL MATCHES
8501:
1.1.1.2 ! misho 8502: You can use the "PartialMatch" operation when you want the pattern to
1.1 misho 8503: match any substring of the text.
8504:
8505: Example: simple search for a string:
8506: pcrecpp::RE("ell").PartialMatch("hello");
8507:
8508: Example: find first number in a string:
8509: int number;
8510: pcrecpp::RE re("(\\d+)");
8511: re.PartialMatch("x*100 + 20", &number);
8512: assert(number == 100);
8513:
8514:
8515: UTF-8 AND THE MATCHING INTERFACE
8516:
1.1.1.2 ! misho 8517: By default, pattern and text are plain text, one byte per character.
! 8518: The UTF8 flag, passed to the constructor, causes both pattern and
1.1 misho 8519: string to be treated as UTF-8 text, still a byte stream but potentially
1.1.1.2 ! misho 8520: multiple bytes per character. In practice, the text is likelier to be
! 8521: UTF-8 than the pattern, but the match returned may depend on the UTF8
! 8522: flag, so always use it when matching UTF8 text. For example, "." will
! 8523: match one byte normally but with UTF8 set may match up to three bytes
1.1 misho 8524: of a multi-byte character.
8525:
8526: Example:
8527: pcrecpp::RE_Options options;
8528: options.set_utf8();
8529: pcrecpp::RE re(utf8_pattern, options);
8530: re.FullMatch(utf8_string);
8531:
8532: Example: using the convenience function UTF8():
8533: pcrecpp::RE re(utf8_pattern, pcrecpp::UTF8());
8534: re.FullMatch(utf8_string);
8535:
8536: NOTE: The UTF8 flag is ignored if pcre was not configured with the
8537: --enable-utf8 flag.
8538:
8539:
8540: PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE
8541:
1.1.1.2 ! misho 8542: PCRE defines some modifiers to change the behavior of the regular
! 8543: expression engine. The C++ wrapper defines an auxiliary class,
! 8544: RE_Options, as a vehicle to pass such modifiers to a RE class. Cur-
1.1 misho 8545: rently, the following modifiers are supported:
8546:
8547: modifier description Perl corresponding
8548:
8549: PCRE_CASELESS case insensitive match /i
8550: PCRE_MULTILINE multiple lines match /m
8551: PCRE_DOTALL dot matches newlines /s
8552: PCRE_DOLLAR_ENDONLY $ matches only at end N/A
8553: PCRE_EXTRA strict escape parsing N/A
8554: PCRE_EXTENDED ignore whitespaces /x
8555: PCRE_UTF8 handles UTF8 chars built-in
8556: PCRE_UNGREEDY reverses * and *? N/A
8557: PCRE_NO_AUTO_CAPTURE disables capturing parens N/A (*)
8558:
1.1.1.2 ! misho 8559: (*) Both Perl and PCRE allow non capturing parentheses by means of the
! 8560: "?:" modifier within the pattern itself. e.g. (?:ab|cd) does not cap-
1.1 misho 8561: ture, while (ab|cd) does.
8562:
1.1.1.2 ! misho 8563: For a full account on how each modifier works, please check the PCRE
1.1 misho 8564: API reference page.
8565:
1.1.1.2 ! misho 8566: For each modifier, there are two member functions whose name is made
! 8567: out of the modifier in lowercase, without the "PCRE_" prefix. For
1.1 misho 8568: instance, PCRE_CASELESS is handled by
8569:
8570: bool caseless()
8571:
8572: which returns true if the modifier is set, and
8573:
8574: RE_Options & set_caseless(bool)
8575:
8576: which sets or unsets the modifier. Moreover, PCRE_EXTRA_MATCH_LIMIT can
1.1.1.2 ! misho 8577: be accessed through the set_match_limit() and match_limit() member
! 8578: functions. Setting match_limit to a non-zero value will limit the exe-
! 8579: cution of pcre to keep it from doing bad things like blowing the stack
! 8580: or taking an eternity to return a result. A value of 5000 is good
! 8581: enough to stop stack blowup in a 2MB thread stack. Setting match_limit
! 8582: to zero disables match limiting. Alternatively, you can call
! 8583: match_limit_recursion() which uses PCRE_EXTRA_MATCH_LIMIT_RECURSION to
! 8584: limit how much PCRE recurses. match_limit() limits the number of
1.1 misho 8585: matches PCRE does; match_limit_recursion() limits the depth of internal
8586: recursion, and therefore the amount of stack that is used.
8587:
1.1.1.2 ! misho 8588: Normally, to pass one or more modifiers to a RE class, you declare a
1.1 misho 8589: RE_Options object, set the appropriate options, and pass this object to
8590: a RE constructor. Example:
8591:
8592: RE_Options opt;
8593: opt.set_caseless(true);
8594: if (RE("HELLO", opt).PartialMatch("hello world")) ...
8595:
8596: RE_options has two constructors. The default constructor takes no argu-
1.1.1.2 ! misho 8597: ments and creates a set of flags that are off by default. The optional
! 8598: parameter option_flags is to facilitate transfer of legacy code from C
1.1 misho 8599: programs. This lets you do
8600:
8601: RE(pattern,
8602: RE_Options(PCRE_CASELESS|PCRE_MULTILINE)).PartialMatch(str);
8603:
8604: However, new code is better off doing
8605:
8606: RE(pattern,
8607: RE_Options().set_caseless(true).set_multiline(true))
8608: .PartialMatch(str);
8609:
8610: If you are going to pass one of the most used modifiers, there are some
8611: convenience functions that return a RE_Options class with the appropri-
1.1.1.2 ! misho 8612: ate modifier already set: CASELESS(), UTF8(), MULTILINE(), DOTALL(),
1.1 misho 8613: and EXTENDED().
8614:
1.1.1.2 ! misho 8615: If you need to set several options at once, and you don't want to go
! 8616: through the pains of declaring a RE_Options object and setting several
! 8617: options, there is a parallel method that give you such ability on the
! 8618: fly. You can concatenate several set_xxxxx() member functions, since
! 8619: each of them returns a reference to its class object. For example, to
! 8620: pass PCRE_CASELESS, PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one
1.1 misho 8621: statement, you may write:
8622:
8623: RE(" ^ xyz \\s+ .* blah$",
8624: RE_Options()
8625: .set_caseless(true)
8626: .set_extended(true)
8627: .set_multiline(true)).PartialMatch(sometext);
8628:
8629:
8630: SCANNING TEXT INCREMENTALLY
8631:
1.1.1.2 ! misho 8632: The "Consume" operation may be useful if you want to repeatedly match
1.1 misho 8633: regular expressions at the front of a string and skip over them as they
1.1.1.2 ! misho 8634: match. This requires use of the "StringPiece" type, which represents a
! 8635: sub-range of a real string. Like RE, StringPiece is defined in the
1.1 misho 8636: pcrecpp namespace.
8637:
8638: Example: read lines of the form "var = value" from a string.
8639: string contents = ...; // Fill string somehow
8640: pcrecpp::StringPiece input(contents); // Wrap in a StringPiece
8641:
8642: string var;
8643: int value;
8644: pcrecpp::RE re("(\\w+) = (\\d+)\n");
8645: while (re.Consume(&input, &var, &value)) {
8646: ...;
8647: }
8648:
1.1.1.2 ! misho 8649: Each successful call to "Consume" will set "var/value", and also
1.1 misho 8650: advance "input" so it points past the matched text.
8651:
1.1.1.2 ! misho 8652: The "FindAndConsume" operation is similar to "Consume" but does not
! 8653: anchor your match at the beginning of the string. For example, you
1.1 misho 8654: could extract all words from a string by repeatedly calling
8655:
8656: pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)
8657:
8658:
8659: PARSING HEX/OCTAL/C-RADIX NUMBERS
8660:
8661: By default, if you pass a pointer to a numeric value, the corresponding
1.1.1.2 ! misho 8662: text is interpreted as a base-10 number. You can instead wrap the
1.1 misho 8663: pointer with a call to one of the operators Hex(), Octal(), or CRadix()
1.1.1.2 ! misho 8664: to interpret the text in another base. The CRadix operator interprets
! 8665: C-style "0" (base-8) and "0x" (base-16) prefixes, but defaults to
1.1 misho 8666: base-10.
8667:
8668: Example:
8669: int a, b, c, d;
8670: pcrecpp::RE re("(.*) (.*) (.*) (.*)");
8671: re.FullMatch("100 40 0100 0x40",
8672: pcrecpp::Octal(&a), pcrecpp::Hex(&b),
8673: pcrecpp::CRadix(&c), pcrecpp::CRadix(&d));
8674:
8675: will leave 64 in a, b, c, and d.
8676:
8677:
8678: REPLACING PARTS OF STRINGS
8679:
1.1.1.2 ! misho 8680: You can replace the first match of "pattern" in "str" with "rewrite".
! 8681: Within "rewrite", backslash-escaped digits (\1 to \9) can be used to
! 8682: insert text matching corresponding parenthesized group from the pat-
1.1 misho 8683: tern. \0 in "rewrite" refers to the entire matching text. For example:
8684:
8685: string s = "yabba dabba doo";
8686: pcrecpp::RE("b+").Replace("d", &s);
8687:
1.1.1.2 ! misho 8688: will leave "s" containing "yada dabba doo". The result is true if the
1.1 misho 8689: pattern matches and a replacement occurs, false otherwise.
8690:
1.1.1.2 ! misho 8691: GlobalReplace is like Replace except that it replaces all occurrences
! 8692: of the pattern in the string with the rewrite. Replacements are not
1.1 misho 8693: subject to re-matching. For example:
8694:
8695: string s = "yabba dabba doo";
8696: pcrecpp::RE("b+").GlobalReplace("d", &s);
8697:
1.1.1.2 ! misho 8698: will leave "s" containing "yada dada doo". It returns the number of
1.1 misho 8699: replacements made.
8700:
1.1.1.2 ! misho 8701: Extract is like Replace, except that if the pattern matches, "rewrite"
! 8702: is copied into "out" (an additional argument) with substitutions. The
! 8703: non-matching portions of "text" are ignored. Returns true iff a match
1.1 misho 8704: occurred and the extraction happened successfully; if no match occurs,
8705: the string is left unaffected.
8706:
8707:
8708: AUTHOR
8709:
8710: The C++ wrapper was contributed by Google Inc.
8711: Copyright (c) 2007 Google Inc.
8712:
8713:
8714: REVISION
8715:
1.1.1.2 ! misho 8716: Last updated: 08 January 2012
1.1 misho 8717: ------------------------------------------------------------------------------
8718:
8719:
8720: PCRESAMPLE(3) PCRESAMPLE(3)
8721:
8722:
8723: NAME
8724: PCRE - Perl-compatible regular expressions
8725:
8726:
8727: PCRE SAMPLE PROGRAM
8728:
8729: A simple, complete demonstration program, to get you started with using
8730: PCRE, is supplied in the file pcredemo.c in the PCRE distribution. A
8731: listing of this program is given in the pcredemo documentation. If you
8732: do not have a copy of the PCRE distribution, you can save this listing
8733: to re-create pcredemo.c.
8734:
1.1.1.2 ! misho 8735: The demonstration program, which uses the original PCRE 8-bit library,
! 8736: compiles the regular expression that is its first argument, and matches
! 8737: it against the subject string in its second argument. No PCRE options
! 8738: are set, and default character tables are used. If matching succeeds,
! 8739: the program outputs the portion of the subject that matched, together
! 8740: with the contents of any captured substrings.
1.1 misho 8741:
8742: If the -g option is given on the command line, the program then goes on
8743: to check for further matches of the same regular expression in the same
1.1.1.2 ! misho 8744: subject string. The logic is a little bit tricky because of the possi-
! 8745: bility of matching an empty string. Comments in the code explain what
1.1 misho 8746: is going on.
8747:
1.1.1.2 ! misho 8748: If PCRE is installed in the standard include and library directories
1.1 misho 8749: for your operating system, you should be able to compile the demonstra-
8750: tion program using this command:
8751:
8752: gcc -o pcredemo pcredemo.c -lpcre
8753:
1.1.1.2 ! misho 8754: If PCRE is installed elsewhere, you may need to add additional options
! 8755: to the command line. For example, on a Unix-like system that has PCRE
! 8756: installed in /usr/local, you can compile the demonstration program
1.1 misho 8757: using a command like this:
8758:
8759: gcc -o pcredemo -I/usr/local/include pcredemo.c \
8760: -L/usr/local/lib -lpcre
8761:
1.1.1.2 ! misho 8762: In a Windows environment, if you want to statically link the program
1.1 misho 8763: against a non-dll pcre.a file, you must uncomment the line that defines
1.1.1.2 ! misho 8764: PCRE_STATIC before including pcre.h, because otherwise the pcre_mal-
1.1 misho 8765: loc() and pcre_free() exported functions will be declared
8766: __declspec(dllimport), with unwanted results.
8767:
1.1.1.2 ! misho 8768: Once you have compiled and linked the demonstration program, you can
1.1 misho 8769: run simple tests like this:
8770:
8771: ./pcredemo 'cat|dog' 'the cat sat on the mat'
8772: ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
8773:
1.1.1.2 ! misho 8774: Note that there is a much more comprehensive test program, called
! 8775: pcretest, which supports many more facilities for testing regular
! 8776: expressions and both PCRE libraries. The pcredemo program is provided
! 8777: as a simple coding example.
1.1 misho 8778:
1.1.1.2 ! misho 8779: If you try to run pcredemo when PCRE is not installed in the standard
! 8780: library directory, you may get an error like this on some operating
1.1 misho 8781: systems (e.g. Solaris):
8782:
1.1.1.2 ! misho 8783: ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or
1.1 misho 8784: directory
8785:
1.1.1.2 ! misho 8786: This is caused by the way shared library support works on those sys-
1.1 misho 8787: tems. You need to add
8788:
8789: -R/usr/local/lib
8790:
8791: (for example) to the compile command to get round this problem.
8792:
8793:
8794: AUTHOR
8795:
8796: Philip Hazel
8797: University Computing Service
8798: Cambridge CB2 3QH, England.
8799:
8800:
8801: REVISION
8802:
1.1.1.2 ! misho 8803: Last updated: 10 January 2012
! 8804: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 8805: ------------------------------------------------------------------------------
8806: PCRELIMITS(3) PCRELIMITS(3)
8807:
8808:
8809: NAME
8810: PCRE - Perl-compatible regular expressions
8811:
8812:
8813: SIZE AND OTHER LIMITATIONS
8814:
8815: There are some size limitations in PCRE but it is hoped that they will
8816: never in practice be relevant.
8817:
1.1.1.2 ! misho 8818: The maximum length of a compiled pattern is approximately 64K data
! 8819: units (bytes for the 8-bit library, 16-bit units for the 16-bit
! 8820: library) if PCRE is compiled with the default internal linkage size of
! 8821: 2 bytes. If you want to process regular expressions that are truly
! 8822: enormous, you can compile PCRE with an internal linkage size of 3 or 4
! 8823: (when building the 16-bit library, 3 is rounded up to 4). See the
! 8824: README file in the source distribution and the pcrebuild documentation
! 8825: for details. In these cases the limit is substantially larger. How-
! 8826: ever, the speed of execution is slower.
1.1 misho 8827:
8828: All values in repeating quantifiers must be less than 65536.
8829:
8830: There is no limit to the number of parenthesized subpatterns, but there
8831: can be no more than 65535 capturing subpatterns.
8832:
8833: There is a limit to the number of forward references to subsequent sub-
8834: patterns of around 200,000. Repeated forward references with fixed
8835: upper limits, for example, (?2){0,100} when subpattern number 2 is to
8836: the right, are included in the count. There is no limit to the number
8837: of backward references.
8838:
8839: The maximum length of name for a named subpattern is 32 characters, and
8840: the maximum number of named subpatterns is 10000.
8841:
8842: The maximum length of a subject string is the largest positive number
8843: that an integer variable can hold. However, when using the traditional
8844: matching function, PCRE uses recursion to handle subpatterns and indef-
8845: inite repetition. This means that the available stack space may limit
8846: the size of a subject string that can be processed by certain patterns.
8847: For a discussion of stack issues, see the pcrestack documentation.
8848:
8849:
8850: AUTHOR
8851:
8852: Philip Hazel
8853: University Computing Service
8854: Cambridge CB2 3QH, England.
8855:
8856:
8857: REVISION
8858:
1.1.1.2 ! misho 8859: Last updated: 08 January 2012
! 8860: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 8861: ------------------------------------------------------------------------------
8862:
8863:
8864: PCRESTACK(3) PCRESTACK(3)
8865:
8866:
8867: NAME
8868: PCRE - Perl-compatible regular expressions
8869:
8870:
8871: PCRE DISCUSSION OF STACK USAGE
8872:
1.1.1.2 ! misho 8873: When you call pcre[16]_exec(), it makes use of an internal function
! 8874: called match(). This calls itself recursively at branch points in the
! 8875: pattern, in order to remember the state of the match so that it can
! 8876: back up and try a different alternative if the first one fails. As
! 8877: matching proceeds deeper and deeper into the tree of possibilities, the
! 8878: recursion depth increases. The match() function is also called in other
! 8879: circumstances, for example, whenever a parenthesized sub-pattern is
! 8880: entered, and in certain cases of repetition.
1.1 misho 8881:
8882: Not all calls of match() increase the recursion depth; for an item such
8883: as a* it may be called several times at the same level, after matching
8884: different numbers of a's. Furthermore, in a number of cases where the
8885: result of the recursive call would immediately be passed back as the
8886: result of the current call (a "tail recursion"), the function is just
8887: restarted instead.
8888:
1.1.1.2 ! misho 8889: The above comments apply when pcre[16]_exec() is run in its normal
! 8890: interpretive manner. If the pattern was studied with the
! 8891: PCRE_STUDY_JIT_COMPILE option, and just-in-time compiling was success-
! 8892: ful, and the options passed to pcre[16]_exec() were not incompatible,
! 8893: the matching process uses the JIT-compiled code instead of the match()
! 8894: function. In this case, the memory requirements are handled entirely
! 8895: differently. See the pcrejit documentation for details.
1.1 misho 8896:
1.1.1.2 ! misho 8897: The pcre[16]_dfa_exec() function operates in an entirely different way,
! 8898: and uses recursion only when there is a regular expression recursion or
1.1 misho 8899: subroutine call in the pattern. This includes the processing of asser-
8900: tion and "once-only" subpatterns, which are handled like subroutine
8901: calls. Normally, these are never very deep, and the limit on the com-
1.1.1.2 ! misho 8902: plexity of pcre[16]_dfa_exec() is controlled by the amount of workspace
! 8903: it is given. However, it is possible to write patterns with runaway
! 8904: infinite recursions; such patterns will cause pcre[16]_dfa_exec() to
! 8905: run out of stack. At present, there is no protection against this.
1.1 misho 8906:
1.1.1.2 ! misho 8907: The comments that follow do NOT apply to pcre[16]_dfa_exec(); they are
! 8908: relevant only for pcre[16]_exec() without the JIT optimization.
1.1 misho 8909:
1.1.1.2 ! misho 8910: Reducing pcre[16]_exec()'s stack usage
1.1 misho 8911:
8912: Each time that match() is actually called recursively, it uses memory
8913: from the process stack. For certain kinds of pattern and data, very
8914: large amounts of stack may be needed, despite the recognition of "tail
8915: recursion". You can often reduce the amount of recursion, and there-
8916: fore the amount of stack used, by modifying the pattern that is being
8917: matched. Consider, for example, this pattern:
8918:
8919: ([^<]|<(?!inet))+
8920:
8921: It matches from wherever it starts until it encounters "<inet" or the
8922: end of the data, and is the kind of pattern that might be used when
8923: processing an XML file. Each iteration of the outer parentheses matches
8924: either one character that is not "<" or a "<" that is not followed by
8925: "inet". However, each time a parenthesis is processed, a recursion
8926: occurs, so this formulation uses a stack frame for each matched charac-
8927: ter. For a long string, a lot of stack is required. Consider now this
8928: rewritten pattern, which matches exactly the same strings:
8929:
8930: ([^<]++|<(?!inet))+
8931:
8932: This uses very much less stack, because runs of characters that do not
8933: contain "<" are "swallowed" in one item inside the parentheses. Recur-
8934: sion happens only when a "<" character that is not followed by "inet"
8935: is encountered (and we assume this is relatively rare). A possessive
8936: quantifier is used to stop any backtracking into the runs of non-"<"
8937: characters, but that is not related to stack usage.
8938:
8939: This example shows that one way of avoiding stack problems when match-
8940: ing long subject strings is to write repeated parenthesized subpatterns
8941: to match more than one character whenever possible.
8942:
1.1.1.2 ! misho 8943: Compiling PCRE to use heap instead of stack for pcre[16]_exec()
1.1 misho 8944:
8945: In environments where stack memory is constrained, you might want to
8946: compile PCRE to use heap memory instead of stack for remembering back-
1.1.1.2 ! misho 8947: up points when pcre[16]_exec() is running. This makes it run a lot more
1.1 misho 8948: slowly, however. Details of how to do this are given in the pcrebuild
8949: documentation. When built in this way, instead of using the stack, PCRE
8950: obtains and frees memory by calling the functions that are pointed to
1.1.1.2 ! misho 8951: by the pcre[16]_stack_malloc and pcre[16]_stack_free variables. By
! 8952: default, these point to malloc() and free(), but you can replace the
! 8953: pointers to cause PCRE to use your own functions. Since the block sizes
! 8954: are always the same, and are always freed in reverse order, it may be
! 8955: possible to implement customized memory handlers that are more effi-
! 8956: cient than the standard functions.
1.1 misho 8957:
1.1.1.2 ! misho 8958: Limiting pcre[16]_exec()'s stack usage
1.1 misho 8959:
8960: You can set limits on the number of times that match() is called, both
1.1.1.2 ! misho 8961: in total and recursively. If a limit is exceeded, pcre[16]_exec()
! 8962: returns an error code. Setting suitable limits should prevent it from
! 8963: running out of stack. The default values of the limits are very large,
! 8964: and unlikely ever to operate. They can be changed when PCRE is built,
! 8965: and they can also be set when pcre[16]_exec() is called. For details of
! 8966: these interfaces, see the pcrebuild documentation and the section on
! 8967: extra data for pcre[16]_exec() in the pcreapi documentation.
1.1 misho 8968:
8969: As a very rough rule of thumb, you should reckon on about 500 bytes per
8970: recursion. Thus, if you want to limit your stack usage to 8Mb, you
8971: should set the limit at 16000 recursions. A 64Mb stack, on the other
8972: hand, can support around 128000 recursions.
8973:
8974: In Unix-like environments, the pcretest test program has a command line
8975: option (-S) that can be used to increase the size of its stack. As long
8976: as the stack is large enough, another option (-M) can be used to find
8977: the smallest limits that allow a particular pattern to match a given
1.1.1.2 ! misho 8978: subject string. This is done by calling pcre[16]_exec() repeatedly with
1.1 misho 8979: different limits.
8980:
1.1.1.2 ! misho 8981: Obtaining an estimate of stack usage
! 8982:
! 8983: The actual amount of stack used per recursion can vary quite a lot,
! 8984: depending on the compiler that was used to build PCRE and the optimiza-
! 8985: tion or debugging options that were set for it. The rule of thumb value
! 8986: of 500 bytes mentioned above may be larger or smaller than what is
! 8987: actually needed. A better approximation can be obtained by running this
! 8988: command:
! 8989:
! 8990: pcretest -m -C
! 8991:
! 8992: The -C option causes pcretest to output information about the options
! 8993: with which PCRE was compiled. When -m is also given (before -C), infor-
! 8994: mation about stack use is given in a line like this:
! 8995:
! 8996: Match recursion uses stack: approximate frame size = 640 bytes
! 8997:
! 8998: The value is approximate because some recursions need a bit more (up to
! 8999: perhaps 16 more bytes).
! 9000:
! 9001: If the above command is given when PCRE is compiled to use the heap
! 9002: instead of the stack for recursion, the value that is output is the
! 9003: size of each block that is obtained from the heap.
! 9004:
1.1 misho 9005: Changing stack size in Unix-like systems
9006:
9007: In Unix-like environments, there is not often a problem with the stack
9008: unless very long strings are involved, though the default limit on
9009: stack size varies from system to system. Values from 8Mb to 64Mb are
9010: common. You can find your default limit by running the command:
9011:
9012: ulimit -s
9013:
9014: Unfortunately, the effect of running out of stack is often SIGSEGV,
9015: though sometimes a more explicit error message is given. You can nor-
9016: mally increase the limit on stack size by code such as this:
9017:
9018: struct rlimit rlim;
9019: getrlimit(RLIMIT_STACK, &rlim);
9020: rlim.rlim_cur = 100*1024*1024;
9021: setrlimit(RLIMIT_STACK, &rlim);
9022:
9023: This reads the current limits (soft and hard) using getrlimit(), then
9024: attempts to increase the soft limit to 100Mb using setrlimit(). You
1.1.1.2 ! misho 9025: must do this before calling pcre[16]_exec().
1.1 misho 9026:
9027: Changing stack size in Mac OS X
9028:
9029: Using setrlimit(), as described above, should also work on Mac OS X. It
9030: is also possible to set a stack size when linking a program. There is a
9031: discussion about stack sizes in Mac OS X at this web site:
9032: http://developer.apple.com/qa/qa2005/qa1419.html.
9033:
9034:
9035: AUTHOR
9036:
9037: Philip Hazel
9038: University Computing Service
9039: Cambridge CB2 3QH, England.
9040:
9041:
9042: REVISION
9043:
1.1.1.2 ! misho 9044: Last updated: 21 January 2012
! 9045: Copyright (c) 1997-2012 University of Cambridge.
1.1 misho 9046: ------------------------------------------------------------------------------
9047:
9048:
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 / pcre / doc