![\"PCRE2:](\"https://raw.githubusercontent.com/PCRE2Project/pcre2/refs/heads/pages/pages/static/images/pcre2-readme-dark.svg\")
\n| Website | \n\n\nhttps://pcre2project.github.io/pcre2/\n\n | \n
|---|---|
| Distribution | \n\n\n[](https://github.com/PCRE2Project/pcre2/releases) \n[](https://github.com/PCRE2Project/pcre2/blob/main/LICENCE.md)\n\n |
| Testing | \n\n\n[](https://app.codecov.io/gh/PCRE2Project/pcre2/components) \n[](https://github.com/PCRE2Project/pcre2/actions/workflows/dev.yml) \n[](https://github.com/PCRE2Project/pcre2/actions/workflows/clang-analyzer.yml) \n[](https://github.com/PCRE2Project/pcre2/actions/workflows/dev.yml) \n[](https://scan.coverity.com/projects/pcre2?tab=overview) \n[](https://github.com/PCRE2Project/pcre2/actions/workflows/codeql.yml) \n[](https://google.github.io/oss-fuzz/) \n[](https://scorecard.dev/viewer/?uri=github.com%2FPCRE2Project%2Fpcre2) \n\n | \n
| Platforms | \nTested continuously on Linux, Windows, macOS, FreeBSD, OpenBSD, Solaris, z/OS; \nx86, ARM, RISC-V, POWER, S390X; others known to work\n | \n
Show script
\n\n```bash session\n# Fetch PCRE2 with 'git clone', or use curl/wget to download a release.\n# Here, let's use git to check out a release tag:\ngit clone https://github.com/PCRE2Project/pcre2.git ./pcre2 \\\n --branch pcre2-$PCRE2_VERSION \\\n -c advice.detachedHead=false --depth 1\n\n# If using the JIT, remember to fetch the Git submodule:\n(cd ./pcre2; git submodule update --init)\n\n# Now let's build PCRE2:\n(cd ./pcre2; \\\n cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug \\\n -DPCRE2_SUPPORT_JIT=ON -B build; \\\n cmake --build build/)\n\n# Great, PCRE2 is built.\n\n# Here's a quick little demo to show how we can make use of PCRE2.\n# For a fuller example, see './pcre2/src/pcre2demo.c'.\n# See below for the demo code.\n\n# Compile the demo:\ngcc -g -I./pcre2/build -L./pcre2/build demo.c -o demo -lpcre2-8\n\n# Finally, run our demo:\n./demo 'c.t' 'dogs and cats'\n\n# We fetched, built, and called PCRE2 successfully! :)\n```\n\nFile `demo.c`:\n\n```c\n/* Set PCRE2_CODE_UNIT_WIDTH to indicate we will use 8-bit input. */\n#define PCRE2_CODE_UNIT_WIDTH 8\n#include- \n
- Operating systems \n
- \nOur continuous integration tests on Linux (GCC and Clang, glibc and musl), Windows (MSVC and MinGW-x64), and macOS (Clang), as well as FreeBSD, OpenBSD, Solaris (Oracle Studio
cc), and z/OS (xlcandibm-clang).\n \n - Processors \n
- \nPCRE2 is tested continuously on x86 (i686 and amd64), ARM 32- and 64-bit (armv7 and aarch64), RISC-V (riscv64), POWER (ppc64le), and the big-endian S390x.\n \n
Perl-compatible Regular Expressions (revised API: PCRE2)
\n\nThe HTML documentation for PCRE2 consists of a number of pages that are listed\nbelow in alphabetical order. If you are new to PCRE2, please read the first one\nfirst.\n
\n\n| pcre2 | \nIntroductory page |
| pcre2-config | \nInformation about the installation configuration |
| pcre2api | \nPCRE2's native API |
| pcre2build | \nBuilding PCRE2 |
| pcre2callout | \nThe callout facility |
| pcre2compat | \nCompability with Perl |
| pcre2convert | \nExperimental foreign pattern conversion functions |
| pcre2demo | \nA demonstration C program that uses the PCRE2 library |
| pcre2grep | \nThe pcre2grep command |
| pcre2jit | \nDiscussion of the just-in-time optimization support |
| pcre2limits | \nDetails of size and other limits |
| pcre2matching | \nDiscussion of the two matching algorithms |
| pcre2partial | \nUsing PCRE2 for partial matching |
| pcre2pattern | \nSpecification of the regular expressions supported by PCRE2 |
| pcre2perform | \nSome comments on performance |
| pcre2posix | \nThe POSIX API to the PCRE2 8-bit library |
| pcre2sample | \nDiscussion of the pcre2demo program |
| pcre2serialize | \nSerializing functions for saving precompiled patterns |
| pcre2syntax | \nSyntax quick-reference summary |
| pcre2test | \nThe pcre2test command for testing PCRE2 |
| pcre2unicode | \nDiscussion of Unicode and UTF-8/UTF-16/UTF-32 support |
\nThere are also individual pages that summarize the interface for each function\nin the library.\n
\n\n| pcre2_callout_enumerate | \nEnumerate callouts in a compiled pattern |
| pcre2_code_copy | \nCopy a compiled pattern |
| pcre2_code_copy_with_tables | \nCopy a compiled pattern and its character tables |
| pcre2_code_free | \nFree a compiled pattern |
| pcre2_compile | \nCompile a regular expression pattern |
| pcre2_compile_context_copy | \nCopy a compile context |
| pcre2_compile_context_create | \nCreate a compile context |
| pcre2_compile_context_free | \nFree a compile context |
| pcre2_config | \nShow build-time related configuration options |
| pcre2_convert_context_copy | \nCopy a convert context |
| pcre2_convert_context_create | \nCreate a convert context |
| pcre2_convert_context_free | \nFree a convert context |
| pcre2_converted_pattern_free | \nFree converted foreign pattern |
| pcre2_dfa_match | \nMatch a compiled pattern to a subject string\n (DFA algorithm; not Perl compatible) |
| pcre2_general_context_copy | \nCopy a general context |
| pcre2_general_context_create | \nCreate a general context |
| pcre2_general_context_free | \nFree a general context |
| pcre2_get_error_message | \nGet textual error message for error number |
| pcre2_get_mark | \nGet a (*MARK) name |
| pcre2_get_match_data_size | \nGet the size of a match data block |
| pcre2_get_ovector_count | \nGet the ovector count |
| pcre2_get_ovector_pointer | \nGet a pointer to the ovector |
| pcre2_get_startchar | \nGet the starting character offset |
| pcre2_jit_compile | \nProcess a compiled pattern with the JIT compiler |
| pcre2_jit_free_unused_memory | \nFree unused JIT memory |
| pcre2_jit_match | \nFast path interface to JIT matching |
| pcre2_jit_stack_assign | \nAssign stack for JIT matching |
| pcre2_jit_stack_create | \nCreate a stack for JIT matching |
| pcre2_jit_stack_free | \nFree a JIT matching stack |
| pcre2_maketables | \nBuild character tables in current locale |
| pcre2_maketables_free | \nFree character tables |
| pcre2_match | \nMatch a compiled pattern to a subject string\n (Perl compatible) |
| pcre2_match_context_copy | \nCopy a match context |
| pcre2_match_context_create | \nCreate a match context |
| pcre2_match_context_free | \nFree a match context |
| pcre2_match_data_create | \nCreate a match data block |
| pcre2_match_data_create_from_pattern | \nCreate a match data block getting size from pattern |
| pcre2_match_data_free | \nFree a match data block |
| pcre2_next_match | \nGet the match parameters for the next match |
| pcre2_pattern_convert | \nExperimental foreign pattern converter |
| pcre2_pattern_info | \nExtract information about a pattern |
| pcre2_serialize_decode | \nDecode serialized compiled patterns |
| pcre2_serialize_encode | \nSerialize compiled patterns for save/restore |
| pcre2_serialize_free | \nFree serialized compiled patterns |
| pcre2_serialize_get_number_of_codes | \nGet number of serialized compiled patterns |
| pcre2_set_bsr | \nSet \\R convention |
| pcre2_set_callout | \nSet up a callout function |
| pcre2_set_character_tables | \nSet character tables |
| pcre2_set_compile_extra_options | \nSet compile time extra options |
| pcre2_set_compile_recursion_guard | \nSet up a compile recursion guard function |
| pcre2_set_depth_limit | \nSet the match backtracking depth limit |
| pcre2_set_glob_escape | \nSet glob escape character |
| pcre2_set_glob_separator | \nSet glob separator character |
| pcre2_set_heap_limit | \nSet the match backtracking heap limit |
| pcre2_set_match_limit | \nSet the match limit |
| pcre2_set_max_pattern_compiled_length | \nSet the maximum length of a compiled pattern |
| pcre2_set_max_pattern_length | \nSet the maximum length of a pattern |
| pcre2_set_max_varlookbehind | \nSet the maximum match length for a variable-length lookbehind |
| pcre2_set_newline | \nSet the newline convention |
| pcre2_set_offset_limit | \nSet the offset limit |
| pcre2_set_optimize | \nSet an optimization directive |
| pcre2_set_parens_nest_limit | \nSet the parentheses nesting limit |
| pcre2_set_recursion_limit | \nObsolete: use pcre2_set_depth_limit |
| pcre2_set_recursion_memory_management | \nObsolete function that (from 10.30 onwards) does nothing |
| pcre2_set_substitute_callout | \nSet a substitution callout function |
| pcre2_set_substitute_case_callout | \nSet a substitution case callout function |
| pcre2_substitute | \nMatch a compiled pattern to a subject string and do\n substitutions |
| pcre2_substring_copy_byname | \nExtract named substring into given buffer |
| pcre2_substring_copy_bynumber | \nExtract numbered substring into given buffer |
| pcre2_substring_free | \nFree extracted substring |
| pcre2_substring_get_byname | \nExtract named substring into new memory |
| pcre2_substring_get_bynumber | \nExtract numbered substring into new memory |
| pcre2_substring_length_byname | \nFind length of named substring |
| pcre2_substring_length_bynumber | \nFind length of numbered substring |
| pcre2_substring_list_free | \nFree list of extracted substrings |
| pcre2_substring_list_get | \nExtract all substrings into new memory |
| pcre2_substring_nametable_scan | \nFind table entries for given string name |
| pcre2_substring_number_from_name | \nConvert captured string name to number |
pcre2-config man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
SYNOPSIS
\n\npcre2-config [--prefix] [--exec-prefix] [--version]\n [--libs8] [--libs16] [--libs32] [--libs-posix]\n [--cflags] [--cflags-posix]\n
\nDESCRIPTION
\n\npcre2-config returns the configuration of the installed PCRE2 libraries\nand the options required to compile a program to use them. Some of the options\napply only to the 8-bit, 16-bit, or 32-bit libraries, respectively, and are not\navailable for libraries that have not been built. If an unavailable option is\nencountered, the \"usage\" information is output.\n
\nOPTIONS
\n\n--prefix\nWrites the directory prefix used in the PCRE2 installation for\narchitecture-independent files (/usr on many systems, /usr/local on\nsome systems) to the standard output.\n
\n\n--exec-prefix\nWrites the directory prefix used in the PCRE2 installation for\narchitecture-dependent files (normally the same as --prefix) to the\nstandard output.\n
\n\n--version\nWrites the version number of the installed PCRE2 libraries to the standard\noutput.\n
\n\n--libs8\nWrites to the standard output the command line options required to link\nwith the 8-bit PCRE2 library (-lpcre2-8 on many systems).\n
\n\n--libs16\nWrites to the standard output the command line options required to link\nwith the 16-bit PCRE2 library (-lpcre2-16 on many systems).\n
\n\n--libs32\nWrites to the standard output the command line options required to link\nwith the 32-bit PCRE2 library (-lpcre2-32 on many systems).\n
\n\n--libs-posix\nWrites to the standard output the command line options required to link with\nPCRE2's POSIX API wrapper library (-lpcre2-posix -lpcre2-8 on many\nsystems).\n
\n\n--cflags\nWrites to the standard output the command line options required to compile\nfiles that use PCRE2 (this may include some -I options, but is blank on\nmany systems).\n
\n\n--cflags-posix\nWrites to the standard output the command line options required to compile\nfiles that use PCRE2's POSIX API wrapper library (this may include some\n-I options, but is blank on many systems).\n
\nSEE ALSO
\n\npcre2(3)\n
\nAUTHOR
\n\nThis manual page was originally written by Mark Baker for the Debian GNU/Linux\nsystem. It has been subsequently revised as a generic PCRE2 man page.\n
\nREVISION
\n\nLast updated: 22 February 2025\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2.html", "content": "\n\npcre2 man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
INTRODUCTION
\n\nPCRE2 is the name used for a revised API for the PCRE library, which is a set\nof functions, written in C, that implement regular expression pattern matching\nusing the same syntax and semantics as Perl, with just a few differences. After\nnearly two decades, the limitations of the original API were making development\nincreasingly difficult. The new API is more extensible, and it was simplified\nby abolishing the separate \"study\" optimizing function; in PCRE2, patterns are\nautomatically optimized where possible. Since forking from PCRE1, the code has\nbeen extensively refactored and new features introduced. The old library is now\nobsolete and is no longer maintained.\n
\n\nAs well as Perl-style regular expression patterns, some features that appeared\nin Python and the original PCRE before they appeared in Perl are available\nusing the Python syntax. There is also support for some .NET and Oniguruma\nsyntax items, and there are options for requesting minor changes that give\nbetter ECMAScript (JavaScript) compatibility.\n
\n\nThe source code for PCRE2 can be compiled to support strings of 8-bit, 16-bit,\nor 32-bit code units, which means that up to three separate libraries may be\ninstalled, one for each code unit size. The size of a code unit is not related\nto the bit size of the underlying hardware. In a 64-bit environment that also\nsupports 32-bit applications, versions of PCRE2 that are compiled in both\n64-bit and 32-bit modes may be needed.\n
\n\nThe original work to extend PCRE to 16-bit and 32-bit code units was done by\nZoltan Herczeg and Christian Persch, respectively. In all three cases, strings\ncan be interpreted either as one character per code unit, or as UTF-encoded\nUnicode, with support for Unicode general category properties. Unicode support\nis optional at build time (but is the default). However, processing strings as\nUTF code units must be enabled explicitly at run time. The version of Unicode\nin use can be discovered by running\n
\n pcre2test -C\n\n\n
\nThe three libraries contain identical sets of functions, with names ending in\n_8, _16, or _32, respectively (for example, pcre2_compile_8()). However,\nby defining PCRE2_CODE_UNIT_WIDTH to be 8, 16, or 32, a program that uses just\none code unit width can be written using generic names such as\npcre2_compile(), and the documentation is written assuming that this is\nthe case.\n
\n\nIn addition to the Perl-compatible matching function, PCRE2 contains an\nalternative function that matches the same compiled patterns in a different\nway. In certain circumstances, the alternative function has some advantages.\nFor a discussion of the two matching algorithms, see the\npcre2matching\npage.\n
\n\nDetails of exactly which Perl regular expression features are and are not\nsupported by PCRE2 are given in separate documents. See the\npcre2pattern\nand\npcre2compat\npages. There is a syntax summary in the\npcre2syntax\npage.\n
\n\nSome features of PCRE2 can be included, excluded, or changed when the library\nis built. The\npcre2_config()\nfunction makes it possible for a client to discover which features are\navailable. The features themselves are described in the\npcre2build\npage. Documentation about building PCRE2 for various operating systems can be\nfound in the\nREADME\nand\nNON-AUTOTOOLS-BUILD\nfiles in the source distribution.\n
\n\nThe libraries contains a number of undocumented internal functions and data\ntables that are used by more than one of the exported external functions, but\nwhich are not intended for use by external callers. Their names all begin with\n\"_pcre2\", which hopefully will not provoke any name clashes. In some\nenvironments, it is possible to control which external symbols are exported\nwhen a shared library is built, and in these cases the undocumented symbols are\nnot exported.\n
\nSECURITY CONSIDERATIONS
\n\nIf you are using PCRE2 in a non-UTF application that permits users to supply\narbitrary patterns for compilation, you should be aware of a feature that\nallows users to turn on UTF support from within a pattern. For example, an\n8-bit pattern that begins with \"(*UTF)\" turns on UTF-8 mode, which interprets\npatterns and subjects as strings of UTF-8 code units instead of individual\n8-bit characters. This causes both the pattern and any data against which it is\nmatched to be checked for UTF-8 validity. If the data string is very long, such\na check might use sufficiently many resources as to cause your application to\nlose performance.\n
\n\nOne way of guarding against this possibility is to use the\npcre2_pattern_info() function to check the compiled pattern's options for\nPCRE2_UTF. Alternatively, you can set the PCRE2_NEVER_UTF option when calling\npcre2_compile(). This causes a compile time error if the pattern contains\na UTF-setting sequence.\n
\n\nThe use of Unicode properties for character types such as \\d can also be\nenabled from within the pattern, by specifying \"(*UCP)\". This feature can be\ndisallowed by setting the PCRE2_NEVER_UCP option.\n
\n\nIf your application is one that supports UTF, be aware that validity checking\ncan take time. If the same data string is to be matched many times, you can use\nthe PCRE2_NO_UTF_CHECK option for the second and subsequent matches to avoid\nrunning redundant checks.\n
\n\nThe use of the \\C escape sequence in a UTF-8 or UTF-16 pattern can lead to\nproblems, because it may leave the current matching point in the middle of a\nmulti-code-unit character. The PCRE2_NEVER_BACKSLASH_C option can be used by an\napplication to lock out the use of \\C, causing a compile-time error if it is\nencountered. It is also possible to build PCRE2 with the use of \\C permanently\ndisabled.\n
\n\nAnother way that performance can be hit is by running a pattern that has a very\nlarge search tree against a string that will never match. Nested unlimited\nrepeats in a pattern are a common example. PCRE2 provides some protection\nagainst this: see the pcre2_set_match_limit() function in the\npcre2api\npage. There is a similar function called pcre2_set_depth_limit() that can\nbe used to restrict the amount of memory that is used.\n
\nUSER DOCUMENTATION
\n\nThe user documentation for PCRE2 comprises a number of different sections. In\nthe \"man\" format, each of these is a separate \"man page\". In the HTML format,\neach is a separate page, linked from the index page. In the plain text format,\nthe descriptions of the pcre2grep and pcre2test programs are in\nfiles called pcre2grep.txt and pcre2test.txt, respectively. The\nremaining sections, except for the pcre2demo section (which is a program\nlisting), and the short pages for individual functions, are concatenated in\npcre2.txt, for ease of searching. The sections are as follows:\n
\n pcre2 this document\n pcre2-config show PCRE2 installation configuration information\n pcre2api details of PCRE2's native C API\n pcre2build building PCRE2\n pcre2callout details of the pattern callout feature\n pcre2compat discussion of Perl compatibility\n pcre2convert details of pattern conversion functions\n pcre2demo a demonstration C program that uses PCRE2\n pcre2grep description of the pcre2grep command (8-bit only)\n pcre2jit discussion of just-in-time optimization support\n pcre2limits details of size and other limits\n pcre2matching discussion of the two matching algorithms\n pcre2partial details of the partial matching facility\n pcre2pattern syntax and semantics of supported regular expression patterns\n pcre2perform discussion of performance issues\n pcre2posix the POSIX-compatible C API for the 8-bit library\n pcre2sample discussion of the pcre2demo program\n pcre2serialize details of pattern serialization\n pcre2syntax quick syntax reference\n pcre2test description of the pcre2test command\n pcre2unicode discussion of Unicode and UTF support\n\nIn the \"man\" and HTML formats, there is also a short page for each C library\nfunction, listing its arguments and results.\n\n
AUTHORS
\n\nThe current maintainers of PCRE2 are Nicholas Wilson and Zoltan Herczeg.\n
\n\nPCRE2 was written by Philip Hazel, of the University Computing Service,\nCambridge, England. Many others have also contributed.\n
\n\nTo contact the maintainers, please use the GitHub issues tracker or PCRE2\nmailing list, as described at the project page:\nhttps://github.com/PCRE2Project/pcre2\n
\nREVISION
\n\nLast updated: 22 February 2025\n
\nCopyright © 1997-2021 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_callout_enumerate.html", "content": "\n\npcre2_callout_enumerate man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_callout_enumerate(const pcre2_code *code,\n int (*callback)(pcre2_callout_enumerate_block *, void *),\n void *callout_data);\n
\n\nDESCRIPTION\n
\n\nThis function scans a compiled regular expression and calls the callback()\nfunction for each callout within the pattern. The yield of the function is zero\nfor success and non-zero otherwise. The arguments are:\n
\n code Points to the compiled pattern\n callback The callback function\n callout_data User data that is passed to the callback\n\nThe callback() function is passed a pointer to a data block containing\nthe following fields (not necessarily in this order):\n
\n uint32_t version Block version number\n uint32_t callout_number Number for numbered callouts\n PCRE2_SIZE pattern_position Offset to next item in pattern\n PCRE2_SIZE next_item_length Length of next item in pattern\n PCRE2_SIZE callout_string_offset Offset to string within pattern\n PCRE2_SIZE callout_string_length Length of callout string\n PCRE2_SPTR callout_string Points to callout string or is NULL\n\nThe second argument passed to the callback() function is the callout data\nthat was passed to pcre2_callout_enumerate(). The callback()\nfunction must return zero for success. Any other value causes the pattern scan\nto stop, with the value being passed back as the result of\npcre2_callout_enumerate().\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_code_copy.html", "content": "\n\npcre2_code_copy man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_code *pcre2_code_copy(const pcre2_code *code);\n
\n\nDESCRIPTION\n
\n\nThis function makes a copy of the memory used for a compiled pattern, excluding\nany memory used by the JIT compiler. Without a subsequent call to\npcre2_jit_compile(), the copy can be used only for non-JIT matching. The\npointer to the character tables is copied, not the tables themselves (see\npcre2_code_copy_with_tables()). The yield of the function is NULL if\ncode is NULL or if sufficient memory cannot be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_code_copy_with_tables.html", "content": "\n\npcre2_code_copy_with_tables man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_code *pcre2_code_copy_with_tables(const pcre2_code *code);\n
\n\nDESCRIPTION\n
\n\nThis function makes a copy of the memory used for a compiled pattern, excluding\nany memory used by the JIT compiler. Without a subsequent call to\npcre2_jit_compile(), the copy can be used only for non-JIT matching.\nUnlike pcre2_code_copy(), a separate copy of the character tables is also\nmade, with the new code pointing to it. This memory will be automatically freed\nwhen pcre2_code_free() is called. The yield of the function is NULL if\ncode is NULL or if sufficient memory cannot be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_code_free.html", "content": "\n\npcre2_code_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_code_free(pcre2_code *code);\n
\n\nDESCRIPTION\n
\n\nIf code is NULL, this function does nothing. Otherwise, code must\npoint to a compiled pattern. This function frees its memory, including any\nmemory used by the JIT compiler. If the compiled pattern was created by a call\nto pcre2_code_copy_with_tables(), the memory for the character tables is\nalso freed.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_compile.html", "content": "\n\npcre2_compile man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_code *pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, int *errorcode, PCRE2_SIZE *erroroffset,\n pcre2_compile_context *ccontext);\n
\n\nDESCRIPTION\n
\n\nThis function compiles a regular expression pattern into an internal form. Its\narguments are:\n
\n pattern A string containing expression to be compiled\n length The length of the string or PCRE2_ZERO_TERMINATED\n options Primary option bits\n errorcode Where to put an error code\n erroffset Where to put an error offset\n ccontext Pointer to a compile context or NULL\n\nThe length of the pattern and any error offset that is returned are in code\nunits, not characters. A NULL pattern with zero length is treated as an empty\nstring. A compile context is needed only if you want to provide custom memory\nallocation functions, or to provide an external function for system stack size\nchecking (see pcre2_set_compile_recursion_guard()), or to change one or\nmore of these parameters:\n
\n What \\R matches (Unicode newlines, or CR, LF, CRLF only);\n PCRE2's character tables;\n The newline character sequence;\n The compile time nested parentheses limit;\n The maximum pattern length (in code units) that is allowed;\n The additional options bits.\n\nThe primary option bits are:\n
\n PCRE2_ANCHORED Force pattern anchoring\n PCRE2_ALLOW_EMPTY_CLASS Allow empty classes\n PCRE2_ALT_BSUX Alternative handling of \\u, \\U, and \\x\n PCRE2_ALT_CIRCUMFLEX Alternative handling of ^ in multiline mode\n PCRE2_ALT_EXTENDED_CLASS Alternative extended character class syntax\n PCRE2_ALT_VERBNAMES Process backslashes in verb names\n PCRE2_AUTO_CALLOUT Compile automatic callouts\n PCRE2_CASELESS Do caseless matching\n PCRE2_DOLLAR_ENDONLY $ not to match newline at end\n PCRE2_DOTALL . matches anything including NL\n PCRE2_DUPNAMES Allow duplicate names for subpatterns\n PCRE2_ENDANCHORED Pattern can match only at end of subject\n PCRE2_EXTENDED Ignore white space and # comments\n PCRE2_FIRSTLINE Force matching to be before newline\n PCRE2_LITERAL Pattern characters are all literal\n PCRE2_MATCH_INVALID_UTF Enable support for matching invalid UTF\n PCRE2_MATCH_UNSET_BACKREF Match unset backreferences\n PCRE2_MULTILINE ^ and $ match newlines within data\n PCRE2_NEVER_BACKSLASH_C Lock out the use of \\C in patterns\n PCRE2_NEVER_UCP Lock out PCRE2_UCP, e.g. via (*UCP)\n PCRE2_NEVER_UTF Lock out PCRE2_UTF, e.g. via (*UTF)\n PCRE2_NO_AUTO_CAPTURE Disable numbered capturing paren-\n theses (named ones available)\n PCRE2_NO_AUTO_POSSESS Disable auto-possessification\n PCRE2_NO_DOTSTAR_ANCHOR Disable automatic anchoring for .*\n PCRE2_NO_START_OPTIMIZE Disable match-time start optimizations\n PCRE2_NO_UTF_CHECK Do not check the pattern for UTF validity\n (only relevant if PCRE2_UTF is set)\n PCRE2_UCP Use Unicode properties for \\d, \\w, etc.\n PCRE2_UNGREEDY Invert greediness of quantifiers\n PCRE2_USE_OFFSET_LIMIT Enable offset limit for unanchored matching\n PCRE2_UTF Treat pattern and subjects as UTF strings\n\nPCRE2 must be built with Unicode support (the default) in order to use\nPCRE2_UTF, PCRE2_UCP and related options.\n\n
\nAdditional options may be set in the compile context via the\npcre2_set_compile_extra_options\nfunction.\n
\n\nIf either of errorcode or erroroffset is NULL, the function returns\nNULL immediately. Otherwise, the yield of this function is a pointer to a\nprivate data structure that contains the compiled pattern, or NULL if an error\nwas detected. In the error case, a text error message can be obtained by\npassing the value returned via the errorcode argument to the\npcre2_get_error_message() function. The offset (in code units) where the\nerror was encountered is returned via the erroroffset argument.\n
\n\nIf there is no error, the value passed via errorcode returns the message\n\"no error\" if passed to pcre2_get_error_message(), and the value passed\nvia erroroffset is zero.\n
\n\nThere is a complete description of the PCRE2 native API, with more detail on\neach option, in the\npcre2api\npage, and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_compile_context_copy.html", "content": "\n\npcre2_compile_context_copy man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_compile_context *pcre2_compile_context_copy(\n pcre2_compile_context *ccontext);\n
\n\nDESCRIPTION\n
\n\nThis function makes a new copy of a compile context, using the memory\nallocation function that was used for the original context. The result is NULL\nif the memory cannot be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_compile_context_create.html", "content": "\n\npcre2_compile_context_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_compile_context *pcre2_compile_context_create(\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function creates and initializes a new compile context. If its argument is\nNULL, malloc() is used to get the necessary memory; otherwise the memory\nallocation function within the general context is used. The result is NULL if\nthe memory could not be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_compile_context_free.html", "content": "\n\npcre2_compile_context_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_compile_context_free(pcre2_compile_context *ccontext);\n
\n\nDESCRIPTION\n
\n\nThis function frees the memory occupied by a compile context, using the memory\nfreeing function from the general context with which it was created, or\nfree() if that was not set. If the argument is NULL, the function returns\nimmediately without doing anything.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_config.html", "content": "\n\npcre2_config man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_config(uint32_t what, void *where);\n
\n\nDESCRIPTION\n
\n\nThis function makes it possible for a client program to find out which optional\nfeatures are available in the version of the PCRE2 library it is using. The\narguments are as follows:\n
\n what A code specifying what information is required\n where Points to where to put the information\n\nIf where is NULL, the function returns the amount of memory needed for\nthe requested information. When the information is a string, the value is in\ncode units; for other types of data it is in bytes.\n\n
\nIf where is not NULL, for PCRE2_CONFIG_JITTARGET,\nPCRE2_CONFIG_UNICODE_VERSION, and PCRE2_CONFIG_VERSION it must point to a\nbuffer that is large enough to hold the string. For all other codes it must\npoint to a uint32_t integer variable. The available codes are:\n
\n PCRE2_CONFIG_BSR Indicates what \\R matches by default:\n PCRE2_BSR_UNICODE\n PCRE2_BSR_ANYCRLF\n PCRE2_CONFIG_COMPILED_WIDTHS Which of 8/16/32 support was compiled\n PCRE2_CONFIG_DEPTHLIMIT Default backtracking depth limit\n PCRE2_CONFIG_EFFECTIVE_LINKSIZE How many bytes are used for link size\n PCRE2_CONFIG_HEAPLIMIT Default heap memory limit\n PCRE2_CONFIG_JIT Availability of just-in-time compiler support (1=yes 0=no)\n PCRE2_CONFIG_JITTARGET Information (a string) about the target architecture for the JIT compiler\n PCRE2_CONFIG_LINKSIZE Configured internal link size (2, 3, 4)\n PCRE2_CONFIG_MATCHLIMIT Default internal resource limit\n PCRE2_CONFIG_NEVER_BACKSLASH_C Whether or not \\C is disabled\n PCRE2_CONFIG_NEWLINE Code for the default newline sequence:\n PCRE2_NEWLINE_CR\n PCRE2_NEWLINE_LF\n PCRE2_NEWLINE_CRLF\n PCRE2_NEWLINE_ANY\n PCRE2_NEWLINE_ANYCRLF\n PCRE2_NEWLINE_NUL\n PCRE2_CONFIG_PARENSLIMIT Default parentheses nesting limit\n PCRE2_CONFIG_RECURSIONLIMIT Obsolete: use PCRE2_CONFIG_DEPTHLIMIT\n PCRE2_CONFIG_STACKRECURSE Obsolete: always returns 0\n PCRE2_CONFIG_UNICODE Availability of Unicode support (1=yes 0=no)\n PCRE2_CONFIG_UNICODE_VERSION The Unicode version (a string)\n PCRE2_CONFIG_VERSION The PCRE2 version (a string)\n\nThe function yields a non-negative value on success or the negative value\nPCRE2_ERROR_BADOPTION otherwise. This is also the result for the\nPCRE2_CONFIG_JITTARGET code if JIT support is not available. When a string is\nrequested, the function returns the number of code units used, including the\nterminating zero.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_convert_context_copy.html", "content": "\n\npcre2_convert_context_copy man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_convert_context *pcre2_convert_context_copy(\n pcre2_convert_context *cvcontext);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt makes a new copy of a convert context, using the memory allocation function\nthat was used for the original context. The result is NULL if the memory cannot\nbe obtained.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_convert_context_create.html", "content": "\n\npcre2_convert_context_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_convert_context *pcre2_convert_context_create(\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt creates and initializes a new convert context. If its argument is\nNULL, malloc() is used to get the necessary memory; otherwise the memory\nallocation function within the general context is used. The result is NULL if\nthe memory could not be obtained.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_convert_context_free.html", "content": "\n\npcre2_convert_context_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_convert_context_free(pcre2_convert_context *cvcontext);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt frees the memory occupied by a convert context, using the memory\nfreeing function from the general context with which it was created, or\nfree() if that was not set. If the argument is NULL, the function returns\nimmediately without doing anything.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_converted_pattern_free.html", "content": "\n\npcre2_converted_pattern_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_converted_pattern_free(PCRE2_UCHAR *converted_pattern);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt frees the memory occupied by a converted pattern that was obtained by\ncalling pcre2_pattern_convert() with arguments that caused it to place\nthe converted pattern into newly obtained heap memory. If the argument is NULL,\nthe function returns immediately without doing anything.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_dfa_match.html", "content": "\n\npcre2_dfa_match man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_dfa_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext,\n int *workspace, PCRE2_SIZE wscount);\n
\n\nDESCRIPTION\n
\n\nThis function matches a compiled regular expression against a given subject\nstring, using an alternative matching algorithm that scans the subject string\njust once (except when processing lookaround assertions). This function is\nnot Perl-compatible (the Perl-compatible matching function is\npcre2_match()). The arguments for this function are:\n
\n code Points to the compiled pattern\n subject Points to the subject string\n length Length of the subject string\n startoffset Offset in the subject at which to start matching\n options Option bits\n match_data Points to a match data block, for results\n mcontext Points to a match context, or is NULL\n workspace Points to a vector of ints used as working space\n wscount Number of elements in the vector\n\nThe size of output vector needed to contain all the results depends on the\nnumber of simultaneous matches, not on the number of parentheses in the\npattern. Using pcre2_match_data_create_from_pattern() to create the match\ndata block is therefore not advisable when using this function.\n\n
\nA match context is needed only if you want to set up a callout function or\nspecify the heap limit or the match or the recursion depth limits. The\nlength and startoffset values are code units, not characters. The\noptions are:\n
\n PCRE2_ANCHORED Match only at the first position\n PCRE2_COPY_MATCHED_SUBJECT\n On success, make a private subject copy\n PCRE2_ENDANCHORED Pattern can match only at end of subject\n PCRE2_NOTBOL Subject is not the beginning of a line\n PCRE2_NOTEOL Subject is not the end of a line\n PCRE2_NOTEMPTY An empty string is not a valid match\n PCRE2_NOTEMPTY_ATSTART An empty string at the start of the subject is not a valid match\n PCRE2_NO_UTF_CHECK Do not check the subject for UTF validity (only relevant if PCRE2_UTF\n was set at compile time)\n PCRE2_PARTIAL_HARD Return PCRE2_ERROR_PARTIAL for a partial match even if there is a full match\n PCRE2_PARTIAL_SOFT Return PCRE2_ERROR_PARTIAL for a partial match if no full matches are found\n PCRE2_DFA_RESTART Restart after a partial match\n PCRE2_DFA_SHORTEST Return only the shortest match\n\nThere are restrictions on what may appear in a pattern when using this matching\nfunction. Details are given in the\npcre2matching\ndocumentation. For details of partial matching, see the\npcre2partial\npage. There is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_general_context_copy.html", "content": "\n\npcre2_general_context_copy man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_general_context *pcre2_general_context_copy(\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function makes a new copy of a general context, using the memory\nallocation functions in the context, if set, to get the necessary memory.\nOtherwise malloc() is used. The result is NULL if the memory cannot be\nobtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_general_context_create.html", "content": "\n\npcre2_general_context_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_general_context *pcre2_general_context_create(\n void *(*private_malloc)(size_t, void *),\n void (*private_free)(void *, void *), void *memory_data);\n
\n\nDESCRIPTION\n
\n\nThis function creates and initializes a general context. The arguments define\ncustom memory management functions and a data value that is passed to them when\nthey are called. The private_malloc() function is used to get memory for\nthe context. If either of the first two arguments is NULL, the system memory\nmanagement function is used. The result is NULL if no memory could be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_general_context_free.html", "content": "\n\npcre2_general_context_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_general_context_free(pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function frees the memory occupied by a general context, using the memory\nfreeing function within the context, if set. If the argument is NULL, the\nfunction returns immediately without doing anything.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_error_message.html", "content": "\n\npcre2_get_error_message man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_get_error_message(int errorcode, PCRE2_UCHAR *buffer,\n PCRE2_SIZE bufflen);\n
\n\nDESCRIPTION\n
\n\nThis function provides a textual error message for each PCRE2 error code.\nCompilation errors are positive numbers; UTF formatting errors and matching\nerrors are negative numbers. The arguments are:\n
\n errorcode an error code (positive or negative)\n buffer where to put the message\n bufflen the length of the buffer (code units)\n\nThe function returns the length of the message in code units, excluding the\ntrailing zero, or the negative error code PCRE2_ERROR_NOMEMORY if the buffer is\ntoo small. In this case, the returned message is truncated (but still with a\ntrailing zero). If errorcode does not contain a recognized error code\nnumber, the negative value PCRE2_ERROR_BADDATA is returned.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_mark.html", "content": "\n\npcre2_get_mark man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nPCRE2_SPTR pcre2_get_mark(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nAfter a call of pcre2_match() that was passed the match block that is\nthis function's argument, this function returns a pointer to the last (*MARK),\n(*PRUNE), or (*THEN) name that was encountered during the matching process. The\nname is zero-terminated, and is within the compiled pattern. The length of the\nname is in the preceding code unit. If no name is available, NULL is returned.\n
\n\nAfter a successful match, the name that is returned is the last one on the\nmatching path. After a failed match or a partial match, the last encountered\nname is returned.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_match_data_heapframes_size.html", "content": "\n\npcre2_get_match_data_heapframes_size man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nPCRE2_SIZE pcre2_get_match_data_heapframes_size(\n pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nThis function returns the size, in bytes, of the heapframes data block that is\nowned by its argument.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_match_data_size.html", "content": "\n\npcre2_get_match_data_size man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nPCRE2_SIZE pcre2_get_match_data_size(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nThis function returns the size, in bytes, of the match data block that is its\nargument.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_ovector_count.html", "content": "\n\npcre2_get_ovector_count man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nuint32_t pcre2_get_ovector_count(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nThis function returns the number of pairs of offsets in the ovector that forms\npart of the given match data block.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_ovector_pointer.html", "content": "\n\npcre2_get_ovector_pointer man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nPCRE2_SIZE *pcre2_get_ovector_pointer(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nThis function returns a pointer to the vector of offsets that forms part of the\ngiven match data block. The number of pairs can be found by calling\npcre2_get_ovector_count().\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_get_startchar.html", "content": "\n\npcre2_get_startchar man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nPCRE2_SIZE pcre2_get_startchar(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nAfter a successful call of pcre2_match() that was passed the match block\nthat is this function's argument, this function returns the code unit offset of\nthe character at which the successful match started. For a non-partial match,\nthis can be different to the value of ovector[0] if the pattern contains\nthe \\K escape sequence. After a partial match, however, this value is always\nthe same as ovector[0] because \\K does not affect the result of a\npartial match.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_compile.html", "content": "\n\npcre2_jit_compile man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_jit_compile(pcre2_code *code, uint32_t options);\n
\n\nDESCRIPTION\n
\n\nThis function requests JIT compilation, which, if the just-in-time compiler is\navailable, further processes a compiled pattern into machine code that executes\nmuch faster than the pcre2_match() interpretive matching function. Full\ndetails are given in the\npcre2jit\ndocumentation.\n
\n\nThe availability of JIT support can be tested by calling\npcre2_compile_jit() with a single option PCRE2_JIT_TEST_ALLOC (the\ncode argument is ignored, so a NULL value is accepted). Such a call\nreturns zero if JIT is available and has a working allocator. Otherwise\nit returns PCRE2_ERROR_NOMEMORY if JIT is available but cannot allocate\nexecutable memory, or PCRE2_ERROR_JIT_UNSUPPORTED if JIT support is not\ncompiled.\n
\n\nOtherwise, the first argument must be a pointer that was returned by a\nsuccessful call to pcre2_compile(), and the second must contain one or\nmore of the following bits:\n
\n PCRE2_JIT_COMPLETE compile code for full matching\n PCRE2_JIT_PARTIAL_SOFT compile code for soft partial matching\n PCRE2_JIT_PARTIAL_HARD compile code for hard partial matching\n\nThere is also an obsolete option called PCRE2_JIT_INVALID_UTF, which has been\nsuperseded by the pcre2_compile() option PCRE2_MATCH_INVALID_UTF. The old\noption is deprecated and may be removed in the future.\n\n
\nThe yield of the function when called with any of the three options above is 0\nfor success, or a negative error code otherwise. In particular,\nPCRE2_ERROR_JIT_BADOPTION is returned if JIT is not supported or if an unknown\nbit is set in options. The function can also return PCRE2_ERROR_NOMEMORY\nif JIT is unable to allocate executable memory for the compiler, even if it was\nbecause of a system security restriction. In a few cases, the function may\nreturn with PCRE2_ERROR_JIT_UNSUPPORTED for unsupported features.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_free_unused_memory.html", "content": "\n\npcre2_jit_free_unused_memory man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_jit_free_unused_memory(pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function frees unused JIT executable memory. The argument is a general\ncontext, for custom memory management, or NULL for standard memory management.\nJIT memory allocation retains some memory in order to improve future JIT\ncompilation speed. In low memory conditions,\npcre2_jit_free_unused_memory() can be used to cause this memory to be\nfreed.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_match.html", "content": "\n\npcre2_jit_match man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_jit_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n\nDESCRIPTION\n
\n\nThis function matches a compiled regular expression that has been successfully\nprocessed by the JIT compiler against a given subject string, using a matching\nalgorithm that is similar to Perl's. It is a \"fast path\" interface to JIT, and\nit bypasses some of the sanity checks that pcre2_match() applies.\n
\n\nIn UTF mode, the subject string is not checked for UTF validity. Unless\nPCRE2_MATCH_INVALID_UTF was set when the pattern was compiled, passing an\ninvalid UTF string results in undefined behaviour. Your program may crash or\nloop or give wrong results. In the absence of PCRE2_MATCH_INVALID_UTF you\nshould only call pcre2_jit_match() in UTF mode if you are sure the\nsubject is valid.\n
\n\nThe arguments for pcre2_jit_match() are exactly the same as for\npcre2_match(),\nexcept that the subject string must be specified with a length;\nPCRE2_ZERO_TERMINATED is not supported.\n
\n\nThe supported options are PCRE2_NOTBOL, PCRE2_NOTEOL, PCRE2_NOTEMPTY,\nPCRE2_NOTEMPTY_ATSTART, PCRE2_PARTIAL_HARD, and PCRE2_PARTIAL_SOFT. Unsupported\noptions are ignored.\n
\n\nThe return values are the same as for pcre2_match() plus\nPCRE2_ERROR_JIT_BADOPTION if a matching mode (partial or complete) is requested\nthat was not compiled. For details of partial matching, see the\npcre2partial\npage.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the JIT API in the\npcre2jit\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_stack_assign.html", "content": "\n\npcre2_jit_stack_assign man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_jit_stack_assign(pcre2_match_context *mcontext,\n pcre2_jit_callback callback_function, void *callback_data);\n
\n\nDESCRIPTION\n
\n\nThis function provides control over the memory used by JIT as a run-time stack\nwhen pcre2_match() or pcre2_jit_match() is called with a pattern\nthat has been successfully processed by the JIT compiler. The information that\ndetermines which stack is used is put into a match context that is subsequently\npassed to a matching function. The arguments of this function are:\n
\n mcontext a pointer to a match context\n callback a callback function\n callback_data a JIT stack or a value to be passed to the callback\n\n\n
\nIf mcontext is NULL, the function returns immediately, without doing\nanything.\n
\n\nIf callback is NULL and callback_data is NULL, an internal 32KiB\nblock on the machine stack is used.\n
\n\nIf callback is NULL and callback_data is not NULL,\ncallback_data must be a valid JIT stack, the result of calling\npcre2_jit_stack_create().\n
\n\nIf callback not NULL, it is called with callback_data as an\nargument at the start of matching, in order to set up a JIT stack. If the\nresult is NULL, the internal 32KiB stack is used; otherwise the return value\nmust be a valid JIT stack, the result of calling\npcre2_jit_stack_create().\n
\n\nYou may safely use the same JIT stack for multiple patterns, as long as they\nare all matched in the same thread. In a multithread application, each thread\nmust use its own JIT stack. For more details, see the\npcre2jit\npage.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_stack_create.html", "content": "\n\npcre2_jit_stack_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_jit_stack *pcre2_jit_stack_create(size_t startsize,\n size_t maxsize, pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function is used to create a stack for use by the code compiled by the JIT\ncompiler. The first two arguments are a starting size for the stack, and a\nmaximum size to which it is allowed to grow. The final argument is a general\ncontext, for memory allocation functions, or NULL for standard memory\nallocation. The result can be passed to the JIT run-time code by calling\npcre2_jit_stack_assign() to associate the stack with a compiled pattern,\nwhich can then be processed by pcre2_match() or pcre2_jit_match().\nA maximum stack size of 512KiB to 1MiB should be more than enough for any\npattern. If the stack couldn't be allocated or the values passed were not\nreasonable, NULL will be returned. For more details, see the\npcre2jit\npage.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_jit_stack_free.html", "content": "\n\npcre2_jit_stack_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_jit_stack_free(pcre2_jit_stack *jit_stack);\n
\n\nDESCRIPTION\n
\n\nThis function is used to free a JIT stack that was created by\npcre2_jit_stack_create() when it is no longer needed. If the argument is\nNULL, the function returns immediately without doing anything. For more\ndetails, see the\npcre2jit\npage.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_maketables.html", "content": "\n\npcre2_maketables man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nconst uint8_t *pcre2_maketables(pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function builds a set of character tables for character code points that\nare less than 256. These can be passed to pcre2_compile() in a compile\ncontext in order to override the internal, built-in tables (which were either\ndefaulted or made by pcre2_maketables() when PCRE2 was compiled). See the\npcre2_set_character_tables()\npage. You might want to do this if you are using a non-standard locale.\n
\n\nIf the argument is NULL, malloc() is used to get memory for the tables.\nOtherwise it must point to a general context, which can supply pointers to a\ncustom memory manager. The function yields a pointer to the tables.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_maketables_free.html", "content": "\n\npcre2_maketables_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_maketables_free(pcre2_general_context *gcontext,\n const uint8_t *tables);\n
\n\nDESCRIPTION\n
\n\nThis function discards a set of character tables that were created by a call\nto\npcre2_maketables().\n
\n\nThe gcontext parameter should match what was used in that call to\naccount for any custom allocators that might be in use; if it is NULL\nthe system free() is used.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match.html", "content": "\n\npcre2_match man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n\nDESCRIPTION\n
\n\nThis function matches a compiled regular expression against a given subject\nstring, using a matching algorithm that is similar to Perl's. It returns\noffsets to what it has matched and to captured substrings via the\nmatch_data block, which can be processed by functions with names that\nstart with pcre2_get_ovector_...() or pcre2_substring_...(). The\nreturn from pcre2_match() is one more than the highest numbered capturing\npair that has been set (for example, 1 if there are no captures), zero if the\nvector of offsets is too small, or a negative error code for no match and other\nerrors. The function arguments are:\n
\n code Points to the compiled pattern\n subject Points to the subject string\n length Length of the subject string\n startoffset Offset in the subject at which to start matching\n options Option bits\n match_data Points to a match data block, for results\n mcontext Points to a match context, or is NULL\n\nA match context is needed only if you want to:\n
\n Set up a callout function\n Set a matching offset limit\n Change the heap memory limit\n Change the backtracking match limit\n Change the backtracking depth limit\n Set custom memory management specifically for the match\n\nThe length and startoffset values are code units, not characters.\nThe length may be given as PCRE2_ZERO_TERMINATED for a subject that is\nterminated by a binary zero code unit. The options are:\n
\n PCRE2_ANCHORED Match only at the first position\n PCRE2_COPY_MATCHED_SUBJECT\n On success, make a private subject copy\n PCRE2_DISABLE_RECURSELOOP_CHECK\n Only useful in rare cases; use with care\n PCRE2_ENDANCHORED Pattern can match only at end of subject\n PCRE2_NOTBOL Subject string is not the beginning of a line\n PCRE2_NOTEOL Subject string is not the end of a line\n PCRE2_NOTEMPTY An empty string is not a valid match\n PCRE2_NOTEMPTY_ATSTART An empty string at the start of the subject is not a valid match\n PCRE2_NO_JIT Do not use JIT matching\n PCRE2_NO_UTF_CHECK Do not check the subject for UTF validity (only relevant if PCRE2_UTF\n was set at compile time)\n PCRE2_PARTIAL_HARD Return PCRE2_ERROR_PARTIAL for a partial match even if there is a full match\n PCRE2_PARTIAL_SOFT Return PCRE2_ERROR_PARTIAL for a partial match if no full matches are found\n\nFor details of partial matching, see the\npcre2partial\npage. There is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_context_copy.html", "content": "\n\npcre2_match_context_copy man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_match_context *pcre2_match_context_copy(\n pcre2_match_context *mcontext);\n
\n\nDESCRIPTION\n
\n\nThis function makes a new copy of a match context, using the memory\nallocation function that was used for the original context. The result is NULL\nif the memory cannot be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_context_create.html", "content": "\n\npcre2_match_context_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_match_context *pcre2_match_context_create(\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function creates and initializes a new match context. If its argument is\nNULL, malloc() is used to get the necessary memory; otherwise the memory\nallocation function within the general context is used. The result is NULL if\nthe memory could not be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_context_free.html", "content": "\n\npcre2_match_context_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_match_context_free(pcre2_match_context *mcontext);\n
\n\nDESCRIPTION\n
\n\nThis function frees the memory occupied by a match context, using the memory\nfreeing function from the general context with which it was created, or\nfree() if that was not set. If the argument is NULL, the function returns\nimmediately without doing anything.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_data_create.html", "content": "\n\npcre2_match_data_create man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_match_data *pcre2_match_data_create(uint32_t ovecsize,\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function creates a new match data block, which is used for holding the\nresult of a match. The first argument specifies the number of pairs of offsets\nthat are required. These form the \"output vector\" (ovector) within the match\ndata block, and are used to identify the matched string and any captured\nsubstrings when matching with pcre2_match(), or a number of different\nmatches at the same point when used with pcre2_dfa_match(). There is\nalways one pair of offsets; if ovecsize is zero, it is treated as one.\n
\n\nThe second argument points to a general context, for custom memory management,\nor is NULL for system memory management. The result of the function is NULL if\nthe memory for the block could not be obtained.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_data_create_from_pattern.html", "content": "\n\npcre2_match_data_create_from_pattern man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\npcre2_match_data *pcre2_match_data_create_from_pattern(\n const pcre2_code *code, pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function creates a new match data block for holding the result of a match.\nIf the first argument is NULL, this function returns NULL, otherwise the first\nargument points to a compiled pattern. The number of capturing parentheses\nwithin the pattern is used to compute the number of pairs of offsets that are\nrequired in the match data block. These form the \"output vector\" (ovector)\nwithin the match data block, and are used to identify the matched string and\nany captured substrings when matching with pcre2_match(). If you are\nusing pcre2_dfa_match(), which uses the output vector in a different way,\nyou should use pcre2_match_data_create() instead of this function.\n
\n\nThe second argument points to a general context, for custom memory management,\nor is NULL to use the same memory allocator that was used for the compiled\npattern. The result of the function is NULL if the memory for the block could\nnot be obtained or if NULL was provided as the first argument.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_match_data_free.html", "content": "\n\npcre2_match_data_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_match_data_free(pcre2_match_data *match_data);\n
\n\nDESCRIPTION\n
\n\nIf match_data is NULL, this function does nothing. Otherwise,\nmatch_data must point to a match data block, which this function frees,\nusing the memory freeing function from the general context or compiled pattern\nwith which it was created, or free() if that was not set. If the match\ndata block was previously passed to pcre2_match(), it will have an\nattached heapframe vector; this is also freed.\n
\n\nIf the PCRE2_COPY_MATCHED_SUBJECT was used for a successful match using this\nmatch data block, the copy of the subject that was referenced within the block\nis also freed.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_next_match.html", "content": "\n\npcre2_next_match man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_next_match(pcre2_match_data *match_data,\n PCRE2_SIZE *pstart_offset, uint32_t *poptions);\n
\n\nDESCRIPTION\n
\n\nThis function can be called after one of the match functions\n(pcre2_match(), pcre2_dfa_match(), or pcre2_jit_match()), and\nmust be provided with the same match_data parameter. It outputs the\nappropriate parameters for searching for the next match in the same subject\nstring, and is suitable for applications providing \"global\" matching behaviour\n(for example, replacing all matches in the subject, or splitting the subject on\nall matches, or simply counting the number of matches).\n
\n\nIt returns 0 (\"false\") if there is no need to make any further match attempts,\nor 1 (\"true\") if another match should be attempted.\n
\n\nThe *pstart_offset and *poptions are set if the function returns 1.\nThe *pstart_offset should be passed to the next match attempt directly,\nand the *poptions should be passed to the next match attempt by combining\nwith the application's match options using OR.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_pattern_convert.html", "content": "\n\npcre2_pattern_convert man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_pattern_convert(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, PCRE2_UCHAR **buffer,\n PCRE2_SIZE *blength, pcre2_convert_context *cvcontext);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt converts a foreign pattern (for example, a glob) into a PCRE2 regular\nexpression pattern. Its arguments are:\n
\n pattern The foreign pattern\n length The length of the input pattern or PCRE2_ZERO_TERMINATED\n options Option bits\n buffer Pointer to pointer to output buffer, or NULL\n blength Pointer to output length field\n cvcontext Pointer to a convert context or NULL\n\nThe length of the converted pattern (excluding the terminating zero) is\nreturned via blength. If buffer is NULL, the function just returns\nthe output length. If buffer points to a NULL pointer, heap memory is\nobtained for the converted pattern, using the allocator in the context if\npresent (or else malloc()), and the field pointed to by buffer is\nupdated. If buffer points to a non-NULL field, that must point to a\nbuffer whose size is in the variable pointed to by blength. This value is\nupdated.\n\n
\nThe option bits are:\n
\n PCRE2_CONVERT_UTF Input is UTF\n PCRE2_CONVERT_NO_UTF_CHECK Do not check UTF validity\n PCRE2_CONVERT_POSIX_BASIC Convert POSIX basic pattern\n PCRE2_CONVERT_POSIX_EXTENDED Convert POSIX extended pattern\n PCRE2_CONVERT_GLOB ) Convert\n PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR ) various types\n PCRE2_CONVERT_GLOB_NO_STARSTAR ) of glob\n\nThe return value from pcre2_pattern_convert() is zero on success or a\nnon-zero PCRE2 error code.\n\n
\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_pattern_info.html", "content": "\n\npcre2_pattern_info man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_pattern_info(const pcre2_code *code, uint32_t what,\n void *where);\n
\n\nDESCRIPTION\n
\n\nThis function returns information about a compiled pattern. Its arguments are:\n
\n code Pointer to a compiled regular expression pattern\n what What information is required\n where Where to put the information\n\nThe recognized values for the what argument, and the information they\nrequest are as follows:\n
\n PCRE2_INFO_ALLOPTIONS Final options after compiling\n PCRE2_INFO_ARGOPTIONS Options passed to pcre2_compile()\n PCRE2_INFO_BACKREFMAX Number of highest backreference\n PCRE2_INFO_BSR What \\R matches:\n PCRE2_BSR_UNICODE: Unicode line endings\n PCRE2_BSR_ANYCRLF: CR, LF, or CRLF only\n PCRE2_INFO_CAPTURECOUNT Number of capturing subpatterns\n PCRE2_INFO_DEPTHLIMIT Backtracking depth limit if set, otherwise PCRE2_ERROR_UNSET\n PCRE2_INFO_EXTRAOPTIONS Extra options that were passed in the\n compile context\n PCRE2_INFO_FIRSTBITMAP Bitmap of first code units, or NULL\n PCRE2_INFO_FIRSTCODETYPE Type of start-of-match information\n 0 nothing set\n 1 first code unit is set\n 2 start of string or after newline\n PCRE2_INFO_FIRSTCODEUNIT First code unit when type is 1\n PCRE2_INFO_FRAMESIZE Size of backtracking frame\n PCRE2_INFO_HASBACKSLASHC Return 1 if pattern contains \\C\n PCRE2_INFO_HASCRORLF Return 1 if explicit CR or LF matches exist in the pattern\n PCRE2_INFO_HEAPLIMIT Heap memory limit if set, otherwise PCRE2_ERROR_UNSET\n PCRE2_INFO_JCHANGED Return 1 if (?J) or (?-J) was used\n PCRE2_INFO_JITSIZE Size of JIT compiled code, or 0\n PCRE2_INFO_LASTCODETYPE Type of must-be-present information\n 0 nothing set\n 1 code unit is set\n PCRE2_INFO_LASTCODEUNIT Last code unit when type is 1\n PCRE2_INFO_MATCHEMPTY 1 if the pattern can match an empty string, 0 otherwise\n PCRE2_INFO_MATCHLIMIT Match limit if set, otherwise PCRE2_ERROR_UNSET\n PCRE2_INFO_MAXLOOKBEHIND Length (in characters) of the longest lookbehind assertion\n PCRE2_INFO_MINLENGTH Lower bound length of matching strings\n PCRE2_INFO_NAMECOUNT Number of named subpatterns\n PCRE2_INFO_NAMEENTRYSIZE Size of name table entries\n PCRE2_INFO_NAMETABLE Pointer to name table\n PCRE2_CONFIG_NEWLINE Code for the newline sequence:\n PCRE2_NEWLINE_CR\n PCRE2_NEWLINE_LF\n PCRE2_NEWLINE_CRLF\n PCRE2_NEWLINE_ANY\n PCRE2_NEWLINE_ANYCRLF\n PCRE2_NEWLINE_NUL\n PCRE2_INFO_RECURSIONLIMIT Obsolete synonym for PCRE2_INFO_DEPTHLIMIT\n PCRE2_INFO_SIZE Size of compiled pattern\n\nIf where is NULL, the function returns the amount of memory needed for\nthe requested information, in bytes. Otherwise, the where argument must\npoint to an unsigned 32-bit integer (uint32_t variable), except for the\nfollowing what values, when it must point to a variable of the type\nshown:\n
\n PCRE2_INFO_FIRSTBITMAP const uint8_t *\n PCRE2_INFO_JITSIZE size_t\n PCRE2_INFO_NAMETABLE PCRE2_SPTR\n PCRE2_INFO_SIZE size_t\n\nThe yield of the function is zero on success or:\n
\n PCRE2_ERROR_NULL the argument code is NULL\n PCRE2_ERROR_BADMAGIC the \"magic number\" was not found\n PCRE2_ERROR_BADOPTION the value of what is invalid\n PCRE2_ERROR_BADMODE the pattern was compiled in the wrong mode\n PCRE2_ERROR_UNSET the requested information is not set\n\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_serialize_decode.html", "content": "\n\npcre2_serialize_decode man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint32_t pcre2_serialize_decode(pcre2_code **codes,\n int32_t number_of_codes, const uint8_t *bytes,\n pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function decodes a serialized set of compiled patterns back into a list of\nindividual patterns. This is possible only on a host that is running the same\nversion of PCRE2, with the same code unit width, and the host must also have\nthe same endianness, pointer width and PCRE2_SIZE type. The arguments for\npcre2_serialize_decode() are:\n
\n codes pointer to a vector in which to build the list\n number_of_codes number of slots in the vector\n bytes the serialized byte stream\n gcontext pointer to a general context or NULL\n\nThe bytes argument must point to a block of data that was originally\ncreated by pcre2_serialize_encode(), though it may have been saved on\ndisc or elsewhere in the meantime. If there are more codes in the serialized\ndata than slots in the list, only those compiled patterns that will fit are\ndecoded. The yield of the function is the number of decoded patterns, or one of\nthe following negative error codes:\n
\n PCRE2_ERROR_BADDATA number_of_codes is zero or less\n PCRE2_ERROR_BADMAGIC mismatch of id bytes in bytes\n PCRE2_ERROR_BADMODE mismatch of variable unit size or PCRE version\n PCRE2_ERROR_NOMEMORY memory allocation failed\n PCRE2_ERROR_NULL codes or bytes is NULL\n\nPCRE2_ERROR_BADMAGIC may mean that the data is corrupt, or that it was compiled\non a system with different endianness.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the serialization functions in the\npcre2serialize\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_serialize_encode.html", "content": "\n\npcre2_serialize_encode man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint32_t pcre2_serialize_encode(const pcre2_code **codes,\n int32_t number_of_codes, uint8_t **serialized_bytes,\n PCRE2_SIZE *serialized_size, pcre2_general_context *gcontext);\n
\n\nDESCRIPTION\n
\n\nThis function encodes a list of compiled patterns into a byte stream that can\nbe saved on disc or elsewhere. Note that this is not an abstract format like\nJava or .NET. Conversion of the byte stream back into usable compiled patterns\ncan only happen on a host that is running the same version of PCRE2, with the\nsame code unit width, and the host must also have the same endianness, pointer\nwidth and PCRE2_SIZE type. The arguments for pcre2_serialize_encode()\nare:\n
\n codes pointer to a vector containing the list\n number_of_codes number of slots in the vector\n serialized_bytes set to point to the serialized byte stream\n serialized_size set to the number of bytes in the byte stream\n gcontext pointer to a general context or NULL\n\nThe context argument is used to obtain memory for the byte stream. When the\nserialized data is no longer needed, it must be freed by calling\npcre2_serialize_free(). The yield of the function is the number of\nserialized patterns, or one of the following negative error codes:\n
\n PCRE2_ERROR_BADDATA number_of_codes is zero or less\n PCRE2_ERROR_BADMAGIC mismatch of id bytes in one of the patterns\n PCRE2_ERROR_MEMORY memory allocation failed\n PCRE2_ERROR_MIXEDTABLES the patterns do not all use the same tables\n PCRE2_ERROR_NULL an argument other than gcontext is NULL\n\nPCRE2_ERROR_BADMAGIC means either that a pattern's code has been corrupted, or\nthat a slot in the vector does not point to a compiled pattern.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the serialization functions in the\npcre2serialize\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_serialize_free.html", "content": "\n\npcre2_serialize_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_serialize_free(uint8_t *bytes);\n
\n\nDESCRIPTION\n
\n\nThis function frees the memory that was obtained by\npcre2_serialize_encode() to hold a serialized byte stream. The argument\nmust point to such a byte stream or be NULL, in which case the function returns\nwithout doing anything.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the serialization functions in the\npcre2serialize\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_serialize_get_number_of_codes.html", "content": "\n\npcre2_serialize_get_number_of_codes man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint32_t pcre2_serialize_get_number_of_codes(const uint8_t *bytes);\n
\n\nDESCRIPTION\n
\n\nThe bytes argument must point to a serialized byte stream that was\noriginally created by pcre2_serialize_encode() (though it may have been\nsaved on disc or elsewhere in the meantime). The function returns the number of\nserialized patterns in the byte stream, or one of the following negative error\ncodes:\n
\n PCRE2_ERROR_BADMAGIC mismatch of id bytes in bytes\n PCRE2_ERROR_BADMODE mismatch of variable unit size or PCRE version\n PCRE2_ERROR_NULL the argument is NULL\n\nPCRE2_ERROR_BADMAGIC may mean that the data is corrupt, or that it was compiled\non a system with different endianness.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the serialization functions in the\npcre2serialize\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_bsr.html", "content": "\n\npcre2_set_bsr man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_bsr(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the convention for processing \\R within a compile context.\nThe second argument must be one of PCRE2_BSR_ANYCRLF or PCRE2_BSR_UNICODE. The\nresult is zero for success or PCRE2_ERROR_BADDATA if the second argument is\ninvalid.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_callout.html", "content": "\n\npcre2_set_callout man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_callout_block *),\n void *callout_data);\n
\n\nDESCRIPTION\n
\n\nThis function sets the callout fields in a match context (the first argument).\nThe second argument specifies a callout function, and the third argument is an\nopaque data item that is passed to it. The result of this function is always\nzero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_character_tables.html", "content": "\n\npcre2_set_character_tables man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_character_tables(pcre2_compile_context *ccontext,\n const uint8_t *tables);\n
\n\nDESCRIPTION\n
\n\nThis function sets a pointer to custom character tables within a compile\ncontext. The second argument must point to a set of PCRE2 character tables or\nbe NULL to request the default tables. The result is always zero. Character\ntables can be created by calling pcre2_maketables() or by running the\npcre2_dftables maintenance command in binary mode (see the\npcre2build\ndocumentation).\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_compile_extra_options.html", "content": "\n\npcre2_set_compile_extra_options man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_compile_extra_options(pcre2_compile_context *ccontext,\n uint32_t extra_options);\n
\n\nDESCRIPTION\n
\n\nThis function sets additional option bits for pcre2_compile() that are\nhoused in a compile context. It completely replaces all the bits. The extra\noptions are:\n
\n PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK Allow \\K in lookarounds\n PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES Allow \\x{d800} to \\x{dfff} in UTF-8 and UTF-32 modes\n PCRE2_EXTRA_ALT_BSUX Extended alternate \\u, \\U, and \\x handling\n PCRE2_EXTRA_ASCII_BSD \\d remains ASCII in UCP mode\n PCRE2_EXTRA_ASCII_BSS \\s remains ASCII in UCP mode\n PCRE2_EXTRA_ASCII_BSW \\w remains ASCII in UCP mode\n PCRE2_EXTRA_ASCII_DIGIT [:digit:] and [:xdigit:] POSIX classes remain ASCII in UCP mode\n PCRE2_EXTRA_ASCII_POSIX POSIX classes remain ASCII in UCP mode\n PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL Treat all invalid escapes as a literal following character\n PCRE2_EXTRA_CASELESS_RESTRICT Disable mixed ASCII/non-ASCII case folding\n PCRE2_EXTRA_ESCAPED_CR_IS_LF Interpret \\r as \\n\n PCRE2_EXTRA_MATCH_LINE Pattern matches whole lines\n PCRE2_EXTRA_MATCH_WORD Pattern matches \"words\"\n PCRE2_EXTRA_NEVER_CALLOUT Disallow callouts in pattern\n PCRE2_EXTRA_NO_BS0 Disallow \\0 (but not \\00 or \\000)\n PCRE2_EXTRA_PYTHON_OCTAL Use Python rules for octal\n PCRE2_EXTRA_TURKISH_CASING Use Turkish I case folding\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_compile_recursion_guard.html", "content": "\n\npcre2_set_compile_recursion_guard man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,\n int (*guard_function)(uint32_t, void *), void *user_data);\n
\n\nDESCRIPTION\n
\n\nThis function defines, within a compile context, a function that is called\nwhenever pcre2_compile() starts to compile a parenthesized part of a\npattern. The first argument to the function gives the current depth of\nparenthesis nesting, and the second is user data that is supplied when the\nfunction is set up. The callout function should return zero if all is well, or\nnon-zero to force an error. This feature is provided so that applications can\ncheck the available system stack space, in order to avoid running out. The\nresult of pcre2_set_compile_recursion_guard() is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_depth_limit.html", "content": "\n\npcre2_set_depth_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_depth_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the backtracking depth limit field in a match context. The\nresult is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_glob_escape.html", "content": "\n\npcre2_set_glob_escape man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_glob_escape(pcre2_convert_context *cvcontext,\n uint32_t escape_char);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt sets the escape character that is used when converting globs. The second\nargument must either be zero (meaning there is no escape character) or a\npunctuation character whose code point is less than 256. The default is grave\naccent if running under Windows, otherwise backslash. The result of the\nfunction is zero for success or PCRE2_ERROR_BADDATA if the second argument is\ninvalid.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_glob_separator.html", "content": "\n\npcre2_set_glob_separator man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_glob_separator(pcre2_convert_context *cvcontext,\n uint32_t separator_char);\n
\n\nDESCRIPTION\n
\n\nThis function is part of an experimental set of pattern conversion functions.\nIt sets the component separator character that is used when converting globs.\nThe second argument must be one of the characters forward slash, backslash, or\ndot. The default is backslash when running under Windows, otherwise forward\nslash. The result of the function is zero for success or PCRE2_ERROR_BADDATA if\nthe second argument is invalid.\n
\n\nThe pattern conversion functions are described in the\npcre2convert\ndocumentation.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_heap_limit.html", "content": "\n\npcre2_set_heap_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_heap_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the backtracking heap limit field in a match context. The\nresult is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_match_limit.html", "content": "\n\npcre2_set_match_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_match_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the match limit field in a match context. The result is\nalways zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_max_pattern_compiled_length.html", "content": "\n\npcre2_set_max_pattern_compiled_length man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_max_pattern_compiled_length(\n pcre2_compile_context *ccontext, PCRE2_SIZE value);\n
\n\nDESCRIPTION\n
\n\nThis function sets, in a compile context, the maximum size (in bytes) for the\nmemory needed to hold the compiled version of a pattern that is using this\ncontext. The result is always zero. If a pattern that is passed to\npcre2_compile() referencing this context needs more memory, an error is\ngenerated. The default is the largest number that a PCRE2_SIZE variable can\nhold, which is effectively unlimited.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_max_pattern_length.html", "content": "\n\npcre2_set_max_pattern_length man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_max_pattern_length(pcre2_compile_context *ccontext,\n PCRE2_SIZE value);\n
\n\nDESCRIPTION\n
\n\nThis function sets, in a compile context, the maximum text length (in code\nunits) of the pattern that can be compiled. The result is always zero. If a\nlonger pattern is passed to pcre2_compile() there is an immediate error\nreturn. The default is effectively unlimited, being the largest value a\nPCRE2_SIZE variable can hold.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_max_varlookbehind.html", "content": "\n\npcre2_set_max_varlookbehind man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_max_varlookbehind(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis sets a maximum length for the number of characters matched by a\nvariable-length lookbehind assertion. The default is set when PCRE2 is built,\nwith the ultimate default being 255, the same as Perl. Lookbehind assertions\nwithout a bounding length are not supported. The result is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_newline.html", "content": "\n\npcre2_set_newline man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_newline(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the newline convention within a compile context. This\nspecifies which character(s) are recognized as newlines when compiling and\nmatching patterns. The second argument must be one of:\n
\n PCRE2_NEWLINE_CR Carriage return only\n PCRE2_NEWLINE_LF Linefeed only\n PCRE2_NEWLINE_CRLF CR followed by LF only\n PCRE2_NEWLINE_ANYCRLF Any of the above\n PCRE2_NEWLINE_ANY Any Unicode newline sequence\n PCRE2_NEWLINE_NUL The NUL character (binary zero)\n\nThe result is zero for success or PCRE2_ERROR_BADDATA if the second argument is\ninvalid.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_offset_limit.html", "content": "\n\npcre2_set_offset_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_offset_limit(pcre2_match_context *mcontext,\n PCRE2_SIZE value);\n
\n\nDESCRIPTION\n
\n\nThis function sets the offset limit field in a match context. The result is\nalways zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_optimize.html", "content": "\n\npcre2_set_optimize man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_optimize(pcre2_compile_context *ccontext,\n uint32_t directive);\n
\n\nDESCRIPTION\n
\n\nThis function controls which performance optimizations will be applied\nby pcre2_compile(). It can be called multiple times with the same compile\ncontext; the effects are cumulative, with the effects of later calls taking\nprecedence over earlier ones.\n
\n\nThe result is zero for success, PCRE2_ERROR_NULL if ccontext is NULL,\nor PCRE2_ERROR_BADOPTION if directive is unknown. The latter could be\nuseful to detect if a certain optimization is available.\n
\n\nThe list of possible values for the directive parameter are:\n
\n PCRE2_OPTIMIZATION_FULL Enable all optimizations (default)\n PCRE2_OPTIMIZATION_NONE Disable all optimizations\n PCRE2_AUTO_POSSESS Enable auto-possessification\n PCRE2_AUTO_POSSESS_OFF Disable auto-possessification\n PCRE2_DOTSTAR_ANCHOR Enable implicit dotstar anchoring\n PCRE2_DOTSTAR_ANCHOR_OFF Disable implicit dotstar anchoring\n PCRE2_START_OPTIMIZE Enable start-up optimizations at match time\n PCRE2_START_OPTIMIZE_OFF Disable start-up optimizations at match time\n\nThere is a complete description of the PCRE2 native API, including detailed\ndescriptions directive parameter values in the\npcre2api\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_parens_nest_limit.html", "content": "\n\npcre2_set_parens_nest_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function sets, in a compile context, the maximum depth of nested\nparentheses in a pattern. The result is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_recursion_limit.html", "content": "\n\npcre2_set_recursion_limit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_recursion_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n\nDESCRIPTION\n
\n\nThis function is obsolete and should not be used in new code. Use\npcre2_set_depth_limit() instead.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_recursion_memory_management.html", "content": "\n\npcre2_set_recursion_memory_management man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_recursion_memory_management(\n pcre2_match_context *mcontext,\n void *(*private_malloc)(size_t, void *),\n void (*private_free)(void *, void *), void *memory_data);\n
\n\nDESCRIPTION\n
\n\nFrom release 10.30 onwards, this function is obsolete and does nothing. The\nresult is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_substitute_callout.html", "content": "\n\npcre2_set_substitute_callout man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_substitute_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_substitute_callout_block *, void *),\n void *callout_data);\n
\n\nDESCRIPTION\n
\n\nThis function sets the substitute callout fields in a match context (the first\nargument). The second argument specifies a callout function, and the third\nargument is an opaque data item that is passed to it. The result of this\nfunction is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_set_substitute_case_callout.html", "content": "\n\npcre2_set_substitute_case_callout man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,\n PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE,\n PCRE2_UCHAR *, PCRE2_SIZE,\n int, void *),\n void *callout_data);\n
\n\nDESCRIPTION\n
\n\nThis function sets the substitute case callout fields in a match context (the\nfirst argument). The second argument specifies a callout function, and the third\nargument is an opaque data item that is passed to it. The result of this\nfunction is always zero.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substitute.html", "content": "\n\npcre2_substitute man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substitute(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext, PCRE2_SPTR replacement,\n PCRE2_SIZE rlength, PCRE2_UCHAR *outputbuffer,\n PCRE2_SIZE *outlengthptr);\n
\n\nDESCRIPTION\n
\n\nThis function matches a compiled regular expression against a given subject\nstring, using a matching algorithm that is similar to Perl's. It then makes a\ncopy of the subject, substituting a replacement string for what was matched.\nIts arguments are:\n
\n code Points to the compiled pattern\n subject Points to the subject string\n length Length of the subject string\n startoffset Offset in the subject at which to start matching\n options Option bits\n match_data Points to a match data block, or is NULL\n mcontext Points to a match context, or is NULL\n replacement Points to the replacement string\n rlength Length of the replacement string\n outputbuffer Points to the output buffer\n outlengthptr Points to the length of the output buffer\n\nA match data block is needed only if you want to inspect the data from the\nfinal match that is returned in that block or if PCRE2_SUBSTITUTE_MATCHED is\nset. A match context is needed only if you want to:\n
\n Set up a callout function\n Set a matching offset limit\n Change the backtracking match limit\n Change the backtracking depth limit\n Set custom memory management in the match context\n\nThe length, startoffset and rlength values are code units,\nnot characters, as is the contents of the variable pointed at by\noutlengthptr. This variable must contain the length of the output buffer\nwhen the function is called. If the function is successful, the value is\nchanged to the length of the new string, excluding the trailing zero that is\nautomatically added.\n\n
\nThe subject and replacement lengths can be given as PCRE2_ZERO_TERMINATED for\nzero-terminated strings. The options are:\n
\n PCRE2_ANCHORED Match only at the first position\n PCRE2_ENDANCHORED Match only at end of subject\n PCRE2_NOTBOL Subject is not the beginning of a line\n PCRE2_NOTEOL Subject is not the end of a line\n PCRE2_NOTEMPTY An empty string is not a valid match\n PCRE2_NOTEMPTY_ATSTART An empty string at the start of the subject is not a valid match\n PCRE2_NO_JIT Do not use JIT matching\n PCRE2_NO_UTF_CHECK Do not check for UTF validity in the subject or replacement\n (only relevant if PCRE2_UTF was set at compile time)\n PCRE2_SUBSTITUTE_EXTENDED Do extended replacement processing\n PCRE2_SUBSTITUTE_GLOBAL Replace all occurrences in the subject\n PCRE2_SUBSTITUTE_LITERAL The replacement string is literal\n PCRE2_SUBSTITUTE_MATCHED Use pre-existing match data for first match\n PCRE2_SUBSTITUTE_OVERFLOW_LENGTH If overflow, compute needed length\n PCRE2_SUBSTITUTE_REPLACEMENT_ONLY Return only replacement string(s)\n PCRE2_SUBSTITUTE_UNKNOWN_UNSET Treat unknown group as unset\n PCRE2_SUBSTITUTE_UNSET_EMPTY Simple unset insert = empty string\n\nIf PCRE2_SUBSTITUTE_LITERAL is set, PCRE2_SUBSTITUTE_EXTENDED,\nPCRE2_SUBSTITUTE_UNKNOWN_UNSET, and PCRE2_SUBSTITUTE_UNSET_EMPTY are ignored.\n\n
\nIf PCRE2_SUBSTITUTE_MATCHED is set, match_data must be non-NULL; its\ncontents must be the result of a call to pcre2_match() (or\npcre2_jit_match()) using the same pattern, subject pointer, effective\nsubject length, start offset, and match options.\n
\n\nThe function returns the number of substitutions, which may be zero if there\nare no matches. The result may be greater than one only when\nPCRE2_SUBSTITUTE_GLOBAL is set. In the event of an error, a negative error code\nis returned.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_copy_byname.html", "content": "\n\npcre2_substring_copy_byname man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_copy_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR *buffer, PCRE2_SIZE *bufflen);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for extracting a captured substring, identified\nby name, into a given buffer. The arguments are:\n
\n match_data The match data block for the match\n name Name of the required substring\n buffer Buffer to receive the string\n bufflen Length of buffer (code units)\n\nThe bufflen variable is updated to contain the length of the extracted\nstring, excluding the trailing zero. The yield of the function is zero for\nsuccess or one of the following error numbers:\n
\n PCRE2_ERROR_NOSUBSTRING there are no groups of that name\n PCRE2_ERROR_UNAVAILBLE the ovector was too small for that group\n PCRE2_ERROR_UNSET the group did not participate in the match\n PCRE2_ERROR_NOMEMORY the buffer is not big enough\n\nIf there is more than one group with the given name, the first one that is set\nis returned. In this situation PCRE2_ERROR_UNSET means that no group with the\ngiven name was set.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_copy_bynumber.html", "content": "\n\npcre2_substring_copy_bynumber man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_copy_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR *buffer,\n PCRE2_SIZE *bufflen);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for extracting a captured substring into a given\nbuffer. The arguments are:\n
\n match_data The match data block for the match\n number Number of the required substring\n buffer Buffer to receive the string\n bufflen Length of buffer\n\nThe bufflen variable is updated with the length of the extracted string,\nexcluding the terminating zero. The yield of the function is zero for success\nor one of the following error numbers:\n
\n PCRE2_ERROR_NOSUBSTRING there are no groups of that number\n PCRE2_ERROR_UNAVAILBLE the ovector was too small for that group\n PCRE2_ERROR_UNSET the group did not participate in the match\n PCRE2_ERROR_NOMEMORY the buffer is too small\n\n\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_free.html", "content": "\n\npcre2_substring_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_substring_free(PCRE2_UCHAR *buffer);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for freeing the memory obtained by a previous\ncall to pcre2_substring_get_byname() or\npcre2_substring_get_bynumber(). Its only argument is a pointer to the\nstring. If the argument is NULL, the function does nothing.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_get_byname.html", "content": "\n\npcre2_substring_get_byname man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_get_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR **bufferptr, PCRE2_SIZE *bufflen);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for extracting a captured substring by name into\nnewly acquired memory. The arguments are:\n
\n match_data The match data for the match\n name Name of the required substring\n bufferptr Where to put the string pointer\n bufflen Where to put the string length\n\nThe memory in which the substring is placed is obtained by calling the same\nmemory allocation function that was used for the match data block. The\nconvenience function pcre2_substring_free() can be used to free it when\nit is no longer needed. The yield of the function is zero for success or one of\nthe following error numbers:\n
\n PCRE2_ERROR_NOSUBSTRING there are no groups of that name\n PCRE2_ERROR_UNAVAILBLE the ovector was too small for that group\n PCRE2_ERROR_UNSET the group did not participate in the match\n PCRE2_ERROR_NOMEMORY memory could not be obtained\n\nIf there is more than one group with the given name, the first one that is set\nis returned. In this situation PCRE2_ERROR_UNSET means that no group with the\ngiven name was set.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_get_bynumber.html", "content": "\n\npcre2_substring_get_bynumber man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_get_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR **bufferptr, PCRE2_SIZE *bufflen);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for extracting a captured substring by number\ninto newly acquired memory. The arguments are:\n
\n match_data The match data for the match\n number Number of the required substring\n bufferptr Where to put the string pointer\n bufflen Where to put the string length\n\nThe memory in which the substring is placed is obtained by calling the same\nmemory allocation function that was used for the match data block. The\nconvenience function pcre2_substring_free() can be used to free it when\nit is no longer needed. The yield of the function is zero for success or one of\nthe following error numbers:\n
\n PCRE2_ERROR_NOSUBSTRING there are no groups of that number\n PCRE2_ERROR_UNAVAILBLE the ovector was too small for that group\n PCRE2_ERROR_UNSET the group did not participate in the match\n PCRE2_ERROR_NOMEMORY memory could not be obtained\n\n\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_length_byname.html", "content": "\n\npcre2_substring_length_byname man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_length_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_SIZE *length);\n
\n\nDESCRIPTION\n
\n\nThis function returns the length of a matched substring, identified by name.\nThe arguments are:\n
\n match_data The match data block for the match\n name The substring name\n length Where to return the length, or NULL\n\nThe third argument may be NULL if all you want to know is whether or not a\nsubstring is set. The yield is zero on success, or a negative error code\notherwise.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_length_bynumber.html", "content": "\n\npcre2_substring_length_bynumber man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_length_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_SIZE *length);\n
\n\nDESCRIPTION\n
\n\nThis function returns the length of a matched substring, identified by number.\nThe arguments are:\n
\n match_data The match data block for the match\n number The substring number\n length Where to return the length, or NULL\n\nThe third argument may be NULL if all you want to know is whether or not a\nsubstring is set. The yield is zero on success, or a negative error code\notherwise. After a partial match, only substring 0 is available.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_list_free.html", "content": "\n\npcre2_substring_list_free man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nvoid pcre2_substring_list_free(PCRE2_UCHAR **list);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for freeing the store obtained by a previous\ncall to pcre2substring_list_get(). Its only argument is a pointer to\nthe list of string pointers. If the argument is NULL, the function returns\nimmediately, without doing anything.\n
\n\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_list_get.html", "content": "\n\npcre2_substring_list_get man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_list_get(pcre2_match_data *match_data,\n\" PCRE2_UCHAR ***listptr, PCRE2_SIZE **lengthsptr);\n
\n\nDESCRIPTION\n
\n\nThis is a convenience function for extracting all the captured substrings after\na pattern match. It builds a list of pointers to the strings, and (optionally)\na second list that contains their lengths (in code units), excluding a\nterminating zero that is added to each of them. All this is done in a single\nblock of memory that is obtained using the same memory allocation function that\nwas used to get the match data block. The convenience function\npcre2_substring_list_free() can be used to free it when it is no longer\nneeded. The arguments are:\n
\n match_data The match data block\n listptr Where to put a pointer to the list\n lengthsptr Where to put a pointer to the lengths, or NULL\n\nA pointer to a list of pointers is put in the variable whose address is in\nlistptr. The list is terminated by a NULL pointer. If lengthsptr is\nnot NULL, a matching list of lengths is created, and its address is placed in\nlengthsptr. The yield of the function is zero on success or\nPCRE2_ERROR_NOMEMORY if sufficient memory could not be obtained.\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_nametable_scan.html", "content": "\n\npcre2_substring_nametable_scan man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_nametable_scan(const pcre2_code *code,\n PCRE2_SPTR name, PCRE2_SPTR *first, PCRE2_SPTR *last);\n
\n\nDESCRIPTION\n
\n\nThis convenience function finds, for a compiled pattern, the first and last\nentries for a given name in the table that translates capture group names into\nnumbers.\n
\n code Compiled regular expression\n name Name whose entries required\n first Where to return a pointer to the first entry\n last Where to return a pointer to the last entry\n\nWhen the name is found in the table, if first is NULL, the function\nreturns a group number, but if there is more than one matching entry, it is not\ndefined which one. Otherwise, when both pointers have been set, the yield of\nthe function is the length of each entry in code units. If the name is not\nfound, PCRE2_ERROR_NOSUBSTRING is returned.\n\n
\nThere is a complete description of the PCRE2 native API, including the format of\nthe table entries, in the\npcre2api\npage, and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2_substring_number_from_name.html", "content": "\n\npcre2_substring_number_from_name man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSYNOPSIS\n
\n\n#include <pcre2.h>\n
\n\nint pcre2_substring_number_from_name(const pcre2_code *code,\n PCRE2_SPTR name);\n
\n\nDESCRIPTION\n
\n\nThis convenience function finds the number of a named substring capturing\nparenthesis in a compiled pattern, provided that it is a unique name. The\nfunction arguments are:\n
\n code Compiled regular expression\n name Name whose number is required\n\nThe yield of the function is the number of the parenthesis if the name is\nfound, or PCRE2_ERROR_NOSUBSTRING if it is not found. When duplicate names are\nallowed (PCRE2_DUPNAMES is set), if the name is not unique,\nPCRE2_ERROR_NOUNIQUESUBSTRING is returned. You can obtain the list of numbers\nwith the same name by calling pcre2_substring_nametable_scan().\n\n
\nThere is a complete description of the PCRE2 native API in the\npcre2api\npage and a description of the POSIX API in the\npcre2posix\npage.\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2api.html", "content": "\n\npcre2api man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 NATIVE API BASIC FUNCTIONS\n
- PCRE2 NATIVE API AUXILIARY MATCH FUNCTIONS\n
- PCRE2 NATIVE API GENERAL CONTEXT FUNCTIONS\n
- PCRE2 NATIVE API COMPILE CONTEXT FUNCTIONS\n
- PCRE2 NATIVE API MATCH CONTEXT FUNCTIONS\n
- PCRE2 NATIVE API STRING EXTRACTION FUNCTIONS\n
- PCRE2 NATIVE API STRING SUBSTITUTION FUNCTION\n
- PCRE2 NATIVE API JIT FUNCTIONS\n
- PCRE2 NATIVE API SERIALIZATION FUNCTIONS\n
- PCRE2 NATIVE API AUXILIARY FUNCTIONS\n
- PCRE2 NATIVE API OBSOLETE FUNCTIONS\n
- PCRE2 EXPERIMENTAL PATTERN CONVERSION FUNCTIONS\n
- PCRE2 8-BIT, 16-BIT, AND 32-BIT LIBRARIES\n
- PCRE2 API OVERVIEW\n
- STRING LENGTHS AND OFFSETS\n
- NEWLINES\n
- MULTITHREADING\n
- PCRE2 CONTEXTS\n
- CHECKING BUILD-TIME OPTIONS\n
- COMPILING A PATTERN\n
- JUST-IN-TIME (JIT) COMPILATION\n
- LOCALE SUPPORT\n
- INFORMATION ABOUT A COMPILED PATTERN\n
- INFORMATION ABOUT A PATTERN'S CALLOUTS\n
- SERIALIZATION AND PRECOMPILING\n
- THE MATCH DATA BLOCK\n
- MEMORY USE FOR MATCH DATA BLOCKS\n
- MATCHING A PATTERN: THE TRADITIONAL FUNCTION\n
- NEWLINE HANDLING WHEN MATCHING\n
- HOW PCRE2_MATCH() RETURNS A STRING AND CAPTURED SUBSTRINGS\n
- OTHER INFORMATION ABOUT A MATCH\n
- ERROR RETURNS FROM pcre2_match()\n
- OBTAINING A TEXTUAL ERROR MESSAGE\n
- ITERATING OVER ALL MATCHES\n
- EXTRACTING CAPTURED SUBSTRINGS BY NUMBER\n
- EXTRACTING A LIST OF ALL CAPTURED SUBSTRINGS\n
- EXTRACTING CAPTURED SUBSTRINGS BY NAME\n
- CREATING A NEW STRING WITH SUBSTITUTIONS\n
- DUPLICATE CAPTURE GROUP NAMES\n
- FINDING ALL POSSIBLE MATCHES AT ONE POSITION\n
- MATCHING A PATTERN: THE ALTERNATIVE FUNCTION\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
\n#include <pcre2.h>\n
\n
\nPCRE2 is a new API for PCRE, starting at release 10.0. This document contains a\ndescription of all its native functions. See the\npcre2\ndocument for an overview of all the PCRE2 documentation.\n
PCRE2 NATIVE API BASIC FUNCTIONS
\n\npcre2_code *pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, int *errorcode, PCRE2_SIZE *erroroffset,\n pcre2_compile_context *ccontext);\n
\n
\nvoid pcre2_code_free(pcre2_code *code);\n
\n
\npcre2_match_data *pcre2_match_data_create(uint32_t ovecsize,\n pcre2_general_context *gcontext);\n
\n
\npcre2_match_data *pcre2_match_data_create_from_pattern(\n const pcre2_code *code, pcre2_general_context *gcontext);\n
\n
\nint pcre2_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n
\nint pcre2_dfa_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext,\n int *workspace, PCRE2_SIZE wscount);\n
\n
\nvoid pcre2_match_data_free(pcre2_match_data *match_data);\n
PCRE2 NATIVE API AUXILIARY MATCH FUNCTIONS
\n\nPCRE2_SPTR pcre2_get_mark(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE pcre2_get_match_data_size(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE pcre2_get_match_data_heapframes_size(\n pcre2_match_data *match_data);\n
\n
\nuint32_t pcre2_get_ovector_count(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE *pcre2_get_ovector_pointer(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE pcre2_get_startchar(pcre2_match_data *match_data);\n
PCRE2 NATIVE API GENERAL CONTEXT FUNCTIONS
\n\npcre2_general_context *pcre2_general_context_create(\n void *(*private_malloc)(PCRE2_SIZE, void *),\n void (*private_free)(void *, void *), void *memory_data);\n
\n
\npcre2_general_context *pcre2_general_context_copy(\n pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_general_context_free(pcre2_general_context *gcontext);\n
PCRE2 NATIVE API COMPILE CONTEXT FUNCTIONS
\n\npcre2_compile_context *pcre2_compile_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_compile_context *pcre2_compile_context_copy(\n pcre2_compile_context *ccontext);\n
\n
\nvoid pcre2_compile_context_free(pcre2_compile_context *ccontext);\n
\n
\nint pcre2_set_bsr(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nint pcre2_set_character_tables(pcre2_compile_context *ccontext,\n const uint8_t *tables);\n
\n
\nint pcre2_set_compile_extra_options(pcre2_compile_context *ccontext,\n uint32_t extra_options);\n
\n
\nint pcre2_set_max_pattern_length(pcre2_compile_context *ccontext,\n PCRE2_SIZE value);\n
\n
\nint pcre2_set_max_pattern_compiled_length(\n pcre2_compile_context *ccontext, PCRE2_SIZE value);\n
\n
\nint pcre2_set_max_varlookbehind(pcre2_compile_contest *ccontext,\n uint32_t value);\n
\n
\nint pcre2_set_newline(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nint pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nint pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,\n int (*guard_function)(uint32_t, void *), void *user_data);\n
\n
\nint pcre2_set_optimize(pcre2_compile_context *ccontext,\n uint32_t directive);\n
PCRE2 NATIVE API MATCH CONTEXT FUNCTIONS
\n\npcre2_match_context *pcre2_match_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_match_context *pcre2_match_context_copy(\n pcre2_match_context *mcontext);\n
\n
\nvoid pcre2_match_context_free(pcre2_match_context *mcontext);\n
\n
\nint pcre2_set_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_callout_block *, void *),\n void *callout_data);\n
\n
\nint pcre2_set_substitute_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_substitute_callout_block *, void *),\n void *callout_data);\n
\n
\nint pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,\n PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE,\n PCRE2_UCHAR *, PCRE2_SIZE,\n int, void *),\n void *callout_data);\n
\n
\nint pcre2_set_offset_limit(pcre2_match_context *mcontext,\n PCRE2_SIZE value);\n
\n
\nint pcre2_set_heap_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nint pcre2_set_match_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nint pcre2_set_depth_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
PCRE2 NATIVE API STRING EXTRACTION FUNCTIONS
\n\nint pcre2_substring_copy_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR *buffer, PCRE2_SIZE *bufflen);\n
\n
\nint pcre2_substring_copy_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR *buffer,\n PCRE2_SIZE *bufflen);\n
\n
\nvoid pcre2_substring_free(PCRE2_UCHAR *buffer);\n
\n
\nint pcre2_substring_get_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR **bufferptr, PCRE2_SIZE *bufflen);\n
\n
\nint pcre2_substring_get_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR **bufferptr,\n PCRE2_SIZE *bufflen);\n
\n
\nint pcre2_substring_length_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_SIZE *length);\n
\n
\nint pcre2_substring_length_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_SIZE *length);\n
\n
\nint pcre2_substring_nametable_scan(const pcre2_code *code,\n PCRE2_SPTR name, PCRE2_SPTR *first, PCRE2_SPTR *last);\n
\n
\nint pcre2_substring_number_from_name(const pcre2_code *code,\n PCRE2_SPTR name);\n
\n
\nvoid pcre2_substring_list_free(PCRE2_UCHAR **list);\n
\n
\nint pcre2_substring_list_get(pcre2_match_data *match_data,\n PCRE2_UCHAR ***listptr, PCRE2_SIZE **lengthsptr);\n
PCRE2 NATIVE API STRING SUBSTITUTION FUNCTION
\n\nint pcre2_substitute(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext, PCRE2_SPTR replacement,\n PCRE2_SIZE rlength, PCRE2_UCHAR *outputbuffer,\n PCRE2_SIZE *outlengthptr);\n
\nPCRE2 NATIVE API JIT FUNCTIONS
\n\nint pcre2_jit_compile(pcre2_code *code, uint32_t options);\n
\n
\nint pcre2_jit_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n
\nvoid pcre2_jit_free_unused_memory(pcre2_general_context *gcontext);\n
\n
\npcre2_jit_stack *pcre2_jit_stack_create(size_t startsize,\n size_t maxsize, pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_jit_stack_assign(pcre2_match_context *mcontext,\n pcre2_jit_callback callback_function, void *callback_data);\n
\n
\nvoid pcre2_jit_stack_free(pcre2_jit_stack *jit_stack);\n
PCRE2 NATIVE API SERIALIZATION FUNCTIONS
\n\nint32_t pcre2_serialize_decode(pcre2_code **codes,\n int32_t number_of_codes, const uint8_t *bytes,\n pcre2_general_context *gcontext);\n
\n
\nint32_t pcre2_serialize_encode(const pcre2_code **codes,\n int32_t number_of_codes, uint8_t **serialized_bytes,\n PCRE2_SIZE *serialized_size, pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_serialize_free(uint8_t *bytes);\n
\n
\nint32_t pcre2_serialize_get_number_of_codes(const uint8_t *bytes);\n
PCRE2 NATIVE API AUXILIARY FUNCTIONS
\n\npcre2_code *pcre2_code_copy(const pcre2_code *code);\n
\n
\npcre2_code *pcre2_code_copy_with_tables(const pcre2_code *code);\n
\n
\nint pcre2_get_error_message(int errorcode, PCRE2_UCHAR *buffer,\n PCRE2_SIZE bufflen);\n
\n
\nconst uint8_t *pcre2_maketables(pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_maketables_free(pcre2_general_context *gcontext,\n const uint8_t *tables);\n
\n
\nint pcre2_pattern_info(const pcre2_code *code, uint32_t what,\n void *where);\n
\n
\nint pcre2_callout_enumerate(const pcre2_code *code,\n int (*callback)(pcre2_callout_enumerate_block *, void *),\n void *user_data);\n
\n
\nint pcre2_config(uint32_t what, void *where);\n
PCRE2 NATIVE API OBSOLETE FUNCTIONS
\n\nint pcre2_set_recursion_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nint pcre2_set_recursion_memory_management(\n pcre2_match_context *mcontext,\n void *(*private_malloc)(size_t, void *),\n void (*private_free)(void *, void *), void *memory_data);\n
\n
\nThese functions became obsolete at release 10.30 and are retained only for\nbackward compatibility. They should not be used in new code. The first is\nreplaced by pcre2_set_depth_limit(); the second is no longer needed and\nhas no effect (it always returns zero).\n
PCRE2 EXPERIMENTAL PATTERN CONVERSION FUNCTIONS
\n\npcre2_convert_context *pcre2_convert_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_convert_context *pcre2_convert_context_copy(\n pcre2_convert_context *cvcontext);\n
\n
\nvoid pcre2_convert_context_free(pcre2_convert_context *cvcontext);\n
\n
\nint pcre2_set_glob_escape(pcre2_convert_context *cvcontext,\n uint32_t escape_char);\n
\n
\nint pcre2_set_glob_separator(pcre2_convert_context *cvcontext,\n uint32_t separator_char);\n
\n
\nint pcre2_pattern_convert(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, PCRE2_UCHAR **buffer,\n PCRE2_SIZE *blength, pcre2_convert_context *cvcontext);\n
\n
\nvoid pcre2_converted_pattern_free(PCRE2_UCHAR *converted_pattern);\n
\n
\nThese functions provide a way of converting non-PCRE2 patterns into\npatterns that can be processed by pcre2_compile(). This facility is\nexperimental and may be changed in future releases. At present, \"globs\" and\nPOSIX basic and extended patterns can be converted. Details are given in the\npcre2convert\ndocumentation.\n
PCRE2 8-BIT, 16-BIT, AND 32-BIT LIBRARIES
\n\nThere are three PCRE2 libraries, supporting 8-bit, 16-bit, and 32-bit code\nunits, respectively. However, there is just one header file, pcre2.h.\nThis contains the function prototypes and other definitions for all three\nlibraries. One, two, or all three can be installed simultaneously. On Unix-like\nsystems the libraries are called libpcre2-8, libpcre2-16, and\nlibpcre2-32, and they can also co-exist with the original PCRE libraries.\nEvery PCRE2 function comes in three different forms, one for each library, for\nexample:\n
\n pcre2_compile_8()\n pcre2_compile_16()\n pcre2_compile_32()\n\nThere are also three different sets of data types:\n
\n PCRE2_UCHAR8, PCRE2_UCHAR16, PCRE2_UCHAR32\n PCRE2_SPTR8, PCRE2_SPTR16, PCRE2_SPTR32\n\nThe UCHAR types define unsigned code units of the appropriate widths.\nFor example, PCRE2_UCHAR16 is usually defined as `uint16_t'.\nThe SPTR types are pointers to constants of the equivalent UCHAR types,\nthat is, they are pointers to vectors of unsigned code units.\n\n
\nCharacter strings are passed to a PCRE2 library as sequences of unsigned\nintegers in code units of the appropriate width. The length of a string may\nbe given as a number of code units, or the string may be specified as\nzero-terminated.\n
\n\nMany applications use only one code unit width. For their convenience, macros\nare defined whose names are the generic forms such as pcre2_compile() and\nPCRE2_SPTR. These macros use the value of the macro PCRE2_CODE_UNIT_WIDTH to\ngenerate the appropriate width-specific function and macro names.\nPCRE2_CODE_UNIT_WIDTH is not defined by default. An application must define it\nto be 8, 16, or 32 before including pcre2.h in order to make use of the\ngeneric names.\n
\n\nApplications that use more than one code unit width can be linked with more\nthan one PCRE2 library, but must define PCRE2_CODE_UNIT_WIDTH to be 0 before\nincluding pcre2.h, and then use the real function names. Any code that is\nto be included in an environment where the value of PCRE2_CODE_UNIT_WIDTH is\nunknown should also use the real function names. (Unfortunately, it is not\npossible in C code to save and restore the value of a macro.)\n
\n\nIf PCRE2_CODE_UNIT_WIDTH is not defined before including pcre2.h, a\ncompiler error occurs.\n
\n\nWhen using multiple libraries in an application, you must take care when\nprocessing any particular pattern to use only functions from a single library.\nFor example, if you want to run a match using a pattern that was compiled with\npcre2_compile_16(), you must do so with pcre2_match_16(), not\npcre2_match_8() or pcre2_match_32().\n
\n\nIn the function summaries above, and in the rest of this document and other\nPCRE2 documents, functions and data types are described using their generic\nnames, without the _8, _16, or _32 suffix.\n
\nPCRE2 API OVERVIEW
\n\nPCRE2 has its own native API, which is described in this document. There are\nalso some wrapper functions for the 8-bit library that correspond to the\nPOSIX regular expression API, but they do not give access to all the\nfunctionality of PCRE2 and they are not thread-safe. They are described in the\npcre2posix\ndocumentation. Both these APIs define a set of C function calls.\n
\n\nThe native API C data types, function prototypes, option values, and error\ncodes are defined in the header file pcre2.h, which also contains\ndefinitions of PCRE2_MAJOR and PCRE2_MINOR, the major and minor release numbers\nfor the library. Applications can use these to include support for different\nreleases of PCRE2.\n
\n\nIn a Windows environment, if you want to statically link an application program\nagainst a non-dll PCRE2 library, you must define PCRE2_STATIC before including\npcre2.h.\n
\n\nThe functions pcre2_compile() and pcre2_match() are used for\ncompiling and matching regular expressions in a Perl-compatible manner. A\nsample program that demonstrates the simplest way of using them is provided in\nthe file called pcre2demo.c in the PCRE2 source distribution. A listing\nof this program is given in the\npcre2demo\ndocumentation, and the\npcre2sample\ndocumentation describes how to compile and run it.\n
\n\nThe compiling and matching functions recognize various options that are passed\nas bits in an options argument. There are also some more complicated parameters\nsuch as custom memory management functions and resource limits that are passed\nin \"contexts\" (which are just memory blocks, described below). Simple\napplications do not need to make use of contexts.\n
\n\nJust-in-time (JIT) compiler support is an optional feature of PCRE2 that can be\nbuilt in appropriate hardware environments. It greatly speeds up the matching\nperformance of many patterns. Programs can request that it be used if\navailable by calling pcre2_jit_compile() after a pattern has been\nsuccessfully compiled by pcre2_compile(). This does nothing if JIT\nsupport is not available.\n
\n\nMore complicated programs might need to make use of the specialist functions\npcre2_jit_stack_create(), pcre2_jit_stack_free(), and\npcre2_jit_stack_assign() in order to control the JIT code's memory usage.\n
\n\nJIT matching is automatically used by pcre2_match() if it is available,\nunless the PCRE2_NO_JIT option is set. There is also a direct interface for JIT\nmatching, which gives improved performance at the expense of less sanity\nchecking. The JIT-specific functions are discussed in the\npcre2jit\ndocumentation.\n
\n\nA second matching function, pcre2_dfa_match(), which is not\nPerl-compatible, is also provided. This uses a different algorithm for the\nmatching. The alternative algorithm finds all possible matches (at a given\npoint in the subject), and scans the subject just once (unless there are\nlookaround assertions). However, this algorithm does not return captured\nsubstrings. A description of the two matching algorithms and their advantages\nand disadvantages is given in the\npcre2matching\ndocumentation. There is no JIT support for pcre2_dfa_match().\n
\n\nIn addition to the main compiling and matching functions, there are convenience\nfunctions for extracting captured substrings from a subject string that has\nbeen matched by pcre2_match(). They are:\n
\n pcre2_substring_copy_byname()\n pcre2_substring_copy_bynumber()\n pcre2_substring_get_byname()\n pcre2_substring_get_bynumber()\n pcre2_substring_list_get()\n pcre2_substring_length_byname()\n pcre2_substring_length_bynumber()\n pcre2_substring_nametable_scan()\n pcre2_substring_number_from_name()\n\npcre2_substring_free() and pcre2_substring_list_free() are also\nprovided, to free memory used for extracted strings. If either of these\nfunctions is called with a NULL argument, the function returns immediately\nwithout doing anything.\n\n
\nThe function pcre2_substitute() can be called to match a pattern and\nreturn a copy of the subject string with substitutions for parts that were\nmatched.\n
\n\nFunctions whose names begin with pcre2_serialize_ are used for saving\ncompiled patterns on disc or elsewhere, and reloading them later.\n
\n\nFinally, there are functions for finding out information about a compiled\npattern (pcre2_pattern_info()) and about the configuration with which\nPCRE2 was built (pcre2_config()) and that it is using.\n
\n\nFunctions with names ending with _free() are used for freeing memory\nblocks of various sorts. In all cases, if one of these functions is called with\na NULL argument, it does nothing.\n
\nSTRING LENGTHS AND OFFSETS
\n\nThe PCRE2 API uses string lengths and offsets into strings of code units in\nseveral places. These values are always of type PCRE2_SIZE, which is an\nunsigned integer type, currently always defined as size_t. The largest\nvalue that can be stored in such a type (that is ~(PCRE2_SIZE)0) is reserved\nas a special indicator for zero-terminated strings and unset offsets.\nTherefore, the longest string that can be handled is one less than this\nmaximum. Note that string lengths are always given in code units. Only in the\n8-bit library is such a length the same as the number of bytes in the string.\n
\nNEWLINES
\n\nPCRE2 supports five different conventions for indicating line breaks in\nstrings: a single CR (carriage return) character, a single LF (linefeed)\ncharacter, the two-character sequence CRLF, any of the three preceding, or any\nUnicode newline sequence. The Unicode newline sequences are the three just\nmentioned, plus the single characters VT (vertical tab, U+000B), FF (form feed,\nU+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS\n(paragraph separator, U+2029).\n
\n\nEach of the first three conventions is used by at least one operating system as\nits standard newline sequence. When PCRE2 is built, a default can be specified.\nIf it is not, the default is set to LF, which is the Unix standard. However,\nthe newline convention can be changed by an application when calling\npcre2_compile(), or it can be specified by special text at the start of\nthe pattern itself; this overrides any other settings. See the\npcre2pattern\npage for details of the special character sequences.\n
\n\nIn the PCRE2 documentation the word \"newline\" is used to mean \"the character or\npair of characters that indicate a line break\". The choice of newline\nconvention affects the handling of the dot, circumflex, and dollar\nmetacharacters, the handling of #-comments in /x mode, and, when CRLF is a\nrecognized line ending sequence, the match position advancement for a\nnon-anchored pattern. There is more detail about this in the\nsection on pcre2_match() options\nbelow.\n
\n\nThe choice of newline convention does not affect the interpretation of\nthe \\n or \\r escape sequences, nor does it affect what \\R matches; this has\nits own separate convention.\n
\nMULTITHREADING
\n\nIn a multithreaded application it is important to keep thread-specific data\nseparate from data that can be shared between threads. The PCRE2 library code\nitself is thread-safe: it contains no static or global variables. The API is\ndesigned to be fairly simple for non-threaded applications while at the same\ntime ensuring that multithreaded applications can use it.\n
\n\nThere are several different blocks of data that are used to pass information\nbetween the application and the PCRE2 libraries.\n
\n\nThe compiled pattern\n
\n\nA pointer to the compiled form of a pattern is returned to the user when\npcre2_compile() is successful. The data in the compiled pattern is fixed,\nand does not change when the pattern is matched. Therefore, it is thread-safe,\nthat is, the same compiled pattern can be used by more than one thread\nsimultaneously. For example, an application can compile all its patterns at the\nstart, before forking off multiple threads that use them. However, if the\njust-in-time (JIT) optimization feature is being used, it needs separate memory\nstack areas for each thread. See the\npcre2jit\ndocumentation for more details.\n
\n\nIn a more complicated situation, where patterns are compiled only when they are\nfirst needed, but are still shared between threads, pointers to compiled\npatterns must be protected from simultaneous writing by multiple threads. This\nis somewhat tricky to do correctly. If you know that writing to a pointer is\natomic in your environment, you can use logic like this:\n
\n Get a read-only (shared) lock (mutex) for pointer\n if (pointer == NULL)\n {\n Get a write (unique) lock for pointer\n if (pointer == NULL) pointer = pcre2_compile(...\n }\n Release the lock\n Use pointer in pcre2_match()\n\nOf course, testing for compilation errors should also be included in the code.\n\n\nThe reason for checking the pointer a second time is as follows: Several\nthreads may have acquired the shared lock and tested the pointer for being\nNULL, but only one of them will be given the write lock, with the rest kept\nwaiting. The winning thread will compile the pattern and store the result.\nAfter this thread releases the write lock, another thread will get it, and if\nit does not retest pointer for being NULL, will recompile the pattern and\noverwrite the pointer, creating a memory leak and possibly causing other\nissues.\n
\n\nIn an environment where writing to a pointer may not be atomic, the above logic\nis not sufficient. The thread that is doing the compiling may be descheduled\nafter writing only part of the pointer, which could cause other threads to use\nan invalid value. Instead of checking the pointer itself, a separate \"pointer\nis valid\" flag (that can be updated atomically) must be used:\n
\n Get a read-only (shared) lock (mutex) for pointer\n if (!pointer_is_valid)\n {\n Get a write (unique) lock for pointer\n if (!pointer_is_valid)\n {\n pointer = pcre2_compile(...\n pointer_is_valid = TRUE\n }\n }\n Release the lock\n Use pointer in pcre2_match()\n\nIf JIT is being used, but the JIT compilation is not being done immediately\n(perhaps waiting to see if the pattern is used often enough), similar logic is\nrequired. JIT compilation updates a value within the compiled code block, so a\nthread must gain unique write access to the pointer before calling\npcre2_jit_compile(). Alternatively, pcre2_code_copy() or\npcre2_code_copy_with_tables() can be used to obtain a private copy of the\ncompiled code before calling the JIT compiler.\n\n\nContext blocks\n
\n\nThe next main section below introduces the idea of \"contexts\" in which PCRE2\nfunctions are called. A context is nothing more than a collection of parameters\nthat control the way PCRE2 operates. Grouping a number of parameters together\nin a context is a convenient way of passing them to a PCRE2 function without\nusing lots of arguments. The parameters that are stored in contexts are in some\nsense \"advanced features\" of the API. Many straightforward applications will\nnot need to use contexts.\n
\n\nIn a multithreaded application, if the parameters in a context are values that\nare never changed, the same context can be used by all the threads. However, if\nany thread needs to change any value in a context, it must make its own\nthread-specific copy.\n
\n\nMatch blocks\n
\n\nThe matching functions need a block of memory for storing the results of a\nmatch. This includes details of what was matched, as well as additional\ninformation such as the name of a (*MARK) setting. Each thread must provide its\nown copy of this memory.\n
\nPCRE2 CONTEXTS
\n\nSome PCRE2 functions have a lot of parameters, many of which are used only by\nspecialist applications, for example, those that use custom memory management\nor non-standard character tables. To keep function argument lists at a\nreasonable size, and at the same time to keep the API extensible, \"uncommon\"\nparameters are passed to certain functions in a context instead of\ndirectly. A context is just a block of memory that holds the parameter values.\nApplications that do not need to adjust any of the context parameters can pass\nNULL when a context pointer is required.\n
\n\nThere are three different types of context: a general context that is relevant\nfor several PCRE2 operations, a compile-time context, and a match-time context.\n
\n\nThe general context\n
\n\nAt present, this context just contains pointers to (and data for) external\nmemory management functions that are called from several places in the PCRE2\nlibrary. The context is named `general' rather than specifically `memory'\nbecause in future other fields may be added. If you do not want to supply your\nown custom memory management functions, you do not need to bother with a\ngeneral context. A general context is created by:\n
\n
\npcre2_general_context *pcre2_general_context_create(\n void *(*private_malloc)(PCRE2_SIZE, void *),\n void (*private_free)(void *, void *), void *memory_data);\n
\n
\nThe two function pointers specify custom memory management functions, whose\nprototypes are:\n
\n void *private_malloc(PCRE2_SIZE, void *);\n void private_free(void *, void *);\n\nWhenever code in PCRE2 calls these functions, the final argument is the value\nof memory_data. Either of the first two arguments of the creation\nfunction may be NULL, in which case the system memory management functions\nmalloc() and free() are used. (This is not currently useful, as\nthere are no other fields in a general context, but in future there might be.)\nThe private_malloc() function is used (if supplied) to obtain memory for\nstoring the context, and all three values are saved as part of the context.\n\n
\nWhenever PCRE2 creates a data block of any kind, the block contains a pointer\nto the free() function that matches the malloc() function that was\nused. When the time comes to free the block, this function is called.\n
\n\nA general context can be copied by calling:\n
\n
\npcre2_general_context *pcre2_general_context_copy(\n pcre2_general_context *gcontext);\n
\n
\nThe memory used for a general context should be freed by calling:\n
\n
\nvoid pcre2_general_context_free(pcre2_general_context *gcontext);\n
\n
\nIf this function is passed a NULL argument, it returns immediately without\ndoing anything.\n
\nThe compile context\n
\n\nA compile context is required if you want to provide an external function for\nstack checking during compilation or to change the default values of any of the\nfollowing compile-time parameters:\n
\n What \\R matches (Unicode newlines or CR, LF, CRLF only)\n PCRE2's character tables\n The newline character sequence\n The compile time nested parentheses limit\n The maximum length of the pattern string\n The extra options bits (none set by default)\n Which performance optimizations the compiler should apply\n\nA compile context is also required if you are using custom memory management.\nIf none of these apply, just pass NULL as the context argument of\npcre2_compile().\n\n
\nA compile context is created, copied, and freed by the following functions:\n
\n
\npcre2_compile_context *pcre2_compile_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_compile_context *pcre2_compile_context_copy(\n pcre2_compile_context *ccontext);\n
\n
\nvoid pcre2_compile_context_free(pcre2_compile_context *ccontext);\n
\n
\nA compile context is created with default values for its parameters. These can\nbe changed by calling the following functions, which return 0 on success, or\nPCRE2_ERROR_BADDATA if invalid data is detected.\n
\n
\nint pcre2_set_bsr(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nThe value must be PCRE2_BSR_ANYCRLF, to specify that \\R matches only CR, LF,\nor CRLF, or PCRE2_BSR_UNICODE, to specify that \\R matches any Unicode line\nending sequence. The value is used by the JIT compiler and by the two\ninterpreted matching functions, pcre2_match() and\npcre2_dfa_match().\n
\n
\nint pcre2_set_character_tables(pcre2_compile_context *ccontext,\n const uint8_t *tables);\n
\n
\nThe value must be the result of a call to pcre2_maketables(), whose only\nargument is a general context. This function builds a set of character tables\nin the current locale.\n
\n
\nint pcre2_set_compile_extra_options(pcre2_compile_context *ccontext,\n uint32_t extra_options);\n
\n
\nAs PCRE2 has developed, almost all the 32 option bits that are available in\nthe options argument of pcre2_compile() have been used up. To avoid\nrunning out, the compile context contains a set of extra option bits which are\nused for some newer, assumed rarer, options. This function sets those bits. It\nalways sets all the bits (either on or off). It does not modify any existing\nsetting. The available options are defined in the section entitled \"Extra\ncompile options\"\nbelow.\n
\n
\nint pcre2_set_max_pattern_length(pcre2_compile_context *ccontext,\n PCRE2_SIZE value);\n
\n
\nThis sets a maximum length, in code units, for any pattern string that is\ncompiled with this context. If the pattern is longer, an error is generated.\nThis facility is provided so that applications that accept patterns from\nexternal sources can limit their size. The default is the largest number that a\nPCRE2_SIZE variable can hold, which is effectively unlimited.\n
\n
\nint pcre2_set_max_pattern_compiled_length(\n pcre2_compile_context *ccontext, PCRE2_SIZE value);\n
\n
\nThis sets a maximum size, in bytes, for the memory needed to hold the compiled\nversion of a pattern that is compiled with this context. If the pattern needs\nmore memory, an error is generated. This facility is provided so that\napplications that accept patterns from external sources can limit the amount of\nmemory they use. The default is the largest number that a PCRE2_SIZE variable\ncan hold, which is effectively unlimited.\n
\n
\nint pcre2_set_max_varlookbehind(pcre2_compile_contest *ccontext,\n uint32_t value);\n
\n
\nThis sets a maximum length for the number of characters matched by a\nvariable-length lookbehind assertion. The default is set when PCRE2 is built,\nwith the ultimate default being 255, the same as Perl. Lookbehind assertions\nwithout a bounding length are not supported.\n
\n
\nint pcre2_set_newline(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nThis specifies which characters or character sequences are to be recognized as\nnewlines. The value must be one of PCRE2_NEWLINE_CR (carriage return only),\nPCRE2_NEWLINE_LF (linefeed only), PCRE2_NEWLINE_CRLF (the two-character\nsequence CR followed by LF), PCRE2_NEWLINE_ANYCRLF (any of the above),\nPCRE2_NEWLINE_ANY (any Unicode newline sequence), or PCRE2_NEWLINE_NUL (the\nNUL character, that is a binary zero).\n
\nA pattern can override the value set in the compile context by starting with a\nsequence such as (*CRLF). See the\npcre2pattern\npage for details.\n
\n\nWhen a pattern is compiled with the PCRE2_EXTENDED or PCRE2_EXTENDED_MORE\noption, the newline convention affects the recognition of the end of internal\ncomments starting with #. The value is saved with the compiled pattern for\nsubsequent use by the JIT compiler and by the two interpreted matching\nfunctions, pcre2_match() and pcre2_dfa_match().\n
\n
\nint pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext,\n uint32_t value);\n
\n
\nThis parameter adjusts the limit, set when PCRE2 is built (default 250), on the\ndepth of parenthesis nesting in a pattern. This limit stops rogue patterns\nusing up too much system stack when being compiled. The limit applies to\nparentheses of all kinds, not just capturing parentheses.\n
\n
\nint pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,\n int (*guard_function)(uint32_t, void *), void *user_data);\n
\n
\nThere is at least one application that runs PCRE2 in threads with very limited\nsystem stack, where running out of stack is to be avoided at all costs. The\nparenthesis limit above cannot take account of how much stack is actually\navailable during compilation. For a finer control, you can supply a function\nthat is called whenever pcre2_compile() starts to compile a parenthesized\npart of a pattern. This function can check the actual stack size (or anything\nelse that it wants to, of course).\n
\nThe first argument to the callout function gives the current depth of\nnesting, and the second is user data that is set up by the last argument of\npcre2_set_compile_recursion_guard(). The callout function should return\nzero if all is well, or non-zero to force an error.\n
\n
\nint pcre2_set_optimize(pcre2_compile_context *ccontext,\n uint32_t directive);\n
\n
\nPCRE2 can apply various performance optimizations during compilation, in order\nto make matching faster. For example, the compiler might convert some regex\nconstructs into an equivalent construct which pcre2_match() can execute\nfaster. By default, all available optimizations are enabled. However, in rare\ncases, one might wish to disable specific optimizations. For example, if it is\nknown that some optimizations cannot benefit a certain regex, it might be\ndesirable to disable them, in order to speed up compilation.\n
\nThe permitted values of directive are as follows:\n
\n PCRE2_OPTIMIZATION_FULL\n\nEnable all optional performance optimizations. This is the default value.\n
\n PCRE2_OPTIMIZATION_NONE\n\nDisable all optional performance optimizations.\n
\n PCRE2_AUTO_POSSESS\n PCRE2_AUTO_POSSESS_OFF\n\nEnable/disable \"auto-possessification\" of variable quantifiers such as * and +.\nThis optimization, for example, turns a+b into a++b in order to avoid\nbacktracks into a+ that can never be successful. However, if callouts are in\nuse, auto-possessification means that some callouts are never taken. You can\ndisable this optimization if you want the matching functions to do a full,\nunoptimized search and run all the callouts.\n
\n PCRE2_DOTSTAR_ANCHOR\n PCRE2_DOTSTAR_ANCHOR_OFF\n\nEnable/disable an optimization that is applied when .* is the first significant\nitem in a top-level branch of a pattern, and all the other branches also start\nwith .* or with \\A or \\G or ^. Such a pattern is automatically anchored if\nPCRE2_DOTALL is set for all the .* items and PCRE2_MULTILINE is not set for any\n^ items. Otherwise, the fact that any match must start either at the start of\nthe subject or following a newline is remembered. Like other optimizations,\nthis can cause callouts to be skipped.\n\n
\nDotstar anchor optimization is automatically disabled for .* if it is inside an\natomic group or a capture group that is the subject of a backreference, or if\nthe pattern contains (*PRUNE) or (*SKIP).\n
\n PCRE2_START_OPTIMIZE\n PCRE2_START_OPTIMIZE_OFF\n\nEnable/disable optimizations which cause matching functions to scan the subject\nstring for specific code unit values before attempting a match. For example, if\nit is known that an unanchored match must start with a specific value, the\nmatching code searches the subject for that value, and fails immediately if it\ncannot find it, without actually running the main matching function. This means\nthat a special item such as (*COMMIT) at the start of a pattern is not\nconsidered until after a suitable starting point for the match has been found.\nAlso, when callouts or (*MARK) items are in use, these \"start-up\" optimizations\ncan cause them to be skipped if the pattern is never actually used. The start-up\noptimizations are in effect a pre-scan of the subject that takes place before\nthe pattern is run.\n\n
\nDisabling start-up optimizations ensures that in cases where the result is \"no\nmatch\", the callouts do occur, and that items such as (*COMMIT) and (*MARK) are\nconsidered at every possible starting position in the subject string.\n
\n\nDisabling start-up optimizations may change the outcome of a matching operation.\nConsider the pattern\n
\n (*COMMIT)ABC\n\nWhen this is compiled, PCRE2 records the fact that a match must start with the\ncharacter \"A\". Suppose the subject string is \"DEFABC\". The start-up\noptimization scans along the subject, finds \"A\" and runs the first match\nattempt from there. The (*COMMIT) item means that the pattern must match the\ncurrent starting position, which in this case, it does. However, if the same\nmatch is run without start-up optimizations, the initial scan along the subject\nstring does not happen. The first match attempt is run starting from \"D\" and\nwhen this fails, (*COMMIT) prevents any further matches being tried, so the\noverall result is \"no match\".\n\n
\nAnother start-up optimization makes use of a minimum length for a matching\nsubject, which is recorded when possible. Consider the pattern\n
\n (*MARK:1)B(*MARK:2)(X|Y)\n\nThe minimum length for a match is two characters. If the subject is \"XXBB\", the\n\"starting character\" optimization skips \"XX\", then tries to match \"BB\", which\nis long enough. In the process, (*MARK:2) is encountered and remembered. When\nthe match attempt fails, the next \"B\" is found, but there is only one character\nleft, so there are no more attempts, and \"no match\" is returned with the \"last\nmark seen\" set to \"2\". Without start-up optimizations, however, matches are\ntried at every possible starting position, including at the end of the subject,\nwhere (*MARK:1) is encountered, but there is no \"B\", so the \"last mark seen\"\nthat is returned is \"1\". In this case, the optimizations do not affect the\noverall match result, which is still \"no match\", but they do affect the\nauxiliary information that is returned.\n\n
\nThe match context\n
\n\nA match context is required if you want to:\n
\n Set up a callout function\n Set an offset limit for matching an unanchored pattern\n Change the limit on the amount of heap used when matching\n Change the backtracking match limit\n Change the backtracking depth limit\n Set custom memory management specifically for the match\n\nIf none of these apply, just pass NULL as the context argument of\npcre2_match(), pcre2_dfa_match(), or pcre2_jit_match().\n\n
\nA match context is created, copied, and freed by the following functions:\n
\n
\npcre2_match_context *pcre2_match_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_match_context *pcre2_match_context_copy(\n pcre2_match_context *mcontext);\n
\n
\nvoid pcre2_match_context_free(pcre2_match_context *mcontext);\n
\n
\nA match context is created with default values for its parameters. These can\nbe changed by calling the following functions, which return 0 on success, or\nPCRE2_ERROR_BADDATA if invalid data is detected.\n
\n
\nint pcre2_set_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_callout_block *, void *),\n void *callout_data);\n
\n
\nThis sets up a callout function for PCRE2 to call at specified points\nduring a matching operation. Details are given in the\npcre2callout\ndocumentation.\n
\n
\nint pcre2_set_substitute_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_substitute_callout_block *, void *),\n void *callout_data);\n
\n
\nThis sets up a callout function for PCRE2 to call after each substitution\nmade by pcre2_substitute(). Details are given in the section entitled\n\"Creating a new string with substitutions\"\nbelow.\n
\n
\nint pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,\n PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE,\n PCRE2_UCHAR *, PCRE2_SIZE,\n int, void *),\n void *callout_data);\n
\n
\nThis sets up a callout function for PCRE2 to call when performing case\ntransformations inside pcre2_substitute(). Details are given in the\nsection entitled \"Creating a new string with substitutions\"\nbelow.\n
\n
\nint pcre2_set_offset_limit(pcre2_match_context *mcontext,\n PCRE2_SIZE value);\n
\n
\nThe offset_limit parameter limits how far an unanchored search can\nadvance in the subject string. The default value is PCRE2_UNSET. The\npcre2_match() and pcre2_dfa_match() functions return\nPCRE2_ERROR_NOMATCH if a match with a starting point before or at the given\noffset is not found. The pcre2_substitute() function makes no more\nsubstitutions.\n
\nFor example, if the pattern /abc/ is matched against \"123abc\" with an offset\nlimit less than 3, the result is PCRE2_ERROR_NOMATCH. A match can never be\nfound if the startoffset argument of pcre2_match(),\npcre2_dfa_match(), or pcre2_substitute() is greater than the offset\nlimit set in the match context.\n
\n\nWhen using this facility, you must set the PCRE2_USE_OFFSET_LIMIT option when\ncalling pcre2_compile() so that when JIT is in use, different code can be\ncompiled. If a match is started with a non-default match limit when\nPCRE2_USE_OFFSET_LIMIT is not set, an error is generated.\n
\n\nThe offset limit facility can be used to track progress when searching large\nsubject strings or to limit the extent of global substitutions. See also the\nPCRE2_FIRSTLINE option, which requires a match to start before or at the first\nnewline that follows the start of matching in the subject. If this is set with\nan offset limit, a match must occur in the first line and also within the\noffset limit. In other words, whichever limit comes first is used.\n
\n
\nint pcre2_set_heap_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nThe heap_limit parameter specifies, in units of kibibytes (1024 bytes),\nthe maximum amount of heap memory that pcre2_match() may use to hold\nbacktracking information when running an interpretive match. This limit also\napplies to pcre2_dfa_match(), which may use the heap when processing\npatterns with a lot of nested pattern recursion or lookarounds or atomic\ngroups. This limit does not apply to matching with the JIT optimization, which\nhas its own memory control arrangements (see the\npcre2jit\ndocumentation for more details). If the limit is reached, the negative error\ncode PCRE2_ERROR_HEAPLIMIT is returned. The default limit can be set when PCRE2\nis built; if it is not, the default is set very large and is essentially\nunlimited.\n
\nA value for the heap limit may also be supplied by an item at the start of a\npattern of the form\n
\n (*LIMIT_HEAP=ddd)\n\nwhere ddd is a decimal number. However, such a setting is ignored unless ddd is\nless than the limit set by the caller of pcre2_match() or, if no such\nlimit is set, less than the default.\n\n
\nThe pcre2_match() function always needs some heap memory, so setting a\nvalue of zero guarantees a \"heap limit exceeded\" error. Details of how\npcre2_match() uses the heap are given in the\npcre2perform\ndocumentation.\n
\n\nFor pcre2_dfa_match(), a vector on the system stack is used when\nprocessing pattern recursions, lookarounds, or atomic groups, and only if this\nis not big enough is heap memory used. In this case, setting a value of zero\ndisables the use of the heap.\n
\n
\nint pcre2_set_match_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nThe match_limit parameter provides a means of preventing PCRE2 from using\nup too many computing resources when processing patterns that are not going to\nmatch, but which have a very large number of possibilities in their search\ntrees. The classic example is a pattern that uses nested unlimited repeats.\n
\nThere is an internal counter in pcre2_match() that is incremented each\ntime round its main matching loop. If this value reaches the match limit,\npcre2_match() returns the negative value PCRE2_ERROR_MATCHLIMIT. This has\nthe effect of limiting the amount of backtracking that can take place. For\npatterns that are not anchored, the count restarts from zero for each position\nin the subject string. This limit also applies to pcre2_dfa_match(),\nthough the counting is done in a different way.\n
\n\nWhen pcre2_match() is called with a pattern that was successfully\nprocessed by pcre2_jit_compile(), the way in which matching is executed\nis entirely different. However, there is still the possibility of runaway\nmatching that goes on for a very long time, and so the match_limit value\nis also used in this case (but in a different way) to limit how long the\nmatching can continue.\n
\n\nThe default value for the limit can be set when PCRE2 is built; the default is\n10 million, which handles all but the most extreme cases. A value for the match\nlimit may also be supplied by an item at the start of a pattern of the form\n
\n (*LIMIT_MATCH=ddd)\n\nwhere ddd is a decimal number. However, such a setting is ignored unless ddd is\nless than the limit set by the caller of pcre2_match() or\npcre2_dfa_match() or, if no such limit is set, less than the default.\n
\n
\nint pcre2_set_depth_limit(pcre2_match_context *mcontext,\n uint32_t value);\n
\n
\nThis parameter limits the depth of nested backtracking in pcre2_match().\nEach time a nested backtracking point is passed, a new memory frame is used\nto remember the state of matching at that point. Thus, this parameter\nindirectly limits the amount of memory that is used in a match. However,\nbecause the size of each memory frame depends on the number of capturing\nparentheses, the actual memory limit varies from pattern to pattern. This limit\nwas more useful in versions before 10.30, where function recursion was used for\nbacktracking.\n\n
\nThe depth limit is not relevant, and is ignored, when matching is done using\nJIT compiled code. However, it is supported by pcre2_dfa_match(), which\nuses it to limit the depth of nested internal recursive function calls that\nimplement atomic groups, lookaround assertions, and pattern recursions. This\nlimits, indirectly, the amount of system stack that is used. It was more useful\nin versions before 10.32, when stack memory was used for local workspace\nvectors for recursive function calls. From version 10.32, only local variables\nare allocated on the stack and as each call uses only a few hundred bytes, even\na small stack can support quite a lot of recursion.\n
\n\nIf the depth of internal recursive function calls is great enough, local\nworkspace vectors are allocated on the heap from version 10.32 onwards, so the\ndepth limit also indirectly limits the amount of heap memory that is used. A\nrecursive pattern such as /(.(?2))((?1)|)/, when matched to a very long string\nusing pcre2_dfa_match(), can use a great deal of memory. However, it is\nprobably better to limit heap usage directly by calling\npcre2_set_heap_limit().\n
\n\nThe default value for the depth limit can be set when PCRE2 is built; if it is\nnot, the default is set to the same value as the default for the match limit.\nIf the limit is exceeded, pcre2_match() or pcre2_dfa_match()\nreturns PCRE2_ERROR_DEPTHLIMIT. A value for the depth limit may also be\nsupplied by an item at the start of a pattern of the form\n
\n (*LIMIT_DEPTH=ddd)\n\nwhere ddd is a decimal number. However, such a setting is ignored unless ddd is\nless than the limit set by the caller of pcre2_match() or\npcre2_dfa_match() or, if no such limit is set, less than the default.\n\n
CHECKING BUILD-TIME OPTIONS
\n\nint pcre2_config(uint32_t what, void *where);\n
\n\nThe function pcre2_config() makes it possible for a PCRE2 client to find\nthe value of certain configuration parameters and to discover which optional\nfeatures have been compiled into the PCRE2 library. The\npcre2build\ndocumentation has more details about these features.\n
\n\nThe first argument for pcre2_config() specifies which information is\nrequired. The second argument is a pointer to memory into which the information\nis placed. If NULL is passed, the function returns the amount of memory that is\nneeded for the requested information. For calls that return numerical values,\nthe value is in bytes; when requesting these values, where should point\nto appropriately aligned memory. For calls that return strings, the required\nlength is given in code units, not counting the terminating zero.\n
\n\nWhen requesting information, the returned value from pcre2_config() is\nnon-negative on success, or the negative error code PCRE2_ERROR_BADOPTION if\nthe value in the first argument is not recognized. The following information is\navailable:\n
\n PCRE2_CONFIG_BSR\n\nThe output is a uint32_t integer whose value indicates what character\nsequences the \\R escape sequence matches by default. A value of\nPCRE2_BSR_UNICODE means that \\R matches any Unicode line ending sequence; a\nvalue of PCRE2_BSR_ANYCRLF means that \\R matches only CR, LF, or CRLF. The\ndefault can be overridden when a pattern is compiled.\n
\n PCRE2_CONFIG_COMPILED_WIDTHS\n\nThe output is a uint32_t integer whose lower bits indicate which code unit\nwidths were selected when PCRE2 was built. The 1-bit indicates 8-bit support,\nand the 2-bit and 4-bit indicate 16-bit and 32-bit support, respectively.\n
\n PCRE2_CONFIG_DEPTHLIMIT\n\nThe output is a uint32_t integer that gives the default limit for the depth of\nnested backtracking in pcre2_match() or the depth of nested recursions,\nlookarounds, and atomic groups in pcre2_dfa_match(). Further details are\ngiven with pcre2_set_depth_limit() above.\n
\n PCRE2_CONFIG_EFFECTIVE_LINKSIZE\n\nThe output is a uint32_t integer that contains the number of bytes the library\nuses for internal linkage in compiled regular expressions. Its value is derived\nfrom the value that was provided at build time and that is described below by\nPCRE2_CONFIG_LINKSIZE.\n
\n PCRE2_CONFIG_HEAPLIMIT\n\nThe output is a uint32_t integer that gives, in kibibytes, the default limit\nfor the amount of heap memory used by pcre2_match() or\npcre2_dfa_match(). Further details are given with\npcre2_set_heap_limit() above.\n
\n PCRE2_CONFIG_JIT\n\nThe output is a uint32_t integer that is set to one if support for just-in-time\ncompiling is included in the library; otherwise it is set to zero. Note that\nhaving the support in the library does not guarantee that JIT will be used for\nany given match, and neither does it guarantee that JIT will actually be able\nto function, because it may not be able to allocate executable memory in some\nenvironments. There is a special call to pcre2_jit_compile() that can be\nused to check this. See the\npcre2jit\ndocumentation for more details.\n
\n PCRE2_CONFIG_JITTARGET\n\nThe where argument should point to a code-unit-aligned buffer. All\nprevious versions of PCRE2 have required no more than 128 code units of buffer\ncapacity. However, this requirement is not guaranteed to be maintained, so\napplications should call pcre2_config() with where set to NULL to\nreceive the required buffer size, then assert or allocate a suitably-size buffer\nfor a second call to pcre2_config(). The buffer is filled with a string\nthat contains the name of the architecture for which the JIT compiler is\nconfigured at build time, for example, a 64-bit ARM CPU that supports the\nArmv8.1 extension writes \"ARM-64 (LSE) 64bit (little endian + unaligned)\". If\nJIT support is not available, PCRE2_ERROR_BADOPTION is returned; otherwise the\nnumber of code units used is returned. This is the length of the string plus one\nunit for the terminating zero.\n
\n PCRE2_CONFIG_LINKSIZE\n\nThe output is a uint32_t integer that contains the number of bytes the library\nwas instructed to use for internal linkage in compiled regular expressions.\nWhen PCRE2 is configured, the value can be set to 2, 3, or 4, with the default\nbeing 2 for most libraries.\n\n
\nThe actual number of bytes used depends on the size of the code units that the\nlibrary supports and can be higher. See PCRE2_CONFIG_EFFECTIVE_LINKSIZE above\nfor details.\n
\n\nThe default value of 2 for the 8-bit and 16-bit libraries is sufficient for all\nbut the most massive patterns, since it allows the size of the compiled pattern\nto be up to 65535 code units. Larger values allow larger regular expressions to\nbe compiled by those two libraries, but at the expense of slower matching.\n
\n PCRE2_CONFIG_MATCHLIMIT\n\nThe output is a uint32_t integer that gives the default match limit for\npcre2_match(). Further details are given with\npcre2_set_match_limit() above.\n
\n PCRE2_CONFIG_NEWLINE\n\nThe output is a uint32_t integer whose value specifies the default character\nsequence that is recognized as meaning \"newline\". The values are:\n
\n PCRE2_NEWLINE_CR Carriage return (CR)\n PCRE2_NEWLINE_LF Linefeed (LF)\n PCRE2_NEWLINE_CRLF Carriage return, linefeed (CRLF)\n PCRE2_NEWLINE_ANY Any Unicode line ending\n PCRE2_NEWLINE_ANYCRLF Any of CR, LF, or CRLF\n PCRE2_NEWLINE_NUL The NUL character (binary zero)\n\nThe default should normally correspond to the standard sequence for your\noperating system.\n
\n PCRE2_CONFIG_NEVER_BACKSLASH_C\n\nThe output is a uint32_t integer that is set to one if the use of \\C was\npermanently disabled when PCRE2 was built; otherwise it is set to zero.\n
\n PCRE2_CONFIG_PARENSLIMIT\n\nThe output is a uint32_t integer that gives the maximum depth of nesting\nof parentheses (of any kind) in a pattern. This limit is imposed to cap the\namount of system stack used when a pattern is compiled. It is specified when\nPCRE2 is built; the default is 250. This limit does not take into account the\nstack that may already be used by the calling application. For finer control\nover compilation stack usage, see pcre2_set_compile_recursion_guard().\n
\n PCRE2_CONFIG_STACKRECURSE\n\nThis parameter is obsolete and should not be used in new code. The output is a\nuint32_t integer that is always set to zero.\n
\n PCRE2_CONFIG_TABLES_LENGTH\n\nThe output is a uint32_t integer that gives the length of PCRE2's character\nprocessing tables in bytes. For details of these tables see the\nsection on locale support\nbelow.\n
\n PCRE2_CONFIG_UNICODE_VERSION\n\nThe where argument should point to a code-unit-aligned buffer. All\nprevious versions of PCRE2 have required no more than 24 code units of buffer\ncapacity. However, applications should call pcre2_config() with\nwhere set to NULL to receive the required buffer size, then assert or\nallocate a suitably-size buffer for a second call to pcre2_config(). If\nPCRE2 has been compiled without Unicode support, the buffer is filled with the\ntext \"Unicode not supported\". Otherwise, the Unicode version string (for\nexample, \"8.0.0\") is written. The number of code units used is returned. This is\nthe length of the string plus one unit for the terminating zero.\n
\n PCRE2_CONFIG_UNICODE\n\nThe output is a uint32_t integer that is set to one if Unicode support is\navailable; otherwise it is set to zero. Unicode support implies UTF support.\n
\n PCRE2_CONFIG_VERSION\n\nThe where argument should point to a code-unit-aligned buffer. All\nprevious versions of PCRE2 have required no more than 24 code units of buffer\ncapacity. However, applications should call pcre2_config() with\nwhere set to NULL to receive the required buffer size, then assert or\nallocate a suitably-size buffer for a second call to pcre2_config(). The\nbuffer is filled with the PCRE2 version string, zero-terminated. The number of\ncode units used is returned. This is the length of the string plus one unit for\nthe terminating zero.\n\n
COMPILING A PATTERN
\n\npcre2_code *pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, int *errorcode, PCRE2_SIZE *erroroffset,\n pcre2_compile_context *ccontext);\n
\n
\nvoid pcre2_code_free(pcre2_code *code);\n
\n
\npcre2_code *pcre2_code_copy(const pcre2_code *code);\n
\n
\npcre2_code *pcre2_code_copy_with_tables(const pcre2_code *code);\n
\nThe pcre2_compile() function compiles a pattern into an internal form.\nThe pattern is defined by a pointer to a string of code units and a length in\ncode units. If the pattern is zero-terminated, the length can be specified as\nPCRE2_ZERO_TERMINATED. A NULL pattern pointer with a length of zero is treated\nas an empty string (NULL with a non-zero length causes an error return). The\nfunction returns a pointer to a block of memory that contains the compiled\npattern and related data, or NULL if an error occurred.\n
\n\nIf the compile context argument ccontext is NULL, memory for the compiled\npattern is obtained by calling malloc(). Otherwise, it is obtained from\nthe same memory function that was used for the compile context. The caller must\nfree the memory by calling pcre2_code_free() when it is no longer needed.\nIf pcre2_code_free() is called with a NULL argument, it returns\nimmediately, without doing anything.\n
\n\nThe function pcre2_code_copy() makes a copy of the compiled code in new\nmemory, using the same memory allocator as was used for the original. However,\nif the code has been processed by the JIT compiler (see\nbelow),\nthe JIT information cannot be copied (because it is position-dependent).\nThe new copy can initially be used only for non-JIT matching, though it can be\npassed to pcre2_jit_compile() if required. If pcre2_code_copy() is\ncalled with a NULL argument, it returns NULL.\n
\n\nThe pcre2_code_copy() function provides a way for individual threads in a\nmultithreaded application to acquire a private copy of shared compiled code.\nHowever, it does not make a copy of the character tables used by the compiled\npattern; the new pattern code points to the same tables as the original code.\n(See\n\"Locale Support\"\nbelow for details of these character tables.) In many applications the same\ntables are used throughout, so this behaviour is appropriate. Nevertheless,\nthere are occasions when a copy of a compiled pattern and the relevant tables\nare needed. The pcre2_code_copy_with_tables() provides this facility.\nCopies of both the code and the tables are made, with the new code pointing to\nthe new tables. The memory for the new tables is automatically freed when\npcre2_code_free() is called for the new copy of the compiled code. If\npcre2_code_copy_with_tables() is called with a NULL argument, it returns\nNULL.\n
\n\nNOTE: When one of the matching functions is called, pointers to the compiled\npattern and the subject string are set in the match data block so that they can\nbe referenced by the substring extraction functions after a successful match.\nAfter running a match, you must not free a compiled pattern or a subject string\nuntil after all operations on the\nmatch data block\nhave taken place, unless, in the case of the subject string, you have used the\nPCRE2_COPY_MATCHED_SUBJECT option, which is described in the section entitled\n\"Option bits for pcre2_match()\"\n\">below.\n
\n\nThe options argument for pcre2_compile() contains various bit\nsettings that affect the compilation. It should be zero if none of them are\nrequired. The available options are described below. Some of them (in\nparticular, those that are compatible with Perl, but some others as well) can\nalso be set and unset from within the pattern (see the detailed description in\nthe\npcre2pattern\ndocumentation).\n
\n\nFor those options that can be different in different parts of the pattern, the\ncontents of the options argument specifies their settings at the start of\ncompilation. The PCRE2_ANCHORED, PCRE2_ENDANCHORED, and PCRE2_NO_UTF_CHECK\noptions can be set at the time of matching as well as at compile time.\n
\n\nSome additional options and less frequently required compile-time parameters\n(for example, the newline setting) can be provided in a compile context (as\ndescribed\nabove).\n
\n\nIf errorcode or erroroffset is NULL, pcre2_compile() returns\nNULL immediately. Otherwise, the variables to which these point are set to an\nerror code and an offset (number of code units) within the pattern,\nrespectively, when pcre2_compile() returns NULL because a compilation\nerror has occurred.\n
\n\nThere are over 100 positive error codes that pcre2_compile() may return\nif it finds an error in the pattern. There are also some negative error codes\nthat are used for invalid UTF strings when validity checking is in force. These\nare the same as given by pcre2_match() and pcre2_dfa_match(), and\nare described in the\npcre2unicode\ndocumentation. There is no separate documentation for the positive error codes,\nbecause the textual error messages that are obtained by calling the\npcre2_get_error_message() function (see \"Obtaining a textual error\nmessage\"\nbelow)\nshould be self-explanatory. Macro names starting with PCRE2_ERROR_ are defined\nfor both positive and negative error codes in pcre2.h. When compilation\nis successful errorcode is set to a value that returns the message \"no\nerror\" if passed to pcre2_get_error_message().\n
\n\nThe value returned in erroroffset is an indication of where in the\npattern an error occurred. When there is no error, zero is returned. A non-zero\nvalue is not necessarily the furthest point in the pattern that was read. For\nexample, after the error \"lookbehind assertion is not fixed length\", the error\noffset points to the start of the failing assertion. For an invalid UTF-8 or\nUTF-16 string, the offset is that of the first code unit of the failing\ncharacter.\n
\n\nSome errors are not detected until the whole pattern has been scanned; in these\ncases, the offset passed back is the length of the pattern. Note that the\noffset is in code units, not characters, even in a UTF mode. It may sometimes\npoint into the middle of a UTF-8 or UTF-16 character.\n
\n\nThis code fragment shows a typical straightforward call to\npcre2_compile():\n
\n pcre2_code *re;\n PCRE2_SIZE erroffset;\n int errorcode;\n re = pcre2_compile(\n \"^A.*Z\", /* the pattern */\n PCRE2_ZERO_TERMINATED, /* the pattern is zero-terminated */\n 0, /* default options */\n &errorcode, /* for error code */\n &erroffset, /* for error offset */\n NULL); /* no compile context */\n\n\n\n
\nMain compile options\n
\n\nThe following names for option bits are defined in the pcre2.h header\nfile:\n
\n PCRE2_ANCHORED\n\nIf this bit is set, the pattern is forced to be \"anchored\", that is, it is\nconstrained to match only at the first matching point in the string that is\nbeing searched (the \"subject string\"). This effect can also be achieved by\nappropriate constructs in the pattern itself, which is the only way to do it in\nPerl.\n
\n PCRE2_ALLOW_EMPTY_CLASS\n\nBy default, for compatibility with Perl, a closing square bracket that\nimmediately follows an opening one is treated as a data character for the\nclass. When PCRE2_ALLOW_EMPTY_CLASS is set, it terminates the class, which\ntherefore contains no characters and so can never match.\n
\n PCRE2_ALT_BSUX\n\nThis option request alternative handling of three escape sequences, which\nmakes PCRE2's behaviour more like ECMAscript (aka JavaScript). When it is set:\n\n
\n(1) \\U matches an upper case \"U\" character; by default \\U causes a compile\ntime error (Perl uses \\U to upper case subsequent characters).\n
\n\n(2) \\u matches a lower case \"u\" character unless it is followed by four\nhexadecimal digits, in which case the hexadecimal number defines the code point\nto match. By default, \\u causes a compile time error (Perl uses it to upper\ncase the following character).\n
\n\n(3) \\x matches a lower case \"x\" character unless it is followed by two\nhexadecimal digits, in which case the hexadecimal number defines the code point\nto match. By default, as in Perl, a hexadecimal number is always expected after\n\\x, but it may have one or two digits.\n
\n\nECMAscript 6 added additional functionality to \\u. This can be accessed using\nthe PCRE2_EXTRA_ALT_BSUX extra option (see \"Extra compile options\"\nbelow).\nNote that this alternative escape handling applies only to patterns. Neither of\nthese options affects the processing of replacement strings passed to\npcre2_substitute().\n
\n PCRE2_ALT_CIRCUMFLEX\n\nIn multiline mode (when PCRE2_MULTILINE is set), the circumflex metacharacter\nmatches at the start of the subject (unless PCRE2_NOTBOL is set), and also\nafter any internal newline. However, it does not match after a newline at the\nend of the subject, for compatibility with Perl. If you want a multiline\ncircumflex also to match after a terminating newline, you must set\nPCRE2_ALT_CIRCUMFLEX.\n
\n PCRE2_ALT_EXTENDED_CLASS\n\nAlters the parsing of character classes to follow the extended syntax\ndescribed by Unicode UTS#18. The PCRE2_ALT_EXTENDED_CLASS option has no impact\non the behaviour of the Perl-specific \"(?[...])\" syntax for extended classes,\nbut instead enables the alternative syntax of extended class behaviour inside\nordinary \"[...]\" character classes. See the\npcre2pattern\ndocumentation for details of the character classes supported.\n
\n PCRE2_ALT_VERBNAMES\n\nBy default, for compatibility with Perl, the name in any verb sequence such as\n(*MARK:NAME) is any sequence of characters that does not include a closing\nparenthesis. The name is not processed in any way, and it is not possible to\ninclude a closing parenthesis in the name. However, if the PCRE2_ALT_VERBNAMES\noption is set, normal backslash processing is applied to verb names and only an\nunescaped closing parenthesis terminates the name. A closing parenthesis can be\nincluded in a name either as \\) or between \\Q and \\E. If the PCRE2_EXTENDED\nor PCRE2_EXTENDED_MORE option is set with PCRE2_ALT_VERBNAMES, unescaped\nwhite space in verb names is skipped and #-comments are recognized, exactly as\nin the rest of the pattern.\n
\n PCRE2_AUTO_CALLOUT\n\nIf this bit is set, pcre2_compile() automatically inserts callout items,\nall with number 255, before each pattern item, except immediately before or\nafter an explicit callout in the pattern. For discussion of the callout\nfacility, see the\npcre2callout\ndocumentation.\n
\n PCRE2_CASELESS\n\nIf this bit is set, letters in the pattern match both upper and lower case\nletters in the subject. It is equivalent to Perl's /i option, and it can be\nchanged within a pattern by a (?i) option setting. If either PCRE2_UTF or\nPCRE2_UCP is set, Unicode properties are used for all characters with more than\none other case, and for all characters whose code points are greater than\nU+007F.\n\n
\nNote that there are two ASCII characters, K and S, that, in addition to\ntheir lower case ASCII equivalents, are case-equivalent with U+212A (Kelvin\nsign) and U+017F (long S) respectively. If you do not want this case\nequivalence, you can suppress it by setting PCRE2_EXTRA_CASELESS_RESTRICT.\n
\n\nOne language family, Turkish and Azeri, has its own case-insensitivity rules,\nwhich can be selected by setting PCRE2_EXTRA_TURKISH_CASING. This alters the\nbehaviour of the 'i', 'I', U+0130 (capital I with dot above), and U+0131\n(small dotless i) characters.\n
\n\nFor lower valued characters with only one other case, a lookup table is used\nfor speed. When neither PCRE2_UTF nor PCRE2_UCP is set, a lookup table is used\nfor all code points less than 256, and higher code points (available only in\n16-bit or 32-bit mode) are treated as not having another case.\n
\n\nFrom release 10.45 PCRE2_CASELESS also affects what some of the letter-related\nUnicode property escapes (\\p and \\P) match. The properties Lu (upper case\nletter), Ll (lower case letter), and Lt (title case letter) are all treated as\nLC (cased letter) when PCRE2_CASELESS is set.\n
\n PCRE2_DOLLAR_ENDONLY\n\nIf this bit is set, a dollar metacharacter in the pattern matches only at the\nend of the subject string. Without this option, a dollar also matches\nimmediately before a newline at the end of the string (but not before any other\nnewlines). The PCRE2_DOLLAR_ENDONLY option is ignored if PCRE2_MULTILINE is\nset. There is no equivalent to this option in Perl, and no way to set it within\na pattern.\n
\n PCRE2_DOTALL\n\nIf this bit is set, a dot metacharacter in the pattern matches any character,\nincluding one that indicates a newline. However, it only ever matches one\ncharacter, even if newlines are coded as CRLF. Without this option, a dot does\nnot match when the current position in the subject is at a newline. This option\nis equivalent to Perl's /s option, and it can be changed within a pattern by a\n(?s) option setting. A negative class such as [^a] always matches newline\ncharacters, and the \\N escape sequence always matches a non-newline character,\nindependent of the setting of PCRE2_DOTALL.\n
\n PCRE2_DUPNAMES\n\nIf this bit is set, names used to identify capture groups need not be unique.\nThis can be helpful for certain types of pattern when it is known that only one\ninstance of the named group can ever be matched. There are more details of\nnamed capture groups below; see also the\npcre2pattern\ndocumentation.\n
\n PCRE2_ENDANCHORED\n\nIf this bit is set, the end of any pattern match must be right at the end of\nthe string being searched (the \"subject string\"). If the pattern match\nsucceeds by reaching (*ACCEPT), but does not reach the end of the subject, the\nmatch fails at the current starting point. For unanchored patterns, a new match\nis then tried at the next starting point. However, if the match succeeds by\nreaching the end of the pattern, but not the end of the subject, backtracking\noccurs and an alternative match may be found. Consider these two patterns:\n
\n .(*ACCEPT)|..\n .|..\n\nIf matched against \"abc\" with PCRE2_ENDANCHORED set, the first matches \"c\"\nwhereas the second matches \"bc\". The effect of PCRE2_ENDANCHORED can also be\nachieved by appropriate constructs in the pattern itself, which is the only way\nto do it in Perl.\n\n
\nFor DFA matching with pcre2_dfa_match(), PCRE2_ENDANCHORED applies only\nto the first (that is, the longest) matched string. Other parallel matches,\nwhich are necessarily substrings of the first one, must obviously end before\nthe end of the subject.\n
\n PCRE2_EXTENDED\n\nIf this bit is set, most white space characters in the pattern are totally\nignored except when escaped, inside a character class, or inside a \\Q...\\E\nsequence. However, white space is not allowed within sequences such as (?> that\nintroduce various parenthesized groups, nor within numerical quantifiers such\nas {1,3}. Ignorable white space is permitted between an item and a following\nquantifier and between a quantifier and a following + that indicates\npossessiveness. PCRE2_EXTENDED is equivalent to Perl's /x option, and it can be\nchanged within a pattern by a (?x) option setting.\n\n
\nWhen PCRE2 is compiled without Unicode support, PCRE2_EXTENDED recognizes as\nwhite space only those characters with code points less than 256 that are\nflagged as white space in its low-character table. The table is normally\ncreated by\npcre2_maketables(),\nwhich uses the isspace() function to identify space characters. In most\nASCII environments, the relevant characters are those with code points 0x0009\n(tab), 0x000A (linefeed), 0x000B (vertical tab), 0x000C (formfeed), 0x000D\n(carriage return), and 0x0020 (space).\n
\n\nWhen PCRE2 is compiled with Unicode support, in addition to these characters,\nfive more Unicode \"Pattern White Space\" characters are recognized by\nPCRE2_EXTENDED. These are U+0085 (next line), U+200E (left-to-right mark),\nU+200F (right-to-left mark), U+2028 (line separator), and U+2029 (paragraph\nseparator). This set of characters is the same as recognized by Perl's /x\noption. Note that the horizontal and vertical space characters that are matched\nby the \\h and \\v escapes in patterns are a much bigger set.\n
\n\nAs well as ignoring most white space, PCRE2_EXTENDED also causes characters\nbetween an unescaped # outside a character class and the next newline,\ninclusive, to be ignored, which makes it possible to include comments inside\ncomplicated patterns. Note that the end of this type of comment is a literal\nnewline sequence in the pattern; escape sequences that happen to represent a\nnewline do not count.\n
\n\nWhich characters are interpreted as newlines can be specified by a setting in\nthe compile context that is passed to pcre2_compile() or by a special\nsequence at the start of the pattern, as described in the section entitled\n\"Newline conventions\"\nin the pcre2pattern documentation. A default is defined when PCRE2 is\nbuilt.\n
\n PCRE2_EXTENDED_MORE\n\nThis option has the effect of PCRE2_EXTENDED, but, in addition, unescaped space\nand horizontal tab characters are ignored inside a character class. Note: only\nthese two characters are ignored, not the full set of pattern white space\ncharacters that are ignored outside a character class. PCRE2_EXTENDED_MORE is\nequivalent to Perl's /xx option, and it can be changed within a pattern by a\n(?xx) option setting.\n
\n PCRE2_FIRSTLINE\n\nIf this option is set, the start of an unanchored pattern match must be before\nor at the first newline in the subject string following the start of matching,\nthough the matched text may continue over the newline. If startoffset is\nnon-zero, the limiting newline is not necessarily the first newline in the\nsubject. For example, if the subject string is \"abc\\nxyz\" (where \\n\nrepresents a single-character newline) a pattern match for \"yz\" succeeds with\nPCRE2_FIRSTLINE if startoffset is greater than 3. See also\nPCRE2_USE_OFFSET_LIMIT, which provides a more general limiting facility. If\nPCRE2_FIRSTLINE is set with an offset limit, a match must occur in the first\nline and also within the offset limit. In other words, whichever limit comes\nfirst is used. This option has no effect for anchored patterns.\n
\n PCRE2_LITERAL\n\nIf this option is set, all meta-characters in the pattern are disabled, and it\nis treated as a literal string. Matching literal strings with a regular\nexpression engine is not the most efficient way of doing it. If you are doing a\nlot of literal matching and are worried about efficiency, you should consider\nusing other approaches. The only other main options that are allowed with\nPCRE2_LITERAL are: PCRE2_ANCHORED, PCRE2_ENDANCHORED, PCRE2_AUTO_CALLOUT,\nPCRE2_CASELESS, PCRE2_FIRSTLINE, PCRE2_MATCH_INVALID_UTF,\nPCRE2_NO_START_OPTIMIZE, PCRE2_NO_UTF_CHECK, PCRE2_UTF, and\nPCRE2_USE_OFFSET_LIMIT. The extra options PCRE2_EXTRA_MATCH_LINE and\nPCRE2_EXTRA_MATCH_WORD are also supported. Any other options cause an error.\n
\n PCRE2_MATCH_INVALID_UTF\n\nThis option forces PCRE2_UTF (see below) and also enables support for matching\nby pcre2_match() in subject strings that contain invalid UTF sequences.\nNote, however, that the 16-bit and 32-bit PCRE2 libraries process strings as\nsequences of uint16_t or uint32_t code points. They cannot find valid UTF\nsequences within an arbitrary string of bytes unless such sequences are\nsuitably aligned. This facility is not supported for DFA matching. For details,\nsee the\npcre2unicode\ndocumentation.\n
\n PCRE2_MATCH_UNSET_BACKREF\n\nIf this option is set, a backreference to an unset capture group matches an\nempty string (by default this causes the current matching alternative to fail).\nA pattern such as (\\1)(a) succeeds when this option is set (assuming it can\nfind an \"a\" in the subject), whereas it fails by default, for Perl\ncompatibility. Setting this option makes PCRE2 behave more like ECMAscript (aka\nJavaScript).\n
\n PCRE2_MULTILINE\n\nBy default, for the purposes of matching \"start of line\" and \"end of line\",\nPCRE2 treats the subject string as consisting of a single line of characters,\neven if it actually contains newlines. The \"start of line\" metacharacter (^)\nmatches only at the start of the string, and the \"end of line\" metacharacter\n($) matches only at the end of the string, or before a terminating newline\n(except when PCRE2_DOLLAR_ENDONLY is set). Note, however, that unless\nPCRE2_DOTALL is set, the \"any character\" metacharacter (.) does not match at a\nnewline. This behaviour (for ^, $, and dot) is the same as Perl.\n\n
\nWhen PCRE2_MULTILINE it is set, the \"start of line\" and \"end of line\"\nconstructs match immediately following or immediately before internal newlines\nin the subject string, respectively, as well as at the very start and end. This\nis equivalent to Perl's /m option, and it can be changed within a pattern by a\n(?m) option setting. Note that the \"start of line\" metacharacter does not match\nafter a newline at the end of the subject, for compatibility with Perl.\nHowever, you can change this by setting the PCRE2_ALT_CIRCUMFLEX option. If\nthere are no newlines in a subject string, or no occurrences of ^ or $ in a\npattern, setting PCRE2_MULTILINE has no effect.\n
\n PCRE2_NEVER_BACKSLASH_C\n\nThis option locks out the use of \\C in the pattern that is being compiled.\nThis escape can cause unpredictable behaviour in UTF-8 or UTF-16 modes, because\nit may leave the current matching point in the middle of a multi-code-unit\ncharacter. This option may be useful in applications that process patterns from\nexternal sources. Note that there is also a build-time option that permanently\nlocks out the use of \\C.\n
\n PCRE2_NEVER_UCP\n\nThis option locks out the use of Unicode properties for handling \\B, \\b, \\D,\n\\d, \\S, \\s, \\W, \\w, and some of the POSIX character classes, as described\nfor the PCRE2_UCP option below. In particular, it prevents the creator of the\npattern from enabling this facility by starting the pattern with (*UCP). This\noption may be useful in applications that process patterns from external\nsources. The option combination PCRE2_UCP and PCRE2_NEVER_UCP causes an error.\n
\n PCRE2_NEVER_UTF\n\nThis option locks out interpretation of the pattern as UTF-8, UTF-16, or\nUTF-32, depending on which library is in use. In particular, it prevents the\ncreator of the pattern from switching to UTF interpretation by starting the\npattern with (*UTF). This option may be useful in applications that process\npatterns from external sources. The combination of PCRE2_UTF and\nPCRE2_NEVER_UTF causes an error.\n
\n PCRE2_NO_AUTO_CAPTURE\n\nIf this option is set, it disables the use of numbered capturing parentheses in\nthe pattern. Any opening parenthesis that is not followed by ? behaves as if it\nwere followed by ?: but named parentheses can still be used for capturing (and\nthey acquire numbers in the usual way). This is the same as Perl's /n option.\nNote that, when this option is set, references to capture groups\n(backreferences or recursion/subroutine calls) may only refer to named groups,\nthough the reference can be by name or by number.\n
\n PCRE2_NO_AUTO_POSSESS\n\nIf this (deprecated) option is set, it disables \"auto-possessification\", which\nis an optimization that, for example, turns a+b into a++b in order to avoid\nbacktracks into a+ that can never be successful. However, if callouts are in\nuse, auto-possessification means that some callouts are never taken. You can\nset this option if you want the matching functions to do a full unoptimized\nsearch and run all the callouts, but it is mainly provided for testing\npurposes.\n\n
\nIf a compile context is available, it is recommended to use\npcre2_set_optimize() with the directive PCRE2_AUTO_POSSESS_OFF rather\nthan the compile option PCRE2_NO_AUTO_POSSESS. Note that PCRE2_NO_AUTO_POSSESS\ntakes precedence over the pcre2_set_optimize() optimization directives\nPCRE2_AUTO_POSSESS and PCRE2_AUTO_POSSESS_OFF.\n
\n PCRE2_NO_DOTSTAR_ANCHOR\n\nIf this (deprecated) option is set, it disables an optimization that is applied\nwhen .* is the first significant item in a top-level branch of a pattern, and\nall the other branches also start with .* or with \\A or \\G or ^. The\noptimization is automatically disabled for .* if it is inside an atomic group\nor a capture group that is the subject of a backreference, or if the pattern\ncontains (*PRUNE) or (*SKIP). When the optimization is not disabled, such a\npattern is automatically anchored if PCRE2_DOTALL is set for all the .* items\nand PCRE2_MULTILINE is not set for any ^ items. Otherwise, the fact that any\nmatch must start either at the start of the subject or following a newline is\nremembered. Like other optimizations, this can cause callouts to be skipped.\n(If a compile context is available, it is recommended to use\npcre2_set_optimize() with the directive PCRE2_DOTSTAR_ANCHOR_OFF\ninstead.)\n
\n PCRE2_NO_START_OPTIMIZE\n\nThis is an option whose main effect is at matching time. It does not change\nwhat pcre2_compile() generates, but it does affect the output of the JIT\ncompiler. Setting this option is equivalent to calling\npcre2_set_optimize() with the directive parameter set to\nPCRE2_START_OPTIMIZE_OFF.\n\n
\nThere are a number of optimizations that may occur at the start of a match, in\norder to speed up the process. For example, if it is known that an unanchored\nmatch must start with a specific code unit value, the matching code searches\nthe subject for that value, and fails immediately if it cannot find it, without\nactually running the main matching function. The start-up optimizations are\nin effect a pre-scan of the subject that takes place before the pattern is run.\n
\n\nDisabling the start-up optimizations may cause performance to suffer. However,\nthis may be desirable for patterns which contain callouts or items such as\n(*COMMIT) and (*MARK). See the above description of PCRE2_START_OPTIMIZE_OFF\nfor further details.\n
\n PCRE2_NO_UTF_CHECK\n\nWhen PCRE2_UTF is set, the validity of the pattern as a UTF string is\nautomatically checked. There are discussions about the validity of\nUTF-8 strings,\nUTF-16 strings,\nand\nUTF-32 strings\nin the\npcre2unicode\ndocument. If an invalid UTF sequence is found, pcre2_compile() returns a\nnegative error code.\n\n
\nIf you know that your pattern is a valid UTF string, and you want to skip this\ncheck for performance reasons, you can set the PCRE2_NO_UTF_CHECK option. When\nit is set, the effect of passing an invalid UTF string as a pattern is\nundefined. It may cause your program to crash or loop.\n
\n\nNote that this option can also be passed to pcre2_match() and\npcre2_dfa_match(), to suppress UTF validity checking of the subject\nstring.\n
\n\nNote also that setting PCRE2_NO_UTF_CHECK at compile time does not disable the\nerror that is given if an escape sequence for an invalid Unicode code point is\nencountered in the pattern. In particular, the so-called \"surrogate\" code\npoints (0xd800 to 0xdfff) are invalid. If you want to allow escape sequences\nsuch as \\x{d800} you can set the PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES extra\noption, as described in the section entitled \"Extra compile options\"\nbelow.\nHowever, this is possible only in UTF-8 and UTF-32 modes, because these values\nare not representable in UTF-16.\n
\n PCRE2_UCP\n\nThis option has two effects. Firstly, it change the way PCRE2 processes \\B,\n\\b, \\D, \\d, \\S, \\s, \\W, \\w, and some of the POSIX character classes. By\ndefault, only ASCII characters are recognized, but if PCRE2_UCP is set, Unicode\nproperties are used to classify characters. There are some PCRE2_EXTRA\noptions (see below) that add finer control to this behaviour. More details are\ngiven in the section on\ngeneric character types\nin the\npcre2pattern\npage.\n\n
\nThe second effect of PCRE2_UCP is to force the use of Unicode properties for\nupper/lower casing operations, even when PCRE2_UTF is not set. This makes it\npossible to process strings in the 16-bit UCS-2 code. This option is available\nonly if PCRE2 has been compiled with Unicode support (which is the default).\n
\n\nThe PCRE2_EXTRA_CASELESS_RESTRICT option (see above) restricts caseless\nmatching such that ASCII characters match only ASCII characters and non-ASCII\ncharacters match only non-ASCII characters. The PCRE2_EXTRA_TURKISH_CASING\noption (see above) alters the matching of the 'i' characters to follow their\nbehaviour in Turkish and Azeri languages. For further details on\nPCRE2_EXTRA_CASELESS_RESTRICT and PCRE2_EXTRA_TURKISH_CASING, see the\npcre2unicode\npage.\n
\n PCRE2_UNGREEDY\n\nThis option inverts the \"greediness\" of the quantifiers so that they are not\ngreedy by default, but become greedy if followed by \"?\". It is not compatible\nwith Perl. It can also be set by a (?U) option setting within the pattern.\n
\n PCRE2_USE_OFFSET_LIMIT\n\nThis option must be set for pcre2_compile() if\npcre2_set_offset_limit() is going to be used to set a non-default offset\nlimit in a match context for matches that use this pattern. An error is\ngenerated if an offset limit is set without this option. For more details, see\nthe description of pcre2_set_offset_limit() in the\nsection\nthat describes match contexts. See also the PCRE2_FIRSTLINE\noption above.\n
\n PCRE2_UTF\n\nThis option causes PCRE2 to regard both the pattern and the subject strings\nthat are subsequently processed as strings of UTF characters instead of\nsingle-code-unit strings. It is available when PCRE2 is built to include\nUnicode support (which is the default). If Unicode support is not available,\nthe use of this option provokes an error. Details of how PCRE2_UTF changes the\nbehaviour of PCRE2 are given in the\npcre2unicode\npage. In particular, note that it changes the way PCRE2_CASELESS works.\n\n
\nExtra compile options\n
\n\nThe option bits that can be set in a compile context by calling the\npcre2_set_compile_extra_options() function are as follows:\n
\n PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK\n\nSince release 10.38 PCRE2 has forbidden the use of \\K within lookaround\nassertions, following Perl's lead. This option is provided to re-enable the\nprevious behaviour (act in positive lookarounds, ignore in negative ones) in\ncase anybody is relying on it.\n
\n PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES\n\nThis option applies when compiling a pattern in UTF-8 or UTF-32 mode. It is\nforbidden in UTF-16 mode, and ignored in non-UTF modes. Unicode \"surrogate\"\ncode points in the range 0xd800 to 0xdfff are used in pairs in UTF-16 to encode\ncode points with values in the range 0x10000 to 0x10ffff. The surrogates cannot\ntherefore be represented in UTF-16. They can be represented in UTF-8 and\nUTF-32, but are defined as invalid code points, and cause errors if encountered\nin a UTF-8 or UTF-32 string that is being checked for validity by PCRE2.\n\n
\nThese values also cause errors if encountered in escape sequences such as\n\\x{d912} within a pattern. However, it seems that some applications, when\nusing PCRE2 to check for unwanted characters in UTF-8 strings, explicitly test\nfor the surrogates using escape sequences. The PCRE2_NO_UTF_CHECK option does\nnot disable the error that occurs, because it applies only to the testing of\ninput strings for UTF validity.\n
\n\nIf the extra option PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES is set, surrogate code\npoint values in UTF-8 and UTF-32 patterns no longer provoke errors and are\nincorporated in the compiled pattern. However, they can only match subject\ncharacters if the matching function is called with PCRE2_NO_UTF_CHECK set.\n
\n PCRE2_EXTRA_ALT_BSUX\n\nThe original option PCRE2_ALT_BSUX causes PCRE2 to process \\U, \\u, and \\x in\nthe way that ECMAscript (aka JavaScript) does. Additional functionality was\ndefined by ECMAscript 6; setting PCRE2_EXTRA_ALT_BSUX has the effect of\nPCRE2_ALT_BSUX, but in addition it recognizes \\u{hhh..} as a hexadecimal\ncharacter code, where hhh.. is any number of hexadecimal digits.\n
\n PCRE2_EXTRA_ASCII_BSD\n\nThis option forces \\d to match only ASCII digits, even when PCRE2_UCP is set.\nIt can be changed within a pattern by means of the (?aD) option setting.\n
\n PCRE2_EXTRA_ASCII_BSS\n\nThis option forces \\s to match only ASCII space characters, even when\nPCRE2_UCP is set. It can be changed within a pattern by means of the (?aS)\noption setting.\n
\n PCRE2_EXTRA_ASCII_BSW\n\nThis option forces \\w to match only ASCII word characters, even when PCRE2_UCP\nis set. It can be changed within a pattern by means of the (?aW) option\nsetting.\n
\n PCRE2_EXTRA_ASCII_DIGIT\n\nThis option forces the POSIX character classes [:digit:] and [:xdigit:] to\nmatch only ASCII digits, even when PCRE2_UCP is set. It can be changed within\na pattern by means of the (?aT) option setting.\n
\n PCRE2_EXTRA_ASCII_POSIX\n\nThis option forces all the POSIX character classes, including [:digit:] and\n[:xdigit:], to match only ASCII characters, even when PCRE2_UCP is set. It can\nbe changed within a pattern by means of the (?aP) option setting, but note that\nthis also sets PCRE2_EXTRA_ASCII_DIGIT in order to ensure that (?-aP) unsets\nall ASCII restrictions for POSIX classes.\n
\n PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL\n\nThis is a dangerous option. Use with care. By default, an unrecognized escape\nsuch as \\j or a malformed one such as \\x{2z} causes a compile-time error when\ndetected by pcre2_compile(). Perl is somewhat inconsistent in handling\nsuch items: for example, \\j is treated as a literal \"j\", and non-hexadecimal\ndigits in \\x{} are just ignored, though warnings are given in both cases if\nPerl's warning switch is enabled. However, a malformed octal number after \\o{\nalways causes an error in Perl.\n\n
\nIf the PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL extra option is passed to\npcre2_compile(), all unrecognized or malformed escape sequences are\ntreated as single-character escapes. For example, \\j is a literal \"j\" and\n\\x{2z} is treated as the literal string \"x{2z}\". Setting this option means\nthat typos in patterns may go undetected and have unexpected results. Also note\nthat a sequence such as [\\N{] is interpreted as a malformed attempt at\n[\\N{...}] and so is treated as [N{] whereas [\\N] gives an error because an\nunqualified \\N is a valid escape sequence but is not supported in a character\nclass. To reiterate: this is a dangerous option. Use with great care.\n
\n PCRE2_EXTRA_CASELESS_RESTRICT\n\nWhen either PCRE2_UCP or PCRE2_UTF is set, caseless matching follows Unicode\nrules, which allow for more than two cases per character. There are two\ncase-equivalent character sets that contain both ASCII and non-ASCII\ncharacters. The ASCII letter S is case-equivalent to U+017f (long S) and the\nASCII letter K is case-equivalent to U+212a (Kelvin sign). This option disables\nrecognition of case-equivalences that cross the ASCII/non-ASCII boundary. In a\ncaseless match, both characters must either be ASCII or non-ASCII. The option\ncan be changed within a pattern by the (*CASELESS_RESTRICT) or (?r) option\nsettings.\n
\n PCRE2_EXTRA_ESCAPED_CR_IS_LF\n\nThere are some legacy applications where the escape sequence \\r in a pattern\nis expected to match a newline. If this option is set, \\r in a pattern is\nconverted to \\n so that it matches a LF (linefeed) instead of a CR (carriage\nreturn) character. The option does not affect a literal CR in the pattern, nor\ndoes it affect CR specified as an explicit code point such as \\x{0D}.\n
\n PCRE2_EXTRA_MATCH_LINE\n\nThis option is provided for use by the -x option of pcre2grep. It\ncauses the pattern only to match complete lines. This is achieved by\nautomatically inserting the code for \"^(?:\" at the start of the compiled\npattern and \")$\" at the end. Thus, when PCRE2_MULTILINE is set, the matched\nline may be in the middle of the subject string. This option can be used with\nPCRE2_LITERAL.\n
\n PCRE2_EXTRA_MATCH_WORD\n\nThis option is provided for use by the -w option of pcre2grep. It\ncauses the pattern only to match strings that have a word boundary at the start\nand the end. This is achieved by automatically inserting the code for \"\\b(?:\"\nat the start of the compiled pattern and \")\\b\" at the end. The option may be\nused with PCRE2_LITERAL. However, it is ignored if PCRE2_EXTRA_MATCH_LINE is\nalso set.\n
\n PCRE2_EXTRA_NO_BS0\n\nIf this option is set (note that its final character is the digit 0) it locks\nout the use of the sequence \\0 unless at least one more octal digit follows.\n
\n PCRE2_EXTRA_PYTHON_OCTAL\n\nIf this option is set, PCRE2 follows Python's rules for interpreting octal\nescape sequences. The rules for handling sequences such as \\14, which could\nbe an octal number or a back reference are different. Details are given in the\npcre2pattern\ndocumentation.\n
\n PCRE2_EXTRA_NEVER_CALLOUT\n\nIf this option is set, PCRE2 treats callouts in the pattern as a syntax error,\nreturning PCRE2_ERROR_CALLOUT_CALLER_DISABLED. This is useful if the application\nknows that a callout will not be provided to pcre2_match(), so that\ncallouts in the pattern are not silently ignored.\n
\n PCRE2_EXTRA_TURKISH_CASING\n\nThis option alters case-equivalence of the 'i' letters to follow the\nalphabet used by Turkish and Azeri languages. The option can be changed within\na pattern by the (*TURKISH_CASING) start-of-pattern setting. Either the UTF or\nUCP options must be set. In the 8-bit library, UTF must be set. This option\ncannot be combined with PCRE2_EXTRA_CASELESS_RESTRICT.\n\n
JUST-IN-TIME (JIT) COMPILATION
\n\nint pcre2_jit_compile(pcre2_code *code, uint32_t options);\n
\n
\nint pcre2_jit_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n
\nvoid pcre2_jit_free_unused_memory(pcre2_general_context *gcontext);\n
\n
\npcre2_jit_stack *pcre2_jit_stack_create(size_t startsize,\n size_t maxsize, pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_jit_stack_assign(pcre2_match_context *mcontext,\n pcre2_jit_callback callback_function, void *callback_data);\n
\n
\nvoid pcre2_jit_stack_free(pcre2_jit_stack *jit_stack);\n
\nThese functions provide support for JIT compilation, which, if the just-in-time\ncompiler is available, further processes a compiled pattern into machine code\nthat executes much faster than the pcre2_match() interpretive matching\nfunction. Full details are given in the\npcre2jit\ndocumentation.\n
\n\nJIT compilation is a heavyweight optimization. It can take some time for\npatterns to be analyzed, and for one-off matches and simple patterns the\nbenefit of faster execution might be offset by a much slower compilation time.\nMost (but not all) patterns can be optimized by the JIT compiler.\n
\nLOCALE SUPPORT
\n\nconst uint8_t *pcre2_maketables(pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_maketables_free(pcre2_general_context *gcontext,\n const uint8_t *tables);\n
\nPCRE2 handles caseless matching, and determines whether characters are letters,\ndigits, or whatever, by reference to a set of tables, indexed by character code\npoint. However, this applies only to characters whose code points are less than\n256. By default, higher-valued code points never match escapes such as \\w or\n\\d.\n
\n\nWhen PCRE2 is built with Unicode support (the default), certain Unicode\ncharacter properties can be tested with \\p and \\P, or, alternatively, the\nPCRE2_UCP option can be set when a pattern is compiled; this causes \\w and\nfriends to use Unicode property support instead of the built-in tables.\nPCRE2_UCP also causes upper/lower casing operations on characters with code\npoints greater than 127 to use Unicode properties. These effects apply even\nwhen PCRE2_UTF is not set. There are, however, some PCRE2_EXTRA options (see\nabove) that can be used to modify or suppress them.\n
\n\nThe use of locales with Unicode is discouraged. If you are handling characters\nwith code points greater than 127, you should either use Unicode support, or\nuse locales, but not try to mix the two.\n
\n\nPCRE2 contains a built-in set of character tables that are used by default.\nThese are sufficient for many applications. Normally, the internal tables\nrecognize only ASCII characters. However, when PCRE2 is built, it is possible\nto cause the internal tables to be rebuilt in the default \"C\" locale of the\nlocal system, which may cause them to be different.\n
\n\nThe built-in tables can be overridden by tables supplied by the application\nthat calls PCRE2. These may be created in a different locale from the default.\nAs more and more applications change to using Unicode, the need for this locale\nsupport is expected to die away.\n
\n\nExternal tables are built by calling the pcre2_maketables() function, in\nthe relevant locale. The only argument to this function is a general context,\nwhich can be used to pass a custom memory allocator. If the argument is NULL,\nthe system malloc() is used. The result can be passed to\npcre2_compile() as often as necessary, by creating a compile context and\ncalling pcre2_set_character_tables() to set the tables pointer therein.\n
\n\nFor example, to build and use tables that are appropriate for the French locale\n(where accented characters with values greater than 127 are treated as\nletters), the following code could be used:\n
\n setlocale(LC_CTYPE, \"fr_FR\");\n tables = pcre2_maketables(NULL);\n ccontext = pcre2_compile_context_create(NULL);\n pcre2_set_character_tables(ccontext, tables);\n re = pcre2_compile(..., ccontext);\n\nThe locale name \"fr_FR\" is used on Linux and other Unix-like systems; if you\nare using Windows, the name for the French locale is \"french\".\n\n
\nThe pointer that is passed (via the compile context) to pcre2_compile()\nis saved with the compiled pattern, and the same tables are used by the\nmatching functions. Thus, for any single pattern, compilation and matching both\nhappen in the same locale, but different patterns can be processed in different\nlocales.\n
\n\nIt is the caller's responsibility to ensure that the memory containing the\ntables remains available while they are still in use. When they are no longer\nneeded, you can discard them using pcre2_maketables_free(), which should\npass as its first parameter the same global context that was used to create the\ntables.\n
\n\nSaving locale tables\n
\n\nThe tables described above are just a sequence of binary bytes, which makes\nthem independent of hardware characteristics such as endianness or whether the\nprocessor is 32-bit or 64-bit. A copy of the result of pcre2_maketables()\ncan therefore be saved in a file or elsewhere and re-used later, even in a\ndifferent program or on another computer. The size of the tables (number of\nbytes) must be obtained by calling pcre2_config() with the\nPCRE2_CONFIG_TABLES_LENGTH option because pcre2_maketables() does not\nreturn this value. Note that the pcre2_dftables program, which is part of\nthe PCRE2 build system, can be used stand-alone to create a file that contains\na set of binary tables. See the\npcre2build\ndocumentation for details.\n
\nINFORMATION ABOUT A COMPILED PATTERN
\n\nint pcre2_pattern_info(const pcre2 *code, uint32_t what, void *where);\n
\n\nThe pcre2_pattern_info() function returns general information about a\ncompiled pattern. For information about callouts, see the\nnext section.\nThe first argument for pcre2_pattern_info() is a pointer to the compiled\npattern. The second argument specifies which piece of information is required,\nand the third argument is a pointer to a variable to receive the data. If the\nthird argument is NULL, the first argument is ignored, and the function returns\nthe size in bytes of the variable that is required for the information\nrequested. Otherwise, the yield of the function is zero for success, or one of\nthe following negative numbers:\n
\n PCRE2_ERROR_NULL the argument code was NULL\n PCRE2_ERROR_BADMAGIC the \"magic number\" was not found\n PCRE2_ERROR_BADOPTION the value of what was invalid\n PCRE2_ERROR_UNSET the requested field is not set\n\nThe \"magic number\" is placed at the start of each compiled pattern as a simple\ncheck against passing an arbitrary memory pointer. Here is a typical call of\npcre2_pattern_info(), to obtain the length of the compiled pattern:\n
\n int rc;\n size_t length;\n rc = pcre2_pattern_info(\n re, /* result of pcre2_compile() */\n PCRE2_INFO_SIZE, /* what is required */\n &length); /* where to put the data */\n\nThe possible values for the second argument are defined in pcre2.h, and\nare as follows:\n
\n PCRE2_INFO_ALLOPTIONS\n PCRE2_INFO_ARGOPTIONS\n PCRE2_INFO_EXTRAOPTIONS\n\nReturn copies of the pattern's options. The third argument should point to a\nuint32_t variable. PCRE2_INFO_ARGOPTIONS returns exactly the options that\nwere passed to pcre2_compile(), whereas PCRE2_INFO_ALLOPTIONS returns\nthe compile options as modified by any top-level (*XXX) option settings such as\n(*UTF) at the start of the pattern itself. PCRE2_INFO_EXTRAOPTIONS returns the\nextra options that were set in the compile context by calling the\npcre2_set_compile_extra_options() function.\n\n
\nFor example, if the pattern /(*UTF)abc/ is compiled with the PCRE2_EXTENDED\noption, the result for PCRE2_INFO_ALLOPTIONS is PCRE2_EXTENDED and PCRE2_UTF.\nOption settings such as (?i) that can change within a pattern do not affect the\nresult of PCRE2_INFO_ALLOPTIONS, even if they appear right at the start of the\npattern. (This was different in some earlier releases.)\n
\n\nA pattern compiled without PCRE2_ANCHORED is automatically anchored by PCRE2 if\nthe first significant item in every top-level branch is one of the following:\n
\n ^ unless PCRE2_MULTILINE is set\n \\A always\n \\G always\n .* sometimes - see below\n\nWhen .* is the first significant item, anchoring is possible only when all the\nfollowing are true:\n
\n .* is not in an atomic group\n .* is not in a capture group that is the subject of a backreference\n PCRE2_DOTALL is in force for .*\n Neither (*PRUNE) nor (*SKIP) appears in the pattern\n PCRE2_NO_DOTSTAR_ANCHOR is not set\n Dotstar anchoring has not been disabled with PCRE2_DOTSTAR_ANCHOR_OFF\n\nFor patterns that are auto-anchored, the PCRE2_ANCHORED bit is set in the\noptions returned for PCRE2_INFO_ALLOPTIONS.\n
\n PCRE2_INFO_BACKREFMAX\n\nReturn the number of the highest backreference in the pattern. The third\nargument should point to a uint32_t variable. Named capture groups\nacquire numbers as well as names, and these count towards the highest\nbackreference. Backreferences such as \\4 or \\g{12} match the captured\ncharacters of the given group, but in addition, the check that a capture\ngroup is set in a conditional group such as (?(3)a|b) is also a backreference.\nZero is returned if there are no backreferences.\n
\n PCRE2_INFO_BSR\n\nThe output is a uint32_t integer whose value indicates what character sequences\nthe \\R escape sequence matches. A value of PCRE2_BSR_UNICODE means that \\R\nmatches any Unicode line ending sequence; a value of PCRE2_BSR_ANYCRLF means\nthat \\R matches only CR, LF, or CRLF.\n
\n PCRE2_INFO_CAPTURECOUNT\n\nReturn the highest capture group number in the pattern. In patterns where (?|\nis not used, this is also the total number of capture groups. The third\nargument should point to a uint32_t variable.\n
\n PCRE2_INFO_DEPTHLIMIT\n\nIf the pattern set a backtracking depth limit by including an item of the form\n(*LIMIT_DEPTH=nnnn) at the start, the value is returned. The third argument\nshould point to a uint32_t integer. If no such value has been set, the call to\npcre2_pattern_info() returns the error PCRE2_ERROR_UNSET. Note that this\nlimit will only be used during matching if it is less than the limit set or\ndefaulted by the caller of the match function.\n
\n PCRE2_INFO_FIRSTBITMAP\n\nIn the absence of a single first code unit for a non-anchored pattern,\npcre2_compile() may construct a 256-bit table that defines a fixed set of\nvalues for the first code unit in any match. For example, a pattern that starts\nwith [abc] results in a table with three bits set. When code unit values\ngreater than 255 are supported, the flag bit for 255 means \"any code unit of\nvalue 255 or above\". If such a table was constructed, a pointer to it is\nreturned. Otherwise NULL is returned. The third argument should point to a\nconst uint8_t * variable.\n
\n PCRE2_INFO_FIRSTCODETYPE\n\nReturn information about the first code unit of any matched string, for a\nnon-anchored pattern. The third argument should point to a uint32_t\nvariable. If there is a fixed first value, for example, the letter \"c\" from a\npattern such as (cat|cow|coyote), 1 is returned, and the value can be retrieved\nusing PCRE2_INFO_FIRSTCODEUNIT. If there is no fixed first value, but it is\nknown that a match can occur only at the start of the subject or following a\nnewline in the subject, 2 is returned. Otherwise, and for anchored patterns, 0\nis returned.\n
\n PCRE2_INFO_FIRSTCODEUNIT\n\nReturn the value of the first code unit of any matched string for a pattern\nwhere PCRE2_INFO_FIRSTCODETYPE returns 1; otherwise return 0. The third\nargument should point to a uint32_t variable. In the 8-bit library, the\nvalue is always less than 256. In the 16-bit library the value can be up to\n0xffff. In the 32-bit library in UTF-32 mode the value can be up to 0x10ffff,\nand up to 0xffffffff when not using UTF-32 mode.\n
\n PCRE2_INFO_FRAMESIZE\n\nReturn the size (in bytes) of the data frames that are used to remember\nbacktracking positions when the pattern is processed by pcre2_match()\nwithout the use of JIT. The third argument should point to a size_t\nvariable. The frame size depends on the number of capturing parentheses in the\npattern. Each additional capture group adds two PCRE2_SIZE variables.\n
\n PCRE2_INFO_HASBACKSLASHC\n\nReturn 1 if the pattern contains any instances of \\C, otherwise 0. The third\nargument should point to a uint32_t variable.\n
\n PCRE2_INFO_HASCRORLF\n\nReturn 1 if the pattern contains any explicit matches for CR or LF characters,\notherwise 0. The third argument should point to a uint32_t variable. An\nexplicit match is either a literal CR or LF character, or \\r or \\n or one of\nthe equivalent hexadecimal or octal escape sequences.\n
\n PCRE2_INFO_HEAPLIMIT\n\nIf the pattern set a heap memory limit by including an item of the form\n(*LIMIT_HEAP=nnnn) at the start, the value is returned. The third argument\nshould point to a uint32_t integer. If no such value has been set, the call to\npcre2_pattern_info() returns the error PCRE2_ERROR_UNSET. Note that this\nlimit will only be used during matching if it is less than the limit set or\ndefaulted by the caller of the match function.\n
\n PCRE2_INFO_JCHANGED\n\nReturn 1 if the (?J) or (?-J) option setting is used in the pattern, otherwise\n0. The third argument should point to a uint32_t variable. (?J) and\n(?-J) set and unset the local PCRE2_DUPNAMES option, respectively.\n
\n PCRE2_INFO_JITSIZE\n\nIf the compiled pattern was successfully processed by\npcre2_jit_compile(), return the size of the JIT compiled code, otherwise\nreturn zero. The third argument should point to a size_t variable.\n
\n PCRE2_INFO_LASTCODETYPE\n\nReturns 1 if there is a rightmost literal code unit that must exist in any\nmatched string, other than at its start. The third argument should point to a\nuint32_t variable. If there is no such value, 0 is returned. When 1 is\nreturned, the code unit value itself can be retrieved using\nPCRE2_INFO_LASTCODEUNIT. For anchored patterns, a last literal value is\nrecorded only if it follows something of variable length. For example, for the\npattern /^a\\d+z\\d+/ the returned value is 1 (with \"z\" returned from\nPCRE2_INFO_LASTCODEUNIT), but for /^a\\dz\\d/ the returned value is 0.\n
\n PCRE2_INFO_LASTCODEUNIT\n\nReturn the value of the rightmost literal code unit that must exist in any\nmatched string, other than at its start, for a pattern where\nPCRE2_INFO_LASTCODETYPE returns 1. Otherwise, return 0. The third argument\nshould point to a uint32_t variable.\n
\n PCRE2_INFO_MATCHEMPTY\n\nReturn 1 if the pattern might match an empty string, otherwise 0. The third\nargument should point to a uint32_t variable. When a pattern contains\nrecursive subroutine calls it is not always possible to determine whether or\nnot it can match an empty string. PCRE2 takes a cautious approach and returns 1\nin such cases.\n
\n PCRE2_INFO_MATCHLIMIT\n\nIf the pattern set a match limit by including an item of the form\n(*LIMIT_MATCH=nnnn) at the start, the value is returned. The third argument\nshould point to a uint32_t integer. If no such value has been set, the call to\npcre2_pattern_info() returns the error PCRE2_ERROR_UNSET. Note that this\nlimit will only be used during matching if it is less than the limit set or\ndefaulted by the caller of the match function.\n
\n PCRE2_INFO_MAXLOOKBEHIND\n\nA lookbehind assertion moves back a certain number of characters (not code\nunits) when it starts to process each of its branches. This request returns the\nlargest of these backward moves. The third argument should point to a uint32_t\ninteger. The simple assertions \\b and \\B require a one-character lookbehind\nand cause PCRE2_INFO_MAXLOOKBEHIND to return 1 in the absence of anything\nlonger. \\A also registers a one-character lookbehind, though it does not\nactually inspect the previous character.\n\n
\nNote that this information is useful for multi-segment matching only\nif the pattern contains no nested lookbehinds. For example, the pattern\n(?<=a(?<=ba)c) returns a maximum lookbehind of 2, but when it is processed, the\nfirst lookbehind moves back by two characters, matches one character, then the\nnested lookbehind also moves back by two characters. This puts the matching\npoint three characters earlier than it was at the start.\nPCRE2_INFO_MAXLOOKBEHIND is really only useful as a debugging tool. See the\npcre2partial\ndocumentation for a discussion of multi-segment matching.\n
\n PCRE2_INFO_MINLENGTH\n\nIf a minimum length for matching subject strings was computed, its value is\nreturned. Otherwise the returned value is 0. This value is not computed when\nPCRE2_NO_START_OPTIMIZE is set. The value is a number of characters, which in\nUTF mode may be different from the number of code units. The third argument\nshould point to a uint32_t variable. The value is a lower bound to the\nlength of any matching string. There may not be any strings of that length that\ndo actually match, but every string that does match is at least that long.\n
\n PCRE2_INFO_NAMECOUNT\n PCRE2_INFO_NAMEENTRYSIZE\n PCRE2_INFO_NAMETABLE\n\nPCRE2 supports the use of named as well as numbered capturing parentheses. The\nnames are just an additional way of identifying the parentheses, which still\nacquire numbers. Several convenience functions such as\npcre2_substring_get_byname() are provided for extracting captured\nsubstrings by name. It is also possible to extract the data directly, by first\nconverting the name to a number in order to access the correct pointers in the\noutput vector (described with pcre2_match() below). To do the conversion,\nyou need to use the name-to-number map, which is described by these three\nvalues.\n\n
\nThe map consists of a number of fixed-size entries. PCRE2_INFO_NAMECOUNT gives\nthe number of entries, and PCRE2_INFO_NAMEENTRYSIZE gives the size of each\nentry in code units; both of these return a uint32_t value. The entry\nsize depends on the length of the longest name.\n
\n\nPCRE2_INFO_NAMETABLE returns a pointer to the first entry of the table. This is\na PCRE2_SPTR pointer to a block of code units. In the 8-bit library, the first\ntwo bytes of each entry are the number of the capturing parenthesis, most\nsignificant byte first. In the 16-bit library, the pointer points to 16-bit\ncode units, the first of which contains the parenthesis number. In the 32-bit\nlibrary, the pointer points to 32-bit code units, the first of which contains\nthe parenthesis number. The rest of the entry is the corresponding name, zero\nterminated.\n
\n\nThe names are in alphabetical order. If (?| is used to create multiple capture\ngroups with the same number, as described in the\nsection on duplicate group numbers\nin the\npcre2pattern\npage, the groups may be given the same name, but there is only one entry in the\ntable. Different names for groups of the same number are not permitted.\n
\n\nDuplicate names for capture groups with different numbers are permitted, but\nonly if PCRE2_DUPNAMES is set. They appear in the table in the order in which\nthey were found in the pattern. In the absence of (?| this is the order of\nincreasing number; when (?| is used this is not necessarily the case because\nlater capture groups may have lower numbers.\n
\n\nAs a simple example of the name/number table, consider the following pattern\nafter compilation by the 8-bit library (assume PCRE2_EXTENDED is set, so white\nspace - including newlines - is ignored):\n
\n (?<date> (?<year>(\\d\\d)?\\d\\d) - (?<month>\\d\\d) - (?<day>\\d\\d) )\n\nThere are four named capture groups, so the table has four entries, and each\nentry in the table is eight bytes long. The table is as follows, with\nnon-printing bytes shows in hexadecimal, and undefined bytes shown as ??:\n
\n 00 01 d a t e 00 ??\n 00 05 d a y 00 ?? ??\n 00 04 m o n t h 00\n 00 02 y e a r 00 ??\n\nWhen writing code to extract data from named capture groups using the\nname-to-number map, remember that the length of the entries is likely to be\ndifferent for each compiled pattern.\n
\n PCRE2_INFO_NEWLINE\n\nThe output is one of the following uint32_t values:\n
\n PCRE2_NEWLINE_CR Carriage return (CR)\n PCRE2_NEWLINE_LF Linefeed (LF)\n PCRE2_NEWLINE_CRLF Carriage return, linefeed (CRLF)\n PCRE2_NEWLINE_ANY Any Unicode line ending\n PCRE2_NEWLINE_ANYCRLF Any of CR, LF, or CRLF\n PCRE2_NEWLINE_NUL The NUL character (binary zero)\n\nThis identifies the character sequence that will be recognized as meaning\n\"newline\" while matching.\n
\n PCRE2_INFO_SIZE\n\nReturn the size of the compiled pattern in bytes (for all three libraries). The\nthird argument should point to a size_t variable. This value includes the\nsize of the general data block that precedes the code units of the compiled\npattern itself. The value that is used when pcre2_compile() is getting\nmemory in which to place the compiled pattern may be slightly larger than the\nvalue returned by this option, because there are cases where the code that\ncalculates the size has to over-estimate. Processing a pattern with the JIT\ncompiler does not alter the value returned by this option.\n\n
INFORMATION ABOUT A PATTERN'S CALLOUTS
\n\nint pcre2_callout_enumerate(const pcre2_code *code,\n int (*callback)(pcre2_callout_enumerate_block *, void *),\n void *user_data);\n
\n
\nA script language that supports the use of string arguments in callouts might\nlike to scan all the callouts in a pattern before running the match. This can\nbe done by calling pcre2_callout_enumerate(). The first argument is a\npointer to a compiled pattern, the second points to a callback function, and\nthe third is arbitrary user data. The callback function is called for every\ncallout in the pattern in the order in which they appear. Its first argument is\na pointer to a callout enumeration block, and its second argument is the\nuser_data value that was passed to pcre2_callout_enumerate(). The\ncontents of the callout enumeration block are described in the\npcre2callout\ndocumentation, which also gives further details about callouts.\n
SERIALIZATION AND PRECOMPILING
\n\nIt is possible to save compiled patterns on disc or elsewhere, and reload them\nlater, subject to a number of restrictions. The host on which the patterns are\nreloaded must be running the same version of PCRE2, with the same code unit\nwidth, and must also have the same endianness, pointer width, and PCRE2_SIZE\ntype. Before compiled patterns can be saved, they must be converted to a\n\"serialized\" form, which in the case of PCRE2 is really just a bytecode dump.\nThe functions whose names begin with pcre2_serialize_ are used for\nconverting to and from the serialized form. They are described in the\npcre2serialize\ndocumentation. Note that PCRE2 serialization does not convert compiled patterns\nto an abstract format like Java or .NET serialization.\n
\nTHE MATCH DATA BLOCK
\n\npcre2_match_data *pcre2_match_data_create(uint32_t ovecsize,\n pcre2_general_context *gcontext);\n
\n
\npcre2_match_data *pcre2_match_data_create_from_pattern(\n const pcre2_code *code, pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_match_data_free(pcre2_match_data *match_data);\n
\nInformation about a successful or unsuccessful match is placed in a match\ndata block, which is an opaque structure that is accessed by function calls. In\nparticular, the match data block contains a vector of offsets into the subject\nstring that define the matched parts of the subject. This is known as the\novector.\n
\n\nBefore calling pcre2_match(), pcre2_dfa_match(), or\npcre2_jit_match() you must create a match data block by calling one of\nthe creation functions above. For pcre2_match_data_create(), the first\nargument is the number of pairs of offsets in the ovector.\n
\n\nWhen using pcre2_match(), one pair of offsets is required to identify the\nstring that matched the whole pattern, with an additional pair for each\ncaptured substring. For example, a value of 4 creates enough space to record\nthe matched portion of the subject plus three captured substrings.\n
\n\nWhen using pcre2_dfa_match() there may be multiple matched substrings of\ndifferent lengths at the same point in the subject. The ovector should be made\nlarge enough to hold as many as are expected.\n
\n\nA minimum of at least 1 pair is imposed by pcre2_match_data_create(), so\nit is always possible to return the overall matched string in the case of\npcre2_match() or the longest match in the case of\npcre2_dfa_match(). The maximum number of pairs is 65535; if the first\nargument of pcre2_match_data_create() is greater than this, 65535 is\nused.\n
\n\nThe second argument of pcre2_match_data_create() is a pointer to a\ngeneral context, which can specify custom memory management for obtaining the\nmemory for the match data block. If you are not using custom memory management,\npass NULL, which causes malloc() to be used.\n
\n\nFor pcre2_match_data_create_from_pattern(), the first argument is a\npointer to a compiled pattern. The ovector is created to be exactly the right\nsize to hold all the substrings a pattern might capture when matched using\npcre2_match(). You should not use this call when matching with\npcre2_dfa_match(). The second argument is again a pointer to a general\ncontext, but in this case if NULL is passed, the memory is obtained using the\nsame allocator that was used for the compiled pattern (custom or default).\n
\n\nA match data block can be used many times, with the same or different compiled\npatterns. You can extract information from a match data block after a match\noperation has finished, using functions that are described in the sections on\nmatched strings\nand\nother match data\nbelow.\n
\n\nWhen a call of pcre2_match() fails, valid data is available in the match\nblock only when the error is PCRE2_ERROR_NOMATCH, PCRE2_ERROR_PARTIAL, or one\nof the error codes for an invalid UTF string. Exactly what is available depends\non the error, and is detailed below.\n
\n\nWhen one of the matching functions is called, pointers to the compiled pattern\nand the subject string are set in the match data block so that they can be\nreferenced by the extraction functions after a successful match. After running\na match, you must not free a compiled pattern or a subject string until after\nall operations on the match data block (for that match) have taken place,\nunless, in the case of the subject string, you have used the\nPCRE2_COPY_MATCHED_SUBJECT option, which is described in the section entitled\n\"Option bits for pcre2_match()\"\n\">below.\n
\n\nWhen a match data block itself is no longer needed, it should be freed by\ncalling pcre2_match_data_free(). If this function is called with a NULL\nargument, it returns immediately, without doing anything.\n
\nMEMORY USE FOR MATCH DATA BLOCKS
\n\nPCRE2_SIZE pcre2_get_match_data_size(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE pcre2_get_match_data_heapframes_size(\n pcre2_match_data *match_data);\n
\nThe size of a match data block depends on the size of the ovector that it\ncontains. The function pcre2_get_match_data_size() returns the size, in\nbytes, of the block that is its argument.\n
\n\nWhen pcre2_match() runs interpretively (that is, without using JIT), it\nmakes use of a vector of data frames for remembering backtracking positions.\nThe size of each individual frame depends on the number of capturing\nparentheses in the pattern and can be obtained by calling\npcre2_pattern_info() with the PCRE2_INFO_FRAMESIZE option (see the\nsection entitled \"Information about a compiled pattern\"\n\">above).\n
\n\nHeap memory is used for the frames vector; if the initial memory block turns\nout to be too small during matching, it is automatically expanded. When\npcre2_match() returns, the memory is not freed, but remains attached to\nthe match data block, for use by any subsequent matches that use the same\nblock. It is automatically freed when the match data block itself is freed.\n
\n\nYou can find the current size of the frames vector that a match data block owns\nby calling pcre2_get_match_data_heapframes_size(). For a newly created\nmatch data block the size will be zero. Some types of match may require a lot\nof frames and thus a large vector; applications that run in environments where\nmemory is constrained can check this and free the match data block if the heap\nframes vector has become too big.\n
\nMATCHING A PATTERN: THE TRADITIONAL FUNCTION
\n\nint pcre2_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext);\n
\n\nThe function pcre2_match() is called to match a subject string against a\ncompiled pattern, which is passed in the code argument. You can call\npcre2_match() with the same code argument as many times as you\nlike, in order to find multiple matches in the subject string or to match\ndifferent subject strings with the same pattern.\n
\n\nThis function is the main matching facility of the library, and it operates in\na Perl-like manner. For specialist use there is also an alternative matching\nfunction, which is described\nbelow\nin the section about the pcre2_dfa_match() function.\n
\n\nHere is an example of a simple call to pcre2_match():\n
\n pcre2_match_data *md = pcre2_match_data_create(4, NULL);\n int rc = pcre2_match(\n re, /* result of pcre2_compile() */\n \"some string\", /* the subject string */\n 11, /* the length of the subject string */\n 0, /* start at offset 0 in the subject */\n 0, /* default options */\n md, /* the match data block */\n NULL); /* a match context; NULL means use defaults */\n\nIf the subject string is zero-terminated, the length can be given as\nPCRE2_ZERO_TERMINATED. A match context must be provided if certain less common\nmatching parameters are to be changed. For details, see the section on\nthe match context\nabove.\n\n
\nThe string to be matched by pcre2_match()\n
\n\nThe subject string is passed to pcre2_match() as a pointer in\nsubject, a length in length, and a starting offset in\nstartoffset. The length and offset are in code units, not characters.\nThat is, they are in bytes for the 8-bit library, 16-bit code units for the\n16-bit library, and 32-bit code units for the 32-bit library, whether or not\nUTF processing is enabled. As a special case, if subject is NULL and\nlength is zero, the subject is assumed to be an empty string. If\nlength is non-zero, an error occurs if subject is NULL.\n
\n\nIf startoffset is greater than the length of the subject,\npcre2_match() returns PCRE2_ERROR_BADOFFSET. When the starting offset is\nzero, the search for a match starts at the beginning of the subject, and this\nis by far the most common case. In UTF-8 or UTF-16 mode, the starting offset\nmust point to the start of a character, or to the end of the subject (in UTF-32\nmode, one code unit equals one character, so all offsets are valid). Like the\npattern string, the subject may contain binary zeros.\n
\n\nA non-zero starting offset is useful when searching for another match in the\nsame subject by calling pcre2_match() again after a previous success.\nSetting startoffset differs from passing over a shortened string and\nsetting PCRE2_NOTBOL in the case of a pattern that begins with any kind of\nlookbehind. For example, consider the pattern\n
\n \\Biss\\B\n\nwhich finds occurrences of \"iss\" in the middle of words. (\\B matches only if\nthe current position in the subject is not a word boundary.) When applied to\nthe string \"Mississippi\" the first call to pcre2_match() finds the first\noccurrence. If pcre2_match() is called again with just the remainder of\nthe subject, namely \"issippi\", it does not match, because \\B is always false\nat the start of the subject, which is deemed to be a word boundary. However, if\npcre2_match() is passed the entire string again, but with\nstartoffset set to 4, it finds the second occurrence of \"iss\" because it\nis able to look behind the starting point to discover that it is preceded by a\nletter.\n\n
\nFinding all the matches in a subject is tricky when the pattern can match an\nempty string. PCRE2 includes a helper API to assist with this; see the\nsection entitled \"Iterating over all matches\"\nbelow\nfor details.\n
\n\nIf a non-zero starting offset is passed when the pattern is anchored, a single\nattempt to match at the given offset is made. This can only succeed if the\npattern does not require the match to be at the start of the subject. In other\nwords, the anchoring must be the result of setting the PCRE2_ANCHORED option or\nthe use of .* with PCRE2_DOTALL, not by starting the pattern with ^ or \\A.\n
\n\nOption bits for pcre2_match()\n
\n\nThe unused bits of the options argument for pcre2_match() must be\nzero. The only bits that may be set are PCRE2_ANCHORED,\nPCRE2_COPY_MATCHED_SUBJECT, PCRE2_DISABLE_RECURSELOOP_CHECK, PCRE2_ENDANCHORED,\nPCRE2_NOTBOL, PCRE2_NOTEOL, PCRE2_NOTEMPTY, PCRE2_NOTEMPTY_ATSTART,\nPCRE2_NO_JIT, PCRE2_NO_UTF_CHECK, PCRE2_PARTIAL_HARD, and PCRE2_PARTIAL_SOFT.\nTheir action is described below.\n
\n\nSetting PCRE2_ANCHORED or PCRE2_ENDANCHORED at match time is not supported by\nthe just-in-time (JIT) compiler. If it is set, JIT matching is disabled and the\ninterpretive code in pcre2_match() is run.\nPCRE2_DISABLE_RECURSELOOP_CHECK is ignored by JIT, but apart from PCRE2_NO_JIT\n(obviously), the remaining options are supported for JIT matching.\n
\n PCRE2_ANCHORED\n\nThe PCRE2_ANCHORED option limits pcre2_match() to matching at the first\nmatching position. If a pattern was compiled with PCRE2_ANCHORED, or turned out\nto be anchored by virtue of its contents, it cannot be made unanchored at\nmatching time. Note that setting the option at match time disables JIT\nmatching.\n
\n PCRE2_COPY_MATCHED_SUBJECT\n\nBy default, a pointer to the subject is remembered in the match data block so\nthat, after a successful match, it can be referenced by the substring\nextraction functions. This means that the subject's memory must not be freed\nuntil all such operations are complete. For some applications where the\nlifetime of the subject string is not guaranteed, it may be necessary to make a\ncopy of the subject string, but it is wasteful to do this unless the match is\nsuccessful. After a successful match, if PCRE2_COPY_MATCHED_SUBJECT is set, the\nsubject is copied and the new pointer is remembered in the match data block\ninstead of the original subject pointer. The memory allocator that was used for\nthe match block itself is used. The copy is automatically freed when\npcre2_match_data_free() is called to free the match data block. It is also\nautomatically freed if the match data block is re-used for another match\noperation.\n
\n PCRE2_DISABLE_RECURSELOOP_CHECK\n\nThis option is relevant only to pcre2_match() for interpretive matching.\nIt is ignored when JIT is used, and is forbidden for pcre2_dfa_match().\n\n
\nThe use of recursion in patterns can lead to infinite loops. In the\ninterpretive matcher these would be eventually caught by the match or heap\nlimits, but this could take a long time and/or use a lot of memory if the\nlimits are large. There is therefore a check at the start of each recursion.\nIf the same group is still active from a previous call, and the current subject\npointer is the same as it was at the start of that group, and the furthest\ninspected character of the subject has not changed, an error is generated.\n
\n\nThere are rare cases of matches that would complete, but nevertheless trigger\nthis error. This option disables the check. It is provided mainly for testing\nwhen comparing JIT and interpretive behaviour.\n
\n PCRE2_ENDANCHORED\n\nIf the PCRE2_ENDANCHORED option is set, any string that pcre2_match()\nmatches must be right at the end of the subject string. Note that setting the\noption at match time disables JIT matching.\n
\n PCRE2_NOTBOL\n\nThis option specifies that first character of the subject string is not the\nbeginning of a line, so the circumflex metacharacter should not match before\nit. Setting this without having set PCRE2_MULTILINE at compile time causes\ncircumflex never to match. This option affects only the behaviour of the\ncircumflex metacharacter. It does not affect \\A.\n
\n PCRE2_NOTEOL\n\nThis option specifies that the end of the subject string is not the end of a\nline, so the dollar metacharacter should not match it nor (except in multiline\nmode) a newline immediately before it. Setting this without having set\nPCRE2_MULTILINE at compile time causes dollar never to match. This option\naffects only the behaviour of the dollar metacharacter. It does not affect \\Z\nor \\z.\n
\n PCRE2_NOTEMPTY\n\nAn empty string is not considered to be a valid match if this option is set. If\nthere are alternatives in the pattern, they are tried. If all the alternatives\nmatch the empty string, the entire match fails. For example, if the pattern\n
\n a?b?\n\nis applied to a string not beginning with \"a\" or \"b\", it matches an empty\nstring at the start of the subject. With PCRE2_NOTEMPTY set, this match is not\nvalid, so pcre2_match() searches further into the string for occurrences\nof \"a\" or \"b\".\n
\n PCRE2_NOTEMPTY_ATSTART\n\nThis is like PCRE2_NOTEMPTY, except that it locks out an empty string match\nonly at the first matching position, that is, at the start of the subject plus\nthe starting offset. An empty string match later in the subject is permitted.\nIf the pattern is anchored, such a match can occur only if the pattern contains\n\\K.\n
\n PCRE2_NO_JIT\n\nBy default, if a pattern has been successfully processed by\npcre2_jit_compile(), JIT is automatically used when pcre2_match()\nis called with options that JIT supports. Setting PCRE2_NO_JIT disables the use\nof JIT; it forces matching to be done by the interpreter.\n
\n PCRE2_NO_UTF_CHECK\n\nWhen PCRE2_UTF is set at compile time, the validity of the subject as a UTF\nstring is checked unless PCRE2_NO_UTF_CHECK is passed to pcre2_match() or\nPCRE2_MATCH_INVALID_UTF was passed to pcre2_compile(). The latter special\ncase is discussed in detail in the\npcre2unicode\ndocumentation.\n\n
\nIn the default case, if a non-zero starting offset is given, the check is\napplied only to that part of the subject that could be inspected during\nmatching, and there is a check that the starting offset points to the first\ncode unit of a character or to the end of the subject. If there are no\nlookbehind assertions in the pattern, the check starts at the starting offset.\nOtherwise, it starts at the length of the longest lookbehind before the\nstarting offset, or at the start of the subject if there are not that many\ncharacters before the starting offset. Note that the sequences \\b and \\B are\none-character lookbehinds.\n
\n\nThe check is carried out before any other processing takes place, and a\nnegative error code is returned if the check fails. There are several UTF error\ncodes for each code unit width, corresponding to different problems with the\ncode unit sequence. There are discussions about the validity of\nUTF-8 strings,\nUTF-16 strings,\nand\nUTF-32 strings\nin the\npcre2unicode\ndocumentation.\n
\n\nIf you know that your subject is valid, and you want to skip this check for\nperformance reasons, you can set the PCRE2_NO_UTF_CHECK option when calling\npcre2_match(). You might want to do this for the second and subsequent\ncalls to pcre2_match() if you are making repeated calls to find multiple\nmatches in the same subject string.\n
\n\nWarning: Unless PCRE2_MATCH_INVALID_UTF was set at compile time, when\nPCRE2_NO_UTF_CHECK is set at match time the effect of passing an invalid\nstring as a subject, or an invalid value of startoffset, is undefined.\nYour program may crash or loop indefinitely or give wrong results.\n
\n PCRE2_PARTIAL_HARD\n PCRE2_PARTIAL_SOFT\n\nThese options turn on the partial matching feature. A partial match occurs if\nthe end of the subject string is reached successfully, but there are not enough\nsubject characters to complete the match. In addition, either at least one\ncharacter must have been inspected or the pattern must contain a lookbehind, or\nthe pattern must be one that could match an empty string.\n\n
\nIf this situation arises when PCRE2_PARTIAL_SOFT (but not PCRE2_PARTIAL_HARD)\nis set, matching continues by testing any remaining alternatives. Only if no\ncomplete match can be found is PCRE2_ERROR_PARTIAL returned instead of\nPCRE2_ERROR_NOMATCH. In other words, PCRE2_PARTIAL_SOFT specifies that the\ncaller is prepared to handle a partial match, but only if no complete match can\nbe found.\n
\n\nIf PCRE2_PARTIAL_HARD is set, it overrides PCRE2_PARTIAL_SOFT. In this case, if\na partial match is found, pcre2_match() immediately returns\nPCRE2_ERROR_PARTIAL, without considering any other alternatives. In other\nwords, when PCRE2_PARTIAL_HARD is set, a partial match is considered to be more\nimportant than an alternative complete match.\n
\n\nThere is a more detailed discussion of partial and multi-segment matching, with\nexamples, in the\npcre2partial\ndocumentation.\n
\nNEWLINE HANDLING WHEN MATCHING
\n\nWhen PCRE2 is built, a default newline convention is set; this is usually the\nstandard convention for the operating system. The default can be overridden in\na\ncompile context\nby calling pcre2_set_newline(). It can also be overridden by starting a\npattern string with, for example, (*CRLF), as described in the\nsection on newline conventions\nin the\npcre2pattern\npage. During matching, the newline choice affects the behaviour of the dot,\ncircumflex, and dollar metacharacters. It may also alter the way the match\nstarting position is advanced after a match failure for an unanchored pattern.\n
\n\nWhen PCRE2_NEWLINE_CRLF, PCRE2_NEWLINE_ANYCRLF, or PCRE2_NEWLINE_ANY is set as\nthe newline convention, and a match attempt for an unanchored pattern fails\nwhen the current starting position is at a CRLF sequence, and the pattern\ncontains no explicit matches for CR or LF characters, the match position is\nadvanced by two characters instead of one, in other words, to after the CRLF.\n
\n\nThe above rule is a compromise that makes the most common cases work as\nexpected. For example, if the pattern is .+A (and the PCRE2_DOTALL option is\nnot set), it does not match the string \"\\r\\nA\" because, after failing at the\nstart, it skips both the CR and the LF before retrying. However, the pattern\n[\\r\\n]A does match that string, because it contains an explicit CR or LF\nreference, and so advances only by one character after the first failure.\n
\n\nAn explicit match for CR of LF is either a literal appearance of one of those\ncharacters in the pattern, or one of the \\r or \\n or equivalent octal or\nhexadecimal escape sequences. Implicit matches such as [^X] do not count, nor\ndoes \\s, even though it includes CR and LF in the characters that it matches.\n
\n\nNotwithstanding the above, anomalous effects may still occur when CRLF is a\nvalid newline sequence and explicit \\r or \\n escapes appear in the pattern.\n
\nHOW PCRE2_MATCH() RETURNS A STRING AND CAPTURED SUBSTRINGS
\n\nuint32_t pcre2_get_ovector_count(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE *pcre2_get_ovector_pointer(pcre2_match_data *match_data);\n
\nIn general, a pattern matches a certain portion of the subject, and in\naddition, further substrings from the subject may be picked out by\nparenthesized parts of the pattern. Following the usage in Jeffrey Friedl's\nbook, this is called \"capturing\" in what follows, and the phrase \"capture\ngroup\" (Perl terminology) is used for a fragment of a pattern that picks out a\nsubstring. PCRE2 supports several other kinds of parenthesized group that do\nnot cause substrings to be captured. The pcre2_pattern_info() function\ncan be used to find out how many capture groups there are in a compiled\npattern.\n
\n\nYou can use auxiliary functions for accessing captured substrings\nby number\nor\nby name,\nas described in sections below.\n
\n\nAlternatively, you can make direct use of the vector of PCRE2_SIZE values,\ncalled the ovector, which contains the offsets of captured strings. It is\npart of the\nmatch data block.\nThe function pcre2_get_ovector_pointer() returns the address of the\novector, and pcre2_get_ovector_count() returns the number of pairs of\nvalues it contains.\n
\n\nWithin the ovector, the first in each pair of values is set to the offset of\nthe first code unit of a substring, and the second is set to the offset of the\nfirst code unit after the end of a substring. These values are always code unit\noffsets, not character offsets. That is, they are byte offsets in the 8-bit\nlibrary, 16-bit offsets in the 16-bit library, and 32-bit offsets in the 32-bit\nlibrary.\n
\n\nAfter a partial match (error return PCRE2_ERROR_PARTIAL), only the first pair\nof offsets (that is, ovector[0] and ovector[1]) are set. They\nidentify the part of the subject that was partially matched. See the\npcre2partial\ndocumentation for details of partial matching.\n
\n\nAfter a fully successful match, the first pair of offsets identifies the\nportion of the subject string that was matched by the entire pattern. The next\npair is used for the first captured substring, and so on. The value returned by\npcre2_match() is one more than the highest numbered pair that has been\nset. For example, if two substrings have been captured, the returned value is\n3. If there are no captured substrings, the return value from a successful\nmatch is 1, indicating that just the first pair of offsets has been set.\n
\n\nIf a pattern uses the \\K escape sequence within a positive lookahead assertion,\nthe reported start of a successful match can be greater than the end of the\nmatch. For example, if the pattern (?=ab\\K) is matched against \"ab\", the start\nand end offset values for the match are 2 and 0.\n
\n\nIf a capture group is matched repeatedly within a single match operation, it is\nthe last portion of the subject that it matched that is returned.\n
\n\nIf the ovector is too small to hold all the captured substring offsets, as much\nas possible is filled in, and the function returns a value of zero. If captured\nsubstrings are not of interest, pcre2_match() may be called with a match\ndata block whose ovector is of minimum length (that is, one pair).\n
\n\nIt is possible for capture group number n+1 to match some part of the\nsubject when group n has not been used at all. For example, if the string\n\"abc\" is matched against the pattern (a|(z))(bc) the return from the function\nis 4, and groups 1 and 3 are matched, but 2 is not. When this happens, both\nvalues in the offset pairs corresponding to unused groups are set to\nPCRE2_UNSET.\n
\n\nOffset values that correspond to unused groups at the end of the expression are\nalso set to PCRE2_UNSET. For example, if the string \"abc\" is matched against\nthe pattern (abc)(x(yz)?)? groups 2 and 3 are not matched. The return from the\nfunction is 2, because the highest used capture group number is 1. The offsets\nfor the second and third capture groups (assuming the vector is large enough,\nof course) are set to PCRE2_UNSET.\n
\n\nElements in the ovector that do not correspond to capturing parentheses in the\npattern are never changed. That is, if a pattern contains n capturing\nparentheses, no more than ovector[0] to ovector[2n+1] are set by\npcre2_match(). The other elements retain whatever values they previously\nhad. After a failed match attempt, the contents of the ovector are unchanged.\n
\nOTHER INFORMATION ABOUT A MATCH
\n\nPCRE2_SPTR pcre2_get_mark(pcre2_match_data *match_data);\n
\n
\nPCRE2_SIZE pcre2_get_startchar(pcre2_match_data *match_data);\n
\nAs well as the offsets in the ovector, other information about a match is\nretained in the match data block and can be retrieved by the above functions in\nappropriate circumstances. If they are called at other times, the result is\nundefined.\n
\n\nAfter a successful match, a partial match (PCRE2_ERROR_PARTIAL), or a failure\nto match (PCRE2_ERROR_NOMATCH), a mark name may be available. The function\npcre2_get_mark() can be called to access this name, which can be\nspecified in the pattern by any of the backtracking control verbs, not just\n(*MARK). The same function applies to all the verbs. It returns a pointer to\nthe zero-terminated name, which is within the compiled pattern. If no name is\navailable, NULL is returned. The length of the name (excluding the terminating\nzero) is stored in the code unit that precedes the name. You should use this\nlength instead of relying on the terminating zero if the name might contain a\nbinary zero.\n
\n\nAfter a successful match, the name that is returned is the last mark name\nencountered on the matching path through the pattern. Instances of backtracking\nverbs without names do not count. Thus, for example, if the matching path\ncontains (*MARK:A)(*PRUNE), the name \"A\" is returned. After a \"no match\" or a\npartial match, the last encountered name is returned. For example, consider\nthis pattern:\n
\n ^(*MARK:A)((*MARK:B)a|b)c\n\nWhen it matches \"bc\", the returned name is A. The B mark is \"seen\" in the first\nbranch of the group, but it is not on the matching path. On the other hand,\nwhen this pattern fails to match \"bx\", the returned name is B.\n\n
\nWarning: By default, certain start-of-match optimizations are used to\ngive a fast \"no match\" result in some situations. For example, if the anchoring\nis removed from the pattern above, there is an initial check for the presence\nof \"c\" in the subject before running the matching engine. This check fails for\n\"bx\", causing a match failure without seeing any marks. You can disable the\nstart-of-match optimizations by setting the PCRE2_NO_START_OPTIMIZE option for\npcre2_compile() or by starting the pattern with (*NO_START_OPT).\n
\n\nAfter a successful match, a partial match, or one of the invalid UTF errors\n(for example, PCRE2_ERROR_UTF8_ERR5), pcre2_get_startchar() can be\ncalled. After a successful or partial match it returns the code unit offset of\nthe character at which the match started. For a non-partial match, this can be\ndifferent to the value of ovector[0] if the pattern contains the \\K\nescape sequence. After a partial match, however, this value is always the same\nas ovector[0] because \\K does not affect the result of a partial match.\n
\n\nAfter a UTF check failure, pcre2_get_startchar() can be used to obtain\nthe code unit offset of the invalid UTF character. Details are given in the\npcre2unicode\npage.\n
\nERROR RETURNS FROM pcre2_match()
\n\nIf pcre2_match() fails, it returns a negative number. This can be\nconverted to a text string by calling the pcre2_get_error_message()\nfunction (see \"Obtaining a textual error message\"\nbelow).\nNegative error codes are also returned by other functions, and are documented\nwith them. The codes are given names in the header file. If UTF checking is in\nforce and an invalid UTF subject string is detected, one of a number of\nUTF-specific negative error codes is returned. Details are given in the\npcre2unicode\npage. The following are the other errors that may be returned by\npcre2_match():\n
\n PCRE2_ERROR_NOMATCH\n\nThe subject string did not match the pattern.\n
\n PCRE2_ERROR_PARTIAL\n\nThe subject string did not match, but it did match partially. See the\npcre2partial\ndocumentation for details of partial matching.\n
\n PCRE2_ERROR_BADMAGIC\n\nPCRE2 stores a 4-byte \"magic number\" at the start of the compiled code, to\ncatch the case when it is passed a junk pointer. This is the error that is\nreturned when the magic number is not present.\n
\n PCRE2_ERROR_BADMODE\n\nThis error is given when a compiled pattern is passed to a function in a\nlibrary of a different code unit width, for example, a pattern compiled by\nthe 8-bit library is passed to a 16-bit or 32-bit library function.\n
\n PCRE2_ERROR_BADOFFSET\n\nThe value of startoffset was greater than the length of the subject.\n
\n PCRE2_ERROR_BADOPTION\n\nAn unrecognized bit was set in the options argument.\n
\n PCRE2_ERROR_BADUTFOFFSET\n\nThe UTF code unit sequence that was passed as a subject was checked and found\nto be valid (the PCRE2_NO_UTF_CHECK option was not set), but the value of\nstartoffset did not point to the beginning of a UTF character or the end\nof the subject.\n
\n PCRE2_ERROR_CALLOUT\n\nThis error is never generated by pcre2_match() itself. It is provided for\nuse by callout functions that want to cause pcre2_match() or\npcre2_callout_enumerate() to return a distinctive error code. See the\npcre2callout\ndocumentation for details.\n
\n PCRE2_ERROR_DEPTHLIMIT\n\nThe nested backtracking depth limit was reached.\n
\n PCRE2_ERROR_HEAPLIMIT\n\nThe heap limit was reached.\n
\n PCRE2_ERROR_INTERNAL\n\nAn unexpected internal error has occurred. This error could be caused by a bug\nin PCRE2 or by overwriting of the compiled pattern.\n
\n PCRE2_ERROR_JIT_STACKLIMIT\n\nThis error is returned when a pattern that was successfully studied using JIT\nis being matched, but the memory available for the just-in-time processing\nstack is not large enough. See the\npcre2jit\ndocumentation for more details.\n
\n PCRE2_ERROR_MATCHLIMIT\n\nThe backtracking match limit was reached.\n
\n PCRE2_ERROR_NOMEMORY\n\nHeap memory is used to remember backtracking points. This error is given when\nthe memory allocation function (default or custom) fails. Note that a different\nerror, PCRE2_ERROR_HEAPLIMIT, is given if the amount of memory needed exceeds\nthe heap limit. PCRE2_ERROR_NOMEMORY is also returned if\nPCRE2_COPY_MATCHED_SUBJECT is set and memory allocation fails.\n
\n PCRE2_ERROR_NULL\n\nEither the code, subject, or match_data argument was passed\nas NULL.\n
\n PCRE2_ERROR_RECURSELOOP\n\nThis error is returned when pcre2_match() detects a recursion loop within\nthe pattern. Specifically, it means that either the whole pattern or a\ncapture group has been called recursively for the second time at the same\nposition in the subject string. Some simple patterns that might do this are\ndetected and faulted at compile time, but more complicated cases, in particular\nmutual recursions between two different groups, cannot be detected until\nmatching is attempted.\n\n
OBTAINING A TEXTUAL ERROR MESSAGE
\n\nint pcre2_get_error_message(int errorcode, PCRE2_UCHAR *buffer,\n PCRE2_SIZE bufflen);\n
\n\nA text message for an error code from any PCRE2 function (compile, match, or\nauxiliary) can be obtained by calling pcre2_get_error_message(). The code\nis passed as the first argument, with the remaining two arguments specifying a\ncode unit buffer and its length in code units, into which the text message is\nplaced. The message is returned in code units of the appropriate width for the\nlibrary that is being used.\n
\n\nThe returned message is terminated with a trailing zero, and the function\nreturns the number of code units used, excluding the trailing zero. If the\nerror number is unknown, the negative error code PCRE2_ERROR_BADDATA is\nreturned. If the buffer is too small, the message is truncated (but still with\na trailing zero), and the negative error code PCRE2_ERROR_NOMEMORY is returned.\nNone of the messages is very long; a buffer size of 120 code units is ample.\n
\nITERATING OVER ALL MATCHES
\n\nint pcre2_next_match(pcre2_match_data *match_data,\n PCRE2_SIZE *pstart_offset, uint32_t *poptions);\n
\n\nA common task for applications is to implement \"global\" matching behaviour,\nfor example, replacing all matches in the subject; splitting the subject on all\nmatches; or simply counting the number of matches. The pcre2_next_match()\nfunction helps with this task by providing the appropriate parameters for the\nnext match attempt (available since PCRE2 10.47).\n
\n\nFirst, a match attempt should be made using one of the matching functions\n(pcre2_match(), pcre2_dfa_match(), or pcre2_jit_match()).\nThen, pcre2_next_match() can be called, providing the same\nmatch_data parameter.\n
\n\nIt returns 0 (\"false\") if there is no need to make a further match attempt, or\n1 (\"true\") if another match should be attempted. Returning 1 does not imply that\nthere is another match, only that another match should be attempted (which may\nreturn PCRE2_ERROR_NOMATCH).\n
\n\nThe *pstart_offset and *poptions are set if the function returns 1.\nThe *pstart_offset should be passed to the next match attempt directly,\nand the *poptions should be passed to the next match attempt by combining\nwith the application's match options using OR.\n
\n\nThere is some code that demonstrates how to do this in the\npcre2demo\nsample program. The general pattern is:\n
\n
\n
\n uint32_t app_options = ...;\n uint32_t global_options = 0;\n PCRE2_SIZE start_offset = 0;\n while (1)\n {\n int rc = pcre2_match(re, subject, subject_len, start_offset,\n app_options | global_options, match_data,\n match_context);\n\n if (rc == PCRE2_ERROR_NOMATCH) break; /* no match, and no more attempts */\n if (rc < 0) { ... exit }\n\n ...handle the match\n\n if (!pcre2_next_match(match_data, &start_offset, &global_options))\n break; /* no more attempts */\n }\n\n\n\nThe guarantees provided by pcre2_next_match() are that the start_offset\nwill advance, so the loop will definitely terminate. The conditions which\nensure this are that either: (a) pcre2_next_match() returns 0 (false); or\n(b) the returned *pstart_offset is strictly greater than the previous\nstart_offset; or (c) if the previous match was a successful match of the empty\nstring then the returned *pstart_offset is equal to the previous\novector[1], and *poptions will be set to PCRE2_NOTEMPTY_ATSTART to prevent\nanother empty match from being returned.\n
\n\nA loop implemented as shown above will always terminate, unless there is a bug\nin PCRE2. As a measure of \"defensive programming\", applications are encouraged\nto add an assertion or check to break their loop if it does not make progress\n(and report the issue as a bug).\n
\n\nIf an application does not use the flag PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK, then\neach match is \"well-behaved\" and satisfies:\n
\n start_offset <= ovector[0] <= ovector[1].\n\nIn this case, the matches found by pcre2_match() with pcre2_next_match() will be\nsorted, non-overlapping (possibly touching), and with no duplicates.\n\n
\nOtherwise, if PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK is used, then the guarantees are\nconsiderably weaker. We do not guarantee that the matches will always advance:\nonly that the start_offset will. The matches found by pcre2_match() with\npcre2_next_match() will be a finite sequence (as pcre2_next_match() ensures that\nstart_offset advances, so the search will terminate). The matches can however be\noverlapping, can contain duplicates, and (in truly pathological examples) may\nnot even be sorted by ovector[0]. Additionally, each match itself can end before\nit starts (ovector[1] < ovector[0]). We recommend that applications do not set\nPCRE2_EXTRA_ALLOW_LOOKAROUND_BSK.\n
\nEXTRACTING CAPTURED SUBSTRINGS BY NUMBER
\n\nint pcre2_substring_length_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_SIZE *length);\n
\n
\nint pcre2_substring_copy_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR *buffer,\n PCRE2_SIZE *bufflen);\n
\n
\nint pcre2_substring_get_bynumber(pcre2_match_data *match_data,\n uint32_t number, PCRE2_UCHAR **bufferptr,\n PCRE2_SIZE *bufflen);\n
\n
\nvoid pcre2_substring_free(PCRE2_UCHAR *buffer);\n
\nCaptured substrings can be accessed directly by using the ovector as described\nabove.\nFor convenience, auxiliary functions are provided for extracting captured\nsubstrings as new, separate, zero-terminated strings. A substring that contains\na binary zero is correctly extracted and has a further zero added on the end,\nbut the result is not, of course, a C string.\n
\n\nThe functions in this section identify substrings by number. The number zero\nrefers to the entire matched substring, with higher numbers referring to\nsubstrings captured by parenthesized groups. After a partial match, only\nsubstring zero is available. An attempt to extract any other substring gives\nthe error PCRE2_ERROR_PARTIAL. The next section describes similar functions for\nextracting captured substrings by name.\n
\n\nIf a pattern uses the \\K escape sequence within a positive lookahead assertion,\nthe reported start of a successful match can be greater than the end of the\nmatch. For example, if the pattern (?=ab\\K) is matched against \"ab\", the start\nand end offset values for the match are 2 and 0. In this situation, calling\nthese functions with a zero substring number extracts a zero-length empty\nstring.\n
\n\nYou can find the length in code units of a captured substring without\nextracting it by calling pcre2_substring_length_bynumber(). The first\nargument is a pointer to the match data block, the second is the group number,\nand the third is a pointer to a variable into which the length is placed. If\nyou just want to know whether or not the substring has been captured, you can\npass the third argument as NULL.\n
\n\nThe pcre2_substring_copy_bynumber() function copies a captured substring\ninto a supplied buffer, whereas pcre2_substring_get_bynumber() copies it\ninto new memory, obtained using the same memory allocation function that was\nused for the match data block. The first two arguments of these functions are a\npointer to the match data block and a capture group number.\n
\n\nThe final arguments of pcre2_substring_copy_bynumber() are a pointer to\nthe buffer and a pointer to a variable that contains its length in code units.\nThis is updated to contain the actual number of code units used for the\nextracted substring, excluding the terminating zero.\n
\n\nFor pcre2_substring_get_bynumber() the third and fourth arguments point\nto variables that are updated with a pointer to the new memory and the number\nof code units that comprise the substring, again excluding the terminating\nzero. When the substring is no longer needed, the memory should be freed by\ncalling pcre2_substring_free().\n
\n\nThe return value from all these functions is zero for success, or a negative\nerror code. If the pattern match failed, the match failure code is returned.\nIf a substring number greater than zero is used after a partial match,\nPCRE2_ERROR_PARTIAL is returned. Other possible error codes are:\n
\n PCRE2_ERROR_NOMEMORY\n\nThe buffer was too small for pcre2_substring_copy_bynumber(), or the\nattempt to get memory failed for pcre2_substring_get_bynumber().\n
\n PCRE2_ERROR_NOSUBSTRING\n\nThere is no substring with that number in the pattern, that is, the number is\ngreater than the number of capturing parentheses.\n
\n PCRE2_ERROR_UNAVAILABLE\n\nThe substring number, though not greater than the number of captures in the\npattern, is greater than the number of slots in the ovector, so the substring\ncould not be captured.\n
\n PCRE2_ERROR_UNSET\n\nThe substring did not participate in the match. For example, if the pattern is\n(abc)|(def) and the subject is \"def\", and the ovector contains at least two\ncapturing slots, substring number 1 is unset.\n\n
EXTRACTING A LIST OF ALL CAPTURED SUBSTRINGS
\n\nint pcre2_substring_list_get(pcre2_match_data *match_data,\n PCRE2_UCHAR ***listptr, PCRE2_SIZE **lengthsptr);\n
\n
\nvoid pcre2_substring_list_free(PCRE2_UCHAR **list);\n
\nThe pcre2_substring_list_get() function extracts all available substrings\nand builds a list of pointers to them. It also (optionally) builds a second\nlist that contains their lengths (in code units), excluding a terminating zero\nthat is added to each of them. All this is done in a single block of memory\nthat is obtained using the same memory allocation function that was used to get\nthe match data block.\n
\n\nThis function must be called only after a successful match. If called after a\npartial match, the error code PCRE2_ERROR_PARTIAL is returned.\n
\n\nThe address of the memory block is returned via listptr, which is also\nthe start of the list of string pointers. The end of the list is marked by a\nNULL pointer. The address of the list of lengths is returned via\nlengthsptr. If your strings do not contain binary zeros and you do not\ntherefore need the lengths, you may supply NULL as the lengthsptr\nargument to disable the creation of a list of lengths. The yield of the\nfunction is zero if all went well, or PCRE2_ERROR_NOMEMORY if the memory block\ncould not be obtained. When the list is no longer needed, it should be freed by\ncalling pcre2_substring_list_free().\n
\n\nIf this function encounters a substring that is unset, which can happen when\ncapture group number n+1 matches some part of the subject, but group\nn has not been used at all, it returns an empty string. This can be\ndistinguished from a genuine zero-length substring by inspecting the\nappropriate offset in the ovector, which contain PCRE2_UNSET for unset\nsubstrings, or by calling pcre2_substring_length_bynumber().\n
\nEXTRACTING CAPTURED SUBSTRINGS BY NAME
\n\nint pcre2_substring_number_from_name(const pcre2_code *code,\n PCRE2_SPTR name);\n
\n
\nint pcre2_substring_length_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_SIZE *length);\n
\n
\nint pcre2_substring_copy_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR *buffer, PCRE2_SIZE *bufflen);\n
\n
\nint pcre2_substring_get_byname(pcre2_match_data *match_data,\n PCRE2_SPTR name, PCRE2_UCHAR **bufferptr, PCRE2_SIZE *bufflen);\n
\n
\nvoid pcre2_substring_free(PCRE2_UCHAR *buffer);\n
\nTo extract a substring by name, you first have to find associated number.\nFor example, for this pattern:\n
\n (a+)b(?<xxx>\\d+)...\n\nthe number of the capture group called \"xxx\" is 2. If the name is known to be\nunique (PCRE2_DUPNAMES was not set), you can find the number from the name by\ncalling pcre2_substring_number_from_name(). The first argument is the\ncompiled pattern, and the second is the name. The yield of the function is the\ngroup number, PCRE2_ERROR_NOSUBSTRING if there is no group with that name, or\nPCRE2_ERROR_NOUNIQUESUBSTRING if there is more than one group with that name.\nGiven the number, you can extract the substring directly from the ovector, or\nuse one of the \"bynumber\" functions described above.\n\n
\nFor convenience, there are also \"byname\" functions that correspond to the\n\"bynumber\" functions, the only difference being that the second argument is a\nname instead of a number. If PCRE2_DUPNAMES is set and there are duplicate\nnames, these functions scan all the groups with the given name, and return the\ncaptured substring from the first named group that is set.\n
\n\nIf there are no groups with the given name, PCRE2_ERROR_NOSUBSTRING is\nreturned. If all groups with the name have numbers that are greater than the\nnumber of slots in the ovector, PCRE2_ERROR_UNAVAILABLE is returned. If there\nis at least one group with a slot in the ovector, but no group is found to be\nset, PCRE2_ERROR_UNSET is returned.\n
\n\nWarning: If the pattern uses the (?| feature to set up multiple\ncapture groups with the same number, as described in the\nsection on duplicate group numbers\nin the\npcre2pattern\npage, you cannot use names to distinguish the different capture groups, because\nnames are not included in the compiled code. The matching process uses only\nnumbers. For this reason, the use of different names for groups with the\nsame number causes an error at compile time.\n
\nCREATING A NEW STRING WITH SUBSTITUTIONS
\n\nint pcre2_substitute(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext, PCRE2_SPTR replacement,\n PCRE2_SIZE rlength, PCRE2_UCHAR *outputbuffer,\n PCRE2_SIZE *outlengthptr);\n
\n\nThis function optionally calls pcre2_match() and then makes a copy of the\nsubject string in outputbuffer, replacing parts that were matched with\nthe replacement string, whose length is supplied in rlength, which\ncan be given as PCRE2_ZERO_TERMINATED for a zero-terminated string. As a\nspecial case, if replacement is NULL and rlength is zero, the\nreplacement is assumed to be an empty string. If rlength is non-zero, an\nerror occurs if replacement is NULL.\n
\n\nThere is an option (see PCRE2_SUBSTITUTE_REPLACEMENT_ONLY below) to return just\nthe replacement string(s). The default action is to perform just one\nreplacement if the pattern matches, but there is an option that requests\nmultiple replacements (see PCRE2_SUBSTITUTE_GLOBAL below).\n
\n\nIf successful, pcre2_substitute() returns the number of substitutions\nthat were carried out. This may be zero if no match was found, and is never\ngreater than one unless PCRE2_SUBSTITUTE_GLOBAL is set. A negative value is\nreturned if an error is detected.\n
\n\nMatches in which a \\K item in a lookahead in the pattern causes the match to\nend before it starts are not supported, and give rise to an error return. For\nglobal replacements, matches in which \\K in a lookbehind causes the match to\nstart earlier than the point that was reached in the previous iteration are\nalso not supported. (These cases are only possible if the pattern was compiled\nwith the backwards-compatibility option PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK.)\n
\n\nThe first seven arguments of pcre2_substitute() are the same as for\npcre2_match(), except that the partial matching options are not\npermitted, and match_data may be passed as NULL, in which case a match\ndata block is obtained and freed within this function, using memory management\nfunctions from the match context, if provided, or else those that were used to\nallocate memory for the compiled code.\n
\n\nIf match_data is not NULL and PCRE2_SUBSTITUTE_MATCHED is not set, the\nprovided block is used for all calls to pcre2_match(), and its contents\nafterwards are the result of the final call made internally by\npcre2_substitute() to the matching function. For global changes, this will\nalways be a no-match error. The contents of the ovector within the match data\nblock may or may not have been changed.\n
\n\nAs well as the usual options for pcre2_match(), a number of additional\noptions can be set in the options argument of pcre2_substitute().\nOne such option is PCRE2_SUBSTITUTE_MATCHED. When this is set, an external\nmatch_data block must be provided, and it must have already been used for\nan external call to pcre2_match() (or pcre2_jit_match()) with the\nsame pattern, subject pointer, effective subject length, start offset, and match\noption arguments (substitute-specific options can be added to the options\nargument). If any of these parameters is changed, pcre2_substitute()\nreturns an error. The data in the match_data block (return code, offset\nvector) is used for the first substitution instead of calling\npcre2_match() from within pcre2_substitute(). This allows an\napplication to check for a match before choosing to substitute, without having\nto repeat the match.\n
\n\nIf the contents of the subject buffer are mutated in between pcre2_match()\nand a call to pcre2_substitute() with PCRE2_SUBSTITUTE_MATCHED, the\nbehaviour is unsafe; in particular, in this case, PCRE2 is unable to ensure that\nthe offsets in the ovector point to the start of characters (with UTF-encoded\ninput).\n
\n\nThe contents of the externally supplied match data block are not changed when\nPCRE2_SUBSTITUTE_MATCHED is set, and so the match block is permitted for use in\nanother call using PCRE2_SUBSTITUTE_MATCHED. If PCRE2_SUBSTITUTE_GLOBAL is also\nset, pcre2_match() is called after the first substitution to check for\nfurthe matches, but this is done using an internally obtained match data block,\nthus always leaving the external block unchanged.\n
\n\nThe code argument is not used for matching before the first substitution\nwhen PCRE2_SUBSTITUTE_MATCHED is set, but it must be provided, even when\nPCRE2_SUBSTITUTE_GLOBAL is not set, because it contains information such as the\nUTF setting and the number of capturing parentheses in the pattern.\n
\n\nWhen using PCRE2_SUBSTITUTE_MATCHED, you should not modify the subject string\nin between the prior call to pcre2_match() and pcre2_substitute(),\nas the substitution assumes that the passed-in ovector is compatible with the\nsubject string. Although PCRE2 does verify that the subject is a pointer to the\nsame buffer, it cannot in general verify whether the contents of the buffer have\nchanged. For example, if the subject buffer is mutated from one valid UTF-8\nstring to another valid string, of the same length in code units, the ovector\noffsets are no longer guaranteed to point to the start of a character. Beware\nthat with PCRE2_SUBSTITUTE_MATCHED in UTF mode, the subject string is not\nre-scanned for UTF validity when pcre2_substitute() first uses it.\n
\n\nThe default action of pcre2_substitute() is to return a copy of the\nsubject string with matched substrings replaced. However, if\nPCRE2_SUBSTITUTE_REPLACEMENT_ONLY is set, only the replacement substrings are\nreturned. In the global case, multiple replacements are concatenated in the\noutput buffer. Substitution callouts (see\nbelow)\ncan be used to separate them if necessary.\n
\n\nPartial matching is supported, with limitations: if matching succeeds but with a\npartial match, then pcre2_substitute returns PCRE2_ERROR_PARTIAL. When\npartial-matching (either of PCRE2_PARTIAL_HARD or PCRE2_PARTIAL_SOFT is passed),\nthen PCRE2_SUBSTITUTE_REPLACEMENT_ONLY must also be set, or else\nPCRE2_ERROR_BADOPTION is returned. Similarly, certain replacement items\n($' and $_) cause PCRE2_ERROR_PARTIALSUBS to be returned when partial-matching,\neven if a complete match is found.\n
\n\nThe outlengthptr argument of pcre2_substitute() must point to a\nvariable that contains the length, in code units, of the output buffer. If the\nfunction is successful, the value is updated to contain the length in code\nunits of the new string, excluding the trailing zero that is automatically\nadded.\n
\n\nIf the function is not successful, the value set via outlengthptr depends\non the type of error. For syntax errors in the replacement string, the value is\nthe offset in the replacement string where the error was detected. For other\nerrors, the value is PCRE2_UNSET by default. This includes the case of the\noutput buffer being too small, unless PCRE2_SUBSTITUTE_OVERFLOW_LENGTH is set.\n
\n\nPCRE2_SUBSTITUTE_OVERFLOW_LENGTH changes what happens when the output buffer is\ntoo small. The default action is to return PCRE2_ERROR_NOMEMORY immediately. If\nthis option is set, however, pcre2_substitute() continues to go through\nthe motions of matching and substituting (without, of course, writing anything)\nin order to compute the size of buffer that is needed, which will include the\nextra space for the terminating NUL. This value is passed back via the\noutlengthptr variable, with the result of the function still being\nPCRE2_ERROR_NOMEMORY.\n
\n\nPassing a buffer size of zero is a permitted way of finding out how much memory\nis needed for given substitution. However, this does mean that the entire\noperation is carried out twice. Depending on the application, it may be more\nefficient to allocate a large buffer and free the excess afterwards, instead of\nusing PCRE2_SUBSTITUTE_OVERFLOW_LENGTH.\n
\n\nThe replacement string, which is interpreted as a UTF string in UTF mode, is\nchecked for UTF validity unless PCRE2_NO_UTF_CHECK is set. An invalid UTF\nreplacement string causes an immediate return with the relevant UTF error code.\n
\n\nIf PCRE2_SUBSTITUTE_LITERAL is set, the replacement string is not interpreted\nin any way. By default, however, a dollar character is an escape character that\ncan specify the insertion of characters from capture groups and names from\n(*MARK) or other control verbs in the pattern. Dollar is the only escape\ncharacter (backslash is treated as literal). The following forms are\nrecognized:\n
\n $$ insert a dollar character\n $n or ${n} insert the contents of group n\n $0 or $& insert the entire matched substring\n $` insert the substring that precedes the match\n $' insert the substring that follows the match\n $_ insert the entire input string\n $+ insert the highest-numbered capture group which matched\n $*MARK or ${*MARK} insert a control verb name\n\nEither a group number or a group name can be given for n, for example $2\nor $NAME. Curly brackets are required only if the following character would be\ninterpreted as part of the number or name. The number may be zero to include\nthe entire matched string. For example, if the pattern a(b)c is matched with\n\"=abc=\" and the replacement string \"+$1$0$1+\", the result is \"=+babcb+=\".\n\n\nThe JavaScript form $<name>, where the angle brackets are part of the syntax,\nis also recognized for group names, but not for group numbers or *MARK.\n
\n\n$*MARK inserts the name from the last encountered backtracking control verb on\nthe matching path that has a name. (*MARK) must always include a name, but the\nother verbs need not. For example, in the case of (*MARK:A)(*PRUNE) the name\ninserted is \"A\", but for (*MARK:A)(*PRUNE:B) the relevant name is \"B\". This\nfacility can be used to perform simple simultaneous substitutions, as this\npcre2test example shows:\n
\n /(*MARK:pear)apple|(*MARK:orange)lemon/g,replace=${*MARK}\n apple lemon\n 2: pear orange\n\nPCRE2_SUBSTITUTE_GLOBAL causes the function to iterate over the subject string,\nreplacing every matching substring. If this option is not set, only the first\nmatching substring is replaced. The search for matches takes place in the\noriginal subject string (that is, previous replacements do not affect it).\nIteration is implemented by advancing the startoffset value for each\nsearch, which is always passed the entire subject string. If an offset limit is\nset in the match context, searching stops when that limit is reached.\n\n\nBecause global substitutions apply the pattern repeatedly to the subject string,\nand always iterate over non-overlapping matches, the substitutions done by\npcre2_substitute() do not match and substitute text inside the replacement\nstrings themselves (no recursive/iterative substitution). However, applications\ncan easily implement other alternative replacement strategies, such as\niteratively replacing, then matching and replacing on the result. The\nreplacement loop inside pcre2_substitute() is simple and can be emulated\nin client code by allocating a buffer, searching for matches in a loop, and\ncalling pcre2_substitute() with PCRE2_SUBSTITUTE_REPLACEMENT_ONLY an\nPCRE2_SUBSTITUTE_MATCHED, and without PCRE2_SUBSTITUTE_GLOBAL.\n
\n\nYou can restrict the effect of a global substitution to a portion of the\nsubject string by setting either or both of startoffset and an offset\nlimit. Here is a pcre2test example:\n
\n /B/g,replace=!,use_offset_limit\n ABC ABC ABC ABC\\=offset=3,offset_limit=12\n 2: ABC A!C A!C ABC\n\nWhen continuing with global substitutions after matching a substring with zero\nlength, an attempt to find a non-empty match at the same offset is performed.\nIf this is not successful, the offset is advanced by one character except when\nCRLF is a valid newline sequence and the next two characters are CR, LF. In\nthis case, the offset is advanced by two characters.\n\n
\nPCRE2_SUBSTITUTE_UNKNOWN_UNSET causes references to capture groups that do\nnot appear in the pattern to be treated as unset groups. This option should be\nused with care, because it means that a typo in a group name or number no\nlonger causes the PCRE2_ERROR_NOSUBSTRING error.\n
\n\nPCRE2_SUBSTITUTE_UNSET_EMPTY causes unset capture groups (including unknown\ngroups when PCRE2_SUBSTITUTE_UNKNOWN_UNSET is set) to be treated as empty\nstrings when inserted as described above. If this option is not set, an attempt\nto insert an unset group causes the PCRE2_ERROR_UNSET error. This option does\nnot influence the extended substitution syntax described below.\n
\n\nPCRE2_SUBSTITUTE_EXTENDED causes extra processing to be applied to the\nreplacement string. Without this option, only the dollar character is special,\nand only the group insertion forms listed above are valid. When\nPCRE2_SUBSTITUTE_EXTENDED is set, several things change:\n
\n\nFirstly, backslash in a replacement string is interpreted as an escape\ncharacter. The usual forms such as \\x{ddd} can be used to specify particular\ncharacter codes, and backslash followed by any non-alphanumeric character\nquotes that character. Extended quoting can be coded using \\Q...\\E, exactly\nas in pattern strings. The escapes \\b and \\v are interpreted as the\ncharacters backspace and vertical tab, respectively.\n
\n\nThe interpretation of backslash followed by one or more digits is the same as\nin a pattern, which in Perl has some ambiguities. Details are given in the\npcre2pattern\npage.\n
\n\nThe Python form \\g<n>, where the angle brackets are part of the syntax and\nn is either a group name or number, is recognized as an alternative way\nof inserting the contents of a group, for example \\g<3>.\n
\n\nThere are also four escape sequences for forcing the case of inserted letters.\nCase forcing applies to all inserted characters, including those from capture\ngroups and letters within \\Q...\\E quoted sequences. The insertion mechanism\nhas three states: no case forcing, force upper case, and force lower case. The\nescape sequences change the current state: \\U and \\L change to upper or lower\ncase forcing, respectively, and \\E (when not terminating a \\Q quoted\nsequence) reverts to no case forcing. The sequences \\u and \\l force the next\ncharacter (if it is a letter) to upper or lower case, respectively, and then\nthe state automatically reverts to no case forcing.\n
\n\nHowever, if \\u is immediately followed by \\L or \\l is immediately followed\nby \\U, the next character's case is forced by the first escape sequence, and\nsubsequent characters by the second. This provides a \"title casing\" facility\nthat can be applied to group captures. For example, if group 1 has captured\n\"heLLo\", the replacement string \"\\u\\L$1\" becomes \"Hello\".\n
\n\nIf either PCRE2_UTF or PCRE2_UCP was set when the pattern was compiled, Unicode\nproperties are used for case forcing characters whose code points are greater\nthan 127. However, only simple case folding, as determined by the Unicode file\nCaseFolding.txt is supported. PCRE2 does not support language-specific\nspecial casing rules such as using different lower case Greek sigmas in the\nmiddle and ends of words (as defined in the Unicode file\nSpecialCasing.txt).\n
\n\nNote that case forcing sequences such as \\U...\\E do not nest. For example,\nthe result of processing \"\\Uaa\\LBB\\Ecc\\E\" is \"AAbbcc\"; the final \\E has no\neffect. Note also that the PCRE2_ALT_BSUX and PCRE2_EXTRA_ALT_BSUX options do\nnot apply to replacement strings.\n
\n\nThe final effect of setting PCRE2_SUBSTITUTE_EXTENDED is to add more\nflexibility to capture group substitution. The syntax is similar to that used\nby Bash:\n
\n ${n:-string}\n ${n:+string1:string2}\n\nAs in the simple case, n may be a group number or a name. The first form\nspecifies a default value. If group n is set, its value is inserted; if\nnot, the string is expanded and the result inserted. The second form specifies\nstrings that are expanded and inserted when group n is set or unset,\nrespectively. The first form is just a convenient shorthand for\n\n ${n:+${n}:string}\n\nBackslash can be used to escape colons and closing curly brackets in the\nreplacement strings. A change of the case forcing state within a replacement\nstring remains in force afterwards, as shown in this pcre2test example:\n\n /(some)?(body)/substitute_extended,replace=${1:+\\U:\\L}HeLLo\n body\n 1: hello\n somebody\n 1: HELLO\n\nThe PCRE2_SUBSTITUTE_UNSET_EMPTY option does not affect these extended\nsubstitutions. However, PCRE2_SUBSTITUTE_UNKNOWN_UNSET does cause unknown\ngroups in the extended syntax forms to be treated as unset.\n\n\nIf PCRE2_SUBSTITUTE_LITERAL is set, PCRE2_SUBSTITUTE_UNKNOWN_UNSET,\nPCRE2_SUBSTITUTE_UNSET_EMPTY, and PCRE2_SUBSTITUTE_EXTENDED are irrelevant and\nare ignored.\n
\n\nSubstitution errors\n
\n\nIn the event of an error, pcre2_substitute() returns a negative error\ncode. Except for PCRE2_ERROR_NOMATCH (which is never returned), errors from\npcre2_match() are passed straight back.\n
\n\nPCRE2_ERROR_NOSUBSTRING is returned for a non-existent substring insertion,\nunless PCRE2_SUBSTITUTE_UNKNOWN_UNSET is set.\n
\n\nPCRE2_ERROR_UNSET is returned for an unset substring insertion (including an\nunknown substring when PCRE2_SUBSTITUTE_UNKNOWN_UNSET is set) when the simple\n(non-extended) syntax is used and PCRE2_SUBSTITUTE_UNSET_EMPTY is not set.\n
\n\nPCRE2_ERROR_NOMEMORY is returned if the output buffer is not big enough. If the\nPCRE2_SUBSTITUTE_OVERFLOW_LENGTH option is set, the size of buffer that is\nneeded is returned via outlengthptr. Note that this does not happen by\ndefault.\n
\n\nPCRE2_ERROR_NULL is returned if PCRE2_SUBSTITUTE_MATCHED is set but the\nmatch_data argument is NULL or if the subject or replacement\narguments are NULL. For backward compatibility reasons an exception is made for\nthe replacement argument if the rlength argument is also 0.\n
\n\nPCRE2_ERROR_BADREPLACEMENT is used for miscellaneous syntax errors in the\nreplacement string, with more particular errors being PCRE2_ERROR_BADREPESCAPE\n(invalid escape sequence), PCRE2_ERROR_REPMISSINGBRACE (closing curly bracket\nnot found), PCRE2_ERROR_BADSUBSTITUTION (syntax error in extended group\nsubstitution), and PCRE2_ERROR_BADSUBSPATTERN (the pattern match ended before\nit started or the match started earlier than the current position in the\nsubject, which can happen if \\K is used in a lookaround assertion).\n
\n\nAs for all PCRE2 errors, a text message that describes the error can be\nobtained by calling the pcre2_get_error_message() function (see\n\"Obtaining a textual error message\"\nabove).\n
\n\nSubstitution callouts\n
\n\nint pcre2_set_substitute_callout(pcre2_match_context *mcontext,\n int (*callout_function)(pcre2_substitute_callout_block *, void *),\n void *callout_data);\n
\n
\nThe pcre2_set_substitute_callout() function can be used to specify a\ncallout function for pcre2_substitute(). This information is passed in\na match context. The callout function is called after each substitution has\nbeen processed, but it can cause the replacement not to happen.\n
\nThe callout function is not called for simulated substitutions that happen as a\nresult of the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH option. In this mode, when\nsubstitution processing exceeds the buffer space provided by the caller,\nprocessing continues by counting code units. The simulation is unable to\npopulate the callout block, and so the simulation is pessimistic about the\nrequired buffer size. Whichever is larger of accepted or rejected substitution\nis reported as the required size. Therefore, the returned buffer length may be\nan overestimate (without a substitution callout, it is normally an exact\nmeasurement).\n
\n\nThe first argument of the callout function is a pointer to a substitute callout\nblock structure, which contains the following fields, not necessarily in this\norder:\n
\n uint32_t version;\n uint32_t subscount;\n PCRE2_SPTR input;\n PCRE2_SPTR output;\n PCRE2_SIZE *ovector;\n uint32_t oveccount;\n PCRE2_SIZE output_offsets[2];\n\nThe version field contains the version number of the block format. The\ncurrent version is 0. The version number will increase in future if more fields\nare added, but the intention is never to remove any of the existing fields.\n\n
\nThe subscount field is the number of the current match. It is 1 for the\nfirst callout, 2 for the second, and so on. The input and output\npointers are copies of the values passed to pcre2_substitute().\n
\n\nThe ovector field points to the ovector, which contains the result of the\nmost recent match. The oveccount field contains the number of pairs that\nare set in the ovector, and is always greater than zero.\n
\n\nThe output_offsets vector contains the offsets of the replacement in the\noutput string. This has already been processed for dollar and (if requested)\nbackslash substitutions as described above.\n
\n\nThe second argument of the callout function is the value passed as\ncallout_data when the function was registered. The value returned by the\ncallout function is interpreted as follows:\n
\n\nIf the value is zero, the replacement is accepted, and, if\nPCRE2_SUBSTITUTE_GLOBAL is set, processing continues with a search for the next\nmatch. If the value is not zero, the current replacement is not accepted. If\nthe value is greater than zero, processing continues when\nPCRE2_SUBSTITUTE_GLOBAL is set. Otherwise (the value is less than zero or\nPCRE2_SUBSTITUTE_GLOBAL is not set), the rest of the input is copied to the\noutput and the call to pcre2_substitute() exits, returning the number of\nmatches so far.\n
\n\nSubstitution case callouts\n
\n\nint pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,\n PCRE2_SIZE (*callout_function)(PCRE2_SPTR, PCRE2_SIZE,\n PCRE2_UCHAR *, PCRE2_SIZE,\n int, void *),\n void *callout_data);\n
\n
\nThe pcre2_set_substitute_case_callout() function can be used to specify\na callout function for pcre2_substitute() to use when performing case\ntransformations. This does not affect any case insensitivity behaviour when\nperforming a match, but only the user-visible transformations performed when\nprocessing a substitution such as:\n
\n pcre2_substitute(..., \"\\\\U$1\", ...)\n\n\n
\nThe default case transformations applied by PCRE2 are reasonably complete, and,\nin UTF or UCP mode, perform the simple locale-invariant case transformations as\nspecified by Unicode. This is suitable for the internal (invisible)\ncase-equivalence procedures used during pattern matching, but an application\nmay wish to use more sophisticated locale-aware processing for the user-visible\nsubstitution transformations.\n
\n\nOne example implementation of the callout_function using the ICU\nlibrary would be:\n
\n
\n
\n PCRE2_SIZE\n icu_case_callout(\n PCRE2_SPTR input, PCRE2_SIZE input_len,\n PCRE2_UCHAR *output, PCRE2_SIZE output_cap,\n int to_case, void *data_ptr)\n {\n UErrorCode err = U_ZERO_ERROR;\n int32_t r = to_case == PCRE2_SUBSTITUTE_CASE_LOWER\n ? u_strToLower(output, output_cap, input, input_len, NULL, &err)\n : to_case == PCRE2_SUBSTITUTE_CASE_UPPER\n ? u_strToUpper(output, output_cap, input, input_len, NULL, &err)\n : u_strToTitle(output, output_cap, input, input_len, &first_char_only,\n NULL, &err);\n if (U_FAILURE(err)) return (~(PCRE2_SIZE)0);\n return r;\n }\n\n\n\nThe first and second arguments of the case callout function are the Unicode\nstring to transform.\n
\n\nThe third and fourth arguments are the output buffer and its capacity.\n
\n\nThe fifth is one of the constants PCRE2_SUBSTITUTE_CASE_LOWER,\nPCRE2_SUBSTITUTE_CASE_UPPER, or PCRE2_SUBSTITUTE_CASE_TITLE_FIRST.\nPCRE2_SUBSTITUTE_CASE_LOWER and PCRE2_SUBSTITUTE_CASE_UPPER are passed to the\ncallout to indicate that the case of the entire callout input should be\ncase-transformed. PCRE2_SUBSTITUTE_CASE_TITLE_FIRST is passed to indicate that\nonly the first character or glyph should be transformed to Unicode titlecase\nand the rest to Unicode lowercase (note that titlecasing sometimes uses Unicode\nproperties to titlecase each word in a string; but PCRE2 is requesting that only\nthe single leading character is to be titlecased).\n
\n\nThe sixth argument is the callout_data supplied to\npcre2_set_substitute_case_callout().\n
\n\nThe resulting string in the destination buffer may be larger or smaller than the\ninput, if the casing rules merge or split characters. The return value is the\nlength required for the output string. If a buffer of sufficient size was\nprovided to the callout, then the result must be written to the buffer and the\nnumber of code units returned. If the result does not fit in the provided\nbuffer, then the required capacity must be returned and PCRE2 will not make use\nof the output buffer. PCRE2 provides input and output buffers which overlap, so\nthe callout must support this by suitable internal buffering.\n
\n\nAlternatively, if the callout wishes to indicate an error, then it may return\n(~(PCRE2_SIZE)0). In this case pcre2_substitute() will immediately fail with\nerror PCRE2_ERROR_REPLACECASE.\n
\n\nWhen a case callout is combined with the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH\noption, there are situations when pcre2_substitute() will return an\nunderestimate of the required buffer size. If you call pcre2_substitute() once\nwith PCRE2_SUBSTITUTE_OVERFLOW_LENGTH, and the input buffer is too small for\nthe replacement string to be constructed, then instead of calling the case\ncallout, pcre2_substitute() will make an estimate of the required buffer size.\nThe second call should also pass PCRE2_SUBSTITUTE_OVERFLOW_LENGTH, because that\nsecond call is not guaranteed to succeed either, if the case callout requires\nmore buffer space than expected. The caller must make repeated attempts in a\nloop.\n
\nDUPLICATE CAPTURE GROUP NAMES
\n\nint pcre2_substring_nametable_scan(const pcre2_code *code,\n PCRE2_SPTR name, PCRE2_SPTR *first, PCRE2_SPTR *last);\n
\n\nWhen a pattern is compiled with the PCRE2_DUPNAMES option, names for capture\ngroups are not required to be unique. Duplicate names are always allowed for\ngroups with the same number, created by using the (?| feature. Indeed, if such\ngroups are named, they are required to use the same names.\n
\n\nNormally, patterns that use duplicate names are such that in any one match,\nonly one of each set of identically-named groups participates. An example is\nshown in the\npcre2pattern\ndocumentation.\n
\n\nWhen duplicates are present, pcre2_substring_copy_byname() and\npcre2_substring_get_byname() return the first substring corresponding to\nthe given name that is set. Only if none are set is PCRE2_ERROR_UNSET is\nreturned. The pcre2_substring_number_from_name() function returns the\nerror PCRE2_ERROR_NOUNIQUESUBSTRING when there are duplicate names.\n
\n\nIf you want to get full details of all captured substrings for a given name,\nyou must use the pcre2_substring_nametable_scan() function. The first\nargument is the compiled pattern, and the second is the name. If the third and\nfourth arguments are NULL, the function returns a group number for a unique\nname, or PCRE2_ERROR_NOUNIQUESUBSTRING otherwise.\n
\n\nWhen the third and fourth arguments are not NULL, they must be pointers to\nvariables that are updated by the function. After it has run, they point to the\nfirst and last entries in the name-to-number table for the given name, and the\nfunction returns the length of each entry in code units. In both cases,\nPCRE2_ERROR_NOSUBSTRING is returned if there are no entries for the given name.\n
\n\nThe format of the name table is described\nabove\nin the section entitled Information about a pattern. Given all the\nrelevant entries for the name, you can extract each of their numbers, and hence\nthe captured data.\n
\nFINDING ALL POSSIBLE MATCHES AT ONE POSITION
\n\nThe traditional matching function uses a similar algorithm to Perl, which stops\nwhen it finds the first match at a given point in the subject. If you want to\nfind all possible matches, or the longest possible match at a given position,\nconsider using the alternative matching function (see below) instead. If you\ncannot use the alternative function, you can kludge it up by making use of the\ncallout facility, which is described in the\npcre2callout\ndocumentation.\n
\n\nWhat you have to do is to insert a callout right at the end of the pattern.\nWhen your callout function is called, extract and save the current matched\nsubstring. Then return 1, which forces pcre2_match() to backtrack and try\nother alternatives. Ultimately, when it runs out of matches,\npcre2_match() will yield PCRE2_ERROR_NOMATCH.\n
\nMATCHING A PATTERN: THE ALTERNATIVE FUNCTION
\n\nint pcre2_dfa_match(const pcre2_code *code, PCRE2_SPTR subject,\n PCRE2_SIZE length, PCRE2_SIZE startoffset,\n uint32_t options, pcre2_match_data *match_data,\n pcre2_match_context *mcontext,\n int *workspace, PCRE2_SIZE wscount);\n
\n\nThe function pcre2_dfa_match() is called to match a subject string\nagainst a compiled pattern, using a matching algorithm that scans the subject\nstring just once (not counting lookaround assertions), and does not backtrack\n(except when processing lookaround assertions). This has different\ncharacteristics to the normal algorithm, and is not compatible with Perl. Some\nof the features of PCRE2 patterns are not supported. Nevertheless, there are\ntimes when this kind of matching can be useful. For a discussion of the two\nmatching algorithms, and a list of features that pcre2_dfa_match() does\nnot support, see the\npcre2matching\ndocumentation.\n
\n\nThe arguments for the pcre2_dfa_match() function are the same as for\npcre2_match(), plus two extras. The ovector within the match data block\nis used in a different way, and this is described below. The other common\narguments are used in the same way as for pcre2_match(), so their\ndescription is not repeated here.\n
\n\nThe two additional arguments provide workspace for the function. The workspace\nvector should contain at least 20 elements. It is used for keeping track of\nmultiple paths through the pattern tree. More workspace is needed for patterns\nand subjects where there are a lot of potential matches.\n
\n\nHere is an example of a simple call to pcre2_dfa_match():\n
\n int wspace[20];\n pcre2_match_data *md = pcre2_match_data_create(4, NULL);\n int rc = pcre2_dfa_match(\n re, /* result of pcre2_compile() */\n \"some string\", /* the subject string */\n 11, /* the length of the subject string */\n 0, /* start at offset 0 in the subject */\n 0, /* default options */\n md, /* the match data block */\n NULL, /* a match context; NULL means use defaults */\n wspace, /* working space vector */\n 20); /* number of elements (NOT size in bytes) */\n\n\n
\nOption bits for pcre2_dfa_match()\n
\n\nThe unused bits of the options argument for pcre2_dfa_match() must\nbe zero. The only bits that may be set are PCRE2_ANCHORED,\nPCRE2_COPY_MATCHED_SUBJECT, PCRE2_ENDANCHORED, PCRE2_NOTBOL, PCRE2_NOTEOL,\nPCRE2_NOTEMPTY, PCRE2_NOTEMPTY_ATSTART, PCRE2_NO_UTF_CHECK, PCRE2_PARTIAL_HARD,\nPCRE2_PARTIAL_SOFT, PCRE2_DFA_SHORTEST, and PCRE2_DFA_RESTART. All but the last\nfour of these are exactly the same as for pcre2_match(), so their\ndescription is not repeated here.\n
\n PCRE2_PARTIAL_HARD\n PCRE2_PARTIAL_SOFT\n\nThese have the same general effect as they do for pcre2_match(), but the\ndetails are slightly different. When PCRE2_PARTIAL_HARD is set for\npcre2_dfa_match(), it returns PCRE2_ERROR_PARTIAL if the end of the\nsubject is reached and there is still at least one matching possibility that\nrequires additional characters. This happens even if some complete matches have\nalready been found. When PCRE2_PARTIAL_SOFT is set, the return code\nPCRE2_ERROR_NOMATCH is converted into PCRE2_ERROR_PARTIAL if the end of the\nsubject is reached, there have been no complete matches, but there is still at\nleast one matching possibility. The portion of the string that was inspected\nwhen the longest partial match was found is set as the first matching string in\nboth cases. There is a more detailed discussion of partial and multi-segment\nmatching, with examples, in the\npcre2partial\ndocumentation.\n
\n PCRE2_DFA_SHORTEST\n\nSetting the PCRE2_DFA_SHORTEST option causes the matching algorithm to stop as\nsoon as it has found one match. Because of the way the alternative algorithm\nworks, this is necessarily the shortest possible match at the first possible\nmatching point in the subject string.\n
\n PCRE2_DFA_RESTART\n\nWhen pcre2_dfa_match() returns a partial match, it is possible to call it\nagain, with additional subject characters, and have it continue with the same\nmatch. The PCRE2_DFA_RESTART option requests this action; when it is set, the\nworkspace and wscount options must reference the same vector as\nbefore because data about the match so far is left in them after a partial\nmatch. There is more discussion of this facility in the\npcre2partial\ndocumentation.\n\n
\nSuccessful returns from pcre2_dfa_match()\n
\n\nWhen pcre2_dfa_match() succeeds, it may have matched more than one\nsubstring in the subject. Note, however, that all the matches from one run of\nthe function start at the same point in the subject. The shorter matches are\nall initial substrings of the longer matches. For example, if the pattern\n
\n <.*>\n\nis matched against the string\n
\n This is <something> <something else> <something further> no more\n\nthe three matched strings are\n
\n <something> <something else> <something further>\n <something> <something else>\n <something>\n\nOn success, the yield of the function is a number greater than zero, which is\nthe number of matched substrings. The offsets of the substrings are returned in\nthe ovector, and can be extracted by number in the same way as for\npcre2_match(), but the numbers bear no relation to any capture groups\nthat may exist in the pattern, because DFA matching does not support capturing.\n\n
\nCalls to the convenience functions that extract substrings by name\nreturn the error PCRE2_ERROR_DFA_UFUNC (unsupported function) if used after a\nDFA match. The convenience functions that extract substrings by number never\nreturn PCRE2_ERROR_NOSUBSTRING.\n
\n\nThe matched strings are stored in the ovector in reverse order of length; that\nis, the longest matching string is first. If there were too many matches to fit\ninto the ovector, the yield of the function is zero, and the vector is filled\nwith the longest matches.\n
\n\nNOTE: PCRE2's \"auto-possessification\" optimization usually applies to character\nrepeats at the end of a pattern (as well as internally). For example, the\npattern \"a\\d+\" is compiled as if it were \"a\\d++\". For DFA matching, this\nmeans that only one possible match is found. If you really do want multiple\nmatches in such cases, either use an ungreedy repeat such as \"a\\d+?\" or set\nthe PCRE2_NO_AUTO_POSSESS option when compiling.\n
\n\nError returns from pcre2_dfa_match()\n
\n\nThe pcre2_dfa_match() function returns a negative number when it fails.\nMany of the errors are the same as for pcre2_match(), as described\nabove.\nThere are in addition the following errors that are specific to\npcre2_dfa_match():\n
\n PCRE2_ERROR_DFA_UITEM\n\nThis return is given if pcre2_dfa_match() encounters an item in the\npattern that it does not support, for instance, the use of \\C in a UTF mode or\na backreference.\n
\n PCRE2_ERROR_DFA_UCOND\n\nThis return is given if pcre2_dfa_match() encounters a condition item\nthat uses a backreference for the condition, or a test for recursion in a\nspecific capture group. These are not supported.\n
\n PCRE2_ERROR_DFA_UINVALID_UTF\n\nThis return is given if pcre2_dfa_match() is called for a pattern that\nwas compiled with PCRE2_MATCH_INVALID_UTF. This is not supported for DFA\nmatching.\n
\n PCRE2_ERROR_DFA_WSSIZE\n\nThis return is given if pcre2_dfa_match() runs out of space in the\nworkspace vector.\n
\n PCRE2_ERROR_DFA_RECURSE\n\nWhen a recursion or subroutine call is processed, the matching function calls\nitself recursively, using private memory for the ovector and workspace.\nThis error is given if the internal ovector is not large enough. This should be\nextremely rare, as a vector of size 1000 is used.\n
\n PCRE2_ERROR_DFA_BADRESTART\n\nWhen pcre2_dfa_match() is called with the PCRE2_DFA_RESTART option,\nsome plausibility checks are made on the contents of the workspace, which\nshould contain data about the previous partial match. If any of these checks\nfail, this error is given.\n\n
SEE ALSO
\n\npcre2build(3), pcre2callout(3), pcre2demo(3),\npcre2matching(3), pcre2partial(3), pcre2posix(3),\npcre2sample(3), pcre2unicode(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 29 October 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2build.html", "content": "\n\npcre2build man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- BUILDING PCRE2\n
- PCRE2 BUILD-TIME OPTIONS\n
- BUILDING 8-BIT, 16-BIT AND 32-BIT LIBRARIES\n
- BUILDING SHARED AND STATIC LIBRARIES\n
- UNICODE AND UTF SUPPORT\n
- DISABLING THE USE OF \\C\n
- JUST-IN-TIME COMPILER SUPPORT\n
- NEWLINE RECOGNITION\n
- WHAT \\R MATCHES\n
- HANDLING VERY LARGE PATTERNS\n
- LIMITING PCRE2 RESOURCE USAGE\n
- LIMITING VARIABLE-LENGTH LOOKBEHIND ASSERTIONS\n
- CREATING CHARACTER TABLES AT BUILD TIME\n
- USING EBCDIC CODE\n
- PCRE2GREP SUPPORT FOR EXTERNAL SCRIPTS\n
- PCRE2GREP OPTIONS FOR COMPRESSED FILE SUPPORT\n
- PCRE2GREP BUFFER SIZE\n
- PCRE2TEST OPTION FOR LIBREADLINE SUPPORT\n
- INCLUDING DEBUGGING CODE\n
- DEBUGGING WITH VALGRIND SUPPORT\n
- CODE COVERAGE REPORTING\n
- DISABLING THE Z AND T FORMATTING MODIFIERS\n
- SUPPORT FOR FUZZERS\n
- OBSOLETE OPTION\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
BUILDING PCRE2
\n\nPCRE2 is distributed with a configure script that can be used to build\nthe library in Unix-like environments using the Autotools applications. Also in\nthe distribution are files to support building using CMake instead of\nconfigure. The text file\nREADME\ncontains general information about building with Autotools (some of which is\nrepeated below), and also has some comments about building on various operating\nsystems. The files in the vms directory support building under OpenVMS.\nThere is a lot more information about building PCRE2 without using\nAutotools (including information about using CMake and building \"by\nhand\") in the text file called\nNON-AUTOTOOLS-BUILD.\nYou should consult this file as well as the\nREADME\nfile if you are building in a non-Unix-like environment.\n
\nPCRE2 BUILD-TIME OPTIONS
\n\nThe rest of this document describes the optional features of PCRE2 that can be\nselected when the library is compiled. It assumes use of the configure\nscript, where the optional features are selected or deselected by providing\noptions to configure before running the make command. However, the\nsame options can be selected in both Unix-like and non-Unix-like environments\nif you are using CMake instead of configure to build PCRE2.\n
\n\nIf you are not using Autotools or CMake, option selection can be done by\nediting the config.h file, or by passing parameter settings to the\ncompiler, as described in\nNON-AUTOTOOLS-BUILD.\n
\n\nThe complete list of options for configure (which includes the standard\nones such as the selection of the installation directory) can be obtained by\nrunning\n
\n ./configure --help\n\nThe following sections include descriptions of \"on/off\" options whose names\nbegin with --enable or --disable. Because of the way that configure\nworks, --enable and --disable always come in pairs, so the complementary option\nalways exists as well, but as it specifies the default, it is not described.\nOptions that specify values have names that start with --with. At the end of a\nconfigure run, a summary of the configuration is output.\n\n
BUILDING 8-BIT, 16-BIT AND 32-BIT LIBRARIES
\n\nBy default, a library called libpcre2-8 is built, containing functions\nthat take string arguments contained in arrays of bytes, interpreted either as\nsingle-byte characters, or UTF-8 strings. You can also build two other\nlibraries, called libpcre2-16 and libpcre2-32, which process\nstrings that are contained in arrays of 16-bit and 32-bit code units,\nrespectively. These can be interpreted either as single-unit characters or\nUTF-16/UTF-32 strings. To build these additional libraries, add one or both of\nthe following to the configure command:\n
\n --enable-pcre2-16\n --enable-pcre2-32\n\nIf you do not want the 8-bit library, add\n
\n --disable-pcre2-8\n\nas well. At least one of the three libraries must be built. Note that the POSIX\nwrapper is for the 8-bit library only, and that pcre2grep is an 8-bit\nprogram. Neither of these are built if you select only the 16-bit or 32-bit\nlibraries.\n\n
BUILDING SHARED AND STATIC LIBRARIES
\n\nThe Autotools PCRE2 building process uses libtool to build both shared\nand static libraries by default. You can suppress an unwanted library by adding\none of\n
\n --disable-shared\n --disable-static\n\nto the configure command. Setting --disable-shared ensures that PCRE2\nlibraries are built as static libraries. The binaries that are then created as\npart of the build process (for example, pcre2test and pcre2grep)\nare linked statically with one or more PCRE2 libraries, but may also be\ndynamically linked with other libraries such as libc. If you want these\nbinaries to be fully statically linked, you can set LDFLAGS like this:\n
\n
\nLDFLAGS=--static ./configure --disable-shared\n
\n
\nNote the two hyphens in --static. Of course, this works only if static versions\nof all the relevant libraries are available for linking.\n\n
UNICODE AND UTF SUPPORT
\n\nBy default, PCRE2 is built with support for Unicode and UTF character strings.\nTo build it without Unicode support, add\n
\n --disable-unicode\n\nto the configure command. This setting applies to all three libraries. It\nis not possible to build one library with Unicode support and another without\nin the same configuration.\n\n
\nOf itself, Unicode support does not make PCRE2 treat strings as UTF-8, UTF-16\nor UTF-32. To do that, applications that use the library can set the PCRE2_UTF\noption when they call pcre2_compile() to compile a pattern.\nAlternatively, patterns may be started with (*UTF) unless the application has\nlocked this out by setting PCRE2_NEVER_UTF.\n
\n\nUTF support allows the libraries to process character code points up to\n0x10ffff in the strings that they handle. Unicode support also gives access to\nthe Unicode properties of characters, using pattern escapes such as \\P, \\p,\nand \\X. Only the general category properties such as Lu and Nd,\nscript names, and some bi-directional and binary properties are supported.\nDetails are given in the\npcre2pattern\ndocumentation.\n
\n\nPattern escapes such as \\d and \\w do not by default make use of Unicode\nproperties. The application can request that they do by setting the PCRE2_UCP\noption. Unless the application has set PCRE2_NEVER_UCP, a pattern may also\nrequest this by starting with (*UCP).\n
\nDISABLING THE USE OF \\C
\n\nThe \\C escape sequence, which matches a single code unit, even in a UTF mode,\ncan cause unpredictable behaviour because it may leave the current matching\npoint in the middle of a multi-code-unit character. The application can lock\nit out by setting the PCRE2_NEVER_BACKSLASH_C option when calling\npcre2_compile(). There is also a build-time option\n
\n --enable-never-backslash-C\n\n(note the upper case C) which locks out the use of \\C entirely.\n\n
JUST-IN-TIME COMPILER SUPPORT
\n\nJust-in-time (JIT) compiler support is included in the build by specifying\n
\n --enable-jit\n\nThis support is available only for certain hardware architectures. If this\noption is set for an unsupported architecture, a building error occurs.\nIf in doubt, use\n
\n --enable-jit=auto\n\nwhich enables JIT only if the current hardware is supported. You can check\nif JIT is enabled in the configuration summary that is output at the end of a\nconfigure run. If you are enabling JIT under SELinux you may also want to\nadd\n
\n --enable-jit-sealloc\n\nwhich enables the use of an execmem allocator in JIT that is compatible with\nSELinux. This has no effect if JIT is not enabled. See the\npcre2jit\ndocumentation for a discussion of JIT usage. When JIT support is enabled,\npcre2grep automatically makes use of it, unless you add\n
\n --disable-pcre2grep-jit\n\nto the configure command.\n\n
NEWLINE RECOGNITION
\n\nBy default, PCRE2 interprets the linefeed (LF) character as indicating the end\nof a line. This is the normal newline character on Unix-like systems. You can\ncompile PCRE2 to use carriage return (CR) instead, by adding\n
\n --enable-newline-is-cr\n\nto the configure command. There is also an --enable-newline-is-lf option,\nwhich explicitly specifies linefeed as the newline character.\n\n
\nAlternatively, you can specify that line endings are to be indicated by the\ntwo-character sequence CRLF (CR immediately followed by LF). If you want this,\nadd\n
\n --enable-newline-is-crlf\n\nto the configure command. There is a fourth option, specified by\n
\n --enable-newline-is-anycrlf\n\nwhich causes PCRE2 to recognize any of the three sequences CR, LF, or CRLF as\nindicating a line ending. A fifth option, specified by\n
\n --enable-newline-is-any\n\ncauses PCRE2 to recognize any Unicode newline sequence. The Unicode newline\nsequences are the three just mentioned, plus the single characters VT (vertical\ntab, U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line\nseparator, U+2028), and PS (paragraph separator, U+2029). The final option is\n
\n --enable-newline-is-nul\n\nwhich causes NUL (binary zero) to be set as the default line-ending character.\n\n
\nWhatever default line ending convention is selected when PCRE2 is built can be\noverridden by applications that use the library. At build time it is\nrecommended to use the standard for your operating system.\n
\nWHAT \\R MATCHES
\n\nBy default, the sequence \\R in a pattern matches any Unicode newline sequence,\nindependently of what has been selected as the line ending sequence. If you\nspecify\n
\n --enable-bsr-anycrlf\n\nthe default is changed so that \\R matches only CR, LF, or CRLF. Whatever is\nselected when PCRE2 is built can be overridden by applications that use the\nlibrary.\n\n
HANDLING VERY LARGE PATTERNS
\n\nWithin a compiled pattern, offset values are used to point from one part to\nanother (for example, from an opening parenthesis to an alternation\nmetacharacter). By default, in the 8-bit and 16-bit libraries, two-byte values\nare used for these offsets, leading to a maximum size for a compiled pattern of\naround 64 thousand code units. This is sufficient to handle all but the most\ngigantic patterns. Nevertheless, some people do want to process truly enormous\npatterns, so it is possible to compile PCRE2 to use three-byte or four-byte\noffsets by adding a setting such as\n
\n --with-link-size=3\n\nto the configure command. The value given must be 2, 3, or 4. For the\n16-bit library, a value of 3 is rounded up to 4. In these libraries, using\nlonger offsets slows down the operation of PCRE2 because it has to load\nadditional data when handling them. For the 32-bit library the value is always\n4 and cannot be overridden; the value of --with-link-size is ignored.\n\n
LIMITING PCRE2 RESOURCE USAGE
\n\nThe pcre2_match() function increments a counter each time it goes round\nits main loop. Putting a limit on this counter controls the amount of computing\nresource used by a single call to pcre2_match(). The limit can be changed\nat run time, as described in the\npcre2api\ndocumentation. The default is 10 million, but this can be changed by adding a\nsetting such as\n
\n --with-match-limit=500000\n\nto the configure command. This setting also applies to the\npcre2_dfa_match() matching function, and to JIT matching (though the\ncounting is done differently).\n\n
\nThe pcre2_match() function uses heap memory to record backtracking\npoints. The more nested backtracking points there are (that is, the deeper the\nsearch tree), the more memory is needed. There is an upper limit, specified in\nkibibytes (units of 1024 bytes). This limit can be changed at run time, as\ndescribed in the\npcre2api\ndocumentation. The default limit (in effect unlimited) is 20 million. You can\nchange this by a setting such as\n
\n --with-heap-limit=500\n\nwhich limits the amount of heap to 500 KiB. This limit applies only to\ninterpretive matching in pcre2_match() and pcre2_dfa_match(), which\nmay also use the heap for internal workspace when processing complicated\npatterns. This limit does not apply when JIT (which has its own memory\narrangements) is used.\n\n
\nYou can also explicitly limit the depth of nested backtracking in the\npcre2_match() interpreter. This limit defaults to the value that is set\nfor --with-match-limit. You can set a lower default limit by adding, for\nexample,\n
\n --with-match-limit-depth=10000\n\nto the configure command. This value can be overridden at run time. This\ndepth limit indirectly limits the amount of heap memory that is used, but\nbecause the size of each backtracking \"frame\" depends on the number of\ncapturing parentheses in a pattern, the amount of heap that is used before the\nlimit is reached varies from pattern to pattern. This limit was more useful in\nversions before 10.30, where function recursion was used for backtracking.\n\n
\nAs well as applying to pcre2_match(), the depth limit also controls\nthe depth of recursive function calls in pcre2_dfa_match(). These are\nused for lookaround assertions, atomic groups, and recursion within patterns.\nThe limit does not apply to JIT matching.\n
\nLIMITING VARIABLE-LENGTH LOOKBEHIND ASSERTIONS
\n\nLookbehind assertions in which one or more branches can match a variable number\nof characters are supported only if there is a maximum matching length for each\ntop-level branch. There is a limit to this maximum that defaults to 255\ncharacters. You can alter this default by a setting such as\n
\n --with-max-varlookbehind=100\n\nThe limit can be changed at runtime by calling\npcre2_set_max_varlookbehind(). Lookbehind assertions in which every\nbranch matches a fixed number of characters (not necessarily all the same) are\nnot constrained by this limit.\n\n
CREATING CHARACTER TABLES AT BUILD TIME
\n\nPCRE2 uses fixed tables for processing characters whose code points are less\nthan 256. By default, PCRE2 is built with a set of tables that are distributed\nin the file src/pcre2_chartables.c.dist. These tables are for ASCII codes\nonly. If you add\n
\n --enable-rebuild-chartables\n\nto the configure command, the distributed tables are no longer used.\nInstead, a program called pcre2_dftables is compiled and run. This\noutputs the source for new set of tables, created in the default locale of your\nC run-time system. This method of replacing the tables does not work if you are\ncross compiling, because pcre2_dftables needs to be run on the local\nhost and therefore not compiled with the cross compiler.\n\n
\nIf you need to create alternative tables when cross compiling, you will have to\ndo so \"by hand\". There may also be other reasons for creating tables manually.\nTo cause pcre2_dftables to be built on the local host, run a normal\ncompiling command, and then run the program with the output file as its\nargument, for example:\n
\n cc src/pcre2_dftables.c -o pcre2_dftables\n ./pcre2_dftables src/pcre2_chartables.c\n\nThis builds the tables in the default locale of the local host. If you want to\nspecify a locale, you must use the -L option:\n
\n LC_ALL=fr_FR ./pcre2_dftables -L src/pcre2_chartables.c\n\nYou can also specify -b (with or without -L). This causes the tables to be\nwritten in binary instead of as source code. A set of binary tables can be\nloaded into memory by an application and passed to pcre2_compile() in the\nsame way as tables created by calling pcre2_maketables(). The tables are\njust a string of bytes, independent of hardware characteristics such as\nendianness. This means they can be bundled with an application that runs in\ndifferent environments, to ensure consistent behaviour.\n\n
USING EBCDIC CODE
\n\nPCRE2 assumes by default that it will run in an environment where the character\ncode is ASCII or Unicode, which is a superset of ASCII. This is the case for\nmost computer operating systems. PCRE2 can, however, be compiled to run in an\n8-bit EBCDIC environment by adding\n
\n --enable-ebcdic --disable-unicode\n\nto the configure command. You should only use it if you know that you are\nin an EBCDIC environment (for example, an IBM mainframe operating system).\n\n
\nThis setting implies --enable-rebuild-chartables, in order to ensure that you\nhave the correct default character tables for your system's codepage. There is\nan exception when you set --enable-ebcdic-ignoring-compiler (see below), which\nallows using a default set of EBCDIC 1047 character tables rather than forcing\nuse of --enable-rebuild-chartables.\n
\n\nIt is not supported to enable both EBCDIC input and either ASCII or UTF-8/16/32\nin the same build of the library. When PCRE2 is built with EBCDIC support, it\nalways operates in EBCDIC, and consequently --enable-unicode and --enable-ebcdic\nare mutually exclusive.\n
\n\nThe EBCDIC character that corresponds to an ASCII LF is assumed to have the\nvalue 0x15 by default. However, in some EBCDIC environments, 0x25 is used. In\nsuch an environment you should use\n
\n --enable-ebcdic-nl25\n\n(which implies --enable-ebcdic). The EBCDIC character for CR has the same value\nas in ASCII, namely, 0x0d. Whichever of 0x15 and 0x25 is not chosen as LF\nis made to correspond to the Unicode NEL character (which, in Unicode, is 0x85).\n\n
\nThe options that select newline behaviour, such as --enable-newline-is-cr,\nand equivalent run-time options, refer to these character values in an EBCDIC\nenvironment.\n
\n\nOn systems requiring an EBCDIC build of PCRE2, the compiler should be set to use\nthe correct codepage, so that C character literals such as 'z' use the correct\nnumeric value for whichever EBCDIC codpage is in use. (PCRE2 cannot support\nmultiple EBCDIC codepages dynamically.) However, if this not possible, then you\ncan use\n
\n --enable-ebcdic-ignoring-compiler\n\nin order to disregard the compiler's codepage, and instead force PCRE2 to use\nnumeric constants corresponding to the EBCDIC 1047 codepage instead. This can be\nused to build (or test) EBCDIC support on an ASCII/UTF-8 system such as Linux.\n\n
PCRE2GREP SUPPORT FOR EXTERNAL SCRIPTS
\n\nBy default pcre2grep supports the use of callouts with string arguments\nwithin the patterns it is matching. There are two kinds: one that generates\noutput using local code, and another that calls an external program or script.\nIf --disable-pcre2grep-callout-fork is added to the configure command,\nonly the first kind of callout is supported; if --disable-pcre2grep-callout is\nused, all callouts are completely ignored. For more details of pcre2grep\ncallouts, see the\npcre2grep\ndocumentation.\n
\nPCRE2GREP OPTIONS FOR COMPRESSED FILE SUPPORT
\n\nBy default, pcre2grep reads all files as plain text. You can build it so\nthat it recognizes files whose names end in .gz or .bz2, and reads\nthem with libz or libbz2, respectively, by adding one or both of\n
\n --enable-pcre2grep-libz\n --enable-pcre2grep-libbz2\n\nto the configure command. These options naturally require that the\nrelevant libraries are installed on your system. Configuration will fail if\nthey are not.\n\n
PCRE2GREP BUFFER SIZE
\n\npcre2grep uses an internal buffer to hold a \"window\" on the file it is\nscanning, in order to be able to output \"before\" and \"after\" lines when it\nfinds a match. The default starting size of the buffer is 20KiB. The buffer\nitself is three times this size, but because of the way it is used for holding\n\"before\" lines, the longest line that is guaranteed to be processable is the\nnotional buffer size. If a longer line is encountered, pcre2grep\nautomatically expands the buffer, up to a specified maximum size, whose default\nis 1MiB or the starting size, whichever is the larger. You can change the\ndefault parameter values by adding, for example,\n
\n --with-pcre2grep-bufsize=51200\n --with-pcre2grep-max-bufsize=2097152\n\nto the configure command. The caller of pcre2grep can override\nthese values by using --buffer-size and --max-buffer-size on the command line.\n\n
PCRE2TEST OPTION FOR LIBREADLINE SUPPORT
\n\nIf you add one of\n
\n --enable-pcre2test-libreadline\n --enable-pcre2test-libedit\n\nto the configure command, pcre2test is linked with the\nlibreadline orlibedit library, respectively, and when its input is\nfrom a terminal, it reads it using the readline() function. This provides\nline-editing and history facilities. Note that libreadline is\nGPL-licensed, so if you distribute a binary of pcre2test linked in this\nway, there may be licensing issues. These can be avoided by linking instead\nwith libedit, which has a BSD licence.\n\n
\nSetting --enable-pcre2test-libreadline causes the -lreadline option to be\nadded to the pcre2test build. In many operating environments with a\nsystem-installed readline library this is sufficient. However, in some\nenvironments (e.g. if an unmodified distribution version of readline is in\nuse), some extra configuration may be necessary. The INSTALL file for\nlibreadline says this:\n
\n \"Readline uses the termcap functions, but does not link with\n the termcap or curses library itself, allowing applications\n which link with readline the to choose an appropriate library.\"\n\nIf your environment has not been set up so that an appropriate library is\nautomatically included, you may need to add something like\n
\n LIBS=\"-lncurses\"\n\nimmediately before the configure command.\n\n
INCLUDING DEBUGGING CODE
\n\nIf you add\n
\n --enable-debug\n\nto the configure command, additional debugging code is included in the\nbuild. This feature is intended for use by the PCRE2 maintainers.\n\n
DEBUGGING WITH VALGRIND SUPPORT
\n\nIf you add\n
\n --enable-valgrind\n\nto the configure command, PCRE2 will use valgrind annotations to mark\ncertain memory regions as unaddressable. This allows it to detect invalid\nmemory accesses, and is mostly useful for debugging PCRE2 itself.\n\n
CODE COVERAGE REPORTING
\n\nIf your C compiler is gcc, you can build a version of PCRE2 that can generate a\ncode coverage report for its test suite. To enable this, you must install\nlcov version 1.6 or above. Then specify\n
\n --enable-coverage\n\nto the configure command and build PCRE2 in the usual way.\n\n
\nNote that using ccache (a caching C compiler) is incompatible with code\ncoverage reporting. If you have configured ccache to run automatically\non your system, you must set the environment variable\n
\n CCACHE_DISABLE=1\n\nbefore running make to build PCRE2, so that ccache is not used.\n\n
\nWhen --enable-coverage is used, the following addition targets are added to the\nMakefile:\n
\n make coverage\n\nThis creates a fresh coverage report for the PCRE2 test suite. It is equivalent\nto running \"make coverage-reset\", \"make coverage-baseline\", \"make check\", and\nthen \"make coverage-report\".\n
\n make coverage-reset\n\nThis zeroes the coverage counters, but does nothing else.\n
\n make coverage-baseline\n\nThis captures baseline coverage information.\n
\n make coverage-report\n\nThis creates the coverage report.\n
\n make coverage-clean-report\n\nThis removes the generated coverage report without cleaning the coverage data\nitself.\n
\n make coverage-clean-data\n\nThis removes the captured coverage data without removing the coverage files\ncreated at compile time (*.gcno).\n
\n make coverage-clean\n\nThis cleans all coverage data including the generated coverage report. For more\ninformation about code coverage, see the gcov and lcov\ndocumentation.\n\n
DISABLING THE Z AND T FORMATTING MODIFIERS
\n\nThe C99 standard defines formatting modifiers z and t for size_t and\nptrdiff_t values, respectively. By default, PCRE2 uses these modifiers in\nenvironments other than old versions of Microsoft Visual Studio when\n__STDC_VERSION__ is defined and has a value greater than or equal to 199901L\n(indicating support for C99).\nHowever, there is at least one environment that claims to be C99 but does not\nsupport these modifiers. If\n
\n --disable-percent-zt\n\nis specified, no use is made of the z or t modifiers. Instead of %td or %zu,\na suitable format is used depending in the size of long for the platform.\n\n
SUPPORT FOR FUZZERS
\n\nThere is a special option for use by people who want to run fuzzing tests on\nPCRE2:\n
\n --enable-fuzz-support\n\nAt present this applies only to the 8-bit library. If set, it causes an extra\nlibrary called libpcre2-fuzzsupport.a to be built, but not installed. This\ncontains a single function called LLVMFuzzerTestOneInput() whose arguments are\na pointer to a string and the length of the string. When called, this function\ntries to compile the string as a pattern, and if that succeeds, to match it.\nThis is done both with no options and with some random options bits that are\ngenerated from the string.\n\n
\nSetting --enable-fuzz-support also causes a binary called pcre2fuzzcheck\nto be created. This is normally run under valgrind or used when PCRE2 is\ncompiled with address sanitizing enabled. It calls the fuzzing function and\noutputs information about what it is doing. The input strings are specified by\narguments: if an argument starts with \"=\" the rest of it is a literal input\nstring. Otherwise, it is assumed to be a file name, and the contents of the\nfile are the test string.\n
\nOBSOLETE OPTION
\n\nIn versions of PCRE2 prior to 10.30, there were two ways of handling\nbacktracking in the pcre2_match() function. The default was to use the\nsystem stack, but if\n
\n --disable-stack-for-recursion\n\nwas set, memory on the heap was used. From release 10.30 onwards this has\nchanged (the stack is no longer used) and this option now does nothing except\ngive a warning.\n\n
SEE ALSO
\n\npcre2api(3), pcre2-config(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 17 October 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2callout.html", "content": "\n\npcre2callout man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- SYNOPSIS\n
- DESCRIPTION\n
- MISSING CALLOUTS\n
- THE CALLOUT INTERFACE\n
- RETURN VALUES FROM CALLOUTS\n
- CALLOUT ENUMERATION\n
- AUTHOR\n
- REVISION\n
SYNOPSIS
\n\n#include <pcre2.h>\n
\n\nint (*pcre2_callout)(pcre2_callout_block *, void *);\n
\n
\nint pcre2_callout_enumerate(const pcre2_code *code,\n int (*callback)(pcre2_callout_enumerate_block *, void *),\n void *user_data);\n
DESCRIPTION
\n\nPCRE2 provides a feature called \"callout\", which is a means of temporarily\npassing control to the caller of PCRE2 in the middle of pattern matching. The\ncaller of PCRE2 provides an external function by putting its entry point in\na match context (see pcre2_set_callout() in the\npcre2api\ndocumentation).\n
\n\nWhen using the pcre2_substitute() function, an additional callout feature\nis available. This does a callout after each change to the subject string and\nis described in the\npcre2api\ndocumentation; the rest of this document is concerned with callouts during\npattern matching.\n
\n\nWithin a regular expression, (?C<arg>) indicates a point at which the external\nfunction is to be called. Different callout points can be identified by putting\na number less than 256 after the letter C. The default value is zero.\nAlternatively, the argument may be a delimited string. The starting delimiter\nmust be one of ` ' \" ^ % # $ { and the ending delimiter is the same as the\nstart, except for {, where the ending delimiter is }. If the ending delimiter\nis needed within the string, it must be doubled. For example, this pattern has\ntwo callout points:\n
\n (?C1)abc(?C\"some \"\"arbitrary\"\" text\")def\n\nIf the PCRE2_AUTO_CALLOUT option bit is set when a pattern is compiled, PCRE2\nautomatically inserts callouts, all with number 255, before each item in the\npattern except for immediately before or after an explicit callout. For\nexample, if PCRE2_AUTO_CALLOUT is used with the pattern\n
\n A(?C3)B\n\nit is processed as if it were\n
\n (?C255)A(?C3)B(?C255)\n\nHere is a more complicated example:\n
\n A(\\d{2}|--)\n\nWith PCRE2_AUTO_CALLOUT, this pattern is processed as if it were\n\n (?C255)A(?C255)((?C255)\\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)\n\nNotice that there is a callout before and after each parenthesis and\nalternation bar. If the pattern contains a conditional group whose condition is\nan assertion, an automatic callout is inserted immediately before the\ncondition. Such a callout may also be inserted explicitly, for example:\n\n (?(?C9)(?=a)ab|de) (?(?C%text%)(?!=d)ab|de)\n\nThis applies only to assertion conditions (because they are themselves\nindependent groups).\n\n
\nCallouts can be useful for tracking the progress of pattern matching. The\npcre2test\nprogram has a pattern qualifier (/auto_callout) that sets automatic callouts.\nWhen any callouts are present, the output from pcre2test indicates how\nthe pattern is being matched. This is useful information when you are trying to\noptimize the performance of a particular pattern.\n
\nMISSING CALLOUTS
\n\nYou should be aware that, because of optimizations in the way PCRE2 compiles\nand matches patterns, callouts sometimes do not happen exactly as you might\nexpect.\n
\n\nAuto-possessification\n
\n\nAt compile time, PCRE2 \"auto-possessifies\" repeated items when it knows that\nwhat follows cannot be part of the repeat. For example, a+[bc] is compiled as\nif it were a++[bc]. The pcre2test output when this pattern is compiled\nwith PCRE2_ANCHORED and PCRE2_AUTO_CALLOUT and then applied to the string\n\"aaaa\" is:\n
\n --->aaaa\n +0 ^ a+\n +2 ^ ^ [bc]\n No match\n\nThis indicates that when matching [bc] fails, there is no backtracking into a+\n(because it is being treated as a++) and therefore the callouts that would be\ntaken for the backtracks do not occur. You can disable the auto-possessify\nfeature by passing PCRE2_NO_AUTO_POSSESS to pcre2_compile(), or starting\nthe pattern with (*NO_AUTO_POSSESS). In this case, the output changes to this:\n
\n --->aaaa\n +0 ^ a+\n +2 ^ ^ [bc]\n +2 ^ ^ [bc]\n +2 ^ ^ [bc]\n +2 ^^ [bc]\n No match\n\nThis time, when matching [bc] fails, the matcher backtracks into a+ and tries\nagain, repeatedly, until a+ itself fails.\n\n
\nAutomatic .* anchoring\n
\n\nBy default, an optimization is applied when .* is the first significant item in\na pattern. If PCRE2_DOTALL is set, so that the dot can match any character, the\npattern is automatically anchored. If PCRE2_DOTALL is not set, a match can\nstart only after an internal newline or at the beginning of the subject, and\npcre2_compile() remembers this. If a pattern has more than one top-level\nbranch, automatic anchoring occurs if all branches are anchorable.\n
\n\nThis optimization is disabled, however, if .* is in an atomic group or if there\nis a backreference to the capture group in which it appears. It is also\ndisabled if the pattern contains (*PRUNE) or (*SKIP). However, the presence of\ncallouts does not affect it.\n
\n\nFor example, if the pattern .*\\d is compiled with PCRE2_AUTO_CALLOUT and\napplied to the string \"aa\", the pcre2test output is:\n
\n --->aa\n +0 ^ .*\n +2 ^ ^ \\d\n +2 ^^ \\d\n +2 ^ \\d\n No match\n\nThis shows that all match attempts start at the beginning of the subject. In\nother words, the pattern is anchored. You can disable this optimization by\npassing PCRE2_NO_DOTSTAR_ANCHOR to pcre2_compile(), or starting the\npattern with (*NO_DOTSTAR_ANCHOR). In this case, the output changes to:\n
\n --->aa\n +0 ^ .*\n +2 ^ ^ \\d\n +2 ^^ \\d\n +2 ^ \\d\n +0 ^ .*\n +2 ^^ \\d\n +2 ^ \\d\n No match\n\nThis shows more match attempts, starting at the second subject character.\nAnother optimization, described in the next section, means that there is no\nsubsequent attempt to match with an empty subject.\n\n
\nOther optimizations\n
\n\nOther optimizations that provide fast \"no match\" results also affect callouts.\nFor example, if the pattern is\n
\n ab(?C4)cd\n\nPCRE2 knows that any matching string must contain the letter \"d\". If the\nsubject string is \"abyz\", the lack of \"d\" means that matching doesn't ever\nstart, and the callout is never reached. However, with \"abyd\", though the\nresult is still no match, the callout is obeyed.\n\n
\nFor most patterns PCRE2 also knows the minimum length of a matching string, and\nwill immediately give a \"no match\" return without actually running a match if\nthe subject is not long enough, or, for unanchored patterns, if it has been\nscanned far enough.\n
\n\nYou can disable these optimizations by passing the PCRE2_NO_START_OPTIMIZE\noption to pcre2_compile(), or by starting the pattern with\n(*NO_START_OPT). This slows down the matching process, but does ensure that\ncallouts such as the example above are obeyed.\n
\nTHE CALLOUT INTERFACE
\n\nDuring matching, when PCRE2 reaches a callout point, if an external function is\nprovided in the match context, it is called. This applies to both normal,\nDFA, and JIT matching. The first argument to the callout function is a pointer\nto a pcre2_callout block. The second argument is the void * callout data\nthat was supplied when the callout was set up by calling\npcre2_set_callout() (see the\npcre2api\ndocumentation). The callout block structure contains the following fields, not\nnecessarily in this order:\n
\n uint32_t version;\n uint32_t callout_number;\n uint32_t capture_top;\n uint32_t capture_last;\n uint32_t callout_flags;\n PCRE2_SIZE *offset_vector;\n PCRE2_SPTR mark;\n PCRE2_SPTR subject;\n PCRE2_SIZE subject_length;\n PCRE2_SIZE start_match;\n PCRE2_SIZE current_position;\n PCRE2_SIZE pattern_position;\n PCRE2_SIZE next_item_length;\n PCRE2_SIZE callout_string_offset;\n PCRE2_SIZE callout_string_length;\n PCRE2_SPTR callout_string;\n\nThe version field contains the version number of the block format. The\ncurrent version is 2; the three callout string fields were added for version 1,\nand the callout_flags field for version 2. If you are writing an\napplication that might use an earlier release of PCRE2, you should check the\nversion number before accessing any of these fields. The version number will\nincrease in future if more fields are added, but the intention is never to\nremove any of the existing fields.\n\n
\nFields for numerical callouts\n
\n\nFor a numerical callout, callout_string is NULL, and callout_number\ncontains the number of the callout, in the range 0-255. This is the number\nthat follows (?C for callouts that part of the pattern; it is 255 for\nautomatically generated callouts.\n
\n\nFields for string callouts\n
\n\nFor callouts with string arguments, callout_number is always zero, and\ncallout_string points to the string that is contained within the compiled\npattern. Its length is given by callout_string_length. Duplicated ending\ndelimiters that were present in the original pattern string have been turned\ninto single characters, but there is no other processing of the callout string\nargument. An additional code unit containing binary zero is present after the\nstring, but is not included in the length. The delimiter that was used to start\nthe string is also stored within the pattern, immediately before the string\nitself. You can access this delimiter as callout_string[-1] if you need\nit.\n
\n\nThe callout_string_offset field is the code unit offset to the start of\nthe callout argument string within the original pattern string. This is\nprovided for the benefit of applications such as script languages that might\nneed to report errors in the callout string within the pattern.\n
\n\nFields for all callouts\n
\n\nThe remaining fields in the callout block are the same for both kinds of\ncallout.\n
\n\nThe offset_vector field is a pointer to a vector of capturing offsets\n(the \"ovector\"). You may read the elements in this vector, but you must not\nchange any of them.\n
\n\nFor calls to pcre2_match(), the offset_vector field is not (since\nrelease 10.30) a pointer to the actual ovector that was passed to the matching\nfunction in the match data block. Instead it points to an internal ovector of a\nsize large enough to hold all possible captured substrings in the pattern. Note\nthat whenever a recursion or subroutine call within a pattern completes, the\ncapturing state is reset to what it was before.\n
\n\nThe capture_last field contains the number of the most recently captured\nsubstring, and the capture_top field contains one more than the number of\nthe highest numbered captured substring so far. If no substrings have yet been\ncaptured, the value of capture_last is 0 and the value of\ncapture_top is 1. The values of these fields do not always differ by one;\nfor example, when the callout in the pattern ((a)(b))(?C2) is taken,\ncapture_last is 1 but capture_top is 4.\n
\n\nThe contents of ovector[2] to ovector[<capture_top>*2-1] can be inspected in\norder to extract substrings that have been matched so far, in the same way as\nextracting substrings after a match has completed. The values in ovector[0] and\novector[1] are always PCRE2_UNSET because the match is by definition not\ncomplete. Substrings that have not been captured but whose numbers are less\nthan capture_top also have both of their ovector slots set to\nPCRE2_UNSET.\n
\n\nFor DFA matching, the offset_vector field points to the ovector that was\npassed to the matching function in the match data block for callouts at the top\nlevel, but to an internal ovector during the processing of pattern recursions,\nlookarounds, and atomic groups. However, these ovectors hold no useful\ninformation because pcre2_dfa_match() does not support substring\ncapturing. The value of capture_top is always 1 and the value of\ncapture_last is always 0 for DFA matching.\n
\n\nThe subject and subject_length fields contain copies of the values\nthat were passed to the matching function.\n
\n\nThe start_match field normally contains the offset within the subject at\nwhich the current match attempt started. However, if the escape sequence \\K\nhas been encountered, this value is changed to reflect the modified starting\npoint. If the pattern is not anchored, the callout function may be called\nseveral times from the same point in the pattern for different starting points\nin the subject.\n
\n\nThe current_position field contains the offset within the subject of the\ncurrent match pointer.\n
\n\nThe pattern_position field contains the offset in the pattern string to\nthe next item to be matched.\n
\n\nThe next_item_length field contains the length of the next item to be\nprocessed in the pattern string. When the callout is at the end of the pattern,\nthe length is zero. When the callout precedes an opening parenthesis, the\nlength includes meta characters that follow the parenthesis. For example, in a\ncallout before an assertion such as (?=ab) the length is 3. For an alternation\nbar or a closing parenthesis, the length is one, unless a closing parenthesis\nis followed by a quantifier, in which case its length is included. (This\nchanged in release 10.23. In earlier releases, before an opening parenthesis\nthe length was that of the entire group, and before an alternation bar or a\nclosing parenthesis the length was zero.)\n
\n\nThe pattern_position and next_item_length fields are intended to\nhelp in distinguishing between different automatic callouts, which all have the\nsame callout number. However, they are set for all callouts, and are used by\npcre2test to show the next item to be matched when displaying callout\ninformation.\n
\n\nIn callouts from pcre2_match() the mark field contains a pointer to\nthe zero-terminated name of the most recently passed (*MARK), (*PRUNE), or\n(*THEN) item in the match, or NULL if no such items have been passed. Instances\nof (*PRUNE) or (*THEN) without a name do not obliterate a previous (*MARK). In\ncallouts from the DFA matching function this field always contains NULL.\n
\n\nThe callout_flags field is always zero in callouts from\npcre2_dfa_match() or when JIT is being used. When pcre2_match()\nwithout JIT is used, the following bits may be set:\n
\n PCRE2_CALLOUT_STARTMATCH\n\nThis is set for the first callout after the start of matching for each new\nstarting position in the subject.\n
\n PCRE2_CALLOUT_BACKTRACK\n\nThis is set if there has been a matching backtrack since the previous callout,\nor since the start of matching if this is the first callout from a\npcre2_match() run.\n\n
\nBoth bits are set when a backtrack has caused a \"bumpalong\" to a new starting\nposition in the subject. Output from pcre2test does not indicate the\npresence of these bits unless the callout_extra modifier is set.\n
\n\nThe information in the callout_flags field is provided so that\napplications can track and tell their users how matching with backtracking is\ndone. This can be useful when trying to optimize patterns, or just to\nunderstand how PCRE2 works. There is no support in pcre2_dfa_match()\nbecause there is no backtracking in DFA matching, and there is no support in\nJIT because JIT is all about maximimizing matching performance. In both these\ncases the callout_flags field is always zero.\n
\nRETURN VALUES FROM CALLOUTS
\n\nThe external callout function returns an integer to PCRE2. If the value is\nzero, matching proceeds as normal. If the value is greater than zero, matching\nfails at the current point, but the testing of other matching possibilities\ngoes ahead, just as if a lookahead assertion had failed. If the value is less\nthan zero, the match is abandoned, and the matching function returns the\nnegative value.\n
\n\nNegative values should normally be chosen from the set of PCRE2_ERROR_xxx\nvalues. In particular, PCRE2_ERROR_NOMATCH forces a standard \"no match\"\nfailure. The error number PCRE2_ERROR_CALLOUT is reserved for use by callout\nfunctions; it will never be used by PCRE2 itself.\n
\nCALLOUT ENUMERATION
\n\nint pcre2_callout_enumerate(const pcre2_code *code,\n int (*callback)(pcre2_callout_enumerate_block *, void *),\n void *user_data);\n
\n
\nA script language that supports the use of string arguments in callouts might\nlike to scan all the callouts in a pattern before running the match. This can\nbe done by calling pcre2_callout_enumerate(). The first argument is a\npointer to a compiled pattern, the second points to a callback function, and\nthe third is arbitrary user data. The callback function is called for every\ncallout in the pattern in the order in which they appear. Its first argument is\na pointer to a callout enumeration block, and its second argument is the\nuser_data value that was passed to pcre2_callout_enumerate(). The\ndata block contains the following fields:\n
\n version Block version number\n pattern_position Offset to next item in pattern\n next_item_length Length of next item in pattern\n callout_number Number for numbered callouts\n callout_string_offset Offset to string within pattern\n callout_string_length Length of callout string\n callout_string Points to callout string or is NULL\n\nThe version number is currently 0. It will increase if new fields are ever\nadded to the block. The remaining fields are the same as their namesakes in the\npcre2_callout block that is used for callouts during matching, as\ndescribed\nabove.\n\n
\nNote that the value of pattern_position is unique for each callout.\nHowever, if a callout occurs inside a group that is quantified with a non-zero\nminimum or a fixed maximum, the group is replicated inside the compiled\npattern. For example, a pattern such as /(a){2}/ is compiled as if it were\n/(a)(a)/. This means that the callout will be enumerated more than once, but\nwith the same value for pattern_position in each case.\n
\n\nThe callback function should normally return zero. If it returns a non-zero\nvalue, scanning the pattern stops, and that value is returned from\npcre2_callout_enumerate().\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 26 February 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2compat.html", "content": "\n\npcre2compat man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nDIFFERENCES BETWEEN PCRE2 AND PERL\n
\n\nThis document describes some of the known differences in the ways that PCRE2\nand Perl handle regular expressions. The differences described here are with\nrespect to Perl version 5.38.0, but as both Perl and PCRE2 are continually\nchanging, the information may at times be out of date.\n
\n\n1. When PCRE2_DOTALL (equivalent to Perl's /s qualifier) is not set, the\nbehaviour of the '.' metacharacter differs from Perl. In PCRE2, '.' matches the\nnext character unless it is the start of a newline sequence. This means that,\nif the newline setting is CR, CRLF, or NUL, '.' will match the code point LF\n(0x0A) in ASCII/Unicode environments, and NL (either 0x15 or 0x25) when using\nEBCDIC. In Perl, '.' appears never to match LF, even when 0x0A is not a newline\nindicator.\n
\n\n2. PCRE2 has only a subset of Perl's Unicode support. Details of what it does\nhave are given in the\npcre2unicode\npage.\n
\n\n3. Like Perl, PCRE2 allows repeat quantifiers on parenthesized assertions, but\nthey do not mean what you might think. For example, (?!a){3} does not assert\nthat the next three characters are not \"a\". It just asserts that the next\ncharacter is not \"a\" three times (in principle; PCRE2 optimizes this to run the\nassertion just once). Perl allows some repeat quantifiers on other assertions,\nfor example, \\b* , but these do not seem to have any use. PCRE2 does not allow\nany kind of quantifier on non-lookaround assertions.\n
\n\n4. If a braced quantifier such as {1,2} appears where there is nothing to\nrepeat (for example, at the start of a branch), PCRE2 raises an error whereas\nPerl treats the quantifier characters as literal. When a braced quantifier\n(...){min,max} has min > max, Perl treats it as an item which fails to match\nany portion of the subject (as no number of repetitions can meet the\ncondition), and additionally issues a warning when in warning mode. PCRE2 has\nno warning features, so it gives an error in this case.\n
\n\n5. Capture groups that occur inside negative lookaround assertions are counted,\nbut their entries in the offsets vector are set only when a negative assertion\nis a condition that has a matching branch (that is, the condition is false).\nPerl may set such capture groups in other circumstances.\n
\n\n6. The following Perl escape sequences are not supported: \\F, \\l, \\L, \\u,\n\\U, and \\N when followed by a character name. \\N on its own, matching a\nnon-newline character, and \\N{U+dd..}, matching a Unicode code point, are\nsupported. The escapes that modify the case of following letters are\nimplemented by Perl's general string-handling and are not part of its pattern\nmatching engine. If any of these are encountered by PCRE2, an error is\ngenerated by default. However, if either of the PCRE2_ALT_BSUX or\nPCRE2_EXTRA_ALT_BSUX options is set, \\U and \\u are interpreted as ECMAScript\ninterprets them.\n
\n\n7. The Perl escape sequences \\p, \\P, and \\X are supported only if PCRE2 is\nbuilt with Unicode support (the default). The properties that can be tested\nwith \\p and \\P are limited to the general category properties such as Lu and\nNd, the derived properties Any and Lc (synonym L&), script names such as Greek\nor Han, Bidi_Class, Bidi_Control, and a few binary properties. Both PCRE2 and\nPerl support the Cs (surrogate) property, but in PCRE2 its use is limited. See\nthe\npcre2pattern\ndocumentation for details. The long synonyms for property names that Perl\nsupports (such as \\p{Letter}) are not supported by PCRE2, nor is it permitted\nto prefix any of these properties with \"Is\".\n
\n\n8. PCRE2 supports the \\Q...\\E escape for quoting substrings. Characters\nin between are treated as literals. However, this is slightly different from\nPerl in that $ and @ are also handled as literals inside the quotes. In Perl,\nthey cause variable interpolation (PCRE2 does not have variables). Also, Perl\ndoes \"double-quotish backslash interpolation\" on any backslashes between \\Q\nand \\E which, its documentation says, \"may lead to confusing results\". PCRE2\ntreats a backslash between \\Q and \\E just like any other character. Note the\nfollowing examples:\n
\n Pattern PCRE2 matches Perl matches\n\n \\Qabc$xyz\\E abc$xyz abc followed by the contents of $xyz\n \\Qabc\\$xyz\\E abc\\$xyz abc\\$xyz\n \\Qabc\\E\\$\\Qxyz\\E abc$xyz abc$xyz\n \\QA\\B\\E A\\B A\\B\n \\Q\\\\E \\ \\\\E\n\nThe \\Q...\\E sequence is recognized both inside and outside character classes\nby both PCRE2 and Perl. Another difference from Perl is that any appearance of\n\\Q or \\E inside what might otherwise be a quantifier causes PCRE2 not to\nrecognize the sequence as a quantifier. Perl recognizes a quantifier if\n(redundantly) either of the numbers is inside \\Q...\\E, but not if the\nseparating comma is. When not recognized as a quantifier a sequence such as\n{\\Q1\\E,2} is treated as the literal string \"{1,2}\".\n\n
\n9. Fairly obviously, PCRE2 does not support the (?{code}) and (??{code})\nconstructions. However, PCRE2 does have a \"callout\" feature, which allows an\nexternal function to be called during pattern matching. See the\npcre2callout\ndocumentation for details.\n
\n\n10. Subroutine calls (whether recursive or not) were treated as atomic groups\nup to PCRE2 release 10.23, but from release 10.30 this changed, and\nbacktracking into subroutine calls is now supported, as in Perl.\n
\n\n11. In PCRE2, if any of the backtracking control verbs are used in a group that\nis called as a subroutine (whether or not recursively), their effect is\nconfined to that group; it does not extend to the surrounding pattern. This is\nnot always the case in Perl. In particular, if (*THEN) is present in a group\nthat is called as a subroutine, its action is limited to that group, even if\nthe group does not contain any | characters. Note that such groups are\nprocessed as anchored at the point where they are tested. PCRE2 also confines\nall control verbs within atomic assertions, again including (*THEN) in\nassertions with only one branch.\n
\n\n12. If a pattern contains more than one backtracking control verb, the first\none that is backtracked onto acts. For example, in the pattern\nA(*COMMIT)B(*PRUNE)C a failure in B triggers (*COMMIT), but a failure in C\ntriggers (*PRUNE). Perl's behaviour is more complex; in many cases it is the\nsame as PCRE2, but there are cases where it differs.\n
\n\n13. There are some differences that are concerned with the settings of captured\nstrings when part of a pattern is repeated. For example, matching \"aba\" against\nthe pattern /^(a(b)?)+$/ in Perl leaves $2 unset, but in PCRE2 it is set to\n\"b\".\n
\n\n14. PCRE2's handling of duplicate capture group numbers and names is not as\ngeneral as Perl's. This is a consequence of the fact the PCRE2 works internally\njust with numbers, using an external table to translate between numbers and\nnames. In particular, a pattern such as (?|(?<a>A)|(?<b>B)), where the two\ncapture groups have the same number but different names, is not supported, and\ncauses an error at compile time. If it were allowed, it would not be possible\nto distinguish which group matched, because both names map to capture group\nnumber 1. To avoid this confusing situation, an error is given at compile time.\n
\n\n15. Perl used to recognize comments in some places that PCRE2 does not, for\nexample, between the ( and ? at the start of a group. If the /x modifier is\nset, Perl allowed white space between ( and ? though the latest Perls give an\nerror (for a while it was just deprecated). There may still be some cases where\nPerl behaves differently.\n
\n\n16. Perl, when in warning mode, gives warnings for character classes such as\n[A-\\d] or [a-[:digit:]]. It then treats the hyphens as literals. PCRE2 has no\nwarning features, so it gives an error in these cases because they are almost\ncertainly user mistakes.\n
\n\n17. In PCRE2, until release 10.45, the upper/lower case character properties Lu\nand Ll were not affected when case-independent matching was specified. Perl has\nchanged in this respect, and PCRE2 has now changed to match. When caseless\nmatching is in force, Lu, Ll, and Lt (title case) are all treated as Lc (cased\nletter).\n
\n\n18. From release 5.32.0, Perl locks out the use of \\K in lookaround\nassertions. From release 10.38 PCRE2 does the same by default. However, there\nis an option for re-enabling the previous behaviour. When this option is set,\n\\K is acted on when it occurs in positive assertions, but is ignored in\nnegative assertions.\n
\n\n19. PCRE2 provides some extensions to the Perl regular expression facilities.\nPerl 5.10 included new features that were not in earlier versions of Perl, some\nof which (such as named parentheses) were in PCRE2 for some time before. This\nlist is with respect to Perl 5.38:\n
\n
\n(a) If PCRE2_DOLLAR_ENDONLY is set and PCRE2_MULTILINE is not set, the $\nmeta-character matches only at the very end of the string.\n
\n
\n(b) A backslash followed by a letter with no special meaning is faulted. (Perl\ncan be made to issue a warning.)\n
\n
\n(c) If PCRE2_UNGREEDY is set, the greediness of the repetition quantifiers is\ninverted, that is, by default they are not greedy, but if followed by a\nquestion mark they are.\n
\n
\n(d) PCRE2_ANCHORED can be used at matching time to force a pattern to be tried\nonly at the first matching position in the subject string.\n
\n
\n(e) The PCRE2_NOTBOL, PCRE2_NOTEOL, PCRE2_NOTEMPTY and PCRE2_NOTEMPTY_ATSTART\noptions have no Perl equivalents.\n
\n
\n(f) The \\R escape sequence can be restricted to match only CR, LF, or CRLF\nby the PCRE2_BSR_ANYCRLF option.\n
\n
\n(g) The callout facility is PCRE2-specific. Perl supports codeblocks and\nvariable interpolation, but not general hooks on every match.\n
\n
\n(h) The partial matching facility is PCRE2-specific.\n
\n
\n(i) The alternative matching function (pcre2_dfa_match()) matches in a\ndifferent way and is not Perl-compatible.\n
\n
\n(j) PCRE2 recognizes some special sequences such as (*CR) or (*NO_JIT) at\nthe start of a pattern. These set overall options that cannot be changed within\nthe pattern.\n
\n
\n(k) PCRE2 supports non-atomic positive lookaround assertions. This is an\nextension to the lookaround facilities. The default, Perl-compatible\nlookarounds are atomic.\n
\n
\n(l) There are three syntactical items in patterns that can refer to a capturing\ngroup by number: back references such as \\g{2}, subroutine calls such as (?3),\nand condition references such as (?(4)...). PCRE2 supports relative group\nnumbers such as +2 and -4 in all three cases. Perl supports both plus and minus\nfor subroutine calls, but only minus for back references, and no relative\nnumbering at all for conditions.\n
\n
\n(m) The scan substring assertion (syntax (*scs:(n)...)) is a PCRE2 extension\nthat is not available in Perl.\n
\n20. Perl has different limits than PCRE2. See the\npcre2limits\ndocumentation for details. Perl went with 5.10 from recursion to iteration\nkeeping the intermediate matches on the heap, which is ~10% slower but does not\nfall into any stack-overflow limit. PCRE2 made a similar change at release\n10.30, and also has many build-time and run-time customizable limits.\n
\n\n21. Unlike Perl, PCRE2 doesn't have character set modifiers and specially no way\nto set characters by context just like Perl's \"/d\". A regular expression using\nPCRE2_UTF and PCRE2_UCP will use similar rules to Perl's \"/u\"; something closer\nto \"/a\" could be selected by adding other PCRE2_EXTRA_ASCII* options on top.\n
\n\n22. Some recursive patterns that Perl diagnoses as infinite recursions can be\nhandled by PCRE2, either by the interpreter or the JIT. An example is\n/(?:|(?0)abcd)(?(R)|\\z)/, which matches a sequence of any number of repeated\n\"abcd\" substrings at the end of the subject.\n
\n\n23. Both PCRE2 and Perl error when \\x{ escapes are invalid, but Perl tries to\nrecover and prints a warning if the problem was that an invalid hexadecimal\ndigit was found. Since PCRE2 doesn't have warnings it returns an error instead.\nAdditionally, Perl accepts \\x{} and generates NUL unlike PCRE2.\n
\n\n24. From release 10.45, PCRE2 gives an error if \\x is not followed by a\nhexadecimal digit or a curly bracket. It used to interpret this as the NUL\ncharacter. Perl still generates NUL, but warns when in warning mode in most\ncases.\n
\n\nAUTHOR\n
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
\nREVISION\n
\n\nLast updated: 02 June 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2convert.html", "content": "\n\npcre2convert man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- EXPERIMENTAL PATTERN CONVERSION FUNCTIONS\n
- THE CONVERT CONTEXT\n
- THE CONVERSION FUNCTION\n
- CONVERTING GLOBS\n
- CONVERTING POSIX PATTERNS\n
- AUTHOR\n
- REVISION\n
EXPERIMENTAL PATTERN CONVERSION FUNCTIONS
\n\nThis document describes a set of functions that can be used to convert\n\"foreign\" patterns into PCRE2 regular expressions. This facility is currently\nexperimental, and may be changed in future releases. Two kinds of pattern,\nglobs and POSIX patterns, are supported.\n
\nTHE CONVERT CONTEXT
\n\npcre2_convert_context *pcre2_convert_context_create(\n pcre2_general_context *gcontext);\n
\n
\npcre2_convert_context *pcre2_convert_context_copy(\n pcre2_convert_context *cvcontext);\n
\n
\nvoid pcre2_convert_context_free(pcre2_convert_context *cvcontext);\n
\n
\nint pcre2_set_glob_escape(pcre2_convert_context *cvcontext,\n uint32_t escape_char);\n
\n
\nint pcre2_set_glob_separator(pcre2_convert_context *cvcontext,\n uint32_t separator_char);\n
\n
\nA convert context is used to hold parameters that affect the way that pattern\nconversion works. Like all PCRE2 contexts, you need to use a context only if\nyou want to override the defaults. There are the usual create, copy, and free\nfunctions. If custom memory management functions are set in a general context\nthat is passed to pcre2_convert_context_create(), they are used for all\nmemory management within the conversion functions.\n
\nThere are only two parameters in the convert context at present. Both apply\nonly to glob conversions. The escape character defaults to grave accent under\nWindows, otherwise backslash. It can be set to zero, meaning no escape\ncharacter, or to any punctuation character with a code point less than 256.\nThe separator character defaults to backslash under Windows, otherwise forward\nslash. It can be set to forward slash, backslash, or dot.\n
\n\nThe two setting functions return zero on success, or PCRE2_ERROR_BADDATA if\ntheir second argument is invalid.\n
\nTHE CONVERSION FUNCTION
\n\nint pcre2_pattern_convert(PCRE2_SPTR pattern, PCRE2_SIZE length,\n uint32_t options, PCRE2_UCHAR **buffer,\n PCRE2_SIZE *blength, pcre2_convert_context *cvcontext);\n
\n
\nvoid pcre2_converted_pattern_free(PCRE2_UCHAR *converted_pattern);\n
\n
\nThe first two arguments of pcre2_pattern_convert() define the foreign\npattern that is to be converted. The length may be given as\nPCRE2_ZERO_TERMINATED. The options argument defines how the pattern is to\nbe processed. If the input is UTF, the PCRE2_CONVERT_UTF option should be set.\nPCRE2_CONVERT_NO_UTF_CHECK may also be set if you are sure the input is valid.\nOne or more of the glob options, or one of the following POSIX options must be\nset to define the type of conversion that is required:\n
\n PCRE2_CONVERT_GLOB\n PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR\n PCRE2_CONVERT_GLOB_NO_STARSTAR\n PCRE2_CONVERT_POSIX_BASIC\n PCRE2_CONVERT_POSIX_EXTENDED\n\nDetails of the conversions are given below. The buffer and blength\narguments define how the output is handled:\n\n
\nIf buffer is NULL, the function just returns the length of the converted\npattern via blength. This is one less than the length of buffer needed,\nbecause a terminating zero is always added to the output.\n
\n\nIf buffer points to a NULL pointer, an output buffer is obtained using\nthe allocator in the context or malloc() if no context is supplied. A\npointer to this buffer is placed in the variable to which buffer points.\nWhen no longer needed the output buffer must be freed by calling\npcre2_converted_pattern_free(). If this function is called with a NULL\nargument, it returns immediately without doing anything.\n
\n\nIf buffer points to a non-NULL pointer, blength must be set to the\nactual length of the buffer provided (in code units).\n
\n\nIn all cases, after successful conversion, the variable pointed to by\nblength is updated to the length actually used (in code units), excluding\nthe terminating zero that is always added.\n
\n\nIf an error occurs, the length (via blength) is set to the offset\nwithin the input pattern where the error was detected. Only gross syntax errors\nare caught; there are plenty of errors that will get passed on for\npcre2_compile() to discover.\n
\n\nThe return from pcre2_pattern_convert() is zero on success or a non-zero\nPCRE2 error code. Note that PCRE2 error codes may be positive or negative:\npcre2_compile() uses mostly positive codes and pcre2_match()\nnegative ones; pcre2_convert() uses existing codes of both kinds. A\ntextual error message can be obtained by calling\npcre2_get_error_message().\n
\nCONVERTING GLOBS
\n\nGlobs are used to match file names, and consequently have the concept of a\n\"path separator\", which defaults to backslash under Windows and forward slash\notherwise. If PCRE2_CONVERT_GLOB is set, the wildcards * and ? are not\npermitted to match separator characters, but the double-star (**) feature\n(which does match separators) is supported.\n
\n\nPCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR matches globs with wildcards allowed to\nmatch separator characters. PCRE2_CONVERT_GLOB_NO_STARSTAR matches globs with\nthe double-star feature disabled. These options may be given together.\n
\nCONVERTING POSIX PATTERNS
\n\nPOSIX defines two kinds of regular expression pattern: basic and extended.\nThese can be processed by setting PCRE2_CONVERT_POSIX_BASIC or\nPCRE2_CONVERT_POSIX_EXTENDED, respectively.\n
\n\nIn POSIX patterns, backslash is not special in a character class. Unmatched\nclosing parentheses are treated as literals.\n
\n\nIn basic patterns, ? + | {} and () must be escaped to be recognized\nas metacharacters outside a character class. If the first character in the\npattern is * it is treated as a literal. ^ is a metacharacter only at the start\nof a branch.\n
\n\nIn extended patterns, a backslash not in a character class always\nmakes the next character literal, whatever it is. There are no backreferences.\n
\n\nNote: POSIX mandates that the longest possible match at the first matching\nposition must be found. This is not what pcre2_match() does; it yields\nthe first match that is found. An application can use pcre2_dfa_match()\nto find the longest match, but that does not support backreferences (but then\nneither do POSIX extended patterns).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 14 November 2023\n
\nCopyright © 1997-2018 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2demo.html", "content": "\n\npcre2demo man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSOURCE CODE\n
\n\n/*************************************************\n* PCRE2 DEMONSTRATION PROGRAM *\n*************************************************/\n\n/* This is a demonstration program to illustrate a straightforward way of\nusing the PCRE2 regular expression library from a C program. See the\npcre2sample documentation for a short discussion (\"man pcre2sample\" if you have\nthe PCRE2 man pages installed). PCRE2 is a revised API for the library, and is\nincompatible with the original PCRE API.\n\nThere are actually three libraries, each supporting a different code unit\nwidth. This demonstration program uses the 8-bit library. The default is to\nprocess each code unit as a separate character, but if the pattern begins with\n\"(*UTF)\", both it and the subject are treated as UTF-8 strings, where\ncharacters may occupy multiple code units.\n\nIn Unix-like environments, if PCRE2 is installed in your standard system\nlibraries, you should be able to compile this program using this command:\n\ncc -Wall pcre2demo.c -lpcre2-8 -o pcre2demo\n\nIf PCRE2 is not installed in a standard place, it is likely to be installed\nwith support for the pkg-config mechanism. If you have pkg-config, you can\ncompile this program using this command:\n\ncc -Wall pcre2demo.c `pkg-config --cflags --libs libpcre2-8` -o pcre2demo\n\nIf you do not have pkg-config, you may have to use something like this:\n\ncc -Wall pcre2demo.c -I/usr/local/include -L/usr/local/lib \\\n -R/usr/local/lib -lpcre2-8 -o pcre2demo\n\nReplace \"/usr/local/include\" and \"/usr/local/lib\" with wherever the include and\nlibrary files for PCRE2 are installed on your system. Only some operating\nsystems (Solaris is one) use the -R option.\n\nBuilding under Windows:\n\nIf you want to statically link this program against a non-dll .a file, you must\ndefine PCRE2_STATIC before including pcre2.h, so in this environment, uncomment\nthe following line. */\n\n/* #define PCRE2_STATIC */\n\n/* The PCRE2_CODE_UNIT_WIDTH macro must be defined before including pcre2.h.\nFor a program that uses only one code unit width, setting it to 8, 16, or 32\nmakes it possible to use generic function names such as pcre2_compile(). Note\nthat just changing 8 to 16 (for example) is not sufficient to convert this\nprogram to process 16-bit characters. Even in a fully 16-bit environment, where\nstring-handling functions such as strcmp() and printf() work with 16-bit\ncharacters, the code for handling the table of named substrings will still need\nto be modified. */\n\n#define PCRE2_CODE_UNIT_WIDTH 8\n\n#include <stdio.h>\n#include <string.h>\n#include <pcre2.h>\n\n\n/**************************************************************************\n* Here is the program. The API includes the concept of \"contexts\" for *\n* setting up unusual interface requirements for compiling and matching, *\n* such as custom memory managers and non-standard newline definitions. *\n* This program does not do any of this, so it makes no use of contexts, *\n* always passing NULL where a context could be given. *\n**************************************************************************/\n\nint main(int argc, char **argv)\n{\npcre2_code *re;\nPCRE2_SPTR pattern; /* PCRE2_SPTR is a pointer to unsigned code units of */\nPCRE2_SPTR subject; /* the appropriate width (in this case, 8 bits). */\nPCRE2_SPTR name_table;\n\nint errornumber;\nint find_all, caseless_match;\nint i;\nint rc;\n\nuint32_t namecount;\nuint32_t name_entry_size;\n\nPCRE2_SIZE erroroffset;\nPCRE2_SIZE *ovector;\nPCRE2_SIZE ovector_last[2];\nPCRE2_SIZE subject_length;\n\npcre2_match_data *match_data;\n\n\n/**************************************************************************\n* First, sort out the command line. Options: *\n* - \"-g\" to request repeated matching to find all occurrences, *\n* like Perl's /g option. We set the variable find_all to a non-zero *\n* value if the -g option is present. *\n* - \"-i\" to request caseless matching, like Perl's /i option. We set the *\n* variable caseless_match to PCRE2_CASELESS if the -i option is *\n* present. *\n**************************************************************************/\n\nfind_all = 0;\ncaseless_match = 0;\nfor (i = 1; i < argc; i++)\n {\n if (strcmp(argv[i], \"-g\") == 0) find_all = 1;\n else if (strcmp(argv[i], \"-i\") == 0) caseless_match = PCRE2_CASELESS;\n else if (argv[i][0] == '-')\n {\n printf(\"Unrecognised option %s\\n\", argv[i]);\n return 1;\n }\n else break;\n }\n\n/* After the options, we require exactly two arguments, which are the pattern,\nand the subject string. */\n\nif (argc - i != 2)\n {\n printf(\"Exactly two arguments required: a regex and a subject string\\n\");\n return 1;\n }\n\n/* Pattern and subject are char arguments, so they can be straightforwardly\ncast to PCRE2_SPTR because we are working in 8-bit code units. The subject\nlength is cast to PCRE2_SIZE for completeness, though PCRE2_SIZE is in fact\ndefined to be size_t. */\n\npattern = (PCRE2_SPTR)argv[i];\nsubject = (PCRE2_SPTR)argv[i+1];\nsubject_length = (PCRE2_SIZE)strlen((char *)subject);\n\n\n/*************************************************************************\n* Now we are going to compile the regular expression pattern, and handle *\n* any errors that are detected. *\n*************************************************************************/\n\nre = pcre2_compile(\n pattern, /* the pattern */\n PCRE2_ZERO_TERMINATED, /* indicates pattern is zero-terminated */\n caseless_match, /* possibly enable caseless */\n &errornumber, /* for error number */\n &erroroffset, /* for error offset */\n NULL); /* use default compile context */\n\n/* Compilation failed: print the error message and exit. */\n\nif (re == NULL)\n {\n PCRE2_UCHAR buffer[256];\n pcre2_get_error_message(errornumber, buffer, sizeof(buffer));\n printf(\"PCRE2 compilation failed at offset %d: %s\\n\", (int)erroroffset,\n buffer);\n return 1;\n }\n\n\n/*************************************************************************\n* If the compilation succeeded, we call PCRE2 again, in order to do a *\n* pattern match against the subject string. This does just ONE match. If *\n* further matching is needed, it will be done below. Before running the *\n* match we must set up a match_data block for holding the result. Using *\n* pcre2_match_data_create_from_pattern() ensures that the block is *\n* exactly the right size for the number of capturing parentheses in the *\n* pattern. If you need to know the actual size of a match_data block as *\n* a number of bytes, you can find it like this: *\n* *\n* PCRE2_SIZE match_data_size = pcre2_get_match_data_size(match_data); *\n*************************************************************************/\n\nmatch_data = pcre2_match_data_create_from_pattern(re, NULL);\n\n/* Now run the match. */\n\nrc = pcre2_match(\n re, /* the compiled pattern */\n subject, /* the subject string */\n subject_length, /* the length of the subject */\n 0, /* start at offset 0 in the subject */\n 0, /* default options */\n match_data, /* block for storing the result */\n NULL); /* use default match context */\n\n/* Matching failed: handle error cases */\n\nif (rc < 0)\n {\n switch(rc)\n {\n case PCRE2_ERROR_NOMATCH: printf(\"No match\\n\"); break;\n /*\n Handle other special cases if you like\n */\n default: printf(\"Matching error %d\\n\", rc); break;\n }\n pcre2_match_data_free(match_data); /* Release memory used for the match */\n pcre2_code_free(re); /* data and the compiled pattern. */\n return 1;\n }\n\n/* Match succeeded. Get a pointer to the output vector, where string offsets\nare stored. */\n\novector = pcre2_get_ovector_pointer(match_data);\nprintf(\"Match succeeded at offset %d\\n\", (int)ovector[0]);\n\n\n/*************************************************************************\n* We have found the first match within the subject string. If the output *\n* vector wasn't big enough, say so. Then output any substrings that were *\n* captured. *\n*************************************************************************/\n\n/* The output vector wasn't big enough. This should not happen, because we used\npcre2_match_data_create_from_pattern() above. */\n\nif (rc == 0)\n printf(\"ovector was not big enough for all the captured substrings\\n\");\n\n/* Since release 10.38 PCRE2 has locked out the use of \\K in lookaround\nassertions. This is the recommended behaviour. However, the option\nPCRE2_EXTRA_ALLOW_LOOKAROUND_BSK allows applications to re-enable the old\nbehaviour. If that is set, it is possible to run patterns such as /(?=.\\K)/ that\nuse \\K in an assertion to set the start of a match later than its end. In this\ndemonstration program, we show how to detect this case, although it cannot arise\nbecause the option is never set. */\n\nif (ovector[0] > ovector[1])\n {\n printf(\"\\\\K was used in an assertion to set the match start after its end.\\n\"\n \"From end to start the match was: %.*s\\n\", (int)(ovector[0] - ovector[1]),\n (char *)(subject + ovector[1]));\n printf(\"Run abandoned\\n\");\n pcre2_match_data_free(match_data);\n pcre2_code_free(re);\n return 1;\n }\n\n/* Show substrings stored in the output vector by number. Obviously, in a real\napplication you might want to do things other than print them. */\n\nfor (i = 0; i < rc; i++)\n {\n PCRE2_SPTR substring_start = subject + ovector[2*i];\n PCRE2_SIZE substring_length = ovector[2*i+1] - ovector[2*i];\n printf(\"%2d: %.*s\\n\", i, (int)substring_length, (char *)substring_start);\n }\n\n\n/**************************************************************************\n* That concludes the basic part of this demonstration program. We have *\n* compiled a pattern, and performed a single match. The code that follows *\n* shows first how to access named substrings, and then how to code for *\n* repeated matches on the same subject. *\n**************************************************************************/\n\n/* See if there are any named substrings, and if so, show them by name. First\nwe have to extract the count of named parentheses from the pattern. */\n\n(void)pcre2_pattern_info(\n re, /* the compiled pattern */\n PCRE2_INFO_NAMECOUNT, /* get the number of named substrings */\n &namecount); /* where to put the answer */\n\nif (namecount == 0)\n printf(\"No named substrings\\n\");\nelse\n {\n PCRE2_SPTR tabptr;\n printf(\"Named substrings\\n\");\n\n /* Before we can access the substrings, we must extract the table for\n translating names to numbers, and the size of each entry in the table. */\n\n (void)pcre2_pattern_info(\n re, /* the compiled pattern */\n PCRE2_INFO_NAMETABLE, /* address of the table */\n &name_table); /* where to put the answer */\n\n (void)pcre2_pattern_info(\n re, /* the compiled pattern */\n PCRE2_INFO_NAMEENTRYSIZE, /* size of each entry in the table */\n &name_entry_size); /* where to put the answer */\n\n /* Now we can scan the table and, for each entry, print the number, the name,\n and the substring itself. In the 8-bit library the number is held in two\n bytes, most significant first. */\n\n tabptr = name_table;\n for (i = 0; i < namecount; i++)\n {\n int n = (tabptr[0] << 8) | tabptr[1];\n printf(\"(%d) %*s: %.*s\\n\", n, name_entry_size - 3, tabptr + 2,\n (int)(ovector[2*n+1] - ovector[2*n]), subject + ovector[2*n]);\n tabptr += name_entry_size;\n }\n }\n\n\n/*************************************************************************\n* If the \"-g\" option was given on the command line, we want to continue *\n* to search for additional matches in the subject string, in a similar *\n* way to the /g option in Perl. This turns out to be trickier than you *\n* might think because of the possibility of matching an empty string. *\n* *\n* To help with this task, PCRE2 provides the pcre2_next_match() helper. *\n*************************************************************************/\n\nif (!find_all) /* Check for -g */\n {\n pcre2_match_data_free(match_data); /* Release the memory that was used */\n pcre2_code_free(re); /* for the match data and the pattern. */\n return 0; /* Exit the program. */\n }\n\n/* Loop for second and subsequent matches */\n\novector_last[0] = ovector[0];\novector_last[1] = ovector[1];\n\nfor (;;)\n {\n PCRE2_SIZE start_offset;\n uint32_t options;\n\n /* After each successful match, we use pcre2_next_match() to obtain the match\n parameters for subsequent match attempts. */\n\n if (!pcre2_next_match(match_data, &start_offset, &options))\n break;\n\n /* Run the next matching operation */\n\n rc = pcre2_match(\n re, /* the compiled pattern */\n subject, /* the subject string */\n subject_length, /* the length of the subject */\n start_offset, /* starting offset in the subject */\n options, /* options */\n match_data, /* block for storing the result */\n NULL); /* use default match context */\n\n /* If this match attempt fails, exit the loop for subsequent matches. */\n\n if (rc == PCRE2_ERROR_NOMATCH)\n break;\n\n /* Other matching errors are not recoverable. */\n\n if (rc < 0)\n {\n printf(\"Matching error %d\\n\", rc);\n pcre2_match_data_free(match_data);\n pcre2_code_free(re);\n return 1;\n }\n\n /* This demonstration program depends on pcre2_next_match() to ensure that the\n loop for second and subsequent matches does not run forever. However, it would\n be robust practice for a production application to verify this. The following\n block of code shows how to do this. This error case is not reachable unless\n there is a bug in PCRE2.\n\n Because this program does not set the PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK option,\n the logic is simple. We verify that either ovector[1] has advanced, or that we\n have an empty match touching the end of a previous non-empty match. See the\n API documentation for guidance if your application uses\n PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK and searches for multiple matches. */\n\n if (!(ovector[1] > ovector_last[1] ||\n (ovector[1] == ovector[0] && ovector_last[1] > ovector_last[0] &&\n ovector[1] == ovector_last[1])))\n {\n printf(\"\\\\K was used in an assertion to yield non-advancing matches.\\n\");\n printf(\"Run abandoned\\n\");\n pcre2_match_data_free(match_data);\n pcre2_code_free(re);\n return 1;\n }\n\n ovector_last[0] = ovector[0];\n ovector_last[1] = ovector[1];\n\n /* Match succeeded. */\n\n printf(\"\\nMatch succeeded again at offset %d\\n\", (int)ovector[0]);\n\n /* The match succeeded, but the output vector wasn't big enough. This\n should not happen. */\n\n if (rc == 0)\n printf(\"ovector was not big enough for all the captured substrings\\n\");\n\n /* We guard against patterns such as /(?=.\\K)/ that use \\K in an assertion to\n set the start of a match later than its end. As explained above, this case\n should not occur because this demonstration program does not set the\n PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK option, however, we do include code showing\n how to detect it. */\n\n if (ovector[0] > ovector[1])\n {\n printf(\"\\\\K was used in an assertion to set the match start after its end.\\n\"\n \"From end to start the match was: %.*s\\n\", (int)(ovector[0] - ovector[1]),\n (char *)(subject + ovector[1]));\n printf(\"Run abandoned\\n\");\n pcre2_match_data_free(match_data);\n pcre2_code_free(re);\n return 1;\n }\n\n /* As before, show substrings stored in the output vector by number, and then\n also any named substrings. */\n\n for (i = 0; i < rc; i++)\n {\n PCRE2_SPTR substring_start = subject + ovector[2*i];\n size_t substring_length = ovector[2*i+1] - ovector[2*i];\n printf(\"%2d: %.*s\\n\", i, (int)substring_length, (char *)substring_start);\n }\n\n if (namecount == 0)\n printf(\"No named substrings\\n\");\n else\n {\n PCRE2_SPTR tabptr = name_table;\n printf(\"Named substrings\\n\");\n for (i = 0; i < namecount; i++)\n {\n int n = (tabptr[0] << 8) | tabptr[1];\n printf(\"(%d) %*s: %.*s\\n\", n, name_entry_size - 3, tabptr + 2,\n (int)(ovector[2*n+1] - ovector[2*n]), subject + ovector[2*n]);\n tabptr += name_entry_size;\n }\n }\n } /* End of loop to find second and subsequent matches */\n\nprintf(\"\\n\");\n\npcre2_match_data_free(match_data);\npcre2_code_free(re);\nreturn 0;\n}\n\n/* End of pcre2demo.c */\n\nReturn to the PCRE2 index page.\n
\n"
},
{
"path": "doc/html/pcre2grep.html",
"content": "\n\npcre2grep specification \n\n\npcre2grep man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- SYNOPSIS\n
- DESCRIPTION\n
- SUPPORT FOR COMPRESSED FILES\n
- BINARY FILES\n
- BINARY ZEROS IN PATTERNS\n
- OPTIONS\n
- ENVIRONMENT VARIABLES\n
- NEWLINES\n
- OPTIONS COMPATIBILITY WITH GNU GREP\n
- OPTIONS WITH DATA\n
- USING PCRE2'S CALLOUT FACILITY\n
- MATCHING ERRORS\n
- DIAGNOSTICS\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
SYNOPSIS
\n\npcre2grep [options] [long options] [pattern] [path1 path2 ...]\n
\nDESCRIPTION
\n\npcre2grep searches files for character patterns, in the same way as other\ngrep commands do, but it uses the PCRE2 regular expression library to support\npatterns that are compatible with the regular expressions of Perl 5. See\npcre2syntax(3)\nfor a quick-reference summary of pattern syntax, or\npcre2pattern(3)\nfor a full description of the syntax and semantics of the regular expressions\nthat PCRE2 supports.\n
\n\nPatterns, whether supplied on the command line or in a separate file, are given\nwithout delimiters. For example:\n
\n pcre2grep Thursday /etc/motd\n\nIf you attempt to use delimiters (for example, by surrounding a pattern with\nslashes, as is common in Perl scripts), they are interpreted as part of the\npattern. Quotes can of course be used to delimit patterns on the command line\nbecause they are interpreted by the shell, and indeed quotes are required if a\npattern contains white space or shell metacharacters.\n\n
\nThe first argument that follows any option settings is treated as the single\npattern to be matched when neither -e nor -f is present.\nConversely, when one or both of these options are used to specify patterns, all\narguments are treated as path names. At least one of -e, -f, or an\nargument pattern must be provided.\n
\n\nIf no files are specified, pcre2grep reads the standard input. The\nstandard input can also be referenced by a name consisting of a single hyphen.\nFor example:\n
\n pcre2grep some-pattern file1 - file3\n\nBy default, input files are searched line by line, so pattern assertions about\nthe beginning and end of a subject string (^, $, \\A, \\Z, and \\z) match at\nthe beginning and end of each line. When a line matches a pattern, it is copied\nto the standard output, and if there is more than one file, the file name is\noutput at the start of each line, followed by a colon. However, there are\noptions that can change how pcre2grep behaves. For example, the -M\noption makes it possible to search for strings that span line boundaries. What\ndefines a line boundary is controlled by the -N (--newline) option.\nThe -h and -H options control whether or not file names are shown,\nand the -Z option changes the file name terminator to a zero byte.\n\n
\nThe amount of memory used for buffering files that are being scanned is\ncontrolled by parameters that can be set by the --buffer-size and\n--max-buffer-size options. The first of these sets the size of buffer\nthat is obtained at the start of processing. If an input file contains very\nlong lines, a larger buffer may be needed; this is handled by automatically\nextending the buffer, up to the limit specified by --max-buffer-size. The\ndefault values for these parameters can be set when pcre2grep is\nbuilt; if nothing is specified, the defaults are set to 20KiB and 1MiB\nrespectively. An error occurs if a line is too long and the buffer can no\nlonger be expanded.\n
\n\nThe block of memory that is actually used is three times the \"buffer size\", to\nallow for buffering \"before\" and \"after\" lines. If the buffer size is too\nsmall, fewer than requested \"before\" and \"after\" lines may be output.\n
\n\nWhen matching with a multiline pattern, the size of the buffer must be at least\nhalf of the maximum match expected or the pattern might fail to match.\n
\n\nPatterns can be no longer than 8KiB or BUFSIZ bytes, whichever is the greater.\nBUFSIZ is defined in <stdio.h>. When there is more than one pattern\n(specified by the use of -e and/or -f), each pattern is applied to\neach line in the order in which they are defined, except that all the -e\npatterns are tried before the -f patterns.\n
\n\nBy default, as soon as one pattern matches a line, no further patterns are\nconsidered. However, if --colour (or --color) is used to colour the\nmatching substrings, or if --only-matching, --file-offsets,\n--line-offsets, or --output is used to output only the part of the\nline that matched (either shown literally, or as an offset), the behaviour is\ndifferent. In this situation, all the patterns are applied to the line. If\nthere is more than one match, the one that begins nearest to the start of the\nsubject is processed; if there is more than one match at that position, the one\nwith the longest matching substring is processed; if the matching substrings\nare equal, the first match found is processed.\n
\n\nScanning with all the patterns resumes immediately following the match, so that\nlater matches on the same line can be found. Note, however, that an overlapping\nmatch that starts in the middle of another match will not be processed.\n
\n\nThe above behaviour was changed at release 10.41 to be more compatible with GNU\ngrep. In earlier releases, pcre2grep did not recognize matches from\nlater patterns that were earlier in the subject.\n
\n\nPatterns that can match an empty string are accepted, but empty string\nmatches are never recognized. An example is the pattern \"(super)?(man)?\", in\nwhich all components are optional. This pattern finds all occurrences of both\n\"super\" and \"man\"; the output differs from matching with \"super|man\" when only\nthe matching substrings are being shown.\n
\n\nIf the LC_ALL or LC_CTYPE environment variable is set,\npcre2grep uses the value to set a locale when calling the PCRE2 library.\nThe --locale option can be used to override this.\n
\nSUPPORT FOR COMPRESSED FILES
\n\nCompile-time options for pcre2grep can set it up to use libz or\nlibbz2 for reading compressed files whose names end in .gz or\n.bz2, respectively. You can find out whether your pcre2grep binary\nhas support for one or both of these file types by running it with the\n--help option. If the appropriate support is not present, all files are\ntreated as plain text. The standard input is always so treated. If a file with\na .gz or .bz2 extension is not in fact compressed, it is read as a\nplain text file. When input is from a compressed .gz or .bz2 file, the\n--line-buffered option is ignored.\n
\nBINARY FILES
\n\nBy default, a file that contains a binary zero byte within the first 1024 bytes\nis identified as a binary file, and is processed specially. However, if the\nnewline type is specified as NUL, that is, the line terminator is a binary\nzero, the test for a binary file is not applied. See the --binary-files\noption for a means of changing the way binary files are handled.\n
\nBINARY ZEROS IN PATTERNS
\n\nPatterns passed from the command line are strings that are terminated by a\nbinary zero, so cannot contain internal zeros. However, patterns that are read\nfrom a file via the -f option may contain binary zeros.\n
\nOPTIONS
\n\nThe order in which some of the options appear can affect the output. For\nexample, both the -H and -l options affect the printing of file\nnames. Whichever comes later in the command line will be the one that takes\neffect. Similarly, except where noted below, if an option is given twice, the\nlater setting is used. Numerical values for options may be followed by K or M,\nto signify multiplication by 1024 or 1024*1024 respectively.\n
\n\n--\nThis terminates the list of options. It is useful if the next item on the\ncommand line starts with a hyphen but is not an option. This allows for the\nprocessing of patterns and file names that start with hyphens.\n
\n\n-A number, --after-context=number\nOutput up to number lines of context after each matching line. Fewer\nlines are output if the next match or the end of the file is reached, or if the\nprocessing buffer size has been set too small. If file names and/or line\nnumbers are being output, a hyphen separator is used instead of a colon for the\ncontext lines (the -Z option can be used to change the file name\nterminator to a zero byte). A line containing \"--\" is output between each group\nof lines, unless they are in fact contiguous in the input file. The value of\nnumber is expected to be relatively small. When -c is used,\n-A is ignored.\n
\n\n-a, --text\nTreat binary files as text. This is equivalent to\n--binary-files=text.\n
\n\n--allow-lookaround-bsk\nPCRE2 now forbids the use of \\K in lookarounds by default, in line with Perl.\nThis option causes pcre2grep to set the PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK\noption, which enables this somewhat dangerous usage.\n
\n\n-B number, --before-context=number\nOutput up to number lines of context before each matching line. Fewer\nlines are output if the previous match or the start of the file is within\nnumber lines, or if the processing buffer size has been set too small. If\nfile names and/or line numbers are being output, a hyphen separator is used\ninstead of a colon for the context lines (the -Z option can be used to\nchange the file name terminator to a zero byte). A line containing \"--\" is\noutput between each group of lines, unless they are in fact contiguous in the\ninput file. The value of number is expected to be relatively small. When\n-c is used, -B is ignored.\n
\n\n--binary-files=word\nSpecify how binary files are to be processed. If the word is \"binary\" (the\ndefault), pattern matching is performed on binary files, but the only output is\n\"Binary file <name> matches\" when a match succeeds. If the word is \"text\",\nwhich is equivalent to the -a or --text option, binary files are\nprocessed in the same way as any other file. In this case, when a match\nsucceeds, the output may be binary garbage, which can have nasty effects if\nsent to a terminal. If the word is \"without-match\", which is equivalent to the\n-I option, binary files are not processed at all; they are assumed not to\nbe of interest and are skipped without causing any output or affecting the\nreturn code.\n
\n\n--buffer-size=number\nSet the parameter that controls how much memory is obtained at the start of\nprocessing for buffering files that are being scanned. See also\n--max-buffer-size below.\n
\n\n-C number, --context=number\nOutput number lines of context both before and after each matching line.\nThis is equivalent to setting both -A and -B to the same value.\n
\n\n-c, --count\nDo not output lines from the files that are being scanned; instead output the\nnumber of lines that would have been shown, either because they matched, or, if\n-v is set, because they failed to match. By default, this count is\nexactly the same as the number of lines that would have been output, but if the\n-M (multiline) option is used (without -v), there may be more\nsuppressed lines than the count (that is, the number of matches).\n
\n
\nIf no lines are selected, the number zero is output. If several files are\nbeing scanned, a count is output for each of them and the -t option can\nbe used to cause a total to be output at the end. However, if the\n--files-with-matches option is also used, only those files whose counts\nare greater than zero are listed. When -c is used, the -A,\n-B, and -C options are ignored.\n
\n--colour, --color\nIf this option is given without any data, it is equivalent to \"--colour=auto\".\nIf data is required, it must be given in the same shell item, separated by an\nequals sign.\n
\n\n--colour=value, --color=value\nThis option specifies under what circumstances the parts of a line that matched\na pattern should be coloured in the output. It is ignored if\n--file-offsets, --line-offsets, or --output is set. By\ndefault, output is not coloured. The value for the --colour option (which\nis optional, see above) may be \"never\", \"always\", or \"auto\". In the latter\ncase, colouring happens only if the standard output is connected to a terminal.\nMore resources are used when colouring is enabled, because pcre2grep has\nto search for all possible matches in a line, not just one, in order to colour\nthem all.\n
\n
\nThe colour that is used can be specified by setting one of the environment\nvariables PCRE2GREP_COLOUR, PCRE2GREP_COLOR, PCREGREP_COLOUR, or\nPCREGREP_COLOR, which are checked in that order. If none of these are set,\npcre2grep looks for GREP_COLORS or GREP_COLOR (in that order). The value\nof the variable should be a string of two numbers, separated by a semicolon,\nexcept in the case of GREP_COLORS, which must start with \"ms=\" or \"mt=\"\nfollowed by two semicolon-separated colours, terminated by the end of the\nstring or by a colon. If GREP_COLORS does not start with \"ms=\" or \"mt=\" it is\nignored, and GREP_COLOR is checked.\n
\n
\nIf the string obtained from one of the above variables contains any characters\nother than semicolon or digits, the setting is ignored and the default colour\nis used. The string is copied directly into the control string for setting\ncolour on a terminal, so it is your responsibility to ensure that the values\nmake sense. If no relevant environment variable is set, the default is \"1;31\",\nwhich gives red.\n
\n-D action, --devices=action\nIf an input path is not a regular file or a directory, \"action\" specifies how\nit is to be processed. Valid values are \"read\" (the default) or \"skip\"\n(silently skip the path).\n
\n\n-d action, --directories=action\nIf an input path is a directory, \"action\" specifies how it is to be processed.\nValid values are \"read\" (the default in non-Windows environments, for\ncompatibility with GNU grep), \"recurse\" (equivalent to the -r option), or\n\"skip\" (silently skip the path, the default in Windows environments). In the\n\"read\" case, directories are read as if they were ordinary files. In some\noperating systems the effect of reading a directory like this is an immediate\nend-of-file; in others it may provoke an error.\n
\n\n--depth-limit=number\nSee --match-limit below.\n
\n\n-E, --case-restrict\nWhen case distinctions are being ignored in Unicode mode, two ASCII letters (K\nand S) will by default match Unicode characters U+212A (Kelvin sign) and U+017F\n(long S) respectively, as well as their lower case ASCII counterparts. When\nthis option is set, case equivalences are restricted such that no ASCII\ncharacter matches a non-ASCII character, and vice versa.\n
\n\n-e pattern, --regex=pattern, --regexp=pattern\nSpecify a pattern to be matched. This option can be used multiple times in\norder to specify several patterns. It can also be used as a way of specifying a\nsingle pattern that starts with a hyphen. When -e is used, no argument\npattern is taken from the command line; all arguments are treated as file\nnames. There is no limit to the number of patterns. They are applied to each\nline in the order in which they are defined.\n
\n
\nIf -f is used with -e, the command line patterns are matched first,\nfollowed by the patterns from the file(s), independent of the order in which\nthese options are specified.\n
\n--exclude=pattern\nFiles (but not directories) whose names match the pattern are skipped without\nbeing processed. This applies to all files, whether listed on the command line,\nobtained from --file-list, or by scanning a directory. The pattern is a\nPCRE2 regular expression, and is matched against the final component of the\nfile name, not the entire path. The -F, -w, and -x options do\nnot apply to this pattern. The option may be given any number of times in order\nto specify multiple patterns. If a file name matches both an --include\nand an --exclude pattern, it is excluded. There is no short form for this\noption.\n
\n\n--exclude-from=filename\nTreat each non-empty line of the file as the data for an --exclude\noption. What constitutes a newline when reading the file is the operating\nsystem's default. The --newline option has no effect on this option. This\noption may be given more than once in order to specify a number of files to\nread.\n
\n\n--exclude-dir=pattern\nDirectories whose names match the pattern are skipped without being processed,\nwhatever the setting of the --recursive option. This applies to all\ndirectories, whether listed on the command line, obtained from\n--file-list, or by scanning a parent directory. The pattern is a PCRE2\nregular expression, and is matched against the final component of the directory\nname, not the entire path. The -F, -w, and -x options do not\napply to this pattern. The option may be given any number of times in order to\nspecify more than one pattern. If a directory matches both --include-dir\nand --exclude-dir, it is excluded. There is no short form for this\noption.\n
\n\n-F, --fixed-strings\nInterpret each data-matching pattern as a list of fixed strings, separated by\nnewlines, instead of as a regular expression. What constitutes a newline for\nthis purpose is controlled by the --newline option. The -w (match\nas a word) and -x (match whole line) options can be used with -F.\nThey apply to each of the fixed strings. A line is selected if any of the fixed\nstrings are found in it (subject to -w or -x, if present). This\noption applies only to the patterns that are matched against the contents of\nfiles; it does not apply to patterns specified by any of the --include or\n--exclude options.\n
\n\n-f filename, --file=filename\nRead patterns from the file, one per line. As is the case with patterns on the\ncommand line, no delimiters should be used. What constitutes a newline when\nreading the file is the operating system's default interpretation of \\n. The\n--newline option has no effect on this option. Trailing white space is\nremoved from each line, and blank lines are ignored unless the\n--posix-pattern-file option is also provided. An empty file contains no\npatterns and therefore matches nothing. Patterns read from a file in this way\nmay contain binary zeros, which are treated as ordinary character literals.\n
\n
\nIf this option is given more than once, all the specified files are read. A\ndata line is output if any of the patterns match it. A file name can be given\nas \"-\" to refer to the standard input. When -f is used, patterns\nspecified on the command line using -e may also be present; they are\nmatched before the file's patterns. However, no pattern is taken from the\ncommand line; all arguments are treated as the names of paths to be searched.\n
\n--file-list=filename\nRead a list of files and/or directories that are to be scanned from the given\nfile, one per line. What constitutes a newline when reading the file is the\noperating system's default. Trailing white space is removed from each line, and\nblank lines are ignored. These paths are processed before any that are listed\non the command line. The file name can be given as \"-\" to refer to the standard\ninput. If --file and --file-list are both specified as \"-\",\npatterns are read first. This is useful only when the standard input is a\nterminal, from which further lines (the list of files) can be read after an\nend-of-file indication. If this option is given more than once, all the\nspecified files are read.\n
\n\n--file-offsets\nInstead of showing lines or parts of lines that match, show each match as an\noffset from the start of the file and a length, separated by a comma. In this\nmode, --colour has no effect, and no context is shown. That is, the\n-A, -B, and -C options are ignored. If there is more than one\nmatch in a line, each of them is shown separately. This option is mutually\nexclusive with --output, --line-offsets, and --only-matching.\n
\n\n--group-separator=text\nOutput this text string instead of two hyphens between groups of lines when\n-A, -B, or -C is in use. See also --no-group-separator.\n
\n\n-H, --with-filename\nForce the inclusion of the file name at the start of output lines when\nsearching a single file. The file name is not normally shown in this case.\nBy default, for matching lines, the file name is followed by a colon; for\ncontext lines, a hyphen separator is used. The -Z option can be used to\nchange the terminator to a zero byte. If a line number is also being output,\nit follows the file name. When the -M option causes a pattern to match\nmore than one line, only the first is preceded by the file name. This option\noverrides any previous -h, -l, or -L options.\n
\n\n-h, --no-filename\nSuppress the output file names when searching multiple files. File names are\nnormally shown when multiple files are searched. By default, for matching\nlines, the file name is followed by a colon; for context lines, a hyphen\nseparator is used. The -Z option can be used to change the terminator to\na zero byte. If a line number is also being output, it follows the file name.\nThis option overrides any previous -H, -L, or -l options.\n
\n\n--heap-limit=number\nSee --match-limit below.\n
\n\n--help\nOutput a help message, giving brief details of the command options and file\ntype support, and then exit. Anything else on the command line is\nignored.\n
\n\n-I\nIgnore binary files. This is equivalent to\n--binary-files=without-match.\n
\n\n-i, --ignore-case\nIgnore upper/lower case distinctions when pattern matching. This applies when\nmatching path names for inclusion or exclusion as well as when matching lines\nin files.\n
\n\n--include=pattern\nIf any --include patterns are specified, the only files that are\nprocessed are those whose names match one of the patterns and do not match an\n--exclude pattern. This option does not affect directories, but it\napplies to all files, whether listed on the command line, obtained from\n--file-list, or by scanning a directory. The pattern is a PCRE2 regular\nexpression, and is matched against the final component of the file name, not\nthe entire path. The -F, -w, and -x options do not apply to\nthis pattern. The option may be given any number of times. If a file name\nmatches both an --include and an --exclude pattern, it is excluded.\nThere is no short form for this option.\n
\n\n--include-from=filename\nTreat each non-empty line of the file as the data for an --include\noption. What constitutes a newline for this purpose is the operating system's\ndefault. The --newline option has no effect on this option. This option\nmay be given any number of times; all the files are read.\n
\n\n--include-dir=pattern\nIf any --include-dir patterns are specified, the only directories that\nare processed are those whose names match one of the patterns and do not match\nan --exclude-dir pattern. This applies to all directories, whether listed\non the command line, obtained from --file-list, or by scanning a parent\ndirectory. The pattern is a PCRE2 regular expression, and is matched against\nthe final component of the directory name, not the entire path. The -F,\n-w, and -x options do not apply to this pattern. The option may be\ngiven any number of times. If a directory matches both --include-dir and\n--exclude-dir, it is excluded. There is no short form for this option.\n
\n\n-L, --files-without-match\nInstead of outputting lines from the files, just output the names of the files\nthat do not contain any lines that would have been output. Each file name is\noutput once, on a separate line by default, but if the -Z option is set,\nthey are separated by zero bytes instead of newlines. This option overrides any\nprevious -H, -h, or -l options.\n
\n\n-l, --files-with-matches\nInstead of outputting lines from the files, just output the names of the files\ncontaining lines that would have been output. Each file name is output once, on\na separate line, but if the -Z option is set, they are separated by zero\nbytes instead of newlines. Searching normally stops as soon as a matching line\nis found in a file. However, if the -c (count) option is also used,\nmatching continues in order to obtain the correct count, and those files that\nhave at least one match are listed along with their counts. Using this option\nwith -c is a way of suppressing the listing of files with no matches that\noccurs with -c on its own. This option overrides any previous -H,\n-h, or -L options.\n
\n\n--label=name\nThis option supplies a name to be used for the standard input when file names\nare being output. If not supplied, \"(standard input)\" is used. There is no\nshort form for this option.\n
\n\n--line-buffered\nWhen this option is given, non-compressed input is read and processed line by\nline, and the output is flushed after each write. By default, input is read in\nlarge chunks, unless pcre2grep can determine that it is reading from a\nterminal, which is currently possible only in Unix-like environments or\nWindows. Output to terminal is normally automatically flushed by the operating\nsystem. This option can be useful when the input or output is attached to a\npipe and you do not want pcre2grep to buffer up large amounts of data.\nHowever, its use will affect performance, and the -M (multiline) option\nceases to work. When input is from a compressed .gz or .bz2 file,\n--line-buffered is ignored.\n
\n\n--line-offsets\nInstead of showing lines or parts of lines that match, show each match as a\nline number, the offset from the start of the line, and a length. The line\nnumber is terminated by a colon (as usual; see the -n option), and the\noffset and length are separated by a comma. In this mode, --colour has no\neffect, and no context is shown. That is, the -A, -B, and -C\noptions are ignored. If there is more than one match in a line, each of them is\nshown separately. This option is mutually exclusive with --output,\n--file-offsets, and --only-matching.\n
\n\n--locale=locale-name\nThis option specifies a locale to be used for pattern matching. It overrides\nthe value in the LC_ALL or LC_CTYPE environment variables. If no\nlocale is specified, the PCRE2 library's default (usually the \"C\" locale) is\nused. There is no short form for this option.\n
\n\n-M, --multiline\nAllow patterns to match more than one line. When this option is set, the PCRE2\nlibrary is called in \"multiline\" mode, and a match is allowed to continue past\nthe end of the initial line and onto one or more subsequent lines.\n
\n
\nPatterns used with -M may usefully contain literal newline characters and\ninternal occurrences of ^ and $ characters, because in multiline mode these can\nmatch at internal newlines. Because pcre2grep is scanning multiple lines,\nthe \\Z and \\z assertions match only at the end of the last line in the file.\nThe \\A assertion matches at the start of the first line of a match. This can\nbe any line in the file; it is not anchored to the first line.\n
\n
\nThe output for a successful match may consist of more than one line. The first\nline is the line in which the match started, and the last line is the line in\nwhich the match ended. If the matched string ends with a newline sequence, the\noutput ends at the end of that line. If -v is set, none of the lines in a\nmulti-line match are output. Once a match has been handled, scanning restarts\nat the beginning of the line after the one in which the match ended.\n
\n
\nThe newline sequence that separates multiple lines must be matched as part of\nthe pattern. For example, to find the phrase \"regular expression\" in a file\nwhere \"regular\" might be at the end of a line and \"expression\" at the start of\nthe next line, you could use this command:\n
\n pcre2grep -M 'regular\\s+expression' <file>\n\nThe \\s escape sequence matches any white space character, including newlines,\nand is followed by + so as to match trailing white space on the first line as\nwell as possibly handling a two-character newline sequence.\n
\n
\nThere is a limit to the number of lines that can be matched, imposed by the way\nthat pcre2grep buffers the input file as it scans it. With a sufficiently\nlarge processing buffer, this should not be a problem.\n
\n
\nThe -M option does not work when input is read line by line (see\n--line-buffered.)\n\n
\n-m number, --max-count=number\nStop processing after finding number matching lines, or non-matching\nlines if -v is also set. Any trailing context lines are output after the\nfinal match. In multiline mode, each multiline match counts as just one line\nfor this purpose. If this limit is reached when reading the standard input from\na regular file, the file is left positioned just after the last matching line.\nIf -c is also set, the count that is output is never greater than\nnumber. This option has no effect if used with -L, -l, or\n-q, or when just checking for a match in a binary file.\n
\n\n--match-limit=number\nProcessing some regular expression patterns may take a very long time to search\nfor all possible matching strings. Others may require a very large amount of\nmemory. There are three options that set resource limits for matching.\n
\n
\nThe --match-limit option provides a means of limiting computing resource\nusage when processing patterns that are not going to match, but which have a\nvery large number of possibilities in their search trees. The classic example\nis a pattern that uses nested unlimited repeats. Internally, PCRE2 has a\ncounter that is incremented each time around its main processing loop. If the\nvalue set by --match-limit is reached, an error occurs.\n
\n
\nThe --heap-limit option specifies, as a number of kibibytes (units of\n1024 bytes), the maximum amount of heap memory that may be used for matching.\n
\n
\nThe --depth-limit option limits the depth of nested backtracking points,\nwhich indirectly limits the amount of memory that is used. The amount of memory\nneeded for each backtracking point depends on the number of capturing\nparentheses in the pattern, so the amount of memory that is used before this\nlimit acts varies from pattern to pattern. This limit is of use only if it is\nset smaller than --match-limit.\n
\n
\nThere are no short forms for these options. The default limits can be set\nwhen the PCRE2 library is compiled; if they are not specified, the defaults\nare very large and so effectively unlimited.\n
\n--max-buffer-size=number\nThis limits the expansion of the processing buffer, whose initial size can be\nset by --buffer-size. The maximum buffer size is silently forced to be no\nsmaller than the starting buffer size.\n
\n\n-N newline-type, --newline=newline-type\nSix different conventions for indicating the ends of lines in scanned files are\nsupported. For example:\n
\n pcre2grep -N CRLF 'some pattern' <file>\n\nThe newline type may be specified in upper, lower, or mixed case. If the\nnewline type is NUL, lines are separated by binary zero characters. The other\ntypes are the single-character sequences CR (carriage return) and LF\n(linefeed), the two-character sequence CRLF, an \"anycrlf\" type, which\nrecognizes any of the preceding three types, and an \"any\" type, for which any\nUnicode line ending sequence is assumed to end a line. The Unicode sequences\nare the three just mentioned, plus VT (vertical tab, U+000B), FF (form feed,\nU+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS\n(paragraph separator, U+2029).\n
\n
\nWhen the PCRE2 library is built, a default line-ending sequence is specified.\nThis is normally the standard sequence for the operating system. Unless\notherwise specified by this option, pcre2grep uses the library's default.\n
\n
\nThis option makes it possible to use pcre2grep to scan files that have\ncome from other environments without having to modify their line endings. If\nthe data that is being scanned does not agree with the convention set by this\noption, pcre2grep may behave in strange ways. Note that this option does\nnot apply to files specified by the -f, --exclude-from, or\n--include-from options, which are expected to use the operating system's\nstandard newline sequence.\n\n
\n-n, --line-number\nPrecede each output line by its line number in the file, followed by a colon\nfor matching lines or a hyphen for context lines. If the file name is also\nbeing output, it precedes the line number. When the -M option causes a\npattern to match more than one line, only the first is preceded by its line\nnumber. This option is forced if --line-offsets is used.\n
\n\n--no-group-separator\nDo not output a separator between groups of lines when -A, -B, or\n-C is in use. The default is to output a line containing two hyphens. See\nalso --group-separator.\n
\n\n--no-jit\nIf the PCRE2 library is built with support for just-in-time compiling (which\nspeeds up matching), pcre2grep automatically makes use of this, unless it\nwas explicitly disabled at build time. This option can be used to disable the\nuse of JIT at run time. It is provided for testing and working around problems.\nIt should never be needed in normal use.\n
\n\n-O text, --output=text\nWhen there is a match, instead of outputting the line that matched, output just\nthe text specified in this option, followed by an operating-system standard\nnewline. In this mode, --colour has no effect, and no context is shown.\nThat is, the -A, -B, and -C options are ignored. The\n--newline option has no effect on this option, which is mutually\nexclusive with --only-matching, --file-offsets, and\n--line-offsets. However, like --only-matching, if there is more\nthan one match in a line, each of them causes a line of output.\n
\n
\nEscape sequences starting with a dollar character may be used to insert the\ncontents of the matched part of the line and/or captured substrings into the\ntext.\n
\n
\n$<digits> or ${<digits>} is replaced by the captured substring of the given\ndecimal number; $& (or the legacy $0) substitutes the whole match. If the\nnumber is greater than the number of capturing substrings, or if the capture\nis unset, the replacement is empty.\n
\n
\n$a is replaced by bell; $b by backspace; $e by escape; $f by form feed; $n by\nnewline; $r by carriage return; $t by tab; $v by vertical tab.\n
\n
\n$o<digits> or $o{<digits>} is replaced by the character whose code point is the\ngiven octal number. In the first form, up to three octal digits are processed.\nWhen more digits are needed in Unicode mode to specify a wide character, the\nsecond form must be used.\n
\n
\n$x<digits> or $x{<digits>} is replaced by the character represented by the\ngiven hexadecimal number. In the first form, up to two hexadecimal digits are\nprocessed. When more digits are needed in Unicode mode to specify a wide\ncharacter, the second form must be used.\n
\n
\nAny other character is substituted by itself. In particular, $$ is replaced by\na single dollar.\n
\n-o, --only-matching\nShow only the part of the line that matched a pattern instead of the whole\nline. In this mode, no context is shown. That is, the -A, -B, and\n-C options are ignored. If there is more than one match in a line, each\nof them is shown separately, on a separate line of output. If -o is\ncombined with -v (invert the sense of the match to find non-matching\nlines), no output is generated, but the return code is set appropriately. If\nthe matched portion of the line is empty, nothing is output unless the file\nname or line number are being printed, in which case they are shown on an\notherwise empty line. This option is mutually exclusive with --output,\n--file-offsets and --line-offsets.\n
\n\n-onumber, --only-matching=number\nShow only the part of the line that matched the capturing parentheses of the\ngiven number. Up to 50 capturing parentheses are supported by default. This\nlimit can be changed via the --om-capture option. A pattern may contain\nany number of capturing parentheses, but only those whose number is within the\nlimit can be accessed by -o. An error occurs if the number specified by\n-o is greater than the limit.\n
\n
\n-o0 is the same as -o without a number. Because these options can be\ngiven without an argument (see above), if an argument is present, it must be\ngiven in the same shell item, for example, -o3 or --only-matching=2. The\ncomments given for the non-argument case above also apply to this option. If\nthe specified capturing parentheses do not exist in the pattern, or were not\nset in the match, nothing is output unless the file name or line number are\nbeing output.\n
\n
\nIf this option is given multiple times, multiple substrings are output for each\nmatch, in the order the options are given, and all on one line. For example,\n-o3 -o1 -o3 causes the substrings matched by capturing parentheses 3 and 1 and\nthen 3 again to be output. By default, there is no separator (but see the next\nbut one option).\n
\n--om-capture=number\nSet the number of capturing parentheses that can be accessed by -o. The\ndefault is 50.\n
\n\n--om-separator=text\nSpecify a separating string for multiple occurrences of -o. The default\nis an empty string. Separating strings are never coloured.\n
\n\n-P, --no-ucp\nStarting from release 10.43, when UTF/Unicode mode is specified with -u\nor -U, the PCRE2_UCP option is used by default. This means that the\nPOSIX classes in patterns match more than just ASCII characters. For example,\n[:digit:] matches any Unicode decimal digit. The --no-ucp option\nsuppresses PCRE2_UCP, thus restricting the POSIX classes to ASCII characters,\nas was the case in earlier releases. Note that there are now more fine-grained\noption settings within patterns that affect individual classes. For example,\nwhen in UCP mode, the sequence (?aP) restricts [:word:] to ASCII letters, while\nallowing \\w to match Unicode letters and digits.\n
\n\n--posix-pattern-file\nWhen patterns are provided with the -f option, do not trim trailing\nspaces or ignore empty lines in a similar way than other grep tools. To keep\nthe behaviour consistent with older versions, if the pattern read was\nterminated with CRLF (as character literals) then both characters won't be\nincluded as part of it, so if you really need to have pattern ending in '\\r',\nuse a escape sequence or provide it by a different method.\n
\n\n-q, --quiet\nWork quietly, that is, display nothing except error messages. The exit\nstatus indicates whether or not any matches were found.\n
\n\n-r, --recursive\nIf any given path is a directory, recursively scan the files it contains,\ntaking note of any --include and --exclude settings. By default, a\ndirectory is read as a normal file; in some operating systems this gives an\nimmediate end-of-file. This option is a shorthand for setting the -d\noption to \"recurse\".\n
\n\n--recursion-limit=number\nThis is an obsolete synonym for --depth-limit. See --match-limit\nabove for details.\n
\n\n-s, --no-messages\nSuppress error messages about non-existent or unreadable files. Such files are\nquietly skipped. However, the return code is still 2, even if matches were\nfound in other files.\n
\n\n-t, --total-count\nThis option is useful when scanning more than one file. If used on its own,\n-t suppresses all output except for a grand total number of matching\nlines (or non-matching lines if -v is used) in all the files. If -t\nis used with -c, a grand total is output except when the previous output\nis just one line. In other words, it is not output when just one file's count\nis listed. If file names are being output, the grand total is preceded by\n\"TOTAL:\". Otherwise, it appears as just another number. The -t option is\nignored when used with -L (list files without matches), because the grand\ntotal would always be zero.\n
\n\n-u, --utf\nOperate in UTF/Unicode mode. This option is available only if PCRE2 has been\ncompiled with UTF-8 support. All patterns (including those for any\n--exclude and --include options) and all lines that are scanned\nmust be valid strings of UTF-8 characters. If an invalid UTF-8 string is\nencountered, an error occurs.\n
\n\n-U, --utf-allow-invalid\nAs --utf, but in addition subject lines may contain invalid UTF-8 code\nunit sequences. These can never form part of any pattern match. Patterns\nthemselves, however, must still be valid UTF-8 strings. This facility allows\nvalid UTF-8 strings to be sought within arbitrary byte sequences in executable\nor other binary files. For more details about matching in non-valid UTF-8\nstrings, see the\npcre2unicode(3)\ndocumentation.\n
\n\n-V, --version\nWrite the version numbers of pcre2grep and the PCRE2 library to the\nstandard output and then exit. Anything else on the command line is\nignored.\n
\n\n-v, --invert-match\nInvert the sense of the match, so that lines which do not match any of\nthe patterns are the ones that are found. When this option is set, options such\nas --only-matching and --output, which specify parts of a match\nthat are to be output, are ignored.\n
\n\n-w, --word-regex, --word-regexp\nForce the patterns only to match \"words\". That is, there must be a word\nboundary at the start and end of each matched string. This is equivalent to\nhaving \"\\b(?:\" at the start of each pattern, and \")\\b\" at the end. This\noption applies only to the patterns that are matched against the contents of\nfiles; it does not apply to patterns specified by any of the --include or\n--exclude options.\n
\n\n-x, --line-regex, --line-regexp\nForce the patterns to start matching only at the beginnings of lines, and in\naddition, require them to match entire lines. In multiline mode the match may\nbe more than one line. This is equivalent to having \"^(?:\" at the start of each\npattern and \")$\" at the end. This option applies only to the patterns that are\nmatched against the contents of files; it does not apply to patterns specified\nby any of the --include or --exclude options.\n
\n\n-Z, --null\nTerminate files names in the regular output with a zero byte (the NUL\ncharacter) instead of what would normally appear. This is useful when file\nnames contain unusual characters such as colons, hyphens, or even newlines. The\noption does not apply to file names in error messages.\n
\nENVIRONMENT VARIABLES
\n\nThe environment variables LC_ALL and LC_CTYPE are examined, in that\norder, for a locale. The first one that is set is used. This can be overridden\nby the --locale option. If no locale is set, the PCRE2 library's default\n(usually the \"C\" locale) is used.\n
\nNEWLINES
\n\nThe -N (--newline) option allows pcre2grep to scan files with\nnewline conventions that differ from the default. This option affects only the\nway scanned files are processed. It does not affect the interpretation of files\nspecified by the -f, --file-list, --exclude-from, or\n--include-from options.\n
\n\nAny parts of the scanned input files that are written to the standard output\nare copied with whatever newline sequences they have in the input. However, if\nthe final line of a file is output, and it does not end with a newline\nsequence, a newline sequence is added. If the newline setting is CR, LF, CRLF\nor NUL, that line ending is output; for the other settings (ANYCRLF or ANY) a\nsingle NL is used.\n
\n\nThe newline setting does not affect the way in which pcre2grep writes\nnewlines in informational messages to the standard output and error streams.\nUnder Windows, the standard output is set to be binary, so that \"\\r\\n\" at the\nends of output lines that are copied from the input is not converted to\n\"\\r\\r\\n\" by the C I/O library. This means that any messages written to the\nstandard output must end with \"\\r\\n\". For all other operating systems, and\nfor all messages to the standard error stream, \"\\n\" is used.\n
\nOPTIONS COMPATIBILITY WITH GNU GREP
\n\nMany of the short and long forms of pcre2grep's options are the same as\nin the GNU grep program. Any long option of the form --xxx-regexp\n(GNU terminology) is also available as --xxx-regex (PCRE2 terminology).\nHowever, the --case-restrict, --depth-limit, -E,\n--file-list, --file-offsets, --heap-limit,\n--include-dir, --line-offsets, --locale, --match-limit,\n-M, --multiline, -N, --newline, --no-ucp,\n--om-separator, --output, -P, -u, --utf,\n-U, and --utf-allow-invalid options are specific to\npcre2grep, as is the use of the --only-matching option with a\ncapturing parentheses number.\n
\n\nAlthough most of the common options work the same way, a few are different in\npcre2grep. For example, the --include option's argument is a glob\nfor GNU grep, but in pcre2grep it is a regular expression to which\nthe -i option applies. If both the -c and -l options are\ngiven, GNU grep lists only file names, without counts, but pcre2grep\ngives the counts as well.\n
\nOPTIONS WITH DATA
\n\nThere are four different ways in which an option with data can be specified.\nIf a short form option is used, the data may follow immediately, or (with one\nexception) in the next command line item. For example:\n
\n -f/some/file\n -f /some/file\n\nThe exception is the -o option, which may appear with or without data.\nBecause of this, if data is present, it must follow immediately in the same\nitem, for example -o3.\n\n
\nIf a long form option is used, the data may appear in the same command line\nitem, separated by an equals character, or (with two exceptions) it may appear\nin the next command line item. For example:\n
\n --file=/some/file\n --file /some/file\n\nNote, however, that if you want to supply a file name beginning with ~ as data\nin a shell command, and have the shell expand ~ to a home directory, you must\nseparate the file name from the option, because the shell does not treat ~\nspecially unless it is at the start of an item.\n\n
\nThe exceptions to the above are the --colour (or --color) and\n--only-matching options, for which the data is optional. If one of these\noptions does have data, it must be given in the first form, using an equals\ncharacter. Otherwise pcre2grep will assume that it has no data.\n
\nUSING PCRE2'S CALLOUT FACILITY
\n\npcre2grep has, by default, support for calling external programs or\nscripts or echoing specific strings during matching by making use of PCRE2's\ncallout facility. However, this support can be completely or partially disabled\nwhen pcre2grep is built. You can find out whether your binary has support\nfor callouts by running it with the --help option. If callout support is\ncompletely disabled, callouts in patterns are forbidden by pcre2grep.\nIf the facility is partially disabled, calling external programs is not\nsupported, and callouts that request it are ignored.\n
\n\nA callout in a PCRE2 pattern is of the form (?C<arg>) where the argument is\neither a number or a quoted string (see the\npcre2callout\ndocumentation for details). Numbered callouts are ignored by pcre2grep;\nonly callouts with string arguments are useful.\n
\n\nEchoing a specific string\n
\n\nStarting the callout string with a pipe character invokes an echoing facility\nthat avoids calling an external program or script. This facility is always\navailable, provided that callouts were not completely disabled when\npcre2grep was built. The rest of the callout string is processed as a\nzero-terminated string, which means it should not contain any internal binary\nzeros. It is written to the output, having first been passed through the same\nescape processing as text from the --output (-O) option (see\nabove). However, $0 or $& cannot be used to insert a matched substring because\nthe match is still in progress. Instead, the single character '0' is inserted.\nAny syntax errors in the string (for example, a dollar not followed by another\ncharacter) causes the callout to be ignored. No terminator is added to the\noutput string, so if you want a newline, you must include it explicitly using\nthe escape $n. For example:\n
\n pcre2grep '(.)(..(.))(?C\"|[$1] [$2] [$3]$n\")' <some file>\n\nMatching continues normally after the string is output. If you want to see only\nthe callout output but not any output from an actual match, you should end the\npattern with (*FAIL).\n\n
\nCalling external programs or scripts\n
\n\nThis facility can be independently disabled when pcre2grep is built. It\nis supported for Windows, where a call to _spawnvp() is used, for VMS,\nwhere lib$spawn() is used, and for any Unix-like environment where\nfork() and execv() are available.\n
\n\nIf the callout string does not start with a pipe (vertical bar) character, it\nis parsed into a list of substrings separated by pipe characters. The first\nsubstring must be an executable name, with the following substrings specifying\narguments:\n
\n executable_name|arg1|arg2|...\n\nAny substring (including the executable name) may contain escape sequences\nstarted by a dollar character. These are the same as for the --output\n(-O) option documented above, except that $0 or $& cannot insert the\nmatched string because the match is still in progress. Instead, the character\n'0' is inserted. If you need a literal dollar or pipe character in any\nsubstring, use $$ or $| respectively. Here is an example:\n
\n echo -e \"abcde\\n12345\" | pcre2grep \\\n '(?x)(.)(..(.))\n (?C\"/bin/echo|Arg1: [$1] [$2] [$3]|Arg2: $|${1}$| ($4)\")()' -\n\n Output:\n\n Arg1: [a] [bcd] [d] Arg2: |a| ()\n abcde\n Arg1: [1] [234] [4] Arg2: |1| ()\n 12345\n\nThe parameters for the system call that is used to run the program or script\nare zero-terminated strings. This means that binary zero characters in the\ncallout argument will cause premature termination of their substrings, and\ntherefore should not be present. Any syntax errors in the string (for example,\na dollar not followed by another character) causes the callout to be ignored.\nIf running the program fails for any reason (including the non-existence of the\nexecutable), a local matching failure occurs and the matcher backtracks in the\nnormal way.\n\nMATCHING ERRORS
\n\nIt is possible to supply a regular expression that takes a very long time to\nfail to match certain lines. Such patterns normally involve nested indefinite\nrepeats, for example: (a+)*\\d when matched against a line of a's with no final\ndigit. The PCRE2 matching function has a resource limit that causes it to abort\nin these circumstances. If this happens, pcre2grep outputs an error\nmessage and the line that caused the problem to the standard error stream. If\nthere are more than 20 such errors, pcre2grep gives up.\n
\n\nThe --match-limit option of pcre2grep can be used to set the\noverall resource limit. There are also other limits that affect the amount of\nmemory used during matching; see the discussion of --heap-limit and\n--depth-limit above.\n
\nDIAGNOSTICS
\n\nExit status is 0 if any matches were found, 1 if no matches were found, and 2\nfor syntax errors, overlong lines, non-existent or inaccessible files (even if\nmatches were found in other files) or too many matching errors. Using the\n-s option to suppress error messages about inaccessible files does not\naffect the return code.\n
\n\nWhen run under VMS, the return code is placed in the symbol PCRE2GREP_RC\nbecause VMS does not distinguish between exit(0) and exit(1).\n
\nSEE ALSO
\n\npcre2pattern(3), pcre2syntax(3), pcre2callout(3),\npcre2unicode(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 24 January 2025\n
\nCopyright © 1997-2023 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2jit.html", "content": "\n\npcre2jit man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 JUST-IN-TIME COMPILER SUPPORT\n
- AVAILABILITY OF JIT SUPPORT\n
- SIMPLE USE OF JIT\n
- MATCHING SUBJECTS CONTAINING INVALID UTF\n
- UNSUPPORTED OPTIONS AND PATTERN ITEMS\n
- RETURN VALUES FROM JIT MATCHING\n
- CONTROLLING THE JIT STACK\n
- JIT STACK FAQ\n
- FREEING JIT SPECULATIVE MEMORY\n
- EXAMPLE CODE\n
- JIT FAST PATH API\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
PCRE2 JUST-IN-TIME COMPILER SUPPORT
\n\nJust-in-time compiling is a heavyweight optimization that can greatly speed up\npattern matching. However, it comes at the cost of extra processing before the\nmatch is performed, so it is of most benefit when the same pattern is going to\nbe matched many times. This does not necessarily mean many calls of a matching\nfunction; if the pattern is not anchored, matching attempts may take place many\ntimes at various positions in the subject, even for a single call. Therefore,\nif the subject string is very long, it may still pay to use JIT even for\none-off matches. JIT support is available for all of the 8-bit, 16-bit and\n32-bit PCRE2 libraries.\n
\n\nJIT support applies only to the traditional Perl-compatible matching function.\nIt does not apply when the DFA matching function is being used. The code for\nJIT support was written by Zoltan Herczeg.\n
\nAVAILABILITY OF JIT SUPPORT
\n\nJIT support is an optional feature of PCRE2. The \"configure\" option\n--enable-jit (or equivalent CMake option) must be set when PCRE2 is built if\nyou want to use JIT. The support is limited to the following hardware\nplatforms:\n
\n ARM 32-bit (v7, and Thumb2)\n ARM 64-bit\n IBM s390x 64 bit\n Intel x86 32-bit and 64-bit\n LoongArch 64 bit\n MIPS 32-bit and 64-bit\n Power PC 32-bit and 64-bit\n RISC-V 32-bit and 64-bit\n\nIf --enable-jit is set on an unsupported platform, compilation fails.\n\n
\nA client program can tell if JIT support has been compiled by calling\npcre2_config() with the PCRE2_CONFIG_JIT option. The result is one if\nPCRE2 was built with JIT support, and zero otherwise. However, having the JIT\ncode available does not guarantee that it will be used for any particular\nmatch. One reason for this is that there are a number of options and pattern\nitems that are\nnot supported by JIT\n(see below). Another reason is that in some environments JIT is unable to get\nexecutable memory in which to build its compiled code. The only guarantee from\npcre2_config() is that if it returns zero, JIT will definitely not\nbe used.\n
\n\nAs of release 10.45 there is a more informative way to test for JIT support. If\npcre2_compile_jit() is called with the single option PCRE2_JIT_TEST_ALLOC\nit returns zero if JIT is available and has a working allocator. Otherwise it\nreturns PCRE2_ERROR_NOMEMORY if JIT is available but cannot allocate executable\nmemory, or PCRE2_ERROR_JIT_UNSUPPORTED if JIT support is not compiled. The\ncode argument is ignored, so it can be a NULL value.\n
\n\nA simple program does not need to check availability in order to use JIT when\npossible. The API is implemented in a way that falls back to the interpretive\ncode if JIT is not available or cannot be used for a given match. For programs\nthat need the best possible performance, there is a\n\"fast path\"\nAPI that is JIT-specific.\n
\nSIMPLE USE OF JIT
\n\nTo make use of the JIT support in the simplest way, all you have to do is to\ncall pcre2_jit_compile() after successfully compiling a pattern with\npcre2_compile(). This function has two arguments: the first is the\ncompiled pattern pointer that was returned by pcre2_compile(), and the\nsecond is zero or more of the following option bits: PCRE2_JIT_COMPLETE,\nPCRE2_JIT_PARTIAL_HARD, or PCRE2_JIT_PARTIAL_SOFT.\n
\n\nIf JIT support is not available, a call to pcre2_jit_compile() does\nnothing and returns PCRE2_ERROR_JIT_BADOPTION. Otherwise, the compiled pattern\nis passed to the JIT compiler, which turns it into machine code that executes\nmuch faster than the normal interpretive code, but yields exactly the same\nresults. The returned value from pcre2_jit_compile() is zero on success,\nor a negative error code.\n
\n\nThere is a limit to the size of pattern that JIT supports, imposed by the size\nof machine stack that it uses. The exact rules are not documented because they\nmay change at any time, in particular, when new optimizations are introduced.\nIf a pattern is too big, a call to pcre2_jit_compile() returns\nPCRE2_ERROR_NOMEMORY.\n
\n\nPCRE2_JIT_COMPLETE requests the JIT compiler to generate code for complete\nmatches. If you want to run partial matches using the PCRE2_PARTIAL_HARD or\nPCRE2_PARTIAL_SOFT options of pcre2_match(), you should set one or both\nof the other options as well as, or instead of PCRE2_JIT_COMPLETE. The JIT\ncompiler generates different optimized code for each of the three modes\n(normal, soft partial, hard partial). When pcre2_match() is called, the\nappropriate code is run if it is available. Otherwise, the pattern is matched\nusing interpretive code.\n
\n\nYou can call pcre2_jit_compile() multiple times for the same compiled\npattern. It does nothing if it has previously compiled code for any of the\noption bits. For example, you can call it once with PCRE2_JIT_COMPLETE and\n(perhaps later, when you find you need partial matching) again with\nPCRE2_JIT_COMPLETE and PCRE2_JIT_PARTIAL_HARD. This time it will ignore\nPCRE2_JIT_COMPLETE and just compile code for partial matching. If\npcre2_jit_compile() is called with no option bits set, it immediately\nreturns zero. This is an alternative way of testing whether JIT support has\nbeen compiled.\n
\n\nAt present, it is not possible to free JIT compiled code except when the entire\ncompiled pattern is freed by calling pcre2_code_free().\n
\n\nIn some circumstances you may need to call additional functions. These are\ndescribed in the section entitled\n\"Controlling the JIT stack\"\nbelow.\n
\n\nThere are some pcre2_match() options that are not supported by JIT, and\nthere are also some pattern items that JIT cannot handle. Details are given\nbelow.\nIn both cases, matching automatically falls back to the interpretive code. If\nyou want to know whether JIT was actually used for a particular match, you\nshould arrange for a JIT callback function to be set up as described in the\nsection entitled\n\"Controlling the JIT stack\"\nbelow, even if you do not need to supply a non-default JIT stack. Such a\ncallback function is called whenever JIT code is about to be obeyed. If the\nmatch-time options are not right for JIT execution, the callback function is\nnot obeyed.\n
\n\nIf the JIT compiler finds an unsupported item, no JIT data is generated. You\ncan find out if JIT compilation was successful for a compiled pattern by\ncalling pcre2_pattern_info() with the PCRE2_INFO_JITSIZE option. A\nnon-zero result means that JIT compilation was successful. A result of 0 means\nthat JIT support is not available, or the pattern was not processed by\npcre2_jit_compile(), or the JIT compiler was not able to handle the\npattern. Successful JIT compilation does not, however, guarantee the use of JIT\nat match time because there are some match time options that are not supported\nby JIT.\n
\nMATCHING SUBJECTS CONTAINING INVALID UTF
\n\nWhen a pattern is compiled with the PCRE2_UTF option, subject strings are\nnormally expected to be a valid sequence of UTF code units. By default, this is\nchecked at the start of matching and an error is generated if invalid UTF is\ndetected. The PCRE2_NO_UTF_CHECK option can be passed to pcre2_match() to\nskip the check (for improved performance) if you are sure that a subject string\nis valid. If this option is used with an invalid string, the result is\nundefined. The calling program may crash or loop or otherwise misbehave.\n
\n\nHowever, a way of running matches on strings that may contain invalid UTF\nsequences is available. Calling pcre2_compile() with the\nPCRE2_MATCH_INVALID_UTF option has two effects: it tells the interpreter in\npcre2_match() to support invalid UTF, and, if pcre2_jit_compile()\nis subsequently called, the compiled JIT code also supports invalid UTF.\nDetails of how this support works, in both the JIT and the interpretive cases,\nis given in the\npcre2unicode\ndocumentation.\n
\n\nThere is also an obsolete option for pcre2_jit_compile() called\nPCRE2_JIT_INVALID_UTF, which currently exists only for backward compatibility.\nIt is superseded by the pcre2_compile() option PCRE2_MATCH_INVALID_UTF\nand should no longer be used. It may be removed in future.\n
\nUNSUPPORTED OPTIONS AND PATTERN ITEMS
\n\nThe pcre2_match() options that are supported for JIT matching are\nPCRE2_COPY_MATCHED_SUBJECT, PCRE2_NOTBOL, PCRE2_NOTEOL, PCRE2_NOTEMPTY,\nPCRE2_NOTEMPTY_ATSTART, PCRE2_NO_UTF_CHECK, PCRE2_PARTIAL_HARD, and\nPCRE2_PARTIAL_SOFT. The PCRE2_ANCHORED and PCRE2_ENDANCHORED options are not\nsupported at match time.\n
\n\nIf the PCRE2_NO_JIT option is passed to pcre2_match() it disables the\nuse of JIT, forcing matching by the interpreter code.\n
\n\nThe only unsupported pattern items are \\C (match a single data unit) when\nrunning in a UTF mode, and a callout immediately before an assertion condition\nin a conditional group.\n
\nRETURN VALUES FROM JIT MATCHING
\n\nWhen a pattern is matched using JIT, the return values are the same as those\ngiven by the interpretive pcre2_match() code, with the addition of one\nnew error code: PCRE2_ERROR_JIT_STACKLIMIT. This means that the memory used for\nthe JIT stack was insufficient. See\n\"Controlling the JIT stack\"\nbelow for a discussion of JIT stack usage.\n
\n\nThe error code PCRE2_ERROR_MATCHLIMIT is returned by the JIT code if searching\na very large pattern tree goes on for too long, as it is in the same\ncircumstance when JIT is not used, but the details of exactly what is counted\nare not the same. The PCRE2_ERROR_DEPTHLIMIT error code is never returned\nwhen JIT matching is used.\n
\nCONTROLLING THE JIT STACK
\n\nWhen the compiled JIT code runs, it needs a block of memory to use as a stack.\nBy default, it uses 32KiB on the machine stack. However, some large or\ncomplicated patterns need more than this. The error PCRE2_ERROR_JIT_STACKLIMIT\nis given when there is not enough stack. Three functions are provided for\nmanaging blocks of memory for use as JIT stacks. There is further discussion\nabout the use of JIT stacks in the section entitled\n\"JIT stack FAQ\"\nbelow.\n
\n\nThe pcre2_jit_stack_create() function creates a JIT stack. Its arguments\nare a starting size, a maximum size, and a general context (for memory\nallocation functions, or NULL for standard memory allocation). It returns a\npointer to an opaque structure of type pcre2_jit_stack, or NULL if there\nis an error. The pcre2_jit_stack_free() function is used to free a stack\nthat is no longer needed. If its argument is NULL, this function returns\nimmediately, without doing anything. (For the technically minded: the address\nspace is allocated by mmap or VirtualAlloc.) A maximum stack size of 512KiB to\n1MiB should be more than enough for any pattern.\n
\n\nThe pcre2_jit_stack_assign() function specifies which stack JIT code\nshould use. Its arguments are as follows:\n
\n pcre2_match_context *mcontext\n pcre2_jit_callback callback\n void *data\n\nThe first argument is a pointer to a match context. When this is subsequently\npassed to a matching function, its information determines which JIT stack is\nused. If this argument is NULL, the function returns immediately, without doing\nanything. There are three cases for the values of the other two options:\n
\n (1) If callback is NULL and data is NULL, an internal 32KiB block\n on the machine stack is used. This is the default when a match\n context is created.\n\n (2) If callback is NULL and data is not NULL, data must be\n a pointer to a valid JIT stack, the result of calling\n pcre2_jit_stack_create().\n\n (3) If callback is not NULL, it must point to a function that is\n called with data as an argument at the start of matching, in\n order to set up a JIT stack. If the return from the callback\n function is NULL, the internal 32KiB stack is used; otherwise the\n return value must be a valid JIT stack, the result of calling\n pcre2_jit_stack_create().\n\nA callback function is obeyed whenever JIT code is about to be run; it is not\nobeyed when pcre2_match() is called with options that are incompatible\nfor JIT matching. A callback function can therefore be used to determine\nwhether a match operation was executed by JIT or by the interpreter.\n\n
\nYou may safely use the same JIT stack for more than one pattern (either by\nassigning directly or by callback), as long as the patterns are matched\nsequentially in the same thread. Currently, the only way to set up\nnon-sequential matches in one thread is to use callouts: if a callout function\nstarts another match, that match must use a different JIT stack to the one used\nfor currently suspended match(es).\n
\n\nIn a multithread application, if you do not specify a JIT stack, or if you\nassign or pass back NULL from a callback, that is thread-safe, because each\nthread has its own machine stack. However, if you assign or pass back a\nnon-NULL JIT stack, this must be a different stack for each thread so that the\napplication is thread-safe.\n
\n\nStrictly speaking, even more is allowed. You can assign the same non-NULL stack\nto a match context that is used by any number of patterns, as long as they are\nnot used for matching by multiple threads at the same time. For example, you\ncould use the same stack in all compiled patterns, with a global mutex in the\ncallback to wait until the stack is available for use. However, this is an\ninefficient solution, and not recommended.\n
\n\nThis is a suggestion for how a multithreaded program that needs to set up\nnon-default JIT stacks might operate:\n
\n During thread initialization\n thread_local_var = pcre2_jit_stack_create(...)\n\n During thread exit\n pcre2_jit_stack_free(thread_local_var)\n\n Use a one-line callback function\n return thread_local_var\n\nAll the functions described in this section do nothing if JIT is not available.\n\n
JIT STACK FAQ
\n\n(1) Why do we need JIT stacks?\n
\n
\nPCRE2 (and JIT) is a recursive, depth-first engine, so it needs a stack where\nthe local data of the current node is pushed before checking its child nodes.\nAllocating real machine stack on some platforms is difficult. For example, the\nstack chain needs to be updated every time if we extend the stack on PowerPC.\nAlthough it is possible, its updating time overhead decreases performance. So\nwe do the recursion in memory.\n
\n(2) Why don't we simply allocate blocks of memory with malloc()?\n
\n
\nModern operating systems have a nice feature: they can reserve an address space\ninstead of allocating memory. We can safely allocate memory pages inside this\naddress space, so the stack could grow without moving memory data (this is\nimportant because of pointers). Thus we can allocate 1MiB address space, and\nuse only a single memory page (usually 4KiB) if that is enough. However, we can\nstill grow up to 1MiB anytime if needed.\n
\n(3) Who \"owns\" a JIT stack?\n
\n
\nThe owner of the stack is the user program, not the JIT studied pattern or\nanything else. The user program must ensure that if a stack is being used by\npcre2_match(), (that is, it is assigned to a match context that is passed\nto the pattern currently running), that stack must not be used by any other\nthreads (to avoid overwriting the same memory area). The best practice for\nmultithreaded programs is to allocate a stack for each thread, and return this\nstack through the JIT callback function.\n
\n(4) When should a JIT stack be freed?\n
\n
\nYou can free a JIT stack at any time, as long as it will not be used by\npcre2_match() again. When you assign the stack to a match context, only a\npointer is set. There is no reference counting or any other magic. You can free\ncompiled patterns, contexts, and stacks in any order, anytime.\nJust do not call pcre2_match() with a match context pointing to an\nalready freed stack, as that will cause SEGFAULT. (Also, do not free a stack\ncurrently used by pcre2_match() in another thread). You can also replace\nthe stack in a context at any time when it is not in use. You should free the\nprevious stack before assigning a replacement.\n
\n(5) Should I allocate/free a stack every time before/after calling\npcre2_match()?\n
\n
\nNo, because this is too costly in terms of resources. However, you could\nimplement some clever idea which release the stack if it is not used in let's\nsay two minutes. The JIT callback can help to achieve this without keeping a\nlist of patterns.\n
\n(6) OK, the stack is for long term memory allocation. But what happens if a\npattern causes stack overflow with a stack of 1MiB? Is that 1MiB kept until the\nstack is freed?\n
\n
\nEspecially on embedded systems, it might be a good idea to release memory\nsometimes without freeing the stack. There is no API for this at the moment.\nProbably a function call which returns with the currently allocated memory for\nany stack and another which allows releasing memory (shrinking the stack) would\nbe a good idea if someone needs this.\n
\n(7) This is too much of a headache. Isn't there any better solution for JIT\nstack handling?\n
\n
\nNo, thanks to Windows. If POSIX threads were used everywhere, we could throw\nout this complicated API.\n
FREEING JIT SPECULATIVE MEMORY
\n\nvoid pcre2_jit_free_unused_memory(pcre2_general_context *gcontext);\n
\n\nThe JIT executable allocator does not free all memory when it is possible. It\nexpects new allocations, and keeps some free memory around to improve\nallocation speed. However, in low memory conditions, it might be better to free\nall possible memory. You can cause this to happen by calling\npcre2_jit_free_unused_memory(). Its argument is a general context, for custom\nmemory management, or NULL for standard memory management.\n
\nEXAMPLE CODE
\n\nThis is a single-threaded example that specifies a JIT stack without using a\ncallback. A real program should include error checking after all the function\ncalls.\n
\n int rc;\n pcre2_code *re;\n pcre2_match_data *match_data;\n pcre2_match_context *mcontext;\n pcre2_jit_stack *jit_stack;\n\n re = pcre2_compile(pattern, PCRE2_ZERO_TERMINATED, 0,\n &errornumber, &erroffset, NULL);\n rc = pcre2_jit_compile(re, PCRE2_JIT_COMPLETE);\n mcontext = pcre2_match_context_create(NULL);\n jit_stack = pcre2_jit_stack_create(32*1024, 512*1024, NULL);\n pcre2_jit_stack_assign(mcontext, NULL, jit_stack);\n match_data = pcre2_match_data_create(re, 10);\n rc = pcre2_match(re, subject, length, 0, 0, match_data, mcontext);\n /* Process result */\n\n pcre2_code_free(re);\n pcre2_match_data_free(match_data);\n pcre2_match_context_free(mcontext);\n pcre2_jit_stack_free(jit_stack);\n\n\n\n
JIT FAST PATH API
\n\nBecause the API described above falls back to interpreted matching when JIT is\nnot available, it is convenient for programs that are written for general use\nin many environments. However, calling JIT via pcre2_match() does have a\nperformance impact. Programs that are written for use where JIT is known to be\navailable, and which need the best possible performance, can instead use a\n\"fast path\" API to call JIT matching directly instead of calling\npcre2_match() (obviously only for patterns that have been successfully\nprocessed by pcre2_jit_compile()).\n
\n\nThe fast path function is called pcre2_jit_match(), and it takes exactly\nthe same arguments as pcre2_match(). However, the subject string must be\nspecified with a length; PCRE2_ZERO_TERMINATED is not supported. Unsupported\noption bits (for example, PCRE2_ANCHORED and PCRE2_ENDANCHORED) are ignored, as\nis the PCRE2_NO_JIT option. The return values are also the same as for\npcre2_match(), plus PCRE2_ERROR_JIT_BADOPTION if a matching mode (partial\nor complete) is requested that was not compiled.\n
\n\nWhen you call pcre2_match(), as well as testing for invalid options, a\nnumber of other sanity checks are performed on the arguments. For example, if\nthe subject pointer is NULL but the length is non-zero, an immediate error is\ngiven. Also, unless PCRE2_NO_UTF_CHECK is set, a UTF subject string is tested\nfor validity. In the interests of speed, these checks do not happen on the JIT\nfast path. If invalid UTF data is passed when PCRE2_MATCH_INVALID_UTF was not\nset for pcre2_compile(), the result is undefined. The program may crash\nor loop or give wrong results. In the absence of PCRE2_MATCH_INVALID_UTF you\nshould call pcre2_jit_match() in UTF mode only if you are sure the\nsubject is valid.\n
\n\nBypassing the sanity checks and the pcre2_match() wrapping can give\nspeedups of more than 10%.\n
\nSEE ALSO
\n\npcre2api(3), pcre2unicode(3)\n
\nAUTHOR
\n\nPhilip Hazel (FAQ by Zoltan Herczeg)\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 22 August 2024\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2limits.html", "content": "\n\npcre2limits man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nSIZE AND OTHER LIMITATIONS\n
\n\nThere are some size limitations in PCRE2 but it is hoped that they will never\nin practice be relevant.\n
\n\nThe maximum size of a compiled pattern is approximately 64 thousand code units\nfor the 8-bit and 16-bit libraries if PCRE2 is compiled with the default\ninternal linkage size, which is 2 bytes for these libraries. If you want to\nprocess regular expressions that are truly enormous, you can compile PCRE2 with\nan internal linkage size of 3 or 4 (when building the 16-bit library, 3 is\nrounded up to 4). See the README file in the source distribution and the\npcre2build\ndocumentation for details. In these cases the limit is substantially larger.\nHowever, the speed of execution is slower. In the 32-bit library, the internal\nlinkage size is always 4.\n
\n\nThe maximum length of a source pattern string is essentially unlimited; it is\nthe largest number a PCRE2_SIZE variable can hold. However, the program that\ncalls pcre2_compile() can specify a smaller limit.\n
\n\nThe maximum length (in code units) of a subject string is one less than the\nlargest number a PCRE2_SIZE variable can hold. PCRE2_SIZE is an unsigned\ninteger type, usually defined as size_t. Its maximum value (that is\n~(PCRE2_SIZE)0) is reserved as a special indicator for zero-terminated strings\nand unset offsets.\n
\n\nAll values in repeating quantifiers must be less than 65536.\n
\n\nThere are two different limits that apply to branches of lookbehind assertions.\nIf every branch in such an assertion matches a fixed number of characters,\nthe maximum length of any branch is 65535 characters. If any branch matches a\nvariable number of characters, then the maximum matching length for every\nbranch is limited. The default limit is set at compile time, defaulting to 255,\nbut can be changed by the calling program.\n
\n\nThere is no limit to the number of parenthesized groups, but there can be no\nmore than 65535 capture groups, and there is a limit to the depth of nesting of\nparenthesized subpatterns of all kinds. This is imposed in order to limit the\namount of system stack used at compile time. The default limit can be specified\nwhen PCRE2 is built; if not, the default is set to 250. An application can\nchange this limit by calling pcre2_set_parens_nest_limit() to set the limit in\na compile context.\n
\n\nThe maximum length of the name for a named capture group as well as the number\nof such groups is configurable at build time. The maximum length for the name\ndefaults to\n128 code units, and the maximum number of such groups to\n10000.\n
\n\nThe maximum length of a name in a (*MARK), (*PRUNE), (*SKIP), or (*THEN) verb\nis 255 code units for the 8-bit library and 65535 code units for the 16-bit and\n32-bit libraries.\n
\n\nThe maximum length of a string argument to a callout is the largest number a\n32-bit unsigned integer can hold.\n
\n\nThe maximum amount of heap memory used for matching is controlled by the heap\nlimit, which can be set in a pattern or in a match context. The default is a\nvery large number, effectively unlimited.\n
\n\nAUTHOR\n
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
\nREVISION\n
\n\nLast updated: 03 September 2025\n
\nCopyright © 1997-2023 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2matching.html", "content": "\n\npcre2matching man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 MATCHING ALGORITHMS\n
- REGULAR EXPRESSIONS AS TREES\n
- THE STANDARD MATCHING ALGORITHM\n
- THE ALTERNATIVE MATCHING ALGORITHM\n
- ADVANTAGES OF THE ALTERNATIVE ALGORITHM\n
- DISADVANTAGES OF THE ALTERNATIVE ALGORITHM\n
- AUTHOR\n
- REVISION\n
PCRE2 MATCHING ALGORITHMS
\n\nThis document describes the two different algorithms that are available in\nPCRE2 for matching a compiled regular expression against a given subject\nstring. The \"standard\" algorithm is the one provided by the pcre2_match()\nfunction. This works in the same way as Perl's matching function, and provides a\nPerl-compatible matching operation. The just-in-time (JIT) optimization that is\ndescribed in the\npcre2jit\ndocumentation is compatible with this function.\n
\n\nAn alternative algorithm is provided by the pcre2_dfa_match() function;\nit operates in a different way, and is not Perl-compatible. This alternative\nhas advantages and disadvantages compared with the standard algorithm, and\nthese are described below.\n
\n\nWhen there is only one possible way in which a given subject string can match a\npattern, the two algorithms give the same answer. A difference arises, however,\nwhen there are multiple possibilities. For example, if the anchored pattern\n
\n ^<.*>\n\nis matched against the string\n
\n <something> <something else> <something further>\n\nthere are three possible answers. The standard algorithm finds only one of\nthem, whereas the alternative algorithm finds all three.\n\n
REGULAR EXPRESSIONS AS TREES
\n\nThe set of strings that are matched by a regular expression can be represented\nas a tree structure. An unlimited repetition in the pattern makes the tree of\ninfinite size, but it is still a tree. Matching the pattern to a given subject\nstring (from a given starting point) can be thought of as a search of the tree.\nThere are two ways to search a tree: depth-first and breadth-first, and these\ncorrespond to the two matching algorithms provided by PCRE2.\n
\nTHE STANDARD MATCHING ALGORITHM
\n\nIn the terminology of Jeffrey Friedl's book \"Mastering Regular Expressions\",\nthe standard algorithm is an \"NFA algorithm\". It conducts a depth-first search\nof the pattern tree. That is, it proceeds along a single path through the tree,\nchecking that the subject matches what is required. When there is a mismatch,\nthe algorithm tries any alternatives at the current point, and if they all\nfail, it backs up to the previous branch point in the tree, and tries the next\nalternative branch at that level. This often involves backing up (moving to the\nleft) in the subject string as well. The order in which repetition branches are\ntried is controlled by the greedy or ungreedy nature of the quantifier.\n
\n\nIf a leaf node is reached, a matching string has been found, and at that point\nthe algorithm stops. Thus, if there is more than one possible match, this\nalgorithm returns the first one that it finds. Whether this is the shortest,\nthe longest, or some intermediate length depends on the way the alternations\nand the greedy or ungreedy repetition quantifiers are specified in the\npattern.\n
\n\nBecause it ends up with a single path through the tree, it is relatively\nstraightforward for this algorithm to keep track of the substrings that are\nmatched by portions of the pattern in parentheses. This provides support for\ncapturing parentheses and backreferences.\n
\nTHE ALTERNATIVE MATCHING ALGORITHM
\n\nThis algorithm conducts a breadth-first search of the tree. Starting from the\nfirst matching point in the subject, it scans the subject string from left to\nright, once, character by character, and as it does this, it remembers all the\npaths through the tree that represent valid matches. In Friedl's terminology,\nthis is a kind of \"DFA algorithm\", though it is not implemented as a\ntraditional finite state machine (it keeps multiple states active\nsimultaneously).\n
\n\nAlthough the general principle of this matching algorithm is that it scans the\nsubject string only once, without backtracking, there is one exception: when a\nlookaround assertion is encountered, the characters following or preceding the\ncurrent point have to be independently inspected.\n
\n\nThe scan continues until either the end of the subject is reached, or there are\nno more unterminated paths. At this point, terminated paths represent the\ndifferent matching possibilities (if there are none, the match has failed).\nThus, if there is more than one possible match, this algorithm finds all of\nthem, and in particular, it finds the longest. The matches are returned in\nthe output vector in decreasing order of length. There is an option to stop the\nalgorithm after the first match (which is necessarily the shortest) is found.\n
\n\nNote that the size of vector needed to contain all the results depends on the\nnumber of simultaneous matches, not on the number of capturing parentheses in\nthe pattern. Using pcre2_match_data_create_from_pattern() to create the\nmatch data block is therefore not advisable when doing DFA matching.\n
\n\nNote also that all the matches that are found start at the same point in the\nsubject. If the pattern\n
\n cat(er(pillar)?)?\n\nis matched against the string \"the caterpillar catchment\", the result is the\nthree strings \"caterpillar\", \"cater\", and \"cat\" that start at the fifth\ncharacter of the subject. The algorithm does not automatically move on to find\nmatches that start at later positions.\n\n
\nPCRE2's \"auto-possessification\" optimization usually applies to character\nrepeats at the end of a pattern (as well as internally). For example, the\npattern \"a\\d+\" is compiled as if it were \"a\\d++\" because there is no point\neven considering the possibility of backtracking into the repeated digits. For\nDFA matching, this means that only one possible match is found. If you really\ndo want multiple matches in such cases, either use an ungreedy repeat\n(\"a\\d+?\") or set the PCRE2_NO_AUTO_POSSESS option when compiling.\n
\n\nThere are a number of features of PCRE2 regular expressions that are not\nsupported or behave differently in the alternative matching function. Those\nthat are not supported cause an error if encountered.\n
\n\n1. Because the algorithm finds all possible matches, the greedy or ungreedy\nnature of repetition quantifiers is not relevant (though it may affect\nauto-possessification, as just described). During matching, greedy and ungreedy\nquantifiers are treated in exactly the same way. However, possessive\nquantifiers can make a difference when what follows could also match what is\nquantified, for example in a pattern like this:\n
\n ^a++\\w!\n\nThis pattern matches \"aaab!\" but not \"aaa!\", which would be matched by a\nnon-possessive quantifier. Similarly, if an atomic group is present, it is\nmatched as if it were a standalone pattern at the current point, and the\nlongest match is then \"locked in\" for the rest of the overall pattern.\n\n
\n2. When dealing with multiple paths through the tree simultaneously, it is not\nstraightforward to keep track of captured substrings for the different matching\npossibilities, and PCRE2's implementation of this algorithm does not attempt to\ndo this. This means that no captured substrings are available.\n
\n\n3. Because no substrings are captured, a number of related features are not\navailable:\n
\n
\n(a) Backreferences;\n
\n
\n(b) Conditional expressions that use a backreference as the condition or test\nfor a specific group recursion;\n
\n
\n(c) Script runs;\n
\n
\n(d) Scan substring assertions.\n
\n4. Because many paths through the tree may be active, the \\K escape sequence,\nwhich resets the start of the match when encountered (but may be on some paths\nand not on others), is not supported.\n
\n\n5. Callouts are supported, but the value of the capture_top field is\nalways 1, and the value of the capture_last field is always 0.\n
\n\n6. The \\C escape sequence, which (in the standard algorithm) always matches a\nsingle code unit, even in a UTF mode, is not supported in UTF modes because\nthe alternative algorithm moves through the subject string one character (not\ncode unit) at a time, for all active paths through the tree.\n
\n\n7. Except for (*FAIL), the backtracking control verbs such as (*PRUNE) are not\nsupported. (*FAIL) is supported, and behaves like a failing negative assertion.\n
\n\n8. The PCRE2_MATCH_INVALID_UTF option for pcre2_compile() is not\nsupported by pcre2_dfa_match().\n
\nADVANTAGES OF THE ALTERNATIVE ALGORITHM
\n\nThe main advantage of the alternative algorithm is that all possible matches\n(at a single point in the subject) are automatically found, and in particular,\nthe longest match is found. To find more than one match at the same point using\nthe standard algorithm, you have to do kludgy things with callouts.\n
\n\nPartial matching is possible with this algorithm, though it has some\nlimitations. The\npcre2partial\ndocumentation gives details of partial matching and discusses multi-segment\nmatching.\n
\nDISADVANTAGES OF THE ALTERNATIVE ALGORITHM
\n\nThe alternative algorithm suffers from a number of disadvantages:\n
\n\n1. It is substantially slower than the standard algorithm. This is partly\nbecause it has to search for all possible matches, but is also because it is\nless susceptible to optimization.\n
\n\n2. Capturing parentheses and other features such as backreferences that rely on\nthem are not supported.\n
\n\n3. Matching within invalid UTF strings is not supported.\n
\n\n4. Although atomic groups are supported, their use does not provide the\nperformance advantage that it does for the standard algorithm.\n
\n\n5. JIT optimization is not supported.\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 22 February 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2partial.html", "content": "\n\npcre2partial man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PARTIAL MATCHING IN PCRE2\n
- REQUIREMENTS FOR A PARTIAL MATCH\n
- PARTIAL MATCHING USING pcre2_match()\n
- MULTI-SEGMENT MATCHING WITH pcre2_match()\n
- PARTIAL MATCHING USING pcre2_dfa_match()\n
- MULTI-SEGMENT MATCHING WITH pcre2_dfa_match()\n
- AUTHOR\n
- REVISION\n
PARTIAL MATCHING IN PCRE2
\n\nIn normal use of PCRE2, if there is a match up to the end of a subject string,\nbut more characters are needed to match the entire pattern, PCRE2_ERROR_NOMATCH\nis returned, just like any other failing match. There are circumstances where\nit might be helpful to distinguish this \"partial match\" case.\n
\n\nOne example is an application where the subject string is very long, and not\nall available at once. The requirement here is to be able to do the matching\nsegment by segment, but special action is needed when a matched substring spans\nthe boundary between two segments.\n
\n\nAnother example is checking a user input string as it is typed, to ensure that\nit conforms to a required format. Invalid characters can be immediately\ndiagnosed and rejected, giving instant feedback.\n
\n\nPartial matching is a PCRE2-specific feature; it is not Perl-compatible. It is\nrequested by setting one of the PCRE2_PARTIAL_HARD or PCRE2_PARTIAL_SOFT\noptions when calling a matching function. The difference between the two\noptions is whether or not a partial match is preferred to an alternative\ncomplete match, though the details differ between the two types of matching\nfunction. If both options are set, PCRE2_PARTIAL_HARD takes precedence.\n
\n\nIf you want to use partial matching with just-in-time optimized code, as well\nas setting a partial match option for the matching function, you must also call\npcre2_jit_compile() with one or both of these options:\n
\n PCRE2_JIT_PARTIAL_HARD\n PCRE2_JIT_PARTIAL_SOFT\n\nPCRE2_JIT_COMPLETE should also be set if you are going to run non-partial\nmatches on the same pattern. Separate code is compiled for each mode. If the\nappropriate JIT mode has not been compiled, interpretive matching code is used.\n\n
\nSetting a partial matching option disables two of PCRE2's standard\noptimization hints. PCRE2 remembers the last literal code unit in a pattern,\nand abandons matching immediately if it is not present in the subject string.\nThis optimization cannot be used for a subject string that might match only\npartially. PCRE2 also remembers a minimum length of a matching string, and does\nnot bother to run the matching function on shorter strings. This optimization\nis also disabled for partial matching.\n
\nREQUIREMENTS FOR A PARTIAL MATCH
\n\nA possible partial match occurs during matching when the end of the subject\nstring is reached successfully, but either more characters are needed to\ncomplete the match, or the addition of more characters might change what is\nmatched.\n
\n\nExample 1: if the pattern is /abc/ and the subject is \"ab\", more characters are\ndefinitely needed to complete a match. In this case both hard and soft matching\noptions yield a partial match.\n
\n\nExample 2: if the pattern is /ab+/ and the subject is \"ab\", a complete match\ncan be found, but the addition of more characters might change what is\nmatched. In this case, only PCRE2_PARTIAL_HARD returns a partial match;\nPCRE2_PARTIAL_SOFT returns the complete match.\n
\n\nOn reaching the end of the subject, when PCRE2_PARTIAL_HARD is set, if the next\npattern item is \\z, \\Z, \\b, \\B, or $ there is always a partial match.\nOtherwise, for both options, the next pattern item must be one that inspects a\ncharacter, and at least one of the following must be true:\n
\n\n(1) At least one character has already been inspected. An inspected character\nneed not form part of the final matched string; lookbehind assertions and the\n\\K escape sequence provide ways of inspecting characters before the start of a\nmatched string.\n
\n\n(2) The pattern contains one or more lookbehind assertions. This condition\nexists in case there is a lookbehind that inspects characters before the start\nof the match.\n
\n\n(3) There is a special case when the whole pattern can match an empty string.\nWhen the starting point is at the end of the subject, the empty string match is\na possibility, and if PCRE2_PARTIAL_SOFT is set and neither of the above\nconditions is true, it is returned. However, because adding more characters\nmight result in a non-empty match, PCRE2_PARTIAL_HARD returns a partial match,\nwhich in this case means \"there is going to be a match at this point, but until\nsome more characters are added, we do not know if it will be an empty string or\nsomething longer\".\n
\nPARTIAL MATCHING USING pcre2_match()
\n\nWhen a partial matching option is set, the result of calling\npcre2_match() can be one of the following:\n
\n\nA successful match\nA complete match has been found, starting and ending within this subject.\n
\n\nPCRE2_ERROR_NOMATCH\nNo match can start anywhere in this subject.\n
\n\nPCRE2_ERROR_PARTIAL\nAdding more characters may result in a complete match that uses one or more\ncharacters from the end of this subject.\n
\n\nWhen a partial match is returned, the first two elements in the ovector point\nto the portion of the subject that was matched, but the values in the rest of\nthe ovector are undefined. The appearance of \\K in the pattern has no effect\nfor a partial match. Consider this pattern:\n
\n /abc\\K123/\n\nIf it is matched against \"456abc123xyz\" the result is a complete match, and the\novector defines the matched string as \"123\", because \\K resets the \"start of\nmatch\" point. However, if a partial match is requested and the subject string\nis \"456abc12\", a partial match is found for the string \"abc12\", because all\nthese characters are needed for a subsequent re-match with additional\ncharacters.\n\n
\nIf there is more than one partial match, the first one that was found provides\nthe data that is returned. Consider this pattern:\n
\n /123\\w+X|dogY/\n\nIf this is matched against the subject string \"abc123dog\", both alternatives\nfail to match, but the end of the subject is reached during matching, so\nPCRE2_ERROR_PARTIAL is returned. The offsets are set to 3 and 9, identifying\n\"123dog\" as the first partial match. (In this example, there are two partial\nmatches, because \"dog\" on its own partially matches the second alternative.)\n\n
\nHow a partial match is processed by pcre2_match()\n
\n\nWhat happens when a partial match is identified depends on which of the two\npartial matching options is set.\n
\n\nIf PCRE2_PARTIAL_HARD is set, PCRE2_ERROR_PARTIAL is returned as soon as a\npartial match is found, without continuing to search for possible complete\nmatches. This option is \"hard\" because it prefers an earlier partial match over\na later complete match. For this reason, the assumption is made that the end of\nthe supplied subject string is not the true end of the available data, which is\nwhy \\z, \\Z, \\b, \\B, and $ always give a partial match.\n
\n\nIf PCRE2_PARTIAL_SOFT is set, the partial match is remembered, but matching\ncontinues as normal, and other alternatives in the pattern are tried. If no\ncomplete match can be found, PCRE2_ERROR_PARTIAL is returned instead of\nPCRE2_ERROR_NOMATCH. This option is \"soft\" because it prefers a complete match\nover a partial match. All the various matching items in a pattern behave as if\nthe subject string is potentially complete; \\z, \\Z, and $ match at the end of\nthe subject, as normal, and for \\b and \\B the end of the subject is treated\nas a non-alphanumeric.\n
\n\nThe difference between the two partial matching options can be illustrated by a\npattern such as:\n
\n /dog(sbody)?/\n\nThis matches either \"dog\" or \"dogsbody\", greedily (that is, it prefers the\nlonger string if possible). If it is matched against the string \"dog\" with\nPCRE2_PARTIAL_SOFT, it yields a complete match for \"dog\". However, if\nPCRE2_PARTIAL_HARD is set, the result is PCRE2_ERROR_PARTIAL. On the other\nhand, if the pattern is made ungreedy the result is different:\n
\n /dog(sbody)??/\n\nIn this case the result is always a complete match because that is found first,\nand matching never continues after finding a complete match. It might be easier\nto follow this explanation by thinking of the two patterns like this:\n
\n /dog(sbody)?/ is the same as /dogsbody|dog/\n /dog(sbody)??/ is the same as /dog|dogsbody/\n\nThe second pattern will never match \"dogsbody\", because it will always find the\nshorter match first.\n\n
\nExample of partial matching using pcre2test\n
\n\nThe pcre2test data modifiers partial_hard (or ph) and\npartial_soft (or ps) set PCRE2_PARTIAL_HARD and PCRE2_PARTIAL_SOFT,\nrespectively, when calling pcre2_match(). Here is a run of\npcre2test using a pattern that matches the whole subject in the form of a\ndate:\n
\n re> /^\\d?\\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\d\\d$/\n data> 25dec3\\=ph\n Partial match: 23dec3\n data> 3ju\\=ph\n Partial match: 3ju\n data> 3juj\\=ph\n No match\n\nThis example gives the same results for both hard and soft partial matching\noptions. Here is an example where there is a difference:\n
\n re> /^\\d?\\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\d\\d$/\n data> 25jun04\\=ps\n 0: 25jun04\n 1: jun\n data> 25jun04\\=ph\n Partial match: 25jun04\n\nWith PCRE2_PARTIAL_SOFT, the subject is matched completely. For\nPCRE2_PARTIAL_HARD, however, the subject is assumed not to be complete, so\nthere is only a partial match.\n\n
MULTI-SEGMENT MATCHING WITH pcre2_match()
\n\nPCRE was not originally designed with multi-segment matching in mind. However,\nover time, features (including partial matching) that make multi-segment\nmatching possible have been added. A very long string can be searched segment\nby segment by calling pcre2_match() repeatedly, with the aim of achieving\nthe same results that would happen if the entire string was available for\nsearching all the time. Normally, the strings that are being sought are much\nshorter than each individual segment, and are in the middle of very long\nstrings, so the pattern is normally not anchored.\n
\n\nSpecial logic must be implemented to handle a matched substring that spans a\nsegment boundary. PCRE2_PARTIAL_HARD should be used, because it returns a\npartial match at the end of a segment whenever there is the possibility of\nchanging the match by adding more characters. The PCRE2_NOTBOL option should\nalso be set for all but the first segment.\n
\n\nWhen a partial match occurs, the next segment must be added to the current\nsubject and the match re-run, using the startoffset argument of\npcre2_match() to begin at the point where the partial match started.\nFor example:\n
\n re> /\\d?\\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\d\\d/\n data> ...the date is 23ja\\=ph\n Partial match: 23ja\n data> ...the date is 23jan19 and on that day...\\=offset=15\n 0: 23jan19\n 1: jan\n\nNote the use of the offset modifier to start the new match where the\npartial match was found. In this example, the next segment was added to the one\nin which the partial match was found. This is the most straightforward\napproach, typically using a memory buffer that is twice the size of each\nsegment. After a partial match, the first half of the buffer is discarded, the\nsecond half is moved to the start of the buffer, and a new segment is added\nbefore repeating the match as in the example above. After a no match, the\nentire buffer can be discarded.\n\n
\nIf there are memory constraints, you may want to discard text that precedes a\npartial match before adding the next segment. Unfortunately, this is not at\npresent straightforward. In cases such as the above, where the pattern does not\ncontain any lookbehinds, it is sufficient to retain only the partially matched\nsubstring. However, if the pattern contains a lookbehind assertion, characters\nthat precede the start of the partial match may have been inspected during the\nmatching process. When pcre2test displays a partial match, it indicates\nthese characters with '<' if the allusedtext modifier is set:\n
\n re> \"(?<=123)abc\"\n data> xx123ab\\=ph,allusedtext\n Partial match: 123ab\n <<<\n\nHowever, the allusedtext modifier is not available for JIT matching,\nbecause JIT matching does not record the first (or last) consulted characters.\nFor this reason, this information is not available via the API. It is therefore\nnot possible in general to obtain the exact number of characters that must be\nretained in order to get the right match result. If you cannot retain the\nentire segment, you must find some heuristic way of choosing.\n\n
\nIf you know the approximate length of the matching substrings, you can use that\nto decide how much text to retain. The only lookbehind information that is\ncurrently available via the API is the length of the longest individual\nlookbehind in a pattern, but this can be misleading if there are nested\nlookbehinds. The value returned by calling pcre2_pattern_info() with the\nPCRE2_INFO_MAXLOOKBEHIND option is the maximum number of characters (not code\nunits) that any individual lookbehind moves back when it is processed. A\npattern such as \"(?<=(?<!b)a)\" has a maximum lookbehind value of one, but\ninspects two characters before its starting point.\n
\n\nIn a non-UTF or a 32-bit case, moving back is just a subtraction, but in\nUTF-8 or UTF-16 you have to count characters while moving back through the code\nunits.\n
\nPARTIAL MATCHING USING pcre2_dfa_match()
\n\nThe DFA function moves along the subject string character by character, without\nbacktracking, searching for all possible matches simultaneously. If the end of\nthe subject is reached before the end of the pattern, there is the possibility\nof a partial match.\n
\n\nWhen PCRE2_PARTIAL_SOFT is set, PCRE2_ERROR_PARTIAL is returned only if there\nhave been no complete matches. Otherwise, the complete matches are returned.\nIf PCRE2_PARTIAL_HARD is set, a partial match takes precedence over any\ncomplete matches. The portion of the string that was matched when the longest\npartial match was found is set as the first matching string.\n
\n\nBecause the DFA function always searches for all possible matches, and there is\nno difference between greedy and ungreedy repetition, its behaviour is\ndifferent from the pcre2_match(). Consider the string \"dog\" matched\nagainst this ungreedy pattern:\n
\n /dog(sbody)??/\n\nWhereas the standard function stops as soon as it finds the complete match for\n\"dog\", the DFA function also finds the partial match for \"dogsbody\", and so\nreturns that when PCRE2_PARTIAL_HARD is set.\n\n
MULTI-SEGMENT MATCHING WITH pcre2_dfa_match()
\n\nWhen a partial match has been found using the DFA matching function, it is\npossible to continue the match by providing additional subject data and calling\nthe function again with the same compiled regular expression, this time setting\nthe PCRE2_DFA_RESTART option. You must pass the same working space as before,\nbecause this is where details of the previous partial match are stored. You can\nset the PCRE2_PARTIAL_SOFT or PCRE2_PARTIAL_HARD options with PCRE2_DFA_RESTART\nto continue partial matching over multiple segments. Here is an example using\npcre2test:\n
\n re> /^\\d?\\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\d\\d$/\n data> 23ja\\=dfa,ps\n Partial match: 23ja\n data> n05\\=dfa,dfa_restart\n 0: n05\n\nThe first call has \"23ja\" as the subject, and requests partial matching; the\nsecond call has \"n05\" as the subject for the continued (restarted) match.\nNotice that when the match is complete, only the last part is shown; PCRE2 does\nnot retain the previously partially-matched string. It is up to the calling\nprogram to do that if it needs to. This means that, for an unanchored pattern,\nif a continued match fails, it is not possible to try again at a new starting\npoint. All this facility is capable of doing is continuing with the previous\nmatch attempt. For example, consider this pattern:\n
\n 1234|3789\n\nIf the first part of the subject is \"ABC123\", a partial match of the first\nalternative is found at offset 3. There is no partial match for the second\nalternative, because such a match does not start at the same point in the\nsubject string. Attempting to continue with the string \"7890\" does not yield a\nmatch because only those alternatives that match at one point in the subject\nare remembered. Depending on the application, this may or may not be what you\nwant.\n\n
\nIf you do want to allow for starting again at the next character, one way of\ndoing it is to retain some or all of the segment and try a new complete match,\nas described for pcre2_match() above. Another possibility is to work with\ntwo buffers. If a partial match at offset n in the first buffer is\nfollowed by \"no match\" when PCRE2_DFA_RESTART is used on the second buffer, you\ncan then try a new match starting at offset n+1 in the first buffer.\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 27 November 2024\n
\nCopyright © 1997-2019 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2pattern.html", "content": "\n\npcre2pattern man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 REGULAR EXPRESSION DETAILS\n
- EBCDIC CHARACTER CODES\n
- SPECIAL START-OF-PATTERN ITEMS\n
- CHARACTERS AND METACHARACTERS\n
- BACKSLASH\n
- CIRCUMFLEX AND DOLLAR\n
- FULL STOP (PERIOD, DOT) AND \\N\n
- MATCHING A SINGLE CODE UNIT\n
- SQUARE BRACKETS AND CHARACTER CLASSES\n
- PERL EXTENDED CHARACTER CLASSES\n
- UTS#18 EXTENDED CHARACTER CLASSES\n
- POSIX CHARACTER CLASSES\n
- COMPATIBILITY FEATURE FOR WORD BOUNDARIES\n
- VERTICAL BAR\n
- INTERNAL OPTION SETTING\n
- GROUPS\n
- DUPLICATE GROUP NUMBERS\n
- NAMED CAPTURE GROUPS\n
- REPETITION\n
- ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS\n
- BACKREFERENCES\n
- ASSERTIONS\n
- NON-ATOMIC ASSERTIONS\n
- SCAN SUBSTRING ASSERTIONS\n
- SCRIPT RUNS\n
- CONDITIONAL GROUPS\n
- COMMENTS\n
- RECURSIVE PATTERNS\n
- CALLOUTS\n
- BACKTRACKING CONTROL\n
- EBCDIC ENVIRONMENTS\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
PCRE2 REGULAR EXPRESSION DETAILS
\n\nThe syntax and semantics of the regular expressions that are supported by PCRE2\nare described in detail below. There is a quick-reference syntax summary in the\npcre2syntax\npage. PCRE2 tries to match Perl syntax and semantics as closely as it can.\nPCRE2 also supports some alternative regular expression syntax that does not\nconflict with the Perl syntax in order to provide some compatibility with\nregular expressions in Python, .NET, and Oniguruma. There are in addition some\noptions that enable alternative syntax and semantics that are not the same as\nin Perl.\n
\n\nPerl's regular expressions are described in its own documentation, and regular\nexpressions in general are covered in a number of books, some of which have\ncopious examples. Jeffrey Friedl's \"Mastering Regular Expressions\", published\nby O'Reilly, covers regular expressions in great detail. This description of\nPCRE2's regular expressions is intended as reference material.\n
\n\nThis document discusses the regular expression patterns that are supported by\nPCRE2 when its main matching function, pcre2_match(), is used. PCRE2 also\nhas an alternative matching function, pcre2_dfa_match(), which matches\nusing a different algorithm that is not Perl-compatible. Some of the features\ndiscussed below are not available when DFA matching is used. The advantages and\ndisadvantages of the alternative function, and how it differs from the normal\nfunction, are discussed in the\npcre2matching\npage.\n
\nEBCDIC CHARACTER CODES
\n\nMost computers use ASCII or Unicode for encoding characters, and PCRE2 assumes\nthis by default. However, it can be compiled to run in an environment that uses\nthe EBCDIC code, which is the case for some IBM mainframe operating systems. In\nthe sections below, character code values are ASCII or Unicode; in an EBCDIC\nenvironment these characters may have different code values, and there are no\ncode points greater than 255. Differences in behaviour when PCRE2 is running in\nan EBCDIC environment are described in the section\n\"EBCDIC environments\"\nbelow, which you can ignore unless you really are in an EBCDIC environment.\n
\nSPECIAL START-OF-PATTERN ITEMS
\n\nA number of options that can be passed to pcre2_compile() can also be set\nby special items at the start of a pattern. These are not Perl-compatible, but\nare provided to make these options accessible to pattern writers who are not\nable to change the program that processes the pattern. Any number of these\nitems may appear, but they must all be together right at the start of the\npattern string, and the letters must be in upper case.\n
\n\nUTF support\n
\n\nIn the 8-bit and 16-bit PCRE2 libraries, characters may be coded either as\nsingle code units, or as multiple UTF-8 or UTF-16 code units. UTF-32 can be\nspecified for the 32-bit library, in which case it constrains the character\nvalues to valid Unicode code points. To process UTF strings, PCRE2 must be\nbuilt to include Unicode support (which is the default). When using UTF strings\nyou must either call the compiling function with one or both of the PCRE2_UTF\nor PCRE2_MATCH_INVALID_UTF options, or the pattern must start with the special\nsequence (*UTF), which is equivalent to setting the relevant PCRE2_UTF. How\nsetting a UTF mode affects pattern matching is mentioned in several places\nbelow. There is also a summary of features in the\npcre2unicode\npage.\n
\n\nSome applications that allow their users to supply patterns may wish to\nrestrict them to non-UTF data for security reasons. If the PCRE2_NEVER_UTF\noption is passed to pcre2_compile(), (*UTF) is not allowed, and its\nappearance in a pattern causes an error.\n
\n\nUnicode property support\n
\n\nAnother special sequence that may appear at the start of a pattern is (*UCP).\nThis has the same effect as setting the PCRE2_UCP option: it causes sequences\nsuch as \\d and \\w to use Unicode properties to determine character types,\ninstead of recognizing only characters with codes less than 256 via a lookup\ntable. If also causes upper/lower casing operations to use Unicode properties\nfor characters with code points greater than 127, even when UTF is not set.\nThese behaviours can be changed within the pattern; see the section entitled\n\"Internal Option Setting\"\nbelow.\n
\n\nSome applications that allow their users to supply patterns may wish to\nrestrict them for security reasons. If the PCRE2_NEVER_UCP option is passed to\npcre2_compile(), (*UCP) is not allowed, and its appearance in a pattern\ncauses an error.\n
\n\nLocking out empty string matching\n
\n\nStarting a pattern with (*NOTEMPTY) or (*NOTEMPTY_ATSTART) has the same effect\nas passing the PCRE2_NOTEMPTY or PCRE2_NOTEMPTY_ATSTART option to whichever\nmatching function is subsequently called to match the pattern. These options\nlock out the matching of empty strings, either entirely, or only at the start\nof the subject.\n
\n\nDisabling auto-possessification\n
\n\nIf a pattern starts with (*NO_AUTO_POSSESS), it has the same effect as setting\nthe PCRE2_NO_AUTO_POSSESS option, or calling pcre2_set_optimize() with\na PCRE2_AUTO_POSSESS_OFF directive. This stops PCRE2 from making quantifiers\npossessive when what follows cannot match the repeated item. For example, by\ndefault a+b is treated as a++b. For more details, see the\npcre2api\ndocumentation.\n
\n\nDisabling start-up optimizations\n
\n\nIf a pattern starts with (*NO_START_OPT), it has the same effect as setting the\nPCRE2_NO_START_OPTIMIZE option, or calling pcre2_set_optimize() with\na PCRE2_START_OPTIMIZE_OFF directive. This disables several optimizations for\nquickly reaching \"no match\" results. For more details, see the\npcre2api\ndocumentation.\n
\n\nDisabling automatic anchoring\n
\n\nIf a pattern starts with (*NO_DOTSTAR_ANCHOR), it has the same effect as\nsetting the PCRE2_NO_DOTSTAR_ANCHOR option, or\ncalling pcre2_set_optimize() with a PCRE2_DOTSTAR_ANCHOR_OFF directive.\nThis disables optimizations that apply to patterns whose top-level branches\nall start with .* (match any number of arbitrary characters). For more details,\nsee the\npcre2api\ndocumentation.\n
\n\nDisabling JIT compilation\n
\n\nIf a pattern that starts with (*NO_JIT) is successfully compiled, an attempt by\nthe application to apply the JIT optimization by calling\npcre2_jit_compile() is ignored.\n
\n\nSetting match resource limits\n
\n\nThe pcre2_match() function contains a counter that is incremented every\ntime it goes round its main loop. The caller of pcre2_match() can set a\nlimit on this counter, which therefore limits the amount of computing resource\nused for a match. The maximum depth of nested backtracking can also be limited;\nthis indirectly restricts the amount of heap memory that is used, but there is\nalso an explicit memory limit that can be set.\n
\n\nThese facilities are provided to catch runaway matches that are provoked by\npatterns with huge matching trees. A common example is a pattern with nested\nunlimited repeats applied to a long string that does not match. When one of\nthese limits is reached, pcre2_match() gives an error return. The limits\ncan also be set by items at the start of the pattern of the form\n
\n (*LIMIT_HEAP=d)\n (*LIMIT_MATCH=d)\n (*LIMIT_DEPTH=d)\n\nwhere d is any number of decimal digits. However, the value of the setting must\nbe less than the value set (or defaulted) by the caller of pcre2_match()\nfor it to have any effect. In other words, the pattern writer can lower the\nlimits set by the programmer, but not raise them. If there is more than one\nsetting of one of these limits, the lower value is used. The heap limit is\nspecified in kibibytes (units of 1024 bytes).\n\n
\nPrior to release 10.30, LIMIT_DEPTH was called LIMIT_RECURSION. This name is\nstill recognized for backwards compatibility.\n
\n\nThe heap limit applies only when the pcre2_match() or\npcre2_dfa_match() interpreters are used for matching. It does not apply\nto JIT. The match limit is used (but in a different way) when JIT is being\nused, or when pcre2_dfa_match() is called, to limit computing resource\nusage by those matching functions. The depth limit is ignored by JIT but is\nrelevant for DFA matching, which uses function recursion for recursions within\nthe pattern and for lookaround assertions and atomic groups. In this case, the\ndepth limit controls the depth of such recursion.\n
\n\nNewline conventions\n
\n\nPCRE2 supports six different conventions for indicating line breaks in\nstrings: a single CR (carriage return) character, a single LF (linefeed)\ncharacter, the two-character sequence CRLF, any of the three preceding, any\nUnicode newline sequence, or the NUL character (binary zero). The\npcre2api\npage has\nfurther discussion\nabout newlines, and shows how to set the newline convention when calling\npcre2_compile().\n
\n\nIt is also possible to specify a newline convention by starting a pattern\nstring with one of the following sequences:\n
\n (*CR) carriage return\n (*LF) linefeed\n (*CRLF) carriage return, followed by linefeed\n (*ANYCRLF) any of the three above\n (*ANY) all Unicode newline sequences\n (*NUL) the NUL character (binary zero)\n\nThese override the default and the options given to the compiling function. For\nexample, on a Unix system where LF is the default newline sequence, the pattern\n
\n (*CR)a.b\n\nchanges the convention to CR. That pattern matches \"a\\nb\" because LF is no\nlonger a newline. If more than one of these settings is present, the last one\nis used.\n\n
\nThe newline convention affects where the circumflex and dollar assertions are\ntrue. It also affects the interpretation of the dot metacharacter when\nPCRE2_DOTALL is not set, and the behaviour of \\N when not followed by an\nopening brace. However, it does not affect what the \\R escape sequence\nmatches. By default, this is any Unicode newline sequence, for Perl\ncompatibility. However, this can be changed; see the next section and the\ndescription of \\R in the section entitled\n\"Newline sequences\"\nbelow. A change of \\R setting can be combined with a change of newline\nconvention.\n
\n\nSpecifying what \\R matches\n
\n\nIt is possible to restrict \\R to match only CR, LF, or CRLF (instead of the\ncomplete set of Unicode line endings) by setting the option PCRE2_BSR_ANYCRLF\nat compile time. This effect can also be achieved by starting a pattern with\n(*BSR_ANYCRLF). For completeness, (*BSR_UNICODE) is also recognized,\ncorresponding to PCRE2_BSR_UNICODE.\n
\nCHARACTERS AND METACHARACTERS
\n\nA regular expression is a pattern that is matched against a subject string from\nleft to right. Most characters stand for themselves in a pattern, and match the\ncorresponding characters in the subject. As a trivial example, the pattern\n
\n The quick brown fox\n\nmatches a portion of a subject string that is identical to itself. When\ncaseless matching is specified (the PCRE2_CASELESS option or (?i) within the\npattern), letters are matched independently of case. Note that there are two\nASCII characters, K and S, that, in addition to their lower case ASCII\nequivalents, are case-equivalent with Unicode U+212A (Kelvin sign) and U+017F\n(long S) respectively when either PCRE2_UTF or PCRE2_UCP is set, unless the\nPCRE2_EXTRA_CASELESS_RESTRICT option is in force (either passed to\npcre2_compile() or set by (*CASELESS_RESTRICT) or (?r) within the\npattern). If the PCRE2_EXTRA_TURKISH_CASING option is in force (either passed\nto pcre2_compile() or set by (*TURKISH_CASING) within the pattern), then\nthe 'i' letters are matched according to Turkish and Azeri languages.\n\n
\nThe power of regular expressions comes from the ability to include wild cards,\ncharacter classes, alternatives, and repetitions in the pattern. These are\nencoded in the pattern by the use of metacharacters, which do not stand\nfor themselves but instead are interpreted in some special way.\n
\n\nThere are two different sets of metacharacters: those that are recognized\nanywhere in the pattern except within square brackets, and those that are\nrecognized within square brackets. Outside square brackets, the metacharacters\nare as follows:\n
\n \\ general escape character with several uses\n ^ assert start of string (or line, in multiline mode)\n $ assert end of string (or line, in multiline mode)\n . match any character except newline (by default)\n [ start character class definition\n | start of alternative branch\n ( start group or control verb\n ) end group or control verb\n * 0 or more quantifier\n + 1 or more quantifier; also \"possessive quantifier\"\n ? 0 or 1 quantifier; also quantifier minimizer\n { potential start of min/max quantifier\n\nBrace characters { and } are also used to enclose data for constructions such\nas \\g{2} or \\k{name}. In almost all uses of braces, space and/or horizontal\ntab characters that follow { or precede } are allowed and are ignored. In the\ncase of quantifiers, they may also appear before or after the comma. The\nexception to this is \\u{...} which is an ECMAScript compatibility feature\nthat is recognized only when the PCRE2_EXTRA_ALT_BSUX option is set. ECMAScript\ndoes not ignore such white space; it causes the item to be interpreted as\nliteral.\n\n\nPart of a pattern that is in square brackets is called a \"character class\". In\na character class the only metacharacters are:\n
\n \\ general escape character\n ^ negate the class, but only if the first character\n - indicates character range\n [ POSIX character class (if followed by POSIX syntax)\n ] terminates the character class\n\nIf a pattern is compiled with the PCRE2_EXTENDED option, most white space in\nthe pattern, other than in a character class, within a \\Q...\\E sequence, or\nbetween a # outside a character class and the next newline, inclusive, is\nignored. An escaping backslash can be used to include a white space or a #\ncharacter as part of the pattern. If the PCRE2_EXTENDED_MORE option is set, the\nsame applies, but in addition unescaped space and horizontal tab characters are\nignored inside a character class. Note: only these two characters are ignored,\nnot the full set of pattern white space characters that are ignored outside a\ncharacter class. Option settings can be changed within a pattern; see the\nsection entitled\n\"Internal Option Setting\"\nbelow.\n\n
\nThe following sections describe the use of each of the metacharacters.\n
\nBACKSLASH
\n\nThe backslash character has several uses. Firstly, if it is followed by a\ncharacter that is not a digit or a letter, it takes away any special meaning\nthat character may have. This use of backslash as an escape character applies\nboth inside and outside character classes.\n
\n\nFor example, if you want to match a * character, you must write \\* in the\npattern. This escaping action applies whether or not the following character\nwould otherwise be interpreted as a metacharacter, so it is always safe to\nprecede a non-alphanumeric with backslash to specify that it stands for itself.\nIn particular, if you want to match a backslash, you write \\\\.\n
\n\nOnly ASCII digits and letters have any special meaning after a backslash. All\nother characters (in particular, those whose code points are greater than 127)\nare treated as literals.\n
\n\nIf you want to treat all characters in a sequence as literals, you can do so by\nputting them between \\Q and \\E. Note that this includes white space even when\nthe PCRE2_EXTENDED option is set so that most other white space is ignored. The\nbehaviour is different from Perl in that $ and @ are handled as literals in\n\\Q...\\E sequences in PCRE2, whereas in Perl, $ and @ cause variable\ninterpolation. Also, Perl does \"double-quotish backslash interpolation\" on any\nbackslashes between \\Q and \\E which, its documentation says, \"may lead to\nconfusing results\". PCRE2 treats a backslash between \\Q and \\E just like any\nother character. Note the following examples:\n
\n Pattern PCRE2 matches Perl matches\n\n \\Qabc$xyz\\E abc$xyz abc followed by the contents of $xyz\n \\Qabc\\$xyz\\E abc\\$xyz abc\\$xyz\n \\Qabc\\E\\$\\Qxyz\\E abc$xyz abc$xyz\n \\QA\\B\\E A\\B A\\B\n \\Q\\\\E \\ \\\\E\n\nThe \\Q...\\E sequence is recognized both inside and outside character classes.\nAn isolated \\E that is not preceded by \\Q is ignored. If \\Q is not followed\nby \\E later in the pattern, the literal interpretation continues to the end of\nthe pattern (that is, \\E is assumed at the end). If the isolated \\Q is inside\na character class, this causes an error, because the character class is then\nnot terminated by a closing square bracket.\n\n
\nAnother difference from Perl is that any appearance of \\Q or \\E inside what\nmight otherwise be a quantifier causes PCRE2 not to recognize the sequence as a\nquantifier. Perl recognizes a quantifier if (redundantly) either of the numbers\nis inside \\Q...\\E, but not if the separating comma is. When not recognized as\na quantifier a sequence such as {\\Q1\\E,2} is treated as the literal string\n\"{1,2}\".\n
\n\nNon-printing characters\n
\n\nA second use of backslash provides a way of encoding non-printing characters\nin patterns in a visible manner. There is no restriction on the appearance of\nnon-printing characters in a pattern, but when a pattern is being prepared by\ntext editing, it is often easier to use one of the following escape sequences\ninstead of the binary character it represents. In an ASCII or Unicode\nenvironment, these escapes are as follows:\n
\n \\a alarm, that is, the BEL character (hex 07)\n \\cx \"control-x\", where x is a non-control ASCII character\n \\e escape (hex 1B)\n \\f form feed (hex 0C)\n \\n linefeed (hex 0A)\n \\r carriage return (hex 0D) (but see below)\n \\t tab (hex 09)\n \\0dd character with octal code 0dd\n \\ddd character with octal code ddd, or back reference\n \\o{ddd..} character with octal code ddd..\n \\xhh character with hex code hh\n \\x{hhh..} character with hex code hhh..\n \\N{U+hhh..} character with Unicode hex code point hhh..\n\nA description of how back references work is given\nlater,\nfollowing the discussion of\nparenthesized groups.\n\n\nBy default, after \\x that is not followed by {, one or two hexadecimal\ndigits are read (letters can be in upper or lower case). If the character that\nfollows \\x is neither { nor a hexadecimal digit, an error occurs. This is\ndifferent from Perl's default behaviour, which generates a NUL character, but\nis in line with the behaviour of Perl's 'strict' mode in re.\n
\n\nAny number of hexadecimal digits may appear between \\x{ and }. If a character\nother than a hexadecimal digit appears between \\x{ and }, or if there is no\nterminating }, an error occurs.\n
\n\nCharacters whose code points are less than 256 can be defined by either of the\ntwo syntaxes for \\x or by an octal sequence. There is no difference in the way\nthey are handled. For example, \\xdc is exactly the same as \\x{dc} or \\334.\nHowever, using the braced versions does make such sequences easier to read.\n
\n\nSupport is available for some ECMAScript (aka JavaScript) escape sequences via\ntwo compile-time options. If PCRE2_ALT_BSUX is set, the sequence \\x followed\nby { is not recognized. Only if \\x is followed by two hexadecimal digits is it\nrecognized as a character escape. Otherwise it is interpreted as a literal \"x\"\ncharacter. In this mode, support for code points greater than 256 is provided\nby \\u, which must be followed by four hexadecimal digits; otherwise it is\ninterpreted as a literal \"u\" character.\n
\n\nPCRE2_EXTRA_ALT_BSUX has the same effect as PCRE2_ALT_BSUX and, in addition,\n\\u{hhh..} is recognized as the character specified by hexadecimal code point.\nThere may be any number of hexadecimal digits, but unlike other places that\nalso use curly brackets, spaces are not allowed and would result in the string\nbeing interpreted as a literal. This syntax is from ECMAScript 6.\n
\n\nThe \\N{U+hhh..} escape sequence is recognized only when PCRE2 is operating in\nUTF mode. Perl also uses \\N{name} to specify characters by Unicode name; PCRE2\ndoes not support this. Note that when \\N is not followed by an opening brace\n(curly bracket) it has an entirely different meaning, matching any character\nthat is not a newline.\n
\n\nThere are some legacy applications where the escape sequence \\r is expected to\nmatch a newline. If the PCRE2_EXTRA_ESCAPED_CR_IS_LF option is set, \\r in a\npattern is converted to \\n so that it matches a LF (linefeed) instead of a CR\n(carriage return) character.\n
\n\nAn error occurs if \\c is not followed by a character whose ASCII code point\nis in the range 32 to 126. The precise effect of \\cx is as follows: if x is a\nlower case letter, it is converted to upper case. Then bit 6 of the character\n(hex 40) is inverted. Thus \\cA to \\cZ become hex 01 to hex 1A (A is 41, Z is\n5A), but \\c{ becomes hex 3B ({ is 7B), and \\c; becomes hex 7B (; is 3B). If\nthe code unit following \\c has a code point less than 32 or greater than 126,\na compile-time error occurs.\n
\n\nFor differences in the way some escapes behave in EBCDIC environments,\nsee section\n\"EBCDIC environments\"\nbelow.\n
\n\nOctal escapes and back references\n
\n\nThe escape \\o must be followed by a sequence of octal digits, enclosed in\nbraces. An error occurs if this is not the case. This escape provides a way of\nspecifying character code points as octal numbers greater than 0777, and it\nalso allows octal numbers and backreferences to be unambiguously distinguished.\n
\n\nIf braces are not used, after \\0 up to two further octal digits are read.\nHowever, if the PCRE2_EXTRA_NO_BS0 option is set, at least one more octal digit\nmust follow \\0 (use \\00 to generate a NUL character). Make sure you supply\ntwo digits after the initial zero if the pattern character that follows is\nitself an octal digit.\n
\n\nInside a character class, when a backslash is followed by any octal digit, up\nto three octal digits are read to generate a code point. Any subsequent digits\nstand for themselves. The sequences \\8 and \\9 are treated as the literal\ncharacters \"8\" and \"9\".\n
\n\nOutside a character class, Perl's handling of a backslash followed by a digit\nother than 0 is complicated by ambiguity, and Perl has changed over time,\ncausing PCRE2 also to change. From PCRE2 release 10.45 there is an option\ncalled PCRE2_EXTRA_PYTHON_OCTAL that causes PCRE2 to use Python's unambiguous\nrules. The next two subsections describe the two sets of rules.\n
\n\nFor greater clarity and unambiguity, it is best to avoid following \\ by a\ndigit greater than zero. Instead, use \\o{...} or \\x{...} to specify numerical\ncharacter code points, and \\g{...} to specify backreferences.\n
\n\nPerl rules for non-class backslash 1-9\n
\n\nAll the digits that follow the backslash are read as a decimal number. If the\nnumber is less than 10, begins with the digit 8 or 9, or if there are at least\nthat many previous capture groups in the expression, the entire sequence is\ntaken as a back reference. Otherwise, up to three octal digits are read to form\na character code. For example:\n
\n \\040 is another way of writing an ASCII space\n \\40 is the same, provided there are fewer than 40 previous capture groups\n \\7 is always a backreference\n \\11 might be a backreference, or another way of writing a tab\n \\011 is always a tab\n \\0113 is a tab followed by the character \"3\"\n \\113 might be a backreference, otherwise the character with octal code 113\n \\377 might be a backreference, otherwise the value 255 (decimal)\n \\81 is always a backreference\n\nNote that octal values of 100 or greater that are specified using this syntax\nmust not be introduced by a leading zero, because no more than three octal\ndigits are ever read.\n\n
\nPython rules for non_class backslash 1-9\n
\n\nIf there are at least three octal digits after the backslash, exactly three are\nread as an octal code point number, but the value must be no greater than\n\\377, even in modes where higher code point values are supported. Any\nsubsequent digits stand for themselves. If there are fewer than three octal\ndigits, the sequence is taken as a decimal back reference. Thus, for example,\n\\12 is always a back reference, independent of how many captures there are in\nthe pattern. An error is generated for a reference to a non-existent capturing\ngroup.\n
\n\nConstraints on character values\n
\n\nCharacters that are specified using octal or hexadecimal numbers are\nlimited to certain values, as follows:\n
\n 8-bit non-UTF mode no greater than 0xff\n 16-bit non-UTF mode no greater than 0xffff\n 32-bit non-UTF mode no greater than 0xffffffff\n All UTF modes no greater than 0x10ffff and a valid code point\n\nInvalid Unicode code points are all those in the range 0xd800 to 0xdfff (the\nso-called \"surrogate\" code points). The check for these can be disabled by the\ncaller of pcre2_compile() by setting the option\nPCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES. However, this is possible only in UTF-8\nand UTF-32 modes, because these values are not representable in UTF-16.\n\n
\nEscape sequences in character classes\n
\n\nAll the sequences that define a single character value can be used both inside\nand outside character classes. In addition, inside a character class, \\b is\ninterpreted as the backspace character (hex 08).\n
\n\nWhen not followed by an opening brace, \\N is not allowed in a character class.\n\\B, \\R, and \\X are not special inside a character class. Like other\nunrecognized alphabetic escape sequences, they cause an error. Outside a\ncharacter class, these sequences have different meanings.\n
\n\nUnsupported escape sequences\n
\n\nIn Perl, the sequences \\F, \\l, \\L, \\u, and \\U are recognized by its string\nhandler and used to modify the case of following characters. By default, PCRE2\ndoes not support these escape sequences in patterns. However, if either of the\nPCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX options is set, \\U matches a \"U\"\ncharacter, and \\u can be used to define a character by code point, as\ndescribed above.\n
\n\nAbsolute and relative backreferences\n
\n\nThe sequence \\g followed by a signed or unsigned number, optionally enclosed\nin braces, is an absolute or relative backreference. A named backreference\ncan be coded as \\g{name}. Backreferences are discussed\nlater,\nfollowing the discussion of\nparenthesized groups.\n
\n\nAbsolute and relative subroutine calls\n
\n\nFor compatibility with Oniguruma, the non-Perl syntax \\g followed by a name or\na number enclosed either in angle brackets or single quotes, is an alternative\nsyntax for referencing a capture group as a subroutine. Details are discussed\nlater.\nNote that \\g{...} (Perl syntax) and \\g<...> (Oniguruma syntax) are not\nsynonymous. The former is a backreference; the latter is a\nsubroutine\ncall.\n
\n\nGeneric character types\n
\n\nAnother use of backslash is for specifying generic character types:\n
\n \\d any decimal digit\n \\D any character that is not a decimal digit\n \\h any horizontal white space character\n \\H any character that is not a horizontal white space character\n \\N any character that is not a newline\n \\s any white space character\n \\S any character that is not a white space character\n \\v any vertical white space character\n \\V any character that is not a vertical white space character\n \\w any \"word\" character\n \\W any \"non-word\" character\n\nThe \\N escape sequence has the same meaning as\nthe \".\" metacharacter\nwhen PCRE2_DOTALL is not set, but setting PCRE2_DOTALL does not change the\nmeaning of \\N. Note that when \\N is followed by an opening brace it has a\ndifferent meaning. See the section entitled\n\"Non-printing characters\"\nabove for details. Perl also uses \\N{name} to specify characters by Unicode\nname; PCRE2 does not support this.\n\n
\nEach pair of lower and upper case escape sequences partitions the complete set\nof characters into two disjoint sets. Any given character matches one, and only\none, of each pair. The sequences can appear both inside and outside character\nclasses. They each match one character of the appropriate type. If the current\nmatching point is at the end of the subject string, all of them fail, because\nthere is no character to match.\n
\n\nThe default \\s characters are HT (9), LF (10), VT (11), FF (12), CR (13), and\nspace (32), which are defined as white space in the \"C\" locale. This list may\nvary if locale-specific matching is taking place. For example, in some locales\nthe \"non-breaking space\" character (\\xA0) is recognized as white space, and in\nothers the VT character is not.\n
\n\nA \"word\" character is an underscore or any character that is a letter or digit.\nBy default, the definition of letters and digits is controlled by PCRE2's\nlow-valued character tables, and may vary if locale-specific matching is taking\nplace (see\n\"Locale support\"\nin the\npcre2api\npage). For example, in a French locale such as \"fr_FR\" in Unix-like systems,\nor \"french\" in Windows, some character codes greater than 127 are used for\naccented letters, and these are then matched by \\w. The use of locales with\nUnicode is discouraged.\n
\n\nBy default, characters whose code points are greater than 127 never match \\d,\n\\s, or \\w, and always match \\D, \\S, and \\W, although this may be different\nfor characters in the range 128-255 when locale-specific matching is happening.\nThese escape sequences retain their original meanings from before Unicode\nsupport was available, mainly for efficiency reasons. If the PCRE2_UCP option\nis set, the behaviour is changed so that Unicode properties are used to\ndetermine character types, as follows:\n
\n \\d any character that matches \\p{Nd} (decimal digit)\n \\s any character that matches \\p{Z} or \\h or \\v\n \\w any character that matches \\p{L}, \\p{N}, \\p{Mn}, or \\p{Pc}\n\nThe addition of \\p{Mn} (non-spacing mark) and the replacement of an explicit\ntest for underscore with a test for \\p{Pc} (connector punctuation) happened in\nPCRE2 release 10.43. This brings PCRE2 into line with Perl.\n\n\nThe upper case escapes match the inverse sets of characters. Note that \\d\nmatches only decimal digits, whereas \\w matches any Unicode digit, as well as\nother character categories. Note also that PCRE2_UCP affects \\b, and\n\\B because they are defined in terms of \\w and \\W. Matching these sequences\nis noticeably slower when PCRE2_UCP is set.\n
\n\nThe effect of PCRE2_UCP on any one of these escape sequences can be negated by\nthe options PCRE2_EXTRA_ASCII_BSD, PCRE2_EXTRA_ASCII_BSS, and\nPCRE2_EXTRA_ASCII_BSW, respectively. These options can be set and reset within\na pattern by means of an internal option setting\n(see below).\n
\n\nThe sequences \\h, \\H, \\v, and \\V, in contrast to the other sequences, which\nmatch only ASCII characters by default, always match a specific list of code\npoints, whether or not PCRE2_UCP is set. The horizontal space characters are:\n
\n U+0009 Horizontal tab (HT)\n U+0020 Space\n U+00A0 Non-break space\n U+1680 Ogham space mark\n U+180E Mongolian vowel separator\n U+2000 En quad\n U+2001 Em quad\n U+2002 En space\n U+2003 Em space\n U+2004 Three-per-em space\n U+2005 Four-per-em space\n U+2006 Six-per-em space\n U+2007 Figure space\n U+2008 Punctuation space\n U+2009 Thin space\n U+200A Hair space\n U+202F Narrow no-break space\n U+205F Medium mathematical space\n U+3000 Ideographic space\n\nThe vertical space characters are:\n
\n U+000A Linefeed (LF)\n U+000B Vertical tab (VT)\n U+000C Form feed (FF)\n U+000D Carriage return (CR)\n U+0085 Next line (NEL)\n U+2028 Line separator\n U+2029 Paragraph separator\n\nIn 8-bit, non-UTF-8 mode, only the characters with code points less than 256\nare relevant.\n\n
\nNewline sequences\n
\n\nOutside a character class, by default, the escape sequence \\R matches any\nUnicode newline sequence. In 8-bit non-UTF-8 mode \\R is equivalent to the\nfollowing:\n
\n (?>\\r\\n|\\n|\\x0b|\\f|\\r|\\x85)\n\nThis is an example of an \"atomic group\", details of which are given\nbelow.\nThis particular group matches either the two-character sequence CR followed by\nLF, or one of the single characters LF (linefeed, U+000A), VT (vertical tab,\nU+000B), FF (form feed, U+000C), CR (carriage return, U+000D), or NEL (next\nline, U+0085). Because this is an atomic group, the two-character sequence is\ntreated as a single unit that cannot be split.\n\n
\nIn other modes, two additional characters whose code points are greater than 255\nare added: LS (line separator, U+2028) and PS (paragraph separator, U+2029).\nUnicode support is not needed for these characters to be recognized.\n
\n\nIt is possible to restrict \\R to match only CR, LF, or CRLF (instead of the\ncomplete set of Unicode line endings) by setting the option PCRE2_BSR_ANYCRLF\nat compile time. (BSR is an abbreviation for \"backslash R\".) This can be made\nthe default when PCRE2 is built; if this is the case, the other behaviour can\nbe requested via the PCRE2_BSR_UNICODE option. It is also possible to specify\nthese settings by starting a pattern string with one of the following\nsequences:\n
\n (*BSR_ANYCRLF) CR, LF, or CRLF only\n (*BSR_UNICODE) any Unicode newline sequence\n\nThese override the default and the options given to the compiling function.\nNote that these special settings, which are not Perl-compatible, are recognized\nonly at the very start of a pattern, and that they must be in upper case. If\nmore than one of them is present, the last one is used. They can be combined\nwith a change of newline convention; for example, a pattern can start with:\n
\n (*ANY)(*BSR_ANYCRLF)\n\nThey can also be combined with the (*UTF) or (*UCP) special sequences. Inside a\ncharacter class, \\R is treated as an unrecognized escape sequence, and causes\nan error.\n\n
\nUnicode character properties\n
\n\nWhen PCRE2 is built with Unicode support (the default), three additional escape\nsequences that match characters with specific properties are available. They\ncan be used in any mode, though in 8-bit and 16-bit non-UTF modes these\nsequences are of course limited to testing characters whose code points are\nless than U+0100 or U+10000, respectively. In 32-bit non-UTF mode, code points\ngreater than 0x10ffff (the Unicode limit) may be encountered. These are all\ntreated as being in the Unknown script and with an unassigned type.\n
\n\nMatching characters by Unicode property is not fast, because PCRE2 has to do a\nmultistage table lookup in order to find a character's property. That is why\nthe traditional escape sequences such as \\d and \\w do not use Unicode\nproperties in PCRE2 by default, though you can make them do so by setting the\nPCRE2_UCP option or by starting the pattern with (*UCP).\n
\n\nThe extra escape sequences that provide property support are:\n
\n \\p{xx} a character with the xx property\n \\P{xx} a character without the xx property\n \\X a Unicode extended grapheme cluster\n\nFor compatibility with Perl, negation can be specified by including a\ncircumflex between the opening brace and the property. For example, \\p{^Lu} is\nthe same as \\P{Lu}.\n\n\nIn accordance with Unicode's \"loose matching\" rules, ASCII white space\ncharacters, hyphens, and underscores are ignored in the properties represented\nby xx above. As well as the space character, ASCII white space can be\ntab, linefeed, vertical tab, formfeed, or carriage return.\n
\n\nSome properties are specified as a name only; others as a name and a value,\nseparated by a colon or an equals sign. The names and values consist of ASCII\nletters and digits (with one Perl-specific exception, see below). They are not\ncase sensitive. Note, however, that the escapes themselves, \\p and \\P,\nare case sensitive. There are abbreviations for many names. The following\nexamples are all equivalent:\n
\n \\p{bidiclass=al}\n \\p{BC=al}\n \\p{ Bidi_Class : AL }\n \\p{ Bi-di class = Al }\n \\P{ ^ Bi-di class = Al }\n\nThere is support for Unicode script names, Unicode general category properties,\n\"Any\", which matches any character (including newline), Bidi_Class, a number of\nbinary (yes/no) properties, and some special PCRE2 properties (described\nbelow).\nCertain other Perl properties such as \"InMusicalSymbols\" are not supported by\nPCRE2. Note that \\P{Any} does not match any characters, so always causes a\nmatch failure.\n\n\nScript properties for \\p and \\P\n
\n\nThere are three different syntax forms for matching a script. Each Unicode\ncharacter has a basic script and, optionally, a list of other scripts (\"Script\nExtensions\") with which it is commonly used. Using the Adlam script as an\nexample, \\p{sc:Adlam} matches characters whose basic script is Adlam, whereas\n\\p{scx:Adlam} matches, in addition, characters that have Adlam in their\nextensions list. The full names \"script\" and \"script extensions\" for the\nproperty types are recognized and, as for all property specifications, an\nequals sign is an alternative to the colon. If a script name is given without a\nproperty type, for example, \\p{Adlam}, it is treated as \\p{scx:Adlam}. Perl\nchanged to this interpretation at release 5.26 and PCRE2 changed at release\n10.40.\n
\n\nUnassigned characters (and in non-UTF 32-bit mode, characters with code points\ngreater than 0x10FFFF) are assigned the \"Unknown\" script. Others that are not\npart of an identified script are lumped together as \"Common\". The current list\nof recognized script names and their 4-character abbreviations can be obtained\nby running this command:\n
\n pcre2test -LS\n\n\n\n
\nThe general category property for \\p and \\P\n
\n\nEach character has exactly one Unicode general category property, specified by\na two-letter abbreviation. If only one letter is specified with \\p or \\P, it\nincludes all the general category properties that start with that letter. In\nthis case, in the absence of negation, the curly brackets in the escape\nsequence are optional; these two examples have the same effect:\n
\n \\p{L}\n \\pL\n\nThe following general category property codes are supported:\n\n C Other\n Cc Control\n Cf Format\n Cn Unassigned\n Co Private use\n Cs Surrogate\n\n L Letter\n Lc Cased letter\n Ll Lower case letter\n Lm Modifier letter\n Lo Other letter\n Lt Title case letter\n Lu Upper case letter\n\n M Mark\n Mc Spacing mark\n Me Enclosing mark\n Mn Non-spacing mark\n\n N Number\n Nd Decimal number\n Nl Letter number\n No Other number\n\n P Punctuation\n Pc Connector punctuation\n Pd Dash punctuation\n Pe Close punctuation\n Pf Final punctuation\n Pi Initial punctuation\n Po Other punctuation\n Ps Open punctuation\n\n S Symbol\n Sc Currency symbol\n Sk Modifier symbol\n Sm Mathematical symbol\n So Other symbol\n\n Z Separator\n Zl Line separator\n Zp Paragraph separator\n Zs Space separator\n\nPerl originally used the name L& for the Lc property. This is still supported\nby Perl, but discouraged. PCRE2 also still supports it. This property matches\nany character that has the Lu, Ll, or Lt property, in other words, any letter\nthat is not classified as a modifier or \"other\". From release 10.45 of PCRE2\nthe properties Lu, Ll, and Lt are all treated as Lc when case-independent\nmatching is set by the PCRE2_CASELESS option or (?i) within the pattern. The\nother properties are not affected by caseless matching.\n\n
\nThe Cs (Surrogate) property applies only to characters whose code points are in\nthe range U+D800 to U+DFFF. These characters are no different to any other\ncharacter when PCRE2 is not in UTF mode (using the 16-bit or 32-bit library).\nHowever, they are not valid in Unicode strings and so cannot be tested by PCRE2\nin UTF mode, unless UTF validity checking has been turned off (see the\ndiscussion of PCRE2_NO_UTF_CHECK in the\npcre2api\npage).\n
\n\nThe long synonyms for property names that Perl supports (such as \\p{Letter})\nare not supported by PCRE2, nor is it permitted to prefix any of these\nproperties with \"Is\".\n
\n\nNo character that is in the Unicode table has the Cn (unassigned) property.\nInstead, this property is assumed for any code point that is not in the\nUnicode table.\n
\n\nBinary (yes/no) properties for \\p and \\P\n
\n\nUnicode defines a number of binary properties, that is, properties whose only\nvalues are true or false. You can obtain a list of those that are recognized by\n\\p and \\P, along with their abbreviations, by running this command:\n
\n pcre2test -LP\n\n\n\n
\nThe Bidi_Class property for \\p and \\P\n
\n\n
\n \\p{Bidi_Class:<class>} matches a character with the given class\n \\p{BC:<class>} matches a character with the given class\n\nThe recognized classes are:\n\n AL Arabic letter\n AN Arabic number\n B paragraph separator\n BN boundary neutral\n CS common separator\n EN European number\n ES European separator\n ET European terminator\n FSI first strong isolate\n L left-to-right\n LRE left-to-right embedding\n LRI left-to-right isolate\n LRO left-to-right override\n NSM non-spacing mark\n ON other neutral\n PDF pop directional format\n PDI pop directional isolate\n R right-to-left\n RLE right-to-left embedding\n RLI right-to-left isolate\n RLO right-to-left override\n S segment separator\n WS white space\n\nAs in all property specifications, an equals sign may be used instead of a\ncolon and the class names are case-insensitive. Only the short names listed\nabove are recognized; PCRE2 does not at present support any long alternatives.\n\n
\nExtended grapheme clusters\n
\n\nThe \\X escape matches any number of Unicode characters that form an \"extended\ngrapheme cluster\", and treats the sequence as an atomic group\n(see below).\nUnicode supports various kinds of composite character by giving each character\na grapheme breaking property, and having rules that use these properties to\ndefine the boundaries of extended grapheme clusters. The rules are defined in\nUnicode Standard Annex 29, \"Unicode Text Segmentation\". Unicode 11.0.0\nabandoned the use of some previous properties that had been used for emojis.\nInstead it introduced various emoji-specific properties. PCRE2 uses only the\nExtended Pictographic property.\n
\n\n\\X always matches at least one character. Then it decides whether to add\nadditional characters according to the following rules for ending a cluster:\n
\n\n1. End at the end of the subject string.\n
\n\n2. Do not end between CR and LF; otherwise end after any control character.\n
\n\n3. Do not break Hangul (a Korean script) syllable sequences. Hangul characters\nare of five types: L, V, T, LV, and LVT. An L character may be followed by an\nL, V, LV, or LVT character; an LV or V character may be followed by a V or T\ncharacter; an LVT or T character may be followed only by a T character.\n
\n\n4. Do not end before extending characters or spacing marks or the zero-width\njoiner (ZWJ) character. Characters with the \"mark\" property always have the\n\"extend\" grapheme breaking property.\n
\n\n5. Do not end after prepend characters.\n
\n\n6. Do not end within emoji modifier sequences or emoji ZWJ (zero-width\njoiner) sequences. An emoji ZWJ sequence consists of a character with the\nExtended_Pictographic property, optionally followed by one or more characters\nwith the Extend property, followed by the ZWJ character, followed by another\nExtended_Pictographic character.\n
\n\n7. Do not break within emoji flag sequences. That is, do not break between\nregional indicator (RI) characters if there are an odd number of RI characters\nbefore the break point.\n
\n\n8. Otherwise, end the cluster.\n
\n\nPCRE2's additional properties\n
\n\nAs well as the standard Unicode properties described above, PCRE2 supports four\nmore that make it possible to convert traditional escape sequences such as \\w\nand \\s to use Unicode properties. PCRE2 uses these non-standard, non-Perl\nproperties internally when PCRE2_UCP is set. However, they may also be used\nexplicitly. These properties are:\n
\n Xan Any alphanumeric character\n Xps Any POSIX space character\n Xsp Any Perl space character\n Xwd Any Perl \"word\" character\n\nXan matches characters that have either the L (letter) or the N (number)\nproperty. Xps matches the characters tab, linefeed, vertical tab, form feed, or\ncarriage return, and any other character that has the Z (separator) property\n(this includes the space character). Xsp is the same as Xps; in PCRE1 it used\nto exclude vertical tab, for Perl compatibility, but Perl changed. Xwd matches\nthe same characters as Xan, plus those that match Mn (non-spacing mark) or Pc\n(connector punctuation, which includes underscore).\n\n
\nThere is another non-standard property, Xuc, which matches any character that\ncan be represented by a Universal Character Name in C++ and other programming\nlanguages. These are the characters $, @, ` (grave accent), and all characters\nwith Unicode code points greater than or equal to U+00A0, except for the\nsurrogates U+D800 to U+DFFF. Note that most base (ASCII) characters are\nexcluded. (Universal Character Names are of the form \\uHHHH or \\UHHHHHHHH\nwhere H is a hexadecimal digit. Note that the Xuc property does not match these\nsequences but the characters that they represent.)\n
\n\nResetting the match start\n
\n\nIn normal use, the escape sequence \\K causes any previously matched characters\nnot to be included in the final matched sequence that is returned. For example,\nthe pattern:\n
\n foo\\Kbar\n\nmatches \"foobar\", but reports that it has matched \"bar\". \\K does not interact\nwith anchoring in any way. The pattern:\n
\n ^foo\\Kbar\n\nmatches only when the subject begins with \"foobar\" (in single line mode),\nthough it again reports the matched string as \"bar\". This feature is similar to\na lookbehind assertion\n(described below),\nbut the part of the pattern that precedes \\K is not constrained to match a\nlimited number of characters, as is required for a lookbehind assertion. The\nuse of \\K does not interfere with the setting of\ncaptured substrings.\nFor example, when the pattern\n
\n (foo)\\Kbar\n\nmatches \"foobar\", the first substring is still set to \"foo\".\n\n
\nFrom version 5.32.0 Perl forbids the use of \\K in lookaround assertions. From\nrelease 10.38 PCRE2 also forbids this by default. However, the\nPCRE2_EXTRA_ALLOW_LOOKAROUND_BSK option can be used when calling\npcre2_compile() to re-enable the previous behaviour. When this option is\nset, \\K is acted upon when it occurs inside positive assertions, but is\nignored in negative assertions. Note that when a pattern such as (?=ab\\K)\nmatches, the reported start of the match can be greater than the end of the\nmatch. Using \\K in a lookbehind assertion at the start of a pattern can also\nlead to odd effects. For example, consider this pattern:\n
\n (?<=\\Kfoo)bar\n\nIf the subject is \"foobar\", a call to pcre2_match() with a starting\noffset of 3 succeeds and reports the matching string as \"foobar\", that is, the\nstart of the reported match is earlier than where the match started.\n\n
\nSimple assertions\n
\n\nThe final use of backslash is for certain simple assertions. An assertion\nspecifies a condition that has to be met at a particular point in a match,\nwithout consuming any characters from the subject string. The use of\ngroups for more complicated assertions is described\nbelow.\nThe backslashed assertions are:\n
\n \\b matches at a word boundary\n \\B matches when not at a word boundary\n \\A matches at the start of the subject\n \\Z matches at the end of the subject\n also matches before a newline at the end of the subject\n \\z matches only at the end of the subject\n \\G matches at the first matching position in the subject\n\nInside a character class, \\b has a different meaning; it matches the backspace\ncharacter. If any other of these assertions appears in a character class, an\n\"invalid escape sequence\" error is generated.\n\n
\nA word boundary is a position in the subject string where the current character\nand the previous character do not both match \\w or \\W (i.e. one matches\n\\w and the other matches \\W), or the start or end of the string if the\nfirst or last character matches \\w, respectively. When PCRE2 is built with\nUnicode support, the meanings of \\w and \\W can be changed by setting the\nPCRE2_UCP option. When this is done, it also affects \\b and \\B. Neither PCRE2\nnor Perl has a separate \"start of word\" or \"end of word\" metasequence. However,\nwhatever follows \\b normally determines which it is. For example, the fragment\n\\ba matches \"a\" at the start of a word.\n
\n\nThe \\A, \\Z, and \\z assertions differ from the traditional circumflex and\ndollar (described in the next section) in that they only ever match at the very\nstart and end of the subject string, whatever options are set. Thus, they are\nindependent of multiline mode. These three assertions are not affected by the\nPCRE2_NOTBOL or PCRE2_NOTEOL options, which affect only the behaviour of the\ncircumflex and dollar metacharacters. However, if the startoffset\nargument of pcre2_match() is non-zero, indicating that matching is to\nstart at a point other than the beginning of the subject, \\A can never match.\nThe difference between \\Z and \\z is that \\Z matches before a newline at the\nend of the string as well as at the very end, whereas \\z matches only at the\nend.\n
\n\nThe \\G assertion is true only when the current matching position is at the\nstart point of the matching process, as specified by the startoffset\nargument of pcre2_match(). It differs from \\A when the value of\nstartoffset is non-zero. By calling pcre2_match() multiple times\nwith appropriate arguments, you can mimic Perl's /g option, and it is in this\nkind of implementation where \\G can be useful.\n
\n\nNote, however, that PCRE2's implementation of \\G, being true at the starting\ncharacter of the matching process, is subtly different from Perl's, which\ndefines it as true at the end of the previous match. In Perl, these can be\ndifferent when the previously matched string was empty. Because PCRE2 does just\none match at a time, it cannot reproduce this behaviour.\n
\n\nIf all the alternatives of a pattern begin with \\G, the expression is anchored\nto the starting match position, and the \"anchored\" flag is set in the compiled\nregular expression.\n
\nCIRCUMFLEX AND DOLLAR
\n\nThe circumflex and dollar metacharacters are zero-width assertions. That is,\nthey test for a particular condition being true without consuming any\ncharacters from the subject string. These two metacharacters are concerned with\nmatching the starts and ends of lines. If the newline convention is set so that\nonly the two-character sequence CRLF is recognized as a newline, isolated CR\nand LF characters are treated as ordinary data characters, and are not\nrecognized as newlines.\n
\n\nOutside a character class, in the default matching mode, the circumflex\ncharacter is an assertion that is true only if the current matching point is at\nthe start of the subject string. If the startoffset argument of\npcre2_match() is non-zero, or if PCRE2_NOTBOL is set, circumflex can\nnever match if the PCRE2_MULTILINE option is unset. Inside a character class,\ncircumflex has an entirely different meaning\n(see below).\n
\n\nCircumflex need not be the first character of the pattern if a number of\nalternatives are involved, but it should be the first thing in each alternative\nin which it appears if the pattern is ever to match that branch. If all\npossible alternatives start with a circumflex, that is, if the pattern is\nconstrained to match only at the start of the subject, it is said to be an\n\"anchored\" pattern. (There are also other constructs that can cause a pattern\nto be anchored.)\n
\n\nThe dollar character is an assertion that is true only if the current matching\npoint is at the end of the subject string, or immediately before a newline at\nthe end of the string (by default), unless PCRE2_NOTEOL is set. Note, however,\nthat it does not actually match the newline. Dollar need not be the last\ncharacter of the pattern if a number of alternatives are involved, but it\nshould be the last item in any branch in which it appears. Dollar has no\nspecial meaning in a character class.\n
\n\nThe meaning of dollar can be changed so that it matches only at the very end of\nthe string, by setting the PCRE2_DOLLAR_ENDONLY option at compile time. This\ndoes not affect the \\Z assertion.\n
\n\nThe meanings of the circumflex and dollar metacharacters are changed if the\nPCRE2_MULTILINE option is set. When this is the case, a dollar character\nmatches before any newlines in the string, as well as at the very end, and a\ncircumflex matches immediately after internal newlines as well as at the start\nof the subject string. It does not match after a newline that ends the string,\nfor compatibility with Perl. However, this can be changed by setting the\nPCRE2_ALT_CIRCUMFLEX option.\n
\n\nFor example, the pattern /^abc$/ matches the subject string \"def\\nabc\" (where\n\\n represents a newline) in multiline mode, but not otherwise. Consequently,\npatterns that are anchored in single line mode because all branches start with\n^ are not anchored in multiline mode, and a match for circumflex is possible\nwhen the startoffset argument of pcre2_match() is non-zero. The\nPCRE2_DOLLAR_ENDONLY option is ignored if PCRE2_MULTILINE is set.\n
\n\nWhen the newline convention (see\n\"Newline conventions\"\nbelow) recognizes the two-character sequence CRLF as a newline, this is\npreferred, even if the single characters CR and LF are also recognized as\nnewlines. For example, if the newline convention is \"any\", a multiline mode\ncircumflex matches before \"xyz\" in the string \"abc\\r\\nxyz\" rather than after\nCR, even though CR on its own is a valid newline. (It also matches at the very\nstart of the string, of course.)\n
\n\nNote that the sequences \\A, \\Z, and \\z can be used to match the start and\nend of the subject in both modes, and if all branches of a pattern start with\n\\A it is always anchored, whether or not PCRE2_MULTILINE is set.\n
\nFULL STOP (PERIOD, DOT) AND \\N
\n\nOutside a character class, a dot in the pattern matches any one character in\nthe subject string except (by default) a character that signifies the end of a\nline. One or more characters may be specified as line terminators (see\n\"Newline conventions\"\nabove).\n
\n\nDot never matches a single line-ending character. When the two-character\nsequence CRLF is the only line ending, dot does not match CR if it is\nimmediately followed by LF, but otherwise it matches all characters (including\nisolated CRs and LFs). When ANYCRLF is selected for line endings, no occurrences\nof CR of LF match dot. When all Unicode line endings are being recognized, dot\ndoes not match CR or LF or any of the other line ending characters.\n
\n\nThe behaviour of dot with regard to newlines can be changed. If the\nPCRE2_DOTALL option is set, a dot matches any one character, without exception.\nIf the two-character sequence CRLF is present in the subject string, it takes\ntwo dots to match it.\n
\n\nThe handling of dot is entirely independent of the handling of circumflex and\ndollar, the only relationship being that they both involve newlines. Dot has no\nspecial meaning in a character class.\n
\n\nThe escape sequence \\N when not followed by an opening brace behaves like a\ndot, except that it is not affected by the PCRE2_DOTALL option. In other words,\nit matches any character except one that signifies the end of a line.\n
\n\nWhen \\N is followed by an opening brace it has a different meaning. See the\nsection entitled\n\"Non-printing characters\"\nabove for details. Perl also uses \\N{name} to specify characters by Unicode\nname; PCRE2 does not support this.\n
\nMATCHING A SINGLE CODE UNIT
\n\nOutside a character class, the escape sequence \\C matches any one code unit,\nwhether or not a UTF mode is set. In the 8-bit library, one code unit is one\nbyte; in the 16-bit library it is a 16-bit unit; in the 32-bit library it is a\n32-bit unit. Unlike a dot, \\C always matches line-ending characters. The\nfeature is provided in Perl in order to match individual bytes in UTF-8 mode,\nbut it is unclear how it can usefully be used.\n
\n\nBecause \\C breaks up characters into individual code units, matching one unit\nwith \\C in UTF-8 or UTF-16 mode means that the rest of the string may start\nwith a malformed UTF character. This has undefined results, because PCRE2\nassumes that it is matching character by character in a valid UTF string (by\ndefault it checks the subject string's validity at the start of processing\nunless the PCRE2_NO_UTF_CHECK or PCRE2_MATCH_INVALID_UTF option is used).\n
\n\nAn application can lock out the use of \\C by setting the\nPCRE2_NEVER_BACKSLASH_C option when compiling a pattern. It is also possible to\nbuild PCRE2 with the use of \\C permanently disabled.\n
\n\nPCRE2 does not allow \\C to appear in lookbehind assertions\n(described below)\nin UTF-8 or UTF-16 modes, because this would make it impossible to calculate\nthe length of the lookbehind. Neither the alternative matching function\npcre2_dfa_match() nor the JIT optimizer support \\C in these UTF modes.\nThe former gives a match-time error; the latter fails to optimize and so the\nmatch is always run using the interpreter.\n
\n\nIn the 32-bit library, however, \\C is always supported (when not explicitly\nlocked out) because it always matches a single code unit, whether or not UTF-32\nis specified.\n
\n\nIn general, the \\C escape sequence is best avoided. However, one way of using\nit that avoids the problem of malformed UTF-8 or UTF-16 characters is to use a\nlookahead to check the length of the next character, as in this pattern, which\ncould be used with a UTF-8 string (ignore white space and line breaks):\n
\n (?| (?=[\\x00-\\x7f])(\\C) |\n (?=[\\x80-\\x{7ff}])(\\C)(\\C) |\n (?=[\\x{800}-\\x{ffff}])(\\C)(\\C)(\\C) |\n (?=[\\x{10000}-\\x{1fffff}])(\\C)(\\C)(\\C)(\\C))\n\nIn this example, a group that starts with (?| resets the capturing parentheses\nnumbers in each alternative (see\n\"Duplicate Group Numbers\"\nbelow). The assertions at the start of each branch check the next UTF-8\ncharacter for values whose encoding uses 1, 2, 3, or 4 bytes, respectively. The\ncharacter's individual bytes are then captured by the appropriate number of\n\\C groups.\n\nSQUARE BRACKETS AND CHARACTER CLASSES
\n\nAn opening square bracket introduces a character class, terminated by a closing\nsquare bracket. A closing square bracket on its own is not special by default.\nIf a closing square bracket is required as a member of the class, it should be\nthe first data character in the class (after an initial circumflex, if present)\nor escaped with a backslash. This means that, by default, an empty class cannot\nbe defined. However, if the PCRE2_ALLOW_EMPTY_CLASS option is set, a closing\nsquare bracket at the start does end the (empty) class.\n
\n\nA character class matches a single character in the subject. A matched\ncharacter must be in the set of characters defined by the class, unless the\nfirst character in the class definition is a circumflex, in which case the\nsubject character must not be in the set defined by the class. If a circumflex\nis actually required as a member of the class, ensure it is not the first\ncharacter, or escape it with a backslash.\n
\n\nFor example, the character class [aeiou] matches any lower case English vowel,\nwhereas [^aeiou] matches all other characters. Note that a circumflex is just a\nconvenient notation for specifying the characters that are in the class by\nenumerating those that are not. A class that starts with a circumflex is not an\nassertion; it still consumes a character from the subject string, and therefore\nit fails to match if the current pointer is at the end of the string.\n
\n\nCharacters in a class may be specified by their code points using \\o, \\x, or\n\\N{U+hh..} in the usual way. When caseless matching is set, any letters in a\nclass represent both their upper case and lower case versions, so for example,\na caseless [aeiou] matches \"A\" as well as \"a\", and a caseless [^aeiou] does not\nmatch \"A\", whereas a caseful version would. Note that there are two ASCII\ncharacters, K and S, that, in addition to their lower case ASCII equivalents,\nare case-equivalent with Unicode U+212A (Kelvin sign) and U+017F (long S)\nrespectively when either PCRE2_UTF or PCRE2_UCP is set. If you do not want\nthese ASCII/non-ASCII case equivalences, you can suppress them by setting\nPCRE2_EXTRA_CASELESS_RESTRICT, either as an option in a compile context, or by\nincluding (*CASELESS_RESTRICT) or (?r) within a pattern.\n
\n\nCharacters that might indicate line breaks are never treated in any special way\nwhen matching character classes, whatever line-ending sequence is in use, and\nwhatever setting of the PCRE2_DOTALL and PCRE2_MULTILINE options is used. A\nclass such as [^a] always matches one of these characters.\n
\n\nThe generic character type escape sequences \\d, \\D, \\h, \\H, \\p, \\P, \\s,\n\\S, \\v, \\V, \\w, and \\W may appear in a character class, and add the\ncharacters that they match to the class. For example, [\\dABCDEF] matches any\nhexadecimal digit. In UTF modes, the PCRE2_UCP option affects the meanings of\n\\d, \\s, \\w and their upper case partners, just as it does when they appear\noutside a character class, as described in the section entitled\n\"Generic character types\"\nabove. The escape sequence \\b has a different meaning inside a character\nclass; it matches the backspace character. The sequences \\B, \\R, and \\X are\nnot special inside a character class. Like any other unrecognized escape\nsequences, they cause an error. The same is true for \\N when not followed by\nan opening brace.\n
\n\nThe minus (hyphen) character can be used to specify a range of characters in a\ncharacter class. For example, [d-m] matches any letter between d and m,\ninclusive. If a minus character is required in a class, it must be escaped with\na backslash or appear in a position where it cannot be interpreted as\nindicating a range, typically as the first or last character in the class,\nor immediately after a range. For example, [b-d-z] matches letters in the range\nb to d, a hyphen character, or z.\n
\n\nThere is some special treatment for alphabetic ranges in EBCDIC environments;\nsee the section\n\"EBCDIC environments\"\nbelow.\n
\n\nPerl treats a hyphen as a literal if it appears before or after a POSIX class\n(see below) or before or after a character type escape such as \\d or \\H.\nHowever, unless the hyphen is the last character in the class, Perl outputs a\nwarning in its warning mode, as this is most likely a user error. As PCRE2 has\nno facility for warning, an error is given in these cases.\n
\n\nIt is not possible to have the literal character \"]\" as the end character of a\nrange. A pattern such as [W-]46] is interpreted as a class of two characters\n(\"W\" and \"-\") followed by a literal string \"46]\", so it would match \"W46]\" or\n\"-46]\". However, if the \"]\" is escaped with a backslash it is interpreted as\nthe end of a range, so [W-\\]46] is interpreted as a class containing a range\nand two other characters. The octal or hexadecimal representation of \"]\" can\nalso be used to end a range.\n
\n\nRanges normally include all code points between the start and end characters,\ninclusive. They can also be used for code points specified numerically, for\nexample [\\000-\\037]. Ranges can include any characters that are valid for the\ncurrent mode. In any UTF mode, the so-called \"surrogate\" characters (those\nwhose code points lie between 0xd800 and 0xdfff inclusive) may not be specified\nexplicitly by default (the PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES option disables\nthis check). However, ranges such as [\\x{d7ff}-\\x{e000}], which include the\nsurrogates, are always permitted.\n
\n\nIf a range that includes letters is used when caseless matching is set, it\nmatches the letters in either case. For example, [W-c] is equivalent to\n[][\\\\^_`wxyzabc], matched caselessly, and in a non-UTF mode, if character\ntables for a French locale are in use, [\\xc8-\\xcb] matches accented E\ncharacters in both cases.\n
\n\nA circumflex can conveniently be used with the upper case character types to\nspecify a more restricted set of characters than the matching lower case type.\nFor example, the class [^\\W_] matches any letter or digit, but not underscore,\nwhereas [\\w] includes underscore. A positive character class should be read as\n\"something OR something OR ...\" and a negative class as \"NOT something AND NOT\nsomething AND NOT ...\".\n
\n\nThe metacharacters that are recognized in character classes are backslash,\nhyphen (when it can be interpreted as specifying a range), circumflex\n(only at the start), and the terminating closing square bracket. An opening\nsquare bracket is also special when it can be interpreted as introducing a\nPOSIX class (see\n\"Posix character classes\"\nbelow), or a special compatibility feature (see\n\"Compatibility feature for word boundaries\"\nbelow. Escaping any non-alphanumeric character in a class turns it into a\nliteral, whether or not it would otherwise be a metacharacter.\n
\nPERL EXTENDED CHARACTER CLASSES
\n\nFrom release 10.45 PCRE2 supports Perl's (?[...]) extended character class\nsyntax. This can be used to perform set operations such as intersection on\ncharacter classes.\n
\n\nThe syntax permitted within (?[...]) is quite different to ordinary character\nclasses. Inside the extended class, there is an expression syntax consisting of\n\"atoms\", operators, and ordinary parentheses \"()\" used for grouping. Such\nclasses always have the Perl /xx modifier (PCRE2 option PCRE2_EXTENDED_MORE)\nturned on within them. This means that literal space and tab characters are\nignored everywhere in the class.\n
\n\nThe allowed atoms are individual characters specified by escape sequences such\nas \\n or \\x{123}, character types such as \\d, POSIX classes such as\n[:alpha:], and nested ordinary (non-extended) character classes. For example,\nin (?[\\d & [...]]) the nested class [...] follows the usual rules for ordinary\ncharacter classes, in which parentheses are not metacharacters, and character\nliterals and ranges are permitted.\n
\n\nCharacter literals and ranges may not appear outside a nested ordinary\ncharacter class because they are not atoms in the extended syntax. The extended\nsyntax does not introduce any additional escape sequences, so (?[\\y]) is an\nunknown escape, as it would be in [\\y].\n
\n\nIn the extended syntax, ^ does not negate a class (except within an\nordinary class nested inside an extended class); it is instead a binary\noperator.\n
\n\nThe binary operators are \"&\" (intersection), \"|\" or \"+\" (union), \"-\"\n(subtraction) and \"^\" (symmetric difference). These are left-associative and\n\"&\" has higher (tighter) precedence, while the others have equal lower\nprecedence. The one prefix unary operator is \"!\" (complement), with highest\nprecedence.\n
\nUTS#18 EXTENDED CHARACTER CLASSES
\n\nThe PCRE2_ALT_EXTENDED_CLASS option enables an alternative to Perl's (?[...])\nsyntax, allowing instead extended class behaviour inside ordinary [...]\ncharacter classes. This altered syntax for [...] classes is loosely described\nby the Unicode standard UTS#18. The PCRE2_ALT_EXTENDED_CLASS option does not\nprevent use of (?[...]) classes; it just changes the meaning of all\n[...] classes that are not nested inside a Perl (?[...]) class.\n
\n\nFirstly, in ordinary Perl [...] syntax, an expression such as \"[a[]\" is a\ncharacter class with two literal characters \"a\" and \"[\", but in UTS#18 extended\nclasses the \"[\" character becomes an additional metacharacter within classes,\ndenoting the start of a nested class, so a literal \"[\" must be escaped as \"\\[\".\n
\n\nSecondly, within the UTS#18 extended syntax, there are operators \"||\", \"&&\",\n\"--\" and \"~~\" which denote character class union, intersection, subtraction,\nand symmetric difference respectively. In standard Perl syntax, these would\nsimply be needlessly-repeated literals (except for \"--\" which could be the\nstart or end of a range). In UTS#18 extended classes these operators can be used\nin constructs such as [\\p{L}--[QW]] for \"Unicode letters, other than Q and W\".\nA literal \"-\" at the start or end of a range must be escaped, so while \"[--1]\"\nin Perl syntax is the range from hyphen to \"1\", it must be escaped as \"[\\--1]\"\nin UTS#18 extended classes.\n
\n\nUnlike Perl's (?[...]) extended classes, the PCRE2_EXTENDED_MORE option to\nignore space and tab characters is not automatically enabled for UTS#18\nextended classes, but it is honoured if set.\n
\n\nExtended UTS#18 classes can be nested, and nested classes are themselves\nextended classes (unlike Perl, where nested classes must be simple classes).\nFor example, [\\p{L}&&[\\p{Thai}||\\p{Greek}]] matches any letter that is in\nthe Thai or Greek scripts. Note that this means that no special grouping\ncharacters (such as the parentheses used in Perl's (?[...]) class syntax) are\nneeded.\n
\n\nIndividual class items (literal characters, literal ranges, properties such as\n\\d or \\p{...}, and nested classes) can be combined by juxtaposition or by an\noperator. Juxtaposition is the implicit union operator, and binds more tightly\nthan any explicit operator. Thus a sequence of literals and/or ranges behaves\nas if it is enclosed in square brackets. For example, [A-Z0-9&&[^E8]] is the\nsame as [[A-Z0-9]&&[^E8]], which matches any upper case alphanumeric character\nexcept \"E\" or \"8\".\n
\n\nPrecedence between the explicit operators is not defined, so mixing operators\nis a syntax error. For example, [A&&B--C] is an error, but [A&&[B--C]] is\nvalid.\n
\n\nThis is an emerging syntax which is being adopted gradually across the regex\necosystem: for example JavaScript adopted the \"/v\" flag in ECMAScript 2024;\nPython's \"re\" module reserves the syntax for future use with a FutureWarning\nfor unescaped use of \"[\" as a literal within character classes. Due to UTS#18\nproviding insufficient guidance, engines interpret the syntax differently.\nRust's \"regex\" crate and Python's \"regex\" PyPi module both implement UTS#18\nextended classes, but with slight incompatibilities ([A||B&&C] is parsed as\n[A||[B&&C]] in Python's \"regex\" but as [[A||B]&&C] in Rust's \"regex\").\n
\n\nPCRE2's syntax adds syntax restrictions similar to ECMASCript's /v flag, so\nthat all the UTS#18 extended classes accepted as valid by PCRE2 have the\nproperty that they are interpreted either with the same behaviour, or as\ninvalid, by all other major engines. Please file an issue if you are aware of\ncross-engine differences in behaviour between PCRE2 and another major engine.\n
\nPOSIX CHARACTER CLASSES
\n\nPerl supports the POSIX notation for character classes. This uses names\nenclosed by [: and :] within the enclosing square brackets. PCRE2 also supports\nthis notation, in both ordinary and extended classes. For example,\n
\n [01[:alpha:]%]\n\nmatches \"0\", \"1\", any alphabetic character, or \"%\". The supported class names\nare:\n
\n alnum letters and digits\n alpha letters\n ascii character codes 0 - 127\n blank space or tab only\n cntrl control characters\n digit decimal digits (same as \\d)\n graph printing characters, excluding space\n lower lower case letters\n print printing characters, including space\n punct printing characters, excluding letters and digits and space\n space white space (the same as \\s from PCRE2 8.34)\n upper upper case letters\n word \"word\" characters (same as \\w)\n xdigit hexadecimal digits\n\nThe default \"space\" characters are HT (9), LF (10), VT (11), FF (12), CR (13),\nand space (32). If locale-specific matching is taking place, the list of space\ncharacters may be different; there may be fewer or more of them. \"Space\" and\n\\s match the same set of characters, as do \"word\" and \\w.\n\n
\nThe name \"word\" is a Perl extension, and \"blank\" is a GNU extension from Perl\n5.8. Another Perl extension is negation, which is indicated by a ^ character\nafter the colon. For example,\n
\n [12[:^digit:]]\n\nmatches \"1\", \"2\", or any non-digit. PCRE2 (and Perl) also recognize the POSIX\nsyntax [.ch.] and [=ch=] where \"ch\" is a \"collating element\", but these are not\nsupported, and an error is given if they are encountered.\n\n
\nBy default, characters with values greater than 127 do not match any of the\nPOSIX character classes, although this may be different for characters in the\nrange 128-255 when locale-specific matching is happening. However, in UCP mode,\nunless certain options are set (see below), some of the classes are changed so\nthat Unicode character properties are used. This is achieved by replacing\nPOSIX classes with other sequences, as follows:\n
\n [:alnum:] becomes \\p{Xan}\n [:alpha:] becomes \\p{L}\n [:blank:] becomes \\h\n [:cntrl:] becomes \\p{Cc}\n [:digit:] becomes \\p{Nd}\n [:lower:] becomes \\p{Ll}\n [:space:] becomes \\p{Xps}\n [:upper:] becomes \\p{Lu}\n [:word:] becomes \\p{Xwd}\n\nNegated versions, such as [:^alpha:] use \\P instead of \\p. Four other POSIX\nclasses are handled specially in UCP mode:\n\n\n[:graph:]\nThis matches characters that have glyphs that mark the page when printed. In\nUnicode property terms, it matches all characters with the L, M, N, P, S, or Cf\nproperties, except for:\n
\n U+061C Arabic Letter Mark\n U+180E Mongolian Vowel Separator\n U+2066 - U+2069 Various \"isolate\"s\n\n\n\n
\n[:print:]\nThis matches the same characters as [:graph:] plus space characters that are\nnot controls, that is, characters with the Zs property.\n
\n\n[:punct:]\nThis matches all characters that have the Unicode P (punctuation) property,\nplus those characters with code points less than 256 that have the S (Symbol)\nproperty.\n
\n\n[:xdigit:]\nIn addition to the ASCII hexadecimal digits, this also matches the \"fullwidth\"\nversions of those characters, whose Unicode code points start at U+FF10. This\nis a change that was made in PCRE2 release 10.43 for Perl compatibility.\n
\n\nThe other POSIX classes are unchanged by PCRE2_UCP, and match only characters\nwith code points less than 256.\n
\n\nThere are two options that can be used to restrict the POSIX classes to ASCII\ncharacters when PCRE2_UCP is set. The option PCRE2_EXTRA_ASCII_DIGIT affects\njust [:digit:] and [:xdigit:]. Within a pattern, this can be set and unset by\n(?aT) and (?-aT). The PCRE2_EXTRA_ASCII_POSIX option disables UCP processing\nfor all POSIX classes, including [:digit:] and [:xdigit:]. Within a pattern,\n(?aP) and (?-aP) set and unset both these options for consistency.\n
\nCOMPATIBILITY FEATURE FOR WORD BOUNDARIES
\n\nIn the POSIX.2 compliant library that was included in 4.4BSD Unix, the ugly\nsyntax [[:<:]] and [[:>:]] is used for matching \"start of word\" and \"end of\nword\". PCRE2 treats these items as follows:\n
\n [[:<:]] is converted to \\b(?=\\w)\n [[:>:]] is converted to \\b(?<=\\w)\n\nOnly these exact character sequences are recognized. A sequence such as\n[a[:<:]b] provokes error for an unrecognized POSIX class name. This support is\nnot compatible with Perl. It is provided to help migrations from other\nenvironments, and is best not used in any new patterns. Note that \\b matches\nat the start and the end of a word (see\n\"Simple assertions\"\nabove), and in a Perl-style pattern the preceding or following character\nnormally shows which is wanted, without the need for the assertions that are\nused above in order to give exactly the POSIX behaviour. Note also that the\nPCRE2_UCP option changes the meaning of \\w (and therefore \\b) by default, so\nit also affects these POSIX sequences.\n\n
VERTICAL BAR
\n\nVertical bar characters are used to separate alternative patterns. For example,\nthe pattern\n
\n gilbert|sullivan\n\nmatches either \"gilbert\" or \"sullivan\". Any number of alternatives may appear,\nand an empty alternative is permitted (matching the empty string). The matching\nprocess tries each alternative in turn, from left to right, and the first one\nthat succeeds is used. If the alternatives are within a group\n(defined below),\n\"succeeds\" means matching the rest of the main pattern as well as the\nalternative in the group.\n\n
INTERNAL OPTION SETTING
\n\nThe settings of several options can be changed within a pattern by a sequence\nof letters enclosed between \"(?\" and \")\". The following are Perl-compatible,\nand are described in detail in the\npcre2api\ndocumentation. The option letters are:\n
\n i for PCRE2_CASELESS\n m for PCRE2_MULTILINE\n n for PCRE2_NO_AUTO_CAPTURE\n s for PCRE2_DOTALL\n x for PCRE2_EXTENDED\n xx for PCRE2_EXTENDED_MORE\n\nFor example, (?im) sets caseless, multiline matching. It is also possible to\nunset these options by preceding the relevant letters with a hyphen, for\nexample (?-im). The two \"extended\" options are not independent; unsetting\neither one cancels the effects of both of them.\n\n
\nA combined setting and unsetting such as (?im-sx), which sets PCRE2_CASELESS\nand PCRE2_MULTILINE while unsetting PCRE2_DOTALL and PCRE2_EXTENDED, is also\npermitted. Only one hyphen may appear in the options string. If a letter\nappears both before and after the hyphen, the option is unset. An empty options\nsetting \"(?)\" is allowed. Needless to say, it has no effect.\n
\n\nIf the first character following (? is a circumflex, it causes all of the above\noptions to be unset. Letters may follow the circumflex to cause some options to\nbe re-instated, but a hyphen may not appear.\n
\n\nSome PCRE2-specific options can be changed by the same mechanism using these\npairs or individual letters:\n
\n aD for PCRE2_EXTRA_ASCII_BSD\n aS for PCRE2_EXTRA_ASCII_BSS\n aW for PCRE2_EXTRA_ASCII_BSW\n aP for PCRE2_EXTRA_ASCII_POSIX and PCRE2_EXTRA_ASCII_DIGIT\n aT for PCRE2_EXTRA_ASCII_DIGIT\n r for PCRE2_EXTRA_CASELESS_RESTRICT\n J for PCRE2_DUPNAMES\n U for PCRE2_UNGREEDY\n\nHowever, except for 'r', these are not unset by (?^), which is equivalent to\n(?-imnrsx). If 'a' is not followed by any of the upper case letters shown\nabove, it sets (or unsets) all the ASCII options.\n\n
\nPCRE2_EXTRA_ASCII_DIGIT has no additional effect when PCRE2_EXTRA_ASCII_POSIX\nis set, but including it in (?aP) means that (?-aP) suppresses all ASCII\nrestrictions for POSIX classes.\n
\n\nWhen one of these option changes occurs at top level (that is, not inside group\nparentheses), the change applies until a subsequent change, or the end of the\npattern. An option change within a group (see below for a description of\ngroups) affects only that part of the group that follows it. At the end of the\ngroup these options are reset to the state they were before the group. For\nexample,\n
\n (a(?i)b)c\n\nmatches abc and aBc and no other strings (assuming PCRE2_CASELESS is not set\nexternally). Any changes made in one alternative do carry on into subsequent\nbranches within the same group. For example,\n
\n (a(?i)b|c)\n\nmatches \"ab\", \"aB\", \"c\", and \"C\", even though when matching \"C\" the first\nbranch is abandoned before the option setting. This is because the effects of\noption settings happen at compile time. There would be some very weird\nbehaviour otherwise.\n\n
\nAs a convenient shorthand, if any option settings are required at the start of\na non-capturing group (see the next section), the option letters may\nappear between the \"?\" and the \":\". Thus the two patterns\n
\n (?i:saturday|sunday)\n (?:(?i)saturday|sunday)\n\nmatch exactly the same set of strings.\n\n
\nNote: There are other PCRE2-specific options, applying to the whole\npattern, which can be set by the application when the compiling function is\ncalled. In addition, the pattern can contain special leading sequences such as\n(*CRLF) to override what the application has set or what has been defaulted.\nDetails are given in the section entitled\n\"Newline sequences\"\nabove. There are also the (*UTF) and (*UCP) leading sequences that can be used\nto set UTF and Unicode property modes; they are equivalent to setting the\nPCRE2_UTF and PCRE2_UCP options, respectively. However, the application can set\nthe PCRE2_NEVER_UTF or PCRE2_NEVER_UCP options, which lock out the use of the\n(*UTF) and (*UCP) sequences.\n
\nGROUPS
\n\nGroups are delimited by parentheses (round brackets), which can be nested.\nTurning part of a pattern into a group does two things:\n
\n
\n1. It localizes a set of alternatives. For example, the pattern\n
\n cat(aract|erpillar|)\n\nmatches \"cataract\", \"caterpillar\", or \"cat\". Without the parentheses, it would\nmatch \"cataract\", \"erpillar\" or an empty string.\n
\n
\n2. It creates a \"capture group\". This means that, when the whole pattern\nmatches, the portion of the subject string that matched the group is passed\nback to the caller, separately from the portion that matched the whole pattern.\n(This applies only to the traditional matching function; the DFA matching\nfunction does not support capturing.)\n\n
\nOpening parentheses are counted from left to right (starting from 1) to obtain\nnumbers for capture groups. For example, if the string \"the red king\" is\nmatched against the pattern\n
\n the ((red|white) (king|queen))\n\nthe captured substrings are \"red king\", \"red\", and \"king\", and are numbered 1,\n2, and 3, respectively.\n\n
\nThe fact that plain parentheses fulfil two functions is not always helpful.\nThere are often times when grouping is required without capturing. If an\nopening parenthesis is followed by a question mark and a colon, the group\ndoes not do any capturing, and is not counted when computing the number of any\nsubsequent capture groups. For example, if the string \"the white queen\"\nis matched against the pattern\n
\n the ((?:red|white) (king|queen))\n\nthe captured substrings are \"white queen\" and \"queen\", and are numbered 1 and\n2. The maximum number of capture groups is 65535.\n\n
\nAs a convenient shorthand, if any option settings are required at the start of\na non-capturing group, the option letters may appear between the \"?\" and the\n\":\". Thus the two patterns\n
\n (?i:saturday|sunday)\n (?:(?i)saturday|sunday)\n\nmatch exactly the same set of strings. Because alternative branches are tried\nfrom left to right, and options are not reset until the end of the group is\nreached, an option setting in one branch does affect subsequent branches, so\nthe above patterns match \"SUNDAY\" as well as \"Saturday\".\n\n
DUPLICATE GROUP NUMBERS
\n\nPerl 5.10 introduced a feature whereby each alternative in a group uses the\nsame numbers for its capturing parentheses. Such a group starts with (?| and is\nitself a non-capturing group. For example, consider this pattern:\n
\n (?|(Sat)ur|(Sun))day\n\nBecause the two alternatives are inside a (?| group, both sets of capturing\nparentheses are numbered one. Thus, when the pattern matches, you can look\nat captured substring number one, whichever alternative matched. This construct\nis useful when you want to capture part, but not all, of one of a number of\nalternatives. Inside a (?| group, parentheses are numbered as usual, but the\nnumber is reset at the start of each branch. The numbers of any capturing\nparentheses that follow the whole group start after the highest number used in\nany branch. The following example is taken from the Perl documentation. The\nnumbers underneath show in which buffer the captured content will be stored.\n
\n # before ---------------branch-reset----------- after\n / ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x\n # 1 2 2 3 2 3 4\n\nA backreference to a capture group uses the most recent value that is set for\nthe group. The following pattern matches \"abcabc\" or \"defdef\":\n
\n /(?|(abc)|(def))\\1/\n\nIn contrast, a subroutine call to a capture group always refers to the\nfirst one in the pattern with the given number. The following pattern matches\n\"abcabc\" or \"defabc\":\n
\n /(?|(abc)|(def))(?1)/\n\nA relative reference such as (?-1) is no different: it is just a convenient way\nof computing an absolute group number.\n\n
\nIf a\ncondition test\nfor a group's having matched refers to a non-unique number, the test is\ntrue if any group with that number has matched.\n
\n\nAn alternative approach to using this \"branch reset\" feature is to use\nduplicate named groups, as described in the next section.\n
\nNAMED CAPTURE GROUPS
\n\nIdentifying capture groups by number is simple, but it can be very hard to keep\ntrack of the numbers in complicated patterns. Furthermore, if an expression is\nmodified, the numbers may change. To help with this difficulty, PCRE2 supports\nthe naming of capture groups. This feature was not added to Perl until release\n5.10. Python had the feature earlier, and PCRE1 introduced it at release 4.0,\nusing the Python syntax. PCRE2 supports both the Perl and the Python syntax.\n
\n\nIn PCRE2, a capture group can be named in one of three ways: (?<name>...) or\n(?'name'...) as in Perl, or (?P<name>...) as in Python. Names may be up to\n128 code units long. When PCRE2_UTF is not set, they may contain only ASCII\nalphanumeric characters and underscores, but must start with a non-digit. When\nPCRE2_UTF is set, the syntax of group names is extended to allow any Unicode\nletter or Unicode decimal digit. In other words, group names must match one of\nthese patterns:\n
\n ^[_A-Za-z][_A-Za-z0-9]*\\z when PCRE2_UTF is not set\n ^[_\\p{L}][_\\p{L}\\p{Nd}]*\\z when PCRE2_UTF is set\n\nReferences to capture groups from other parts of the pattern, such as\nbackreferences,\nrecursion,\nand\nconditions,\ncan all be made by name as well as by number.\n\n\nNamed capture groups are allocated numbers as well as names, exactly as\nif the names were not present. In both PCRE2 and Perl, capture groups\nare primarily identified by numbers; any names are just aliases for these\nnumbers. The PCRE2 API provides function calls for extracting the complete\nname-to-number translation table from a compiled pattern, as well as\nconvenience functions for extracting captured substrings by name.\n
\n\nWarning: When more than one capture group has the same number, as\ndescribed in the previous section, a name given to one of them applies to all\nof them. Perl allows identically numbered groups to have different names.\nConsider this pattern, where there are two capture groups, both numbered 1:\n
\n (?|(?<AA>aa)|(?<BB>bb))\n\nPerl allows this, with both names AA and BB as aliases of group 1. Thus, after\na successful match, both names yield the same value (either \"aa\" or \"bb\").\n\n
\nIn an attempt to reduce confusion, PCRE2 does not allow the same group number\nto be associated with more than one name. The example above provokes a\ncompile-time error. However, there is still scope for confusion. Consider this\npattern:\n
\n (?|(?<AA>aa)|(bb))\n\nAlthough the second group number 1 is not explicitly named, the name AA is\nstill an alias for any group 1. Whether the pattern matches \"aa\" or \"bb\", a\nreference by name to group AA yields the matched string.\n\n
\nBy default, a name must be unique within a pattern, except that duplicate names\nare permitted for groups with the same number, for example:\n
\n (?|(?<AA>aa)|(?<AA>bb))\n\nThe duplicate name constraint can be disabled by setting the PCRE2_DUPNAMES\noption at compile time, or by the use of (?J) within the pattern, as described\nin the section entitled\n\"Internal Option Setting\"\nabove.\n\n
\nDuplicate names can be useful for patterns where only one instance of the named\ncapture group can match. Suppose you want to match the name of a weekday,\neither as a 3-letter abbreviation or as the full name, and in both cases you\nwant to extract the abbreviation. This pattern (ignoring the line breaks) does\nthe job:\n
\n (?J)\n (?<DN>Mon|Fri|Sun)(?:day)?|\n (?<DN>Tue)(?:sday)?|\n (?<DN>Wed)(?:nesday)?|\n (?<DN>Thu)(?:rsday)?|\n (?<DN>Sat)(?:urday)?\n\nThere are five capture groups, but only one is ever set after a match. The\nconvenience functions for extracting the data by name returns the substring for\nthe first (and in this example, the only) group of that name that matched. This\nsaves searching to find which numbered group it was. (An alternative way of\nsolving this problem is to use a \"branch reset\" group, as described in the\nprevious section.)\n\n
\nIf you make a backreference to a non-unique named group from elsewhere in the\npattern, the groups to which the name refers are checked in the order in which\nthey appear in the overall pattern. The first one that is set is used for the\nreference. For example, this pattern matches both \"foofoo\" and \"barbar\" but not\n\"foobar\" or \"barfoo\":\n
\n (?J)(?:(?<n>foo)|(?<n>bar))\\k<n>\n\n\n\n
\nIf you make a subroutine call to a non-unique named group, the one that\ncorresponds to the first occurrence of the name is used. In the absence of\nduplicate numbers this is the one with the lowest number.\n
\n\nIf you use a named reference in a condition\ntest (see the\nsection about conditions\nbelow), either to check whether a capture group has matched, or to check for\nrecursion, all groups with the same name are tested. If the condition is true\nfor any one of them, the overall condition is true. This is the same behaviour\nas testing by number. For further details of the interfaces for handling named\ncapture groups, see the\npcre2api\ndocumentation.\n
\nREPETITION
\n\nRepetition is specified by quantifiers, which may follow any one of these\nitems:\n
\n a literal data character\n the dot metacharacter\n the \\C escape sequence\n the \\R escape sequence\n the \\X escape sequence\n any escape sequence that matches a single character\n a character class\n a backreference\n a parenthesized group (including lookaround assertions)\n a subroutine call (recursive or otherwise)\n\nIf a quantifier does not follow a repeatable item, an error occurs. The\ngeneral repetition quantifier specifies a minimum and maximum number of\npermitted matches by giving two numbers in curly brackets (braces), separated\nby a comma. The numbers must be less than 65536, and the first must be less\nthan or equal to the second. For example,\n
\n z{2,4}\n\nmatches \"zz\", \"zzz\", or \"zzzz\". A closing brace on its own is not a special\ncharacter. If the second number is omitted, but the comma is present, there is\nno upper limit; if the second number and the comma are both omitted, the\nquantifier specifies an exact number of required matches. Thus\n\n [aeiou]{3,}\n\nmatches at least 3 successive vowels, but may match many more, whereas\n\n \\d{8}\n\nmatches exactly 8 digits. If the first number is omitted, the lower limit is\ntaken as zero; in this case the upper limit must be present.\n\n X{,4} is interpreted as X{0,4}\n\nThis is a change in behaviour that happened in Perl 5.34.0 and PCRE2 10.43. In\nearlier versions such a sequence was not interpreted as a quantifier. Other\nregular expression engines may behave either way.\n\n\nIf the characters that follow an opening brace do not match the syntax of a\nquantifier, the brace is taken as a literal character. In particular, this\nmeans that {,} is a literal string of three characters.\n
\n\nNote that not every opening brace is potentially the start of a quantifier\nbecause braces are used in other items such as \\N{U+345} or \\k{name}.\n
\n\nIn UTF modes, quantifiers apply to characters rather than to individual code\nunits. Thus, for example, \\x{100}{2} matches two characters, each of\nwhich is represented by a two-byte sequence in a UTF-8 string. Similarly,\n\\X{3} matches three Unicode extended grapheme clusters, each of which may be\nseveral code units long (and they may be of different lengths).\n
\n\nThe quantifier {0} is permitted, causing the expression to behave as if the\nprevious item and the quantifier were not present. This may be useful for\ncapture groups that are referenced as\nsubroutines\nfrom elsewhere in the pattern (but see also the section entitled\n\"Defining capture groups for use by reference only\"\nbelow). Except for parenthesized groups, items that have a {0} quantifier are\nomitted from the compiled pattern.\n
\n\nFor convenience, the three most common quantifiers have single-character\nabbreviations:\n
\n * is equivalent to {0,}\n + is equivalent to {1,}\n ? is equivalent to {0,1}\n\nIt is possible to construct infinite loops by following a group that can match\nno characters with a quantifier that has no upper limit, for example:\n\n (a?)*\n\nEarlier versions of Perl and PCRE1 used to give an error at compile time for\nsuch patterns. However, because there are cases where this can be useful, such\npatterns are now accepted, but whenever an iteration of such a group matches no\ncharacters, matching moves on to the next item in the pattern instead of\nrepeatedly matching an empty string. This does not prevent backtracking into\nany of the iterations if a subsequent item fails to match.\n\n
\nBy default, quantifiers are \"greedy\", that is, they match as much as possible\n(up to the maximum number of permitted repetitions), without causing the rest\nof the pattern to fail. The classic example of where this gives problems is in\ntrying to match comments in C programs. These appear between /* and */ and\nwithin the comment, individual * and / characters may appear. An attempt to\nmatch C comments by applying the pattern\n
\n /\\*.*\\*/\n\nto the string\n
\n /* first comment */ not comment /* second comment */\n\nfails, because it matches the entire string owing to the greediness of the .*\nitem. However, if a quantifier is followed by a question mark, it ceases to be\ngreedy, and instead matches the minimum number of times possible, so the\npattern\n
\n /\\*.*?\\*/\n\ndoes the right thing with C comments. The meaning of the various quantifiers is\nnot otherwise changed, just the preferred number of matches. Do not confuse\nthis use of question mark with its use as a quantifier in its own right.\nBecause it has two uses, it can sometimes appear doubled, as in\n
\n \\d??\\d\n\nwhich matches one digit by preference, but can match two if that is the only\nway the rest of the pattern matches.\n\n
\nIf the PCRE2_UNGREEDY option is set (an option that is not available in Perl),\nthe quantifiers are not greedy by default, but individual ones can be made\ngreedy by following them with a question mark. In other words, it inverts the\ndefault behaviour.\n
\n\nWhen a parenthesized group is quantified with a minimum repeat count that\nis greater than 1 or with a limited maximum, more memory is required for the\ncompiled pattern, in proportion to the size of the minimum or maximum.\n
\n\nIf a pattern starts with .* or .{0,} and the PCRE2_DOTALL option (equivalent\nto Perl's /s) is set, thus allowing the dot to match newlines, the pattern is\nimplicitly anchored, because whatever follows will be tried against every\ncharacter position in the subject string, so there is no point in retrying the\noverall match at any position after the first. PCRE2 normally treats such a\npattern as though it were preceded by \\A.\n
\n\nIn cases where it is known that the subject string contains no newlines, it is\nworth setting PCRE2_DOTALL in order to obtain this optimization, or\nalternatively, using ^ to indicate anchoring explicitly.\n
\n\nHowever, there are some cases where the optimization cannot be used. When .*\nis inside capturing parentheses that are the subject of a backreference\nelsewhere in the pattern, a match at the start may fail where a later one\nsucceeds. Consider, for example:\n
\n (.*)abc\\1\n\nIf the subject is \"xyz123abc123\" the match point is the fourth character. For\nthis reason, such a pattern is not implicitly anchored.\n\n
\nAnother case where implicit anchoring is not applied is when the leading .* is\ninside an atomic group. Once again, a match at the start may fail where a later\none succeeds. Consider this pattern:\n
\n (?>.*?a)b\n\nIt matches \"ab\" in the subject \"aab\". The use of the backtracking control verbs\n(*PRUNE) and (*SKIP) also disable this optimization. To do so explicitly,\neither pass the compile option PCRE2_NO_DOTSTAR_ANCHOR, or call\npcre2_set_optimize() with a PCRE2_DOTSTAR_ANCHOR_OFF directive.\n\n
\nWhen a capture group is repeated, the value captured is the substring that\nmatched the final iteration. For example, after\n
\n (tweedle[dume]{3}\\s*)+\n\nhas matched \"tweedledum tweedledee\" the value of the captured substring is\n\"tweedledee\". However, if there are nested capture groups, the corresponding\ncaptured values may have been set in previous iterations. For example, after\n\n (a|(b))+\n\nmatches \"aba\" the value of the second captured substring is \"b\".\n\n
ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS
\n\nWith both maximizing (\"greedy\") and minimizing (\"ungreedy\" or \"lazy\")\nrepetition, failure of what follows normally causes the repeated item to be\nre-evaluated to see if a different number of repeats allows the rest of the\npattern to match. Sometimes it is useful to prevent this, either to change the\nnature of the match, or to cause it fail earlier than it otherwise might, when\nthe author of the pattern knows there is no point in carrying on.\n
\n\nConsider, for example, the pattern \\d+foo when applied to the subject line\n
\n 123456bar\n\nAfter matching all 6 digits and then failing to match \"foo\", the normal\naction of the matcher is to try again with only 5 digits matching the \\d+\nitem, and then with 4, and so on, before ultimately failing. \"Atomic grouping\"\n(a term taken from Jeffrey Friedl's book) provides the means for specifying\nthat once a group has matched, it is not to be re-evaluated in this way.\n\n
\nIf we use atomic grouping for the previous example, the matcher gives up\nimmediately on failing to match \"foo\" the first time. The notation is a kind of\nspecial parenthesis, starting with (?> as in this example:\n
\n (?>\\d+)foo\n\nPerl 5.28 introduced an experimental alphabetic form starting with (* which may\nbe easier to remember:\n
\n (*atomic:\\d+)foo\n\nThis kind of parenthesized group \"locks up\" the part of the pattern it contains\nonce it has matched, and a failure further into the pattern is prevented from\nbacktracking into it. Backtracking past it to previous items, however, works as\nnormal.\n\n
\nAn alternative description is that a group of this type matches exactly the\nstring of characters that an identical standalone pattern would match, if\nanchored at the current point in the subject string.\n
\n\nAtomic groups are not capture groups. Simple cases such as the above example\ncan be thought of as a maximizing repeat that must swallow everything it can.\nSo, while both \\d+ and \\d+? are prepared to adjust the number of digits they\nmatch in order to make the rest of the pattern match, (?>\\d+) can only match\nan entire sequence of digits.\n
\n\nAtomic groups in general can of course contain arbitrarily complicated\nexpressions, and can be nested. However, when the contents of an atomic\ngroup is just a single repeated item, as in the example above, a simpler\nnotation, called a \"possessive quantifier\" can be used. This consists of an\nadditional + character following a quantifier. Using this notation, the\nprevious example can be rewritten as\n
\n \\d++foo\n\nNote that a possessive quantifier can be used with an entire group, for\nexample:\n
\n (abc|xyz){2,3}+\n\nPossessive quantifiers are always greedy; the setting of the PCRE2_UNGREEDY\noption is ignored. They are a convenient notation for the simpler forms of\natomic group. However, there is no difference in the meaning of a possessive\nquantifier and the equivalent atomic group, though there may be a performance\ndifference; possessive quantifiers should be slightly faster.\n\n\nThe possessive quantifier syntax is an extension to the Perl 5.8 syntax.\nJeffrey Friedl originated the idea (and the name) in the first edition of his\nbook. Mike McCloskey liked it, so implemented it when he built Sun's Java\npackage, and PCRE1 copied it from there. It found its way into Perl at release\n5.10.\n
\n\nPCRE2 has an optimization that automatically \"possessifies\" certain simple\npattern constructs. For example, the sequence A+B is treated as A++B because\nthere is no point in backtracking into a sequence of A's when B must follow.\nThis feature can be disabled by the PCRE2_NO_AUTO_POSSESS option, by calling\npcre2_set_optimize() with a PCRE2_AUTO_POSSESS_OFF directive, or by\nstarting the pattern with (*NO_AUTO_POSSESS).\n
\n\nWhen a pattern contains an unlimited repeat inside a group that can itself be\nrepeated an unlimited number of times, the use of an atomic group is the only\nway to avoid some failing matches taking a very long time indeed. The pattern\n
\n (\\D+|<\\d+>)*[!?]\n\nmatches an unlimited number of substrings that either consist of non-digits, or\ndigits enclosed in <>, followed by either ! or ?. When it matches, it runs\nquickly. However, if it is applied to\n
\n aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\nit takes a long time before reporting failure. This is because the string can\nbe divided between the internal \\D+ repeat and the external * repeat in a\nlarge number of ways, and all have to be tried. (The example uses [!?] rather\nthan a single character at the end, because both PCRE2 and Perl have an\noptimization that allows for fast failure when a single character is used. They\nremember the last single character that is required for a match, and fail early\nif it is not present in the string.) If the pattern is changed so that it uses\nan atomic group, like this:\n
\n ((?>\\D+)|<\\d+>)*[!?]\n\nsequences of non-digits cannot be broken, and failure happens quickly.\n\n
BACKREFERENCES
\n\nOutside a character class, a backslash followed by a digit greater than 0 (and\npossibly further digits) is a backreference to a capture group earlier (that\nis, to its left) in the pattern, provided there have been that many previous\ncapture groups.\n
\n\nHowever, if the decimal number following the backslash is less than 8, it is\nalways taken as a backreference, and causes an error only if there are not that\nmany capture groups in the entire pattern. In other words, the group that is\nreferenced need not be to the left of the reference for numbers less than 8. A\n\"forward backreference\" of this type can make sense when a repetition is\ninvolved and the group to the right has participated in an earlier iteration.\n
\n\nIt is not possible to have a numerical \"forward backreference\" to a group whose\nnumber is 8 or more using this syntax because a sequence such as \\50 is\ninterpreted as a character defined in octal. See the subsection entitled\n\"Non-printing characters\"\nabove\nfor further details of the handling of digits following a backslash. Other\nforms of backreferencing do not suffer from this restriction. In particular,\nthere is no problem when named capture groups are used (see below).\n
\n\nAnother way of avoiding the ambiguity inherent in the use of digits following a\nbackslash is to use the \\g escape sequence. This escape must be followed by a\nsigned or unsigned number, optionally enclosed in braces. These examples are\nall identical:\n
\n (ring), \\1\n (ring), \\g1\n (ring), \\g{1}\n\nAn unsigned number specifies an absolute reference without the ambiguity that\nis present in the older syntax. It is also useful when literal digits follow\nthe reference. A signed number is a relative reference. Consider this example:\n\n (abc(def)ghi)\\g{-1}\n\nThe sequence \\g{-1} is a reference to the capture group whose number is one\nless than the number of the next group to be started, so in this example (where\nthe next group would be numbered 3) is it equivalent to \\2, and \\g{-2} would\nbe equivalent to \\1. Note that if this construct is inside a capture group,\nthat group is included in the count, so in this example \\g{-2} also refers to\ngroup 1:\n\n (A)(\\g{-2}B)\n\nThe use of relative references can be helpful in long patterns, and also in\npatterns that are created by joining together fragments that contain references\nwithin themselves.\n\n\nThe sequence \\g{+1} is a reference to the next capture group that is started\nafter this item, and \\g{+2} refers to the one after that, and so on. This kind\nof forward reference can be useful in patterns that repeat. Perl does not\nsupport the use of + in this way.\n
\n\nA backreference matches whatever actually most recently matched the capture\ngroup in the current subject string, rather than anything at all that matches\nthe group (see\n\"Groups as subroutines\"\nbelow for a way of doing that). So the pattern\n
\n (sens|respons)e and \\1ibility\n\nmatches \"sense and sensibility\" and \"response and responsibility\", but not\n\"sense and responsibility\". If caseful matching is in force at the time of the\nbackreference, the case of letters is relevant. For example,\n
\n ((?i)rah)\\s+\\1\n\nmatches \"rah rah\" and \"RAH RAH\", but not \"RAH rah\", even though the original\ncapture group is matched caselessly.\n\n
\nThere are several different ways of writing backreferences to named capture\ngroups. The .NET syntax is \\k{name}, the Python syntax is (?=name), and the\noriginal Perl syntax is \\k<name> or \\k'name'. All of these are now supported\nby both Perl and PCRE2. Perl 5.10's unified backreference syntax, in which \\g\ncan be used for both numeric and named references, is also supported by PCRE2.\nWe could rewrite the above example in any of the following ways:\n
\n (?<p1>(?i)rah)\\s+\\k<p1>\n (?'p1'(?i)rah)\\s+\\k{p1}\n (?P<p1>(?i)rah)\\s+(?P=p1)\n (?<p1>(?i)rah)\\s+\\g{p1}\n\nA capture group that is referenced by name may appear in the pattern before or\nafter the reference.\n\n\nThere may be more than one backreference to the same group. If a group has not\nactually been used in a particular match, backreferences to it always fail by\ndefault. For example, the pattern\n
\n (a|(bc))\\2\n\nalways fails if it starts to match \"a\" rather than \"bc\". However, if the\nPCRE2_MATCH_UNSET_BACKREF option is set at compile time, a backreference to an\nunset value matches an empty string.\n\n
\nBecause there may be many capture groups in a pattern, all digits following a\nbackslash are taken as part of a potential backreference number. If the pattern\ncontinues with a digit character, some delimiter must be used to terminate the\nbackreference. If the PCRE2_EXTENDED or PCRE2_EXTENDED_MORE option is set, this\ncan be white space. Otherwise, the \\g{} syntax or an empty comment (see\n\"Comments\"\nbelow) can be used.\n
\n\nRecursive backreferences\n
\n\nA backreference that occurs inside the group to which it refers fails when the\ngroup is first used, so, for example, (a\\1) never matches. However, such\nreferences can be useful inside repeated groups. For example, the pattern\n
\n (a|b\\1)+\n\nmatches any number of \"a\"s and also \"aba\", \"ababbaa\" etc. At each iteration of\nthe group, the backreference matches the character string corresponding to the\nprevious iteration. In order for this to work, the pattern must be such that\nthe first iteration does not need to match the backreference. This can be done\nusing alternation, as in the example above, or by a quantifier with a minimum\nof zero.\n\n
\nFor versions of PCRE2 less than 10.25, backreferences of this type used to\ncause the group that they reference to be treated as an\natomic group.\nThis restriction no longer applies, and backtracking into such groups can occur\nas normal.\n
\nASSERTIONS
\n\nAn assertion is a test that does not consume any characters. The test must\nsucceed for the match to continue. The simple assertions coded as \\b, \\B,\n\\A, \\G, \\Z, \\z, ^ and $ are described\nabove.\n
\n\nMore complicated assertions are coded as parenthesized groups. If matching such\na group succeeds, matching continues after it, but with the matching position\nin the subject string reset to what it was before the assertion was processed.\n
\n\nA special kind of assertion, called a \"scan substring\" assertion, matches a\nsubpattern against a previously captured substring. This is described in the\nsection entitled\n\"Scan substring assertions\"\nbelow. It is a PCRE2 extension, not compatible with Perl.\n
\n\nThe other goup-based assertions are of two kinds: those that look ahead of the\ncurrent position in the subject string, and those that look behind it, and in\neach case an assertion may be positive (must match for the assertion to be\ntrue) or negative (must not match for the assertion to be true).\n
\n\nThe Perl-compatible lookaround assertions are atomic. If an assertion is true,\nbut there is a subsequent matching failure, there is no backtracking into the\nassertion. However, there are some cases where non-atomic assertions can be\nuseful. PCRE2 has some support for these, described in the section entitled\n\"Non-atomic assertions\"\nbelow, but they are not Perl-compatible.\n
\n\nA lookaround assertion may appear as the condition in a\nconditional group\n(see below). In this case, the result of matching the assertion determines\nwhich branch of the condition is followed.\n
\n\nAssertion groups are not capture groups. If an assertion contains capture\ngroups within it, these are counted for the purposes of numbering the capture\ngroups in the whole pattern. Within each branch of an assertion, locally\ncaptured substrings may be referenced in the usual way. For example, a sequence\nsuch as (.)\\g{-1} can be used to check that two adjacent characters are the\nsame.\n
\n\nWhen a branch within an assertion fails to match, any substrings that were\ncaptured are discarded (as happens with any pattern branch that fails to\nmatch). A negative assertion is true only when all its branches fail to match;\nthis means that no captured substrings are ever retained after a successful\nnegative assertion. When an assertion contains a matching branch, what happens\ndepends on the type of assertion.\n
\n\nFor a positive assertion, internally captured substrings in the successful\nbranch are retained, and matching continues with the next pattern item after\nthe assertion. For a negative assertion, a matching branch means that the\nassertion is not true. If such an assertion is being used as a condition in a\nconditional group\n(see below), captured substrings are retained, because matching continues with\nthe \"no\" branch of the condition. For other failing negative assertions,\ncontrol passes to the previous backtracking point, thus discarding any captured\nstrings within the assertion.\n
\n\nMost assertion groups may be repeated; though it makes no sense to assert the\nsame thing several times, the side effect of capturing in positive assertions\nmay occasionally be useful. However, an assertion that forms the condition for\na conditional group may not be quantified. PCRE2 used to restrict the\nrepetition of assertions, but from release 10.35 the only restriction is that\nan unlimited maximum repetition is changed to be one more than the minimum. For\nexample, {3,} is treated as {3,4}.\n
\n\nAlphabetic assertion names\n
\n\nTraditionally, symbolic sequences such as (?= and (?<= have been used to\nspecify lookaround assertions. Perl 5.28 introduced some experimental\nalphabetic alternatives which might be easier to remember. They all start with\n(* instead of (? and must be written using lower case letters. PCRE2 supports\nthe following synonyms:\n
\n (*positive_lookahead: or (*pla: is the same as (?=\n (*negative_lookahead: or (*nla: is the same as (?!\n (*positive_lookbehind: or (*plb: is the same as (?<=\n (*negative_lookbehind: or (*nlb: is the same as (?<!\n\nFor example, (*pla:foo) is the same assertion as (?=foo). In the following\nsections, the various assertions are described using the original symbolic\nforms.\n\n
\nLookahead assertions\n
\n\nLookahead assertions start with (?= for positive assertions and (?! for\nnegative assertions. For example,\n
\n \\w+(?=;)\n\nmatches a word followed by a semicolon, but does not include the semicolon in\nthe match, and\n
\n foo(?!bar)\n\nmatches any occurrence of \"foo\" that is not followed by \"bar\". Note that the\napparently similar pattern\n
\n (?!foo)bar\n\ndoes not find an occurrence of \"bar\" that is preceded by something other than\n\"foo\"; it finds any occurrence of \"bar\" whatsoever, because the assertion\n(?!foo) is always true when the next three characters are \"bar\". A\nlookbehind assertion is needed to achieve the other effect.\n\n
\nIf you want to force a matching failure at some point in a pattern, the most\nconvenient way to do it is with (?!) because an empty string always matches, so\nan assertion that requires there not to be an empty string must always fail.\nThe backtracking control verb (*FAIL) or (*F) is a synonym for (?!).\n
\n\nLookbehind assertions\n
\n\nLookbehind assertions start with (?<= for positive assertions and (?<! for\nnegative assertions. For example,\n
\n (?<!foo)bar\n\ndoes find an occurrence of \"bar\" that is not preceded by \"foo\". The contents of\na lookbehind assertion are restricted such that there must be a known maximum\nto the lengths of all the strings it matches. There are two cases:\n\n
\nIf every top-level alternative matches a fixed length, for example\n
\n (?<=colour|color)\n\nthere is a limit of 65535 characters to the lengths, which do not have to be\nthe same, as this example demonstrates. This is the only kind of lookbehind\nsupported by PCRE2 versions earlier than 10.43 and by the alternative matching\nfunction pcre2_dfa_match().\n\n
\nIn PCRE2 10.43 and later, pcre2_match() supports lookbehind assertions in\nwhich one or more top-level alternatives can match more than one string length,\nfor example\n
\n (?<=colou?r)\n\nThe maximum matching length for any branch of the lookbehind is limited to a\nvalue set by the calling program (default 255 characters). Unlimited repetition\n(for example \\d*) is not supported. In some cases, the escape sequence \\K\n(see above)\ncan be used instead of a lookbehind assertion at the start of a pattern to get\nround the length limit restriction.\n\n
\nIn UTF-8 and UTF-16 modes, PCRE2 does not allow the \\C escape (which matches a\nsingle code unit even in a UTF mode) to appear in lookbehind assertions,\nbecause it makes it impossible to calculate the length of the lookbehind. The\n\\X and \\R escapes, which can match different numbers of code units, are never\npermitted in lookbehinds.\n
\n\n\"Subroutine\"\ncalls (see below) such as (?2) or (?&X) are permitted in lookbehinds, as long\nas the called capture group matches a limited-length string. However,\nrecursion,\nthat is, a \"subroutine\" call into a group that is already active,\nis not supported.\n
\n\nPCRE2 supports backreferences in lookbehinds, but only if certain conditions\nare met. The PCRE2_MATCH_UNSET_BACKREF option must not be set, there must be no\nuse of (?| in the pattern (it creates duplicate group numbers), and if the\nbackreference is by name, the name must be unique. Of course, the referenced\ngroup must itself match a limited length substring. The following pattern\nmatches words containing at least two characters that begin and end with the\nsame character:\n
\n \\b(\\w)\\w++(?<=\\1)\n\n\n
\nPossessive quantifiers can be used in conjunction with lookbehind assertions to\nspecify efficient matching at the end of subject strings. Consider a simple\npattern such as\n
\n abcd$\n\nwhen applied to a long string that does not match. Because matching proceeds\nfrom left to right, PCRE2 will look for each \"a\" in the subject and then see if\nwhat follows matches the rest of the pattern. If the pattern is specified as\n
\n ^.*abcd$\n\nthe initial .* matches the entire string at first, but when this fails (because\nthere is no following \"a\"), it backtracks to match all but the last character,\nthen all but the last two characters, and so on. Once again the search for \"a\"\ncovers the entire string, from right to left, so we are no better off. However,\nif the pattern is written as\n
\n ^.*+(?<=abcd)\n\nthere can be no backtracking for the .*+ item because of the possessive\nquantifier; it can match only the entire string. The subsequent lookbehind\nassertion does a single test on the last four characters. If it fails, the\nmatch fails immediately. For long strings, this approach makes a significant\ndifference to the processing time.\n\n
\nUsing multiple assertions\n
\n\nSeveral assertions (of any sort) may occur in succession. For example,\n
\n (?<=\\d{3})(?<!999)foo\n\nmatches \"foo\" preceded by three digits that are not \"999\". Notice that each of\nthe assertions is applied independently at the same point in the subject\nstring. First there is a check that the previous three characters are all\ndigits, and then there is a check that the same three characters are not \"999\".\nThis pattern does not match \"foo\" preceded by six characters, the first\nof which are digits and the last three of which are not \"999\". For example, it\ndoesn't match \"123abcfoo\". A pattern to do that is\n\n (?<=\\d{3}...)(?<!999)foo\n\nThis time the first assertion looks at the preceding six characters, checking\nthat the first three are digits, and then the second assertion checks that the\npreceding three characters are not \"999\".\n\n\nAssertions can be nested in any combination. For example,\n
\n (?<=(?<!foo)bar)baz\n\nmatches an occurrence of \"baz\" that is preceded by \"bar\" which in turn is not\npreceded by \"foo\", while\n
\n (?<=\\d{3}(?!999)...)foo\n\nis another pattern that matches \"foo\" preceded by three digits and any three\ncharacters that are not \"999\".\n\nNON-ATOMIC ASSERTIONS
\n\nTraditional lookaround assertions are atomic. That is, if an assertion is true,\nbut there is a subsequent matching failure, there is no backtracking into the\nassertion. However, there are some cases where non-atomic positive assertions\ncan be useful. PCRE2 provides these using the following syntax:\n
\n (*non_atomic_positive_lookahead: or (*napla: or (?*\n (*non_atomic_positive_lookbehind: or (*naplb: or (?<*\n\nConsider the problem of finding the right-most word in a string that also\nappears earlier in the string, that is, it must appear at least twice in total.\nThis pattern returns the required result as captured substring 1:\n
\n ^(?x)(*napla: .* \\b(\\w++)) (?> .*? \\b\\1\\b ){2}\n\nFor a subject such as \"word1 word2 word3 word2 word3 word4\" the result is\n\"word3\". How does it work? At the start, ^(?x) anchors the pattern and sets the\n\"x\" option, which causes white space (introduced for readability) to be\nignored. Inside the assertion, the greedy .* at first consumes the entire\nstring, but then has to backtrack until the rest of the assertion can match a\nword, which is captured by group 1. In other words, when the assertion first\nsucceeds, it captures the right-most word in the string.\n\n\nThe current matching point is then reset to the start of the subject, and the\nrest of the pattern match checks for two occurrences of the captured word,\nusing an ungreedy .*? to scan from the left. If this succeeds, we are done, but\nif the last word in the string does not occur twice, this part of the pattern\nfails. If a traditional atomic lookahead (?= or (*pla: had been used, the\nassertion could not be re-entered, and the whole match would fail. The pattern\nwould succeed only if the very last word in the subject was found twice.\n
\n\nUsing a non-atomic lookahead, however, means that when the last word does not\noccur twice in the string, the lookahead can backtrack and find the second-last\nword, and so on, until either the match succeeds, or all words have been\ntested.\n
\n\nTwo conditions must be met for a non-atomic assertion to be useful: the\ncontents of one or more capturing groups must change after a backtrack into the\nassertion, and there must be a backreference to a changed group later in the\npattern. If this is not the case, the rest of the pattern match fails exactly\nas before because nothing has changed, so using a non-atomic assertion just\nwastes resources.\n
\n\nThere is one exception to backtracking into a non-atomic assertion. If an\n(*ACCEPT) control verb is triggered, the assertion succeeds atomically. That\nis, a subsequent match failure cannot backtrack into the assertion.\n
\n\nNon-atomic assertions are not supported by the alternative matching function\npcre2_dfa_match(). They are supported by JIT, but only if they do not\ncontain any control verbs such as (*ACCEPT). (This may change in future). Note\nthat assertions that appear as conditions for\nconditional groups\n(see below) must be atomic.\n
\nSCAN SUBSTRING ASSERTIONS
\n\nA special kind of assertion, not compatible with Perl, makes it possible to\ncheck the contents of a captured substring by matching it with a subpattern.\nBecause this involves capturing, this feature is not supported by\npcre2_dfa_match().\n
\n\nA scan substring assertion starts with the sequence (*scan_substring: or\n(*scs: which is followed by a list of substring numbers (absolute or relative)\nand/or substring names enclosed in single quotes or angle brackets, all within\nparentheses. The rest of the item is the subpattern that is applied to the\nsubstring, as shown in these examples:\n
\n (*scan_substring:(1)...)\n (*scs:(-2)...)\n (*scs:('AB')...)\n (*scs:(1,'AB',-2)...)\n\nThe list of groups is checked in the order they are given, and it is the\ncontents of the first one that is found to be set that are scanned. When\nPCRE2_DUPNAMES is set and there are ambiguous group names, all groups with the\nsame name are checked in numerical order. A scan substring assertion fails if\nnone of the groups it references have been set.\n\n\nThe pattern match on the substring is always anchored, that is, it must match\nfrom the start of the substring. There is no \"bumpalong\" if it does not match\nat the start. The end of the subject is temporarily reset to be the end of the\nsubstring, so \\Z, \\z, and $ will match there. However, the start of the\nsubject is not reset. This means that ^ matches only if the substring is\nactually at the start of the main subject, but it also means that lookbehind\nassertions into what precedes the substring are possible.\n
\n\nHere is a very simple example: find a word that contains the rare (in English)\nsequence of letters \"rh\" not at the start:\n
\n \\b(\\w++)(*scs:(1).+rh)\n\nThe first group captures a word which is then scanned by the second group.\nThis example does not actually need this heavyweight feature; the same match\ncan be achieved with:\n
\n \\b\\w+?rh\\w*\\b\n\nWhen things are more complicated, however, scanning a captured substring can be\na useful way to describe the required match. For exmple, there is a rather\ncomplicated pattern in the PCRE2 test data that checks an entire subject string\nfor a palindrome, that is, the sequence of letters is the same in both\ndirections. Suppose you want to search for individual words of two or more\ncharacters such as \"level\" that are palindromes:\n
\n (\\b\\w{2,}+\\b)(*scs:(1)...palindrome-matching-pattern...)\n\nWithin a substring scanning subpattern, references to other groups work as\nnormal. Capturing groups may appear, and will retain their values during\nongoing matching if the assertion succeeds.\n\nSCRIPT RUNS
\n\nIn concept, a script run is a sequence of characters that are all from the same\nUnicode script such as Latin or Greek. However, because some scripts are\ncommonly used together, and because some diacritical and other marks are used\nwith multiple scripts, it is not that simple. There is a full description of\nthe rules that PCRE2 uses in the section entitled\n\"Script Runs\"\nin the\npcre2unicode\ndocumentation.\n
\n\nIf part of a pattern is enclosed between (*script_run: or (*sr: and a closing\nparenthesis, it fails if the sequence of characters that it matches are not a\nscript run. After a failure, normal backtracking occurs. Script runs can be\nused to detect spoofing attacks using characters that look the same, but are\nfrom different scripts. The string \"paypal.com\" is an infamous example, where\nthe letters could be a mixture of Latin and Cyrillic. This pattern ensures that\nthe matched characters in a sequence of non-spaces that follow white space are\na script run:\n
\n \\s+(*sr:\\S+)\n\nTo be sure that they are all from the Latin script (for example), a lookahead\ncan be used:\n
\n \\s+(?=\\p{Latin})(*sr:\\S+)\n\nThis works as long as the first character is expected to be a character in that\nscript, and not (for example) punctuation, which is allowed with any script. If\nthis is not the case, a more creative lookahead is needed. For example, if\ndigits, underscore, and dots are permitted at the start:\n\n \\s+(?=[0-9_.]*\\p{Latin})(*sr:\\S+)\n\n\n\n\nIn many cases, backtracking into a script run pattern fragment is not\ndesirable. The script run can employ an atomic group to prevent this. Because\nthis is a common requirement, a shorthand notation is provided by\n(*atomic_script_run: or (*asr:\n
\n (*asr:...) is the same as (*sr:(?>...))\n\nNote that the atomic group is inside the script run. Putting it outside would\nnot prevent backtracking into the script run pattern.\n\n
\nSupport for script runs is not available if PCRE2 is compiled without Unicode\nsupport. A compile-time error is given if any of the above constructs is\nencountered. Script runs are not supported by the alternate matching function,\npcre2_dfa_match() because they use the same mechanism as capturing\nparentheses.\n
\n\nWarning: The (*ACCEPT) control verb\n(see below)\nshould not be used within a script run group, because it causes an immediate\nexit from the group, bypassing the script run checking.\n
\nCONDITIONAL GROUPS
\n\nIt is possible to cause the matching process to obey a pattern fragment\nconditionally or to choose between two alternative fragments, depending on\nthe result of an assertion, or whether a specific capture group has\nalready been matched. The two possible forms of conditional group are:\n
\n (?(condition)yes-pattern)\n (?(condition)yes-pattern|no-pattern)\n\nIf the condition is satisfied, the yes-pattern is used; otherwise the\nno-pattern (if present) is used. An absent no-pattern is equivalent to an empty\nstring (it always matches). If there are more than two alternatives in the\ngroup, a compile-time error occurs. Each of the two alternatives may itself\ncontain nested groups of any form, including conditional groups; the\nrestriction to two alternatives applies only at the level of the condition\nitself. This pattern fragment is an example where the alternatives are complex:\n
\n (?(1) (A|B|C) | (D | (?(2)E|F) | E) )\n\n\n\n
\nThere are five kinds of condition: references to capture groups, references to\nrecursion, two pseudo-conditions called DEFINE and VERSION, and assertions.\n
\n\nChecking for a used capture group by number\n
\n\nIf the text between the parentheses consists of a sequence of digits, the\ncondition is true if a capture group of that number has previously matched. If\nthere is more than one capture group with the same number (see the earlier\nsection about duplicate group numbers),\nthe condition is true if any of them have matched. An alternative notation,\nwhich is a PCRE2 extension, not supported by Perl, is to precede the digits\nwith a plus or minus sign. In this case, the group number is relative rather\nthan absolute. The most recently opened capture group (which could be enclosing\nthis condition) can be referenced by (?(-1), the next most recent by (?(-2),\nand so on. Inside loops it can also make sense to refer to subsequent groups.\nThe next capture group to be opened can be referenced as (?(+1), and so on. The\nvalue zero in any of these forms is not used; it provokes a compile-time error.\n
\n\nConsider the following pattern, which contains non-significant white space to\nmake it more readable (assume the PCRE2_EXTENDED option) and to divide it into\nthree parts for ease of discussion:\n
\n ( \\( )? [^()]+ (?(1) \\) )\n\nThe first part matches an optional opening parenthesis, and if that\ncharacter is present, sets it as the first captured substring. The second part\nmatches one or more characters that are not parentheses. The third part is a\nconditional group that tests whether or not the first capture group\nmatched. If it did, that is, if subject started with an opening parenthesis,\nthe condition is true, and so the yes-pattern is executed and a closing\nparenthesis is required. Otherwise, since no-pattern is not present, the\nconditional group matches nothing. In other words, this pattern matches a\nsequence of non-parentheses, optionally enclosed in parentheses.\n\n
\nIf you were embedding this pattern in a larger one, you could use a relative\nreference:\n
\n ...other stuff... ( \\( )? [^()]+ (?(-1) \\) ) ...\n\nThis makes the fragment independent of the parentheses in the larger pattern.\n\n
\nChecking for a used capture group by name\n
\n\nPerl uses the syntax (?(<name>)...) or (?('name')...) to test for a used\ncapture group by name. For compatibility with earlier versions of PCRE1, which\nhad this facility before Perl, the syntax (?(name)...) is also recognized.\nNote, however, that undelimited names consisting of the letter R followed by\ndigits are ambiguous (see the following section). Rewriting the above example\nto use a named group gives this:\n
\n (?<OPEN> \\( )? [^()]+ (?(<OPEN>) \\) )\n\nIf the name used in a condition of this kind is a duplicate, the test is\napplied to all groups of the same name, and is true if any one of them has\nmatched.\n\n
\nChecking for pattern recursion\n
\n\n\"Recursion\" in this sense refers to any subroutine-like call from one part of\nthe pattern to another, whether or not it is actually recursive. See the\nsections entitled\n\"Recursive patterns\"\nand\n\"Groups as subroutines\"\nbelow for details of recursion and subroutine calls.\n
\n\nIf a condition is the string (R), and there is no capture group with the name\nR, the condition is true if matching is currently in a recursion or subroutine\ncall to the whole pattern or any capture group. If digits follow the letter R,\nand there is no group with that name, the condition is true if the most recent\ncall is into a group with the given number, which must exist somewhere in the\noverall pattern. This is a contrived example that is equivalent to a+b:\n
\n ((?(R1)a+|(?1)b))\n\nHowever, in both cases, if there is a capture group with a matching name, the\ncondition tests for its being set, as described in the section above, instead\nof testing for recursion. For example, creating a group with the name R1 by\nadding (?<R1>) to the above pattern completely changes its meaning.\n\n
\nIf a name preceded by ampersand follows the letter R, for example:\n
\n (?(R&name)...)\n\nthe condition is true if the most recent recursion is into a group of that name\n(which must exist within the pattern).\n\n
\nThis condition does not check the entire recursion stack. It tests only the\ncurrent level. If the name used in a condition of this kind is a duplicate, the\ntest is applied to all groups of the same name, and is true if any one of\nthem is the most recent recursion.\n
\n\nAt \"top level\", all these recursion test conditions are false.\n
\n\nDefining capture groups for use by reference only\n
\n\nIf the condition is the string (DEFINE), the condition is always false, even if\nthere is a group with the name DEFINE. In this case, there may be only one\nalternative in the rest of the conditional group. It is always skipped if\ncontrol reaches this point in the pattern; the idea of DEFINE is that it can be\nused to define subroutines that can be referenced from elsewhere. (The use of\nsubroutines\nis described below.) For example, a pattern to match an IPv4 address such as\n\"192.168.23.245\" could be written like this (ignore white space and line\nbreaks):\n
\n (?(DEFINE) (?<byte> 2[0-4]\\d | 25[0-5] | 1\\d\\d | [1-9]?\\d) )\n \\b (?&byte) (\\.(?&byte)){3} \\b\n\nThe first part of the pattern is a DEFINE group inside which another group\nnamed \"byte\" is defined. This matches an individual component of an IPv4\naddress (a number less than 256). When matching takes place, this part of the\npattern is skipped because DEFINE acts like a false condition. The rest of the\npattern uses references to the named group to match the four dot-separated\ncomponents of an IPv4 address, insisting on a word boundary at each end.\n\n\nChecking the PCRE2 version\n
\n\nPrograms that link with a PCRE2 library can check the version by calling\npcre2_config() with appropriate arguments. Users of applications that do\nnot have access to the underlying code cannot do this. A special \"condition\"\ncalled VERSION exists to allow such users to discover which version of PCRE2\nthey are dealing with by using this condition to match a string such as\n\"yesno\". VERSION must be followed either by \"=\" or \">=\" and a version number.\nFor example:\n
\n (?(VERSION>=10.4)yes|no)\n\nThis pattern matches \"yes\" if the PCRE2 version is greater or equal to 10.4, or\n\"no\" otherwise. The fractional part of the version number could be ommited.\n\n
\nAssertion conditions\n
\n\nIf the condition is not in any of the above formats, it must be a parenthesized\nassertion. This may be a positive or negative lookahead or lookbehind\nassertion. However, it must be a traditional atomic assertion, not one of the\nnon-atomic assertions.\n
\n\nConsider this pattern, again containing non-significant white space, and with\nthe two alternatives on the second line:\n
\n (?(?=[^a-z]*[a-z])\n \\d{2}-[a-z]{3}-\\d{2} | \\d{2}-\\d{2}-\\d{2} )\n\nThe condition is a positive lookahead assertion that matches an optional\nsequence of non-letters followed by a letter. In other words, it tests for the\npresence of at least one letter in the subject. If a letter is found, the\nsubject is matched against the first alternative; otherwise it is matched\nagainst the second. This pattern matches strings in one of the two forms\ndd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.\n\n\nWhen an assertion that is a condition contains capture groups, any\ncapturing that occurs in a matching branch is retained afterwards, for both\npositive and negative assertions, because matching always continues after the\nassertion, whether it succeeds or fails. (Compare non-conditional assertions,\nfor which captures are retained only for positive assertions that succeed.)\n
\nCOMMENTS
\n\nThere are two ways of including comments in patterns that are processed by\nPCRE2. In both cases, the start of the comment must not be in a character\nclass, nor in the middle of any other sequence of related characters such as\n(?: or a group name or number or a Unicode property name. The characters that\nmake up a comment play no part in the pattern matching.\n
\n\nThe sequence (?# marks the start of a comment that continues up to the next\nclosing parenthesis. Nested parentheses are not permitted. If the\nPCRE2_EXTENDED or PCRE2_EXTENDED_MORE option is set, an unescaped # character\nalso introduces a comment, which in this case continues to immediately after\nthe next newline character or character sequence in the pattern. Which\ncharacters are interpreted as newlines is controlled by an option passed to the\ncompiling function or by a special sequence at the start of the pattern, as\ndescribed in the section entitled\n\"Newline conventions\"\nabove. Note that the end of this type of comment is a literal newline sequence\nin the pattern; escape sequences that happen to represent a newline do not\ncount. For example, consider this pattern when PCRE2_EXTENDED is set, and the\ndefault newline convention (a single linefeed character) is in force:\n
\n abc #comment \\n still comment\n\nOn encountering the # character, pcre2_compile() skips along, looking for\na newline in the pattern. The sequence \\n is still literal at this stage, so\nit does not terminate the comment. Only an actual character with the code value\n0x0a (the default newline) does so.\n\n
RECURSIVE PATTERNS
\n\nConsider the problem of matching a string in parentheses, allowing for\nunlimited nested parentheses. Without the use of recursion, the best that can\nbe done is to use a pattern that matches up to some fixed depth of nesting. It\nis not possible to handle an arbitrary nesting depth.\n
\n\nFor some time, Perl has provided a facility that allows regular expressions to\nrecurse (amongst other things). It does this by interpolating Perl code in the\nexpression at run time, and the code can refer to the expression itself. A Perl\npattern using code interpolation to solve the parentheses problem can be\ncreated like this:\n
\n $re = qr{\\( (?: (?>[^()]+) | (?p{$re}) )* \\)}x;\n\nThe (?p{...}) item interpolates Perl code at run time, and in this case refers\nrecursively to the pattern in which it appears.\n\n\nObviously, PCRE2 cannot support the interpolation of Perl code. Instead, it\nsupports special syntax for recursion of the entire pattern, and also for\nindividual capture group recursion. After its introduction in PCRE1 and Python,\nthis kind of recursion was subsequently introduced into Perl at release 5.10.\n
\n\nA special item that consists of (? followed by a number greater than zero and a\nclosing parenthesis is a recursive subroutine call of the capture group of the\ngiven number, provided that it occurs inside that group. (If not, it is a\nnon-recursive subroutine\ncall, which is described in the next section.) The special item (?R) or (?0) is\na recursive call of the entire regular expression.\n
\n\nThis PCRE2 pattern solves the nested parentheses problem (assume the\nPCRE2_EXTENDED option is set so that white space is ignored):\n
\n \\( ( [^()]++ | (?R) )* \\)\n\nFirst it matches an opening parenthesis. Then it matches any number of\nsubstrings which can either be a sequence of non-parentheses, or a recursive\nmatch of the pattern itself (that is, a correctly parenthesized substring).\nFinally there is a closing parenthesis. Note the use of a possessive quantifier\nto avoid backtracking into sequences of non-parentheses.\n\n
\nIf this were part of a larger pattern, you would not want to recurse the entire\npattern, so instead you could use this:\n
\n ( \\( ( [^()]++ | (?1) )* \\) )\n\nWe have put the pattern into parentheses, and caused the recursion to refer to\nthem instead of the whole pattern.\n\n
\nIn a larger pattern, keeping track of parenthesis numbers can be tricky. This\nis made easier by the use of relative references. Instead of (?1) in the\npattern above you can write (?-2) to refer to the second most recently opened\nparentheses preceding the recursion. In other words, a negative number counts\ncapturing parentheses leftwards from the point at which it is encountered.\n
\n\nBe aware however, that if\nduplicate capture group numbers\nare in use, relative references refer to the earliest group with the\nappropriate number. Consider, for example:\n
\n (?|(a)|(b)) (c) (?-2)\n\nThe first two capture groups (a) and (b) are both numbered 1, and group (c)\nis number 2. When the reference (?-2) is encountered, the second most recently\nopened parentheses has the number 1, but it is the first such group (the (a)\ngroup) to which the recursion refers. This would be the same if an absolute\nreference (?1) was used. In other words, relative references are just a\nshorthand for computing a group number.\n\n
\nIt is also possible to refer to subsequent capture groups, by writing\nreferences such as (?+2). However, these cannot be recursive because the\nreference is not inside the parentheses that are referenced. They are always\nnon-recursive subroutine\ncalls, as described in the next section.\n
\n\nAn alternative approach is to use named parentheses. The Perl syntax for this\nis (?&name); PCRE1's earlier syntax (?P>name) is also supported. We could\nrewrite the above example as follows:\n
\n (?<pn> \\( ( [^()]++ | (?&pn) )* \\) )\n\nIf there is more than one group with the same name, the earliest one is\nused.\n\n
\nThe example pattern that we have been looking at contains nested unlimited\nrepeats, and so the use of a possessive quantifier for matching strings of\nnon-parentheses is important when applying the pattern to strings that do not\nmatch. For example, when this pattern is applied to\n
\n (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n\nit yields \"no match\" quickly. However, if a possessive quantifier is not used,\nthe match runs for a very long time indeed because there are so many different\nways the + and * repeats can carve up the subject, and all have to be tested\nbefore failure can be reported.\n\n
\nAt the end of a match, the values of capturing parentheses are those from\nthe outermost level. If you want to obtain intermediate values, a callout\nfunction can be used (see below and the\npcre2callout\ndocumentation). If the pattern above is matched against\n
\n (ab(cd)ef)\n\nthe value for the inner capturing parentheses (numbered 2) is \"ef\", which is\nthe last value taken on at the top level. If a capture group is not matched at\nthe top level, its final captured value is unset, even if it was (temporarily)\nset at a deeper level during the matching process.\n\n
\nDo not confuse the (?R) item with the condition (R), which tests for recursion.\nConsider this pattern, which matches text in angle brackets, allowing for\narbitrary nesting. Only digits are allowed in nested brackets (that is, when\nrecursing), whereas any characters are permitted at the outer level.\n
\n < (?: (?(R) \\d++ | [^<>]*+) | (?R)) * >\n\nIn this pattern, (?(R) is the start of a conditional group, with two different\nalternatives for the recursive and non-recursive cases. The (?R) item is the\nactual recursive call.\n\n
\nDifferences in recursion processing between PCRE2 and Perl\n
\n\nSome former differences between PCRE2 and Perl no longer exist.\n
\n\nBefore release 10.30, recursion processing in PCRE2 differed from Perl in that\na recursive subroutine call was always treated as an atomic group. That is,\nonce it had matched some of the subject string, it was never re-entered, even\nif it contained untried alternatives and there was a subsequent matching\nfailure. (Historical note: PCRE implemented recursion before Perl did.)\n
\n\nStarting with release 10.30, recursive subroutine calls are no longer treated\nas atomic. That is, they can be re-entered to try unused alternatives if there\nis a matching failure later in the pattern. This is now compatible with the way\nPerl works. If you want a subroutine call to be atomic, you must explicitly\nenclose it in an atomic group.\n
\n\nSupporting backtracking into recursions simplifies certain types of recursive\npattern. For example, this pattern matches palindromic strings:\n
\n ^((.)(?1)\\2|.?)$\n\nThe second branch in the group matches a single central character in the\npalindrome when there are an odd number of characters, or nothing when there\nare an even number of characters, but in order to work it has to be able to try\nthe second case when the rest of the pattern match fails. If you want to match\ntypical palindromic phrases, the pattern has to ignore all non-word characters,\nwhich can be done like this:\n
\n ^\\W*+((.)\\W*+(?1)\\W*+\\2|\\W*+.?)\\W*+$\n\nIf run with the PCRE2_CASELESS option, this pattern matches phrases such as \"A\nman, a plan, a canal: Panama!\". Note the use of the possessive quantifier *+ to\navoid backtracking into sequences of non-word characters. Without this, PCRE2\ntakes a great deal longer (ten times or more) to match typical phrases, and\nPerl takes so long that you think it has gone into a loop.\n\n
\nAnother way in which PCRE2 and Perl used to differ in their recursion\nprocessing is in the handling of captured values. Formerly in Perl, when a\ngroup was called recursively or as a subroutine (see the next section), it\nhad no access to any values that were captured outside the recursion, whereas\nin PCRE2 these values can be referenced. Consider this pattern:\n
\n ^(.)(\\1|a(?2))\n\nThis pattern matches \"bab\". The first capturing parentheses match \"b\", then in\nthe second group, when the backreference \\1 fails to match \"b\", the second\nalternative matches \"a\" and then recurses. In the recursion, \\1 does now match\n\"b\" and so the whole match succeeds. This match used to fail in Perl, but in\nlater versions (I tried 5.024) it now works.\n\n
\nGroups as subroutines\n
\n\nIf the syntax for a recursive group call (either by number or by name) is used\noutside the parentheses to which it refers, it operates a bit like a subroutine\nin a programming language. More accurately, PCRE2 treats the referenced group\nas an independent subpattern which it tries to match at the current matching\nposition. The called group may be defined before or after the reference. A\nnumbered reference can be absolute or relative, as in these examples:\n
\n (...(absolute)...)...(?2)...\n (...(relative)...)...(?-1)...\n (...(?+1)...(relative)...\n\nAn earlier example pointed out that the pattern\n
\n (sens|respons)e and \\1ibility\n\nmatches \"sense and sensibility\" and \"response and responsibility\", but not\n\"sense and responsibility\". If instead the pattern\n
\n (sens|respons)e and (?1)ibility\n\nis used, it does match \"sense and responsibility\" as well as the other two\nstrings. Another example is given in the discussion of DEFINE above.\n\n
\nLike recursions, subroutine calls used to be treated as atomic, but this\nchanged at PCRE2 release 10.30, so backtracking into subroutine calls can now\noccur. However, any capturing parentheses that are set during the subroutine\ncall revert to their previous values afterwards.\n
\n\nProcessing options such as case-independence are fixed when a group is\ndefined, so if it is used as a subroutine, such options cannot be changed for\ndifferent calls. For example, consider this pattern:\n
\n (abc)(?i:(?-1))\n\nIt matches \"abcabc\". It does not match \"abcABC\" because the change of\nprocessing option does not affect the called group.\n\n
\nThe behaviour of\nbacktracking control verbs\nin groups when called as subroutines is described in the section entitled\n\"Backtracking verbs in subroutines\"\nbelow.\n
\n\nRecursion and subroutines with returned capture groups\n
\n\nSince PCRE2 10.47, recursion and subroutine calls may also specify a list of\ncapture groups to return. This is a PCRE2 syntax extension not supported by\nPerl. The pattern matching recurses into the referenced expression as described\nabove, however, when the recursion returns to the calling expression the\nsubgroups captured during the recursion can be retained when the calling\nexpression's context is restored.\n
\n\nWhen used as a subroutine, this allows the subroutine's capture groups to\nbe used as return values.\n
\n\nOnly the specific capture groups listed by the caller will be retained, using\nthe following syntax:\n
\n (?R(grouplist)) recurse whole pattern, returning capture groups\n (?n(grouplist)) )\n (?+n(grouplist)) )\n (?-n(grouplist)) ) call subroutine, returning capture groups\n (?&name(grouplist)) )\n (?P>name(grouplist)) )\n\n\n
\nThe list of capture groups \"grouplist\" is a comma-separated list of (absolute\nor relative) group numbers, and group names enclosed in single quotes or angle\nbrackets.\n
\n\nHere is an example which first uses the DEFINE condition to create a re-usable\nroutine for matching a weekday, then calls that subroutine and retains the\ngroups it captures for use later:\n
\n (?x: # ignore whitespace for clarity\n # Define the routine \"weekendday\" which matches Saturday or\n # Sunday, and returns the Sat/Sun prefix as \\k<short>.\n (?(DEFINE) (?<weekendday>\n (?|(?<short>Sat)urday|(?<short>Sun)day) ) )\n # Call the routine. Matches \"Saturday,Sat\" or \"Sunday,Sun\".\n (?&weekendday(<short>)),\\k<short> )\n\n\n
\nThis feature is not available using the Oniguruma syntax \\g<...> or \\g'...'\nbelow.\n
\n\nOniguruma subroutine syntax\n
\n\nFor compatibility with Oniguruma, the non-Perl syntax \\g followed by a name or\na number enclosed either in angle brackets or single quotes, is an alternative\nsyntax for calling a group as a subroutine, possibly recursively. Here are two\nof the examples used above, rewritten using this syntax:\n
\n (?<pn> \\( ( (?>[^()]+) | \\g<pn> )* \\) )\n (sens|respons)e and \\g'1'ibility\n\nPCRE2 supports an extension to Oniguruma: if a number is preceded by a\nplus or a minus sign it is taken as a relative reference. For example:\n
\n (abc)(?i:\\g<-1>)\n\nNote that \\g{...} (Perl syntax) and \\g<...> (Oniguruma syntax) are not\nsynonymous. The former is a backreference; the latter is a subroutine call.\n\n
CALLOUTS
\n\nPerl has a feature whereby using the sequence (?{...}) causes arbitrary Perl\ncode to be obeyed in the middle of matching a regular expression. This makes it\npossible, amongst other things, to extract different substrings that match the\nsame pair of parentheses when there is a repetition.\n
\n\nPCRE2 provides a similar feature, but of course it cannot obey arbitrary Perl\ncode. The feature is called \"callout\". The caller of PCRE2 provides an external\nfunction by putting its entry point in a match context using the function\npcre2_set_callout(), and then passing that context to pcre2_match()\nor pcre2_dfa_match(). If no match context is passed, or if the callout\nentry point is set to NULL, callout points will be passed over silently during\nmatching. To disallow callouts in the pattern syntax, you may use the\nPCRE2_EXTRA_NEVER_CALLOUT option.\n
\n\nWithin a regular expression, (?C<arg>) indicates a point at which the external\nfunction is to be called. There are two kinds of callout: those with a\nnumerical argument and those with a string argument. (?C) on its own with no\nargument is treated as (?C0). A numerical argument allows the application to\ndistinguish between different callouts. String arguments were added for release\n10.20 to make it possible for script languages that use PCRE2 to embed short\nscripts within patterns in a similar way to Perl.\n
\n\nDuring matching, when PCRE2 reaches a callout point, the external function is\ncalled. It is provided with the number or string argument of the callout, the\nposition in the pattern, and one item of data that is also set in the match\nblock. The callout function may cause matching to proceed, to backtrack, or to\nfail.\n
\n\nBy default, PCRE2 implements a number of optimizations at matching time, and\none side-effect is that sometimes callouts are skipped. If you need all\npossible callouts to happen, you need to set options that disable the relevant\noptimizations. More details, including a complete description of the\nprogramming interface to the callout function, are given in the\npcre2callout\ndocumentation.\n
\n\nCallouts with numerical arguments\n
\n\nIf you just want to have a means of identifying different callout points, put a\nnumber less than 256 after the letter C. For example, this pattern has two\ncallout points:\n
\n (?C1)abc(?C2)def\n\nIf the PCRE2_AUTO_CALLOUT flag is passed to pcre2_compile(), numerical\ncallouts are automatically installed before each item in the pattern. They are\nall numbered 255. If there is a conditional group in the pattern whose\ncondition is an assertion, an additional callout is inserted just before the\ncondition. An explicit callout may also be set at this position, as in this\nexample:\n
\n (?(?C9)(?=a)abc|def)\n\nNote that this applies only to assertion conditions, not to other types of\ncondition.\n\n
\nCallouts with string arguments\n
\n\nA delimited string may be used instead of a number as a callout argument. The\nstarting delimiter must be one of ` ' \" ^ % # $ { and the ending delimiter is\nthe same as the start, except for {, where the ending delimiter is }. If the\nending delimiter is needed within the string, it must be doubled. For\nexample:\n
\n (?C'ab ''c'' d')xyz(?C{any text})pqr\n\nThe doubling is removed before the string is passed to the callout function.\n\nBACKTRACKING CONTROL
\n\nThere are a number of special \"Backtracking Control Verbs\" (to use Perl's\nterminology) that modify the behaviour of backtracking during matching. They\nare generally of the form (*VERB) or (*VERB:NAME). Some verbs take either form,\nand may behave differently depending on whether or not a name argument is\npresent. The names are not required to be unique within the pattern.\n
\n\nBy default, for compatibility with Perl, a name is any sequence of characters\nthat does not include a closing parenthesis. The name is not processed in\nany way, and it is not possible to include a closing parenthesis in the name.\nThis can be changed by setting the PCRE2_ALT_VERBNAMES option, but the result\nis no longer Perl-compatible.\n
\n\nWhen PCRE2_ALT_VERBNAMES is set, backslash processing is applied to verb names\nand only an unescaped closing parenthesis terminates the name. However, the\nonly backslash items that are permitted are \\Q, \\E, and sequences such as\n\\x{100} that define character code points. Character type escapes such as \\d\nare faulted.\n
\n\nA closing parenthesis can be included in a name either as \\) or between \\Q\nand \\E. In addition to backslash processing, if the PCRE2_EXTENDED or\nPCRE2_EXTENDED_MORE option is also set, unescaped white space in verb names is\nskipped, and #-comments are recognized, exactly as in the rest of the pattern.\nPCRE2_EXTENDED and PCRE2_EXTENDED_MORE do not affect verb names unless\nPCRE2_ALT_VERBNAMES is also set.\n
\n\nThe maximum length of a name is 255 in the 8-bit library and 65535 in the\n16-bit and 32-bit libraries. If the name is empty, that is, if the closing\nparenthesis immediately follows the colon, the effect is as if the colon were\nnot there. Any number of these verbs may occur in a pattern. Except for\n(*ACCEPT), they may not be quantified.\n
\n\nSince these verbs are specifically related to backtracking, most of them can be\nused only when the pattern is to be matched using the traditional matching\nfunction or JIT, because they use backtracking algorithms. With the exception\nof (*FAIL), which behaves like a failing negative assertion, the backtracking\ncontrol verbs cause an error if encountered by the DFA matching function.\n
\n\nThe behaviour of these verbs in\nrepeated groups,\nassertions,\nand in\ncapture groups called as subroutines\n(whether or not recursively) is documented below.\n
\n\nOptimizations that affect backtracking verbs\n
\n\nPCRE2 contains some optimizations that are used to speed up matching by running\nsome checks at the start of each match attempt. For example, it may know the\nminimum length of matching subject, or that a particular character must be\npresent. When one of these optimizations bypasses the running of a match, any\nincluded backtracking verbs will not, of course, be processed. You can suppress\nthe start-of-match optimizations by setting the PCRE2_NO_START_OPTIMIZE option\nwhen calling pcre2_compile(), by calling pcre2_set_optimize() with a\nPCRE2_START_OPTIMIZE_OFF directive, or by starting the pattern with\n(*NO_START_OPT). There is more discussion of this option in the section\nentitled\n\"Compiling a pattern\"\nin the\npcre2api\ndocumentation.\n
\n\nExperiments with Perl suggest that it too has similar optimizations, and like\nPCRE2, turning them off can change the result of a match.\n
\n\nVerbs that act immediately\n
\n\nThe following verbs act as soon as they are encountered.\n
\n (*ACCEPT) or (*ACCEPT:NAME)\n\nThis verb causes the match to end successfully, skipping the remainder of the\npattern. However, when it is inside a capture group that is called as a\nsubroutine, only that group is ended successfully. Matching then continues\nat the outer level. If (*ACCEPT) in triggered in a positive assertion, the\nassertion succeeds; in a negative assertion, the assertion fails.\n\n
\nIf (*ACCEPT) is inside capturing parentheses, the data so far is captured. For\nexample:\n
\n A((?:A|B(*ACCEPT)|C)D)\n\nThis matches \"AB\", \"AAD\", or \"ACD\"; when it matches \"AB\", \"B\" is captured by\nthe outer parentheses.\n\n
\n(*ACCEPT) is the only backtracking verb that is allowed to be quantified\nbecause an ungreedy quantification with a minimum of zero acts only when a\nbacktrack happens. Consider, for example,\n
\n (A(*ACCEPT)??B)C\n\nwhere A, B, and C may be complex expressions. After matching \"A\", the matcher\nprocesses \"BC\"; if that fails, causing a backtrack, (*ACCEPT) is triggered and\nthe match succeeds. In both cases, all but C is captured. Whereas (*COMMIT)\n(see below) means \"fail on backtrack\", a repeated (*ACCEPT) of this type means\n\"succeed on backtrack\".\n\n
\nWarning: (*ACCEPT) should not be used within a script run group, because\nit causes an immediate exit from the group, bypassing the script run checking.\n
\n (*FAIL) or (*FAIL:NAME)\n\nThis verb causes a matching failure, forcing backtracking to occur. It may be\nabbreviated to (*F). It is equivalent to (?!) but easier to read. The Perl\ndocumentation notes that it is probably useful only when combined with (?{}) or\n(??{}). Those are, of course, Perl features that are not present in PCRE2. The\nnearest equivalent is the callout feature, as for example in this pattern:\n
\n a+(?C)(*FAIL)\n\nA match with the string \"aaaa\" always fails, but the callout is taken before\neach backtrack happens (in this example, 10 times).\n\n
\n(*ACCEPT:NAME) and (*FAIL:NAME) behave the same as (*MARK:NAME)(*ACCEPT) and\n(*MARK:NAME)(*FAIL), respectively, that is, a (*MARK) is recorded just before\nthe verb acts.\n
\n\nRecording which path was taken\n
\n\nThere is one verb whose main purpose is to track how a match was arrived at,\nthough it also has a secondary use in conjunction with advancing the match\nstarting point (see (*SKIP) below).\n
\n (*MARK:NAME) or (*:NAME)\n\nA name is always required with this verb. For all the other backtracking\ncontrol verbs, a NAME argument is optional.\n\n
\nWhen a match succeeds, the name of the last-encountered mark name on the\nmatching path is passed back to the caller as described in the section entitled\n\"Other information about the match\"\nin the\npcre2api\ndocumentation. This applies to all instances of (*MARK) and other verbs,\nincluding those inside assertions and atomic groups. However, there are\ndifferences in those cases when (*MARK) is used in conjunction with (*SKIP) as\ndescribed below.\n
\n\nThe mark name that was last encountered on the matching path is passed back. A\nverb without a NAME argument is ignored for this purpose. Here is an example of\npcre2test output, where the \"mark\" modifier requests the retrieval and\noutputting of (*MARK) data:\n
\n re> /X(*MARK:A)Y|X(*MARK:B)Z/mark\n data> XY\n 0: XY\n MK: A\n XZ\n 0: XZ\n MK: B\n\nThe (*MARK) name is tagged with \"MK:\" in this output, and in this example it\nindicates which of the two alternatives matched. This is a more efficient way\nof obtaining this information than putting each alternative in its own\ncapturing parentheses.\n\n
\nIf a verb with a name is encountered in a positive assertion that is true, the\nname is recorded and passed back if it is the last-encountered. This does not\nhappen for negative assertions or failing positive assertions.\n
\n\nAfter a partial match or a failed match, the last encountered name in the\nentire match process is returned. For example:\n
\n re> /X(*MARK:A)Y|X(*MARK:B)Z/mark\n data> XP\n No match, mark = B\n\nNote that in this unanchored example the mark is retained from the match\nattempt that started at the letter \"X\" in the subject. Subsequent match\nattempts starting at \"P\" and then with an empty string do not get as far as the\n(*MARK) item, but nevertheless do not reset it.\n\n
\nIf you are interested in (*MARK) values after failed matches, you should\nprobably either set the PCRE2_NO_START_OPTIMIZE option or call\npcre2_set_optimize() with a PCRE2_START_OPTIMIZE_OFF directive\n(see above)\nto ensure that the match is always attempted.\n
\n\nVerbs that act after backtracking\n
\n\nThe following verbs do nothing when they are encountered. Matching continues\nwith what follows, but if there is a subsequent match failure, causing a\nbacktrack to the verb, a failure is forced. That is, backtracking cannot pass\nto the left of the verb. However, when one of these verbs appears inside an\natomic group or in an atomic lookaround assertion that is true, its effect is\nconfined to that group, because once the group has been matched, there is never\nany backtracking into it. Backtracking from beyond an atomic assertion or group\nignores the entire group, and seeks a preceding backtracking point.\n
\n\nThese verbs differ in exactly what kind of failure occurs when backtracking\nreaches them. The behaviour described below is what happens when the verb is\nnot in a subroutine or an assertion. Subsequent sections cover these special\ncases.\n
\n (*COMMIT) or (*COMMIT:NAME)\n\nThis verb causes the whole match to fail outright if there is a later matching\nfailure that causes backtracking to reach it. Even if the pattern is\nunanchored, no further attempts to find a match by advancing the starting point\ntake place. If (*COMMIT) is the only backtracking verb that is encountered,\nonce it has been passed pcre2_match() is committed to finding a match at\nthe current starting point, or not at all. For example:\n
\n a+(*COMMIT)b\n\nThis matches \"xxaab\" but not \"aacaab\". It can be thought of as a kind of\ndynamic anchor, or \"I've started, so I must finish.\"\n\n
\nThe behaviour of (*COMMIT:NAME) is not the same as (*MARK:NAME)(*COMMIT). It is\nlike (*MARK:NAME) in that the name is remembered for passing back to the\ncaller. However, (*SKIP:NAME) searches only for names that are set with\n(*MARK), ignoring those set by any of the other backtracking verbs.\n
\n\nIf there is more than one backtracking verb in a pattern, a different one that\nfollows (*COMMIT) may be triggered first, so merely passing (*COMMIT) during a\nmatch does not always guarantee that a match must be at this starting point.\n
\n\nNote that (*COMMIT) at the start of a pattern is not the same as an anchor,\nunless PCRE2's start-of-match optimizations are turned off, as shown in this\noutput from pcre2test:\n
\n re> /(*COMMIT)abc/\n data> xyzabc\n 0: abc\n data>\n re> /(*COMMIT)abc/no_start_optimize\n data> xyzabc\n No match\n\nFor the first pattern, PCRE2 knows that any match must start with \"a\", so the\noptimization skips along the subject to \"a\" before applying the pattern to the\nfirst set of data. The match attempt then succeeds. The second pattern disables\nthe optimization that skips along to the first character. The pattern is now\napplied starting at \"x\", and so the (*COMMIT) causes the match to fail without\ntrying any other starting points.\n
\n (*PRUNE) or (*PRUNE:NAME)\n\nThis verb causes the match to fail at the current starting position in the\nsubject if there is a later matching failure that causes backtracking to reach\nit. If the pattern is unanchored, the normal \"bumpalong\" advance to the next\nstarting character then happens. Backtracking can occur as usual to the left of\n(*PRUNE), before it is reached, or when matching to the right of (*PRUNE), but\nif there is no match to the right, backtracking cannot cross (*PRUNE). In\nsimple cases, the use of (*PRUNE) is just an alternative to an atomic group or\npossessive quantifier, but there are some uses of (*PRUNE) that cannot be\nexpressed in any other way. In an anchored pattern (*PRUNE) has the same effect\nas (*COMMIT).\n\n
\nThe behaviour of (*PRUNE:NAME) is not the same as (*MARK:NAME)(*PRUNE). It is\nlike (*MARK:NAME) in that the name is remembered for passing back to the\ncaller. However, (*SKIP:NAME) searches only for names set with (*MARK),\nignoring those set by other backtracking verbs.\n
\n (*SKIP)\n\nThis verb, when given without a name, is like (*PRUNE), except that if the\npattern is unanchored, the \"bumpalong\" advance is not to the next character,\nbut to the position in the subject where (*SKIP) was encountered. (*SKIP)\nsignifies that whatever text was matched leading up to it cannot be part of a\nsuccessful match if there is a later mismatch. Consider:\n
\n a+(*SKIP)b\n\nIf the subject is \"aaaac...\", after the first match attempt fails (starting at\nthe first character in the string), the starting point skips on to start the\nnext attempt at \"c\". Note that a possessive quantifier does not have the same\neffect as this example; although it would suppress backtracking during the\nfirst match attempt, the second attempt would start at the second character\ninstead of skipping on to \"c\".\n\n
\nIf (*SKIP) is used to specify a new starting position that is the same as the\nstarting position of the current match, or (by being inside a lookbehind)\nearlier, the position specified by (*SKIP) is ignored, and instead the normal\n\"bumpalong\" occurs.\n
\n (*SKIP:NAME)\n\nWhen (*SKIP) has an associated name, its behaviour is modified. When such a\n(*SKIP) is triggered, the previous path through the pattern is searched for the\nmost recent (*MARK) that has the same name. If one is found, the \"bumpalong\"\nadvance is to the subject position that corresponds to that (*MARK) instead of\nto where (*SKIP) was encountered. If no (*MARK) with a matching name is found,\nthe (*SKIP) is ignored.\n\n
\nThe search for a (*MARK) name uses the normal backtracking mechanism, which\nmeans that it does not see (*MARK) settings that are inside atomic groups or\nassertions, because they are never re-entered by backtracking. Compare the\nfollowing pcre2test examples:\n
\n re> /a(?>(*MARK:X))(*SKIP:X)(*F)|(.)/\n data: abc\n 0: a\n 1: a\n data:\n re> /a(?:(*MARK:X))(*SKIP:X)(*F)|(.)/\n data: abc\n 0: b\n 1: b\n\nIn the first example, the (*MARK) setting is in an atomic group, so it is not\nseen when (*SKIP:X) triggers, causing the (*SKIP) to be ignored. This allows\nthe second branch of the pattern to be tried at the first character position.\nIn the second example, the (*MARK) setting is not in an atomic group. This\nallows (*SKIP:X) to find the (*MARK) when it backtracks, and this causes a new\nmatching attempt to start at the second character. This time, the (*MARK) is\nnever seen because \"a\" does not match \"b\", so the matcher immediately jumps to\nthe second branch of the pattern.\n\n
\nNote that (*SKIP:NAME) searches only for names set by (*MARK:NAME). It ignores\nnames that are set by other backtracking verbs.\n
\n (*THEN) or (*THEN:NAME)\n\nThis verb causes a skip to the next innermost alternative when backtracking\nreaches it. That is, it cancels any further backtracking within the current\nalternative. Its name comes from the observation that it can be used for a\npattern-based if-then-else block:\n
\n ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...\n\nIf the COND1 pattern matches, FOO is tried (and possibly further items after\nthe end of the group if FOO succeeds); on failure, the matcher skips to the\nsecond alternative and tries COND2, without backtracking into COND1. If that\nsucceeds and BAR fails, COND3 is tried. If subsequently BAZ fails, there are no\nmore alternatives, so there is a backtrack to whatever came before the entire\ngroup. If (*THEN) is not inside an alternation, it acts like (*PRUNE).\n\n
\nThe behaviour of (*THEN:NAME) is not the same as (*MARK:NAME)(*THEN). It is\nlike (*MARK:NAME) in that the name is remembered for passing back to the\ncaller. However, (*SKIP:NAME) searches only for names set with (*MARK),\nignoring those set by other backtracking verbs.\n
\n\nA group that does not contain a | character is just a part of the enclosing\nalternative; it is not a nested alternation with only one alternative. The\neffect of (*THEN) extends beyond such a group to the enclosing alternative.\nConsider this pattern, where A, B, etc. are complex pattern fragments that do\nnot contain any | characters at this level:\n
\n A (B(*THEN)C) | D\n\nIf A and B are matched, but there is a failure in C, matching does not\nbacktrack into A; instead it moves to the next alternative, that is, D.\nHowever, if the group containing (*THEN) is given an alternative, it\nbehaves differently:\n
\n A (B(*THEN)C | (*FAIL)) | D\n\nThe effect of (*THEN) is now confined to the inner group. After a failure in C,\nmatching moves to (*FAIL), which causes the whole group to fail because there\nare no more alternatives to try. In this case, matching does backtrack into A.\n\n
\nNote that a conditional group is not considered as having two alternatives,\nbecause only one is ever used. In other words, the | character in a conditional\ngroup has a different meaning. Ignoring white space, consider:\n
\n ^.*? (?(?=a) a | b(*THEN)c )\n\nIf the subject is \"ba\", this pattern does not match. Because .*? is ungreedy,\nit initially matches zero characters. The condition (?=a) then fails, the\ncharacter \"b\" is matched, but \"c\" is not. At this point, matching does not\nbacktrack to .*? as might perhaps be expected from the presence of the |\ncharacter. The conditional group is part of the single alternative that\ncomprises the whole pattern, and so the match fails. (If there was a backtrack\ninto .*?, allowing it to match \"b\", the match would succeed.)\n\n
\nThe verbs just described provide four different \"strengths\" of control when\nsubsequent matching fails. (*THEN) is the weakest, carrying on the match at the\nnext alternative. (*PRUNE) comes next, failing the match at the current\nstarting position, but allowing an advance to the next character (for an\nunanchored pattern). (*SKIP) is similar, except that the advance may be more\nthan one character. (*COMMIT) is the strongest, causing the entire match to\nfail.\n
\n\nMore than one backtracking verb\n
\n\nIf more than one backtracking verb is present in a pattern, the one that is\nbacktracked onto first acts. For example, consider this pattern, where A, B,\netc. are complex pattern fragments:\n
\n (A(*COMMIT)B(*THEN)C|ABD)\n\nIf A matches but B fails, the backtrack to (*COMMIT) causes the entire match to\nfail. However, if A and B match, but C fails, the backtrack to (*THEN) causes\nthe next alternative (ABD) to be tried. This behaviour is consistent, but is\nnot always the same as Perl's. It means that if two or more backtracking verbs\nappear in succession, all but the last of them has no effect. Consider this\nexample:\n
\n ...(*COMMIT)(*PRUNE)...\n\nIf there is a matching failure to the right, backtracking onto (*PRUNE) causes\nit to be triggered, and its action is taken. There can never be a backtrack\nonto (*COMMIT).\n\n
\nBacktracking verbs in repeated groups\n
\n\nPCRE2 sometimes differs from Perl in its handling of backtracking verbs in\nrepeated groups. For example, consider:\n
\n /(a(*COMMIT)b)+ac/\n\nIf the subject is \"abac\", Perl matches unless its optimizations are disabled,\nbut PCRE2 always fails because the (*COMMIT) in the second repeat of the group\nacts.\n\n
\nBacktracking verbs in assertions\n
\n\n(*FAIL) in any assertion has its normal effect: it forces an immediate\nbacktrack. The behaviour of the other backtracking verbs depends on whether or\nnot the assertion is standalone or acting as the condition in a conditional\ngroup.\n
\n\n(*ACCEPT) in a standalone positive assertion causes the assertion to succeed\nwithout any further processing; captured strings and a mark name (if set) are\nretained. In a standalone negative assertion, (*ACCEPT) causes the assertion to\nfail without any further processing; captured substrings and any mark name are\ndiscarded.\n
\n\nIf the assertion is a condition, (*ACCEPT) causes the condition to be true for\na positive assertion and false for a negative one; captured substrings are\nretained in both cases.\n
\n\nThe remaining verbs act only when a later failure causes a backtrack to\nreach them. This means that, for the Perl-compatible assertions, their effect\nis confined to the assertion, because Perl lookaround assertions are atomic. A\nbacktrack that occurs after such an assertion is complete does not jump back\ninto the assertion. Note in particular that a (*MARK) name that is set in an\nassertion is not \"seen\" by an instance of (*SKIP:NAME) later in the pattern.\n
\n\nPCRE2 now supports non-atomic positive assertions and also \"scan substring\"\nassertions, as described in the sections entitled\n\"Non-atomic assertions\"\nand\n\"Scan substring assertions\"\nabove. These assertions must be standalone (not used as conditions). They are\nnot Perl-compatible. For these assertions, a later backtrack does jump back\ninto the assertion, and therefore verbs such as (*COMMIT) can be triggered by\nbacktracks from later in the pattern.\n
\n\nThe effect of (*THEN) is not allowed to escape beyond an assertion. If there\nare no more branches to try, (*THEN) causes a positive assertion to be false,\nand a negative assertion to be true. This behaviour differs from Perl when the\nassertion has only one branch.\n
\n\nThe other backtracking verbs are not treated specially if they appear in a\nstandalone positive assertion. In a conditional positive assertion,\nbacktracking (from within the assertion) into (*COMMIT), (*SKIP), or (*PRUNE)\ncauses the condition to be false. However, for both standalone and conditional\nnegative assertions, backtracking into (*COMMIT), (*SKIP), or (*PRUNE) causes\nthe assertion to be true, without considering any further alternative branches.\n
\n\nBacktracking verbs in subroutines\n
\n\nThese behaviours occur whether or not the group is called recursively.\n
\n\n(*ACCEPT) in a group called as a subroutine causes the subroutine match to\nsucceed without any further processing. Matching then continues after the\nsubroutine call. Perl documents this behaviour. Perl's treatment of the other\nverbs in subroutines is different in some cases.\n
\n\n(*FAIL) in a group called as a subroutine has its normal effect: it forces\nan immediate backtrack.\n
\n\n(*COMMIT), (*SKIP), and (*PRUNE) cause the subroutine match to fail when\ntriggered by being backtracked to in a group called as a subroutine. There is\nthen a backtrack at the outer level.\n
\n\n(*THEN), when triggered, skips to the next alternative in the innermost\nenclosing group that has alternatives (its normal behaviour). However, if there\nis no such group within the subroutine's group, the subroutine match fails and\nthere is a backtrack at the outer level.\n
\nEBCDIC ENVIRONMENTS
\n\nDifferences in the way PCRE behaves when it is running in an EBCDIC environment\nare covered in this section.\n
\n\nEscape sequences\n
\n\nWhen PCRE2 is compiled in EBCDIC mode, \\N{U+hhh..} is not supported. \\a, \\e,\n\\f, \\n, \\r, and \\t generate the appropriate EBCDIC code values. The \\c\nescape is processed as specified for Perl in the perlebcdic document. The\nonly characters that are allowed after \\c are A-Z, a-z, or one of @, [, \\, ],\n^, _, or ?. Any other character provokes a compile-time error. The sequence\n\\c@ encodes character code 0; after \\c the letters (in either case) encode\ncharacters 1-26 (hex 01 to hex 1A); [, \\, ], ^, and _ encode characters 27-31\n(hex 1B to hex 1F), and \\c? becomes either 255 (hex FF) or 95 (hex 5F).\n
\n\nThus, apart from \\c?, these escapes generate the same character code values as\nthey do in an ASCII or Unicode environment, though the meanings of the values\nmostly differ. For example, \\cG always generates code value 7, which is BEL in\nASCII but DEL in EBCDIC.\n
\n\nThe sequence \\c? generates DEL (127, hex 7F) in an ASCII environment, but\nbecause 127 is not a control character in EBCDIC, Perl makes it generate the\nAPC character. Unfortunately, there are several variants of EBCDIC. In most of\nthem the APC character has the value 255 (hex FF), but in the one Perl calls\nPOSIX-BC its value is 95 (hex 5F). If certain other characters have POSIX-BC\nvalues, PCRE2 makes \\c? generate 95; otherwise it generates 255.\n
\n\nCharacter classes\n
\n\nIn character classes there is a special case in EBCDIC environments for ranges\nwhose end points are both specified as literal letters in the same case. For\ncompatibility with Perl, EBCDIC code points within the range that are not\nletters are omitted. For example, [h-k] matches only four characters, even\nthough the EBCDIC codes for h and k are 0x88 and 0x92, a range of 11 code\npoints. However, if the range is specified numerically, for example,\n[\\x88-\\x92] or [h-\\x92], all code points are included.\n
\nSEE ALSO
\n\npcre2api(3), pcre2callout(3), pcre2matching(3),\npcre2syntax(3), pcre2(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 03 September 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2perform.html", "content": "\n\npcre2perform man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 PERFORMANCE\n
- COMPILED PATTERN MEMORY USAGE\n
- STACK AND HEAP USAGE AT RUN TIME\n
- PROCESSING TIME\n
- AUTHOR\n
- REVISION\n
PCRE2 PERFORMANCE
\n\nTwo aspects of performance are discussed below: memory usage and processing\ntime. The way you express your pattern as a regular expression can affect both\nof them.\n
\nCOMPILED PATTERN MEMORY USAGE
\n\nPatterns are compiled by PCRE2 into a reasonably efficient interpretive code,\nso that most simple patterns do not use much memory for storing the compiled\nversion. However, there is one case where the memory usage of a compiled\npattern can be unexpectedly large. If a parenthesized group has a quantifier\nwith a minimum greater than 1 and/or a limited maximum, the whole group is\nrepeated in the compiled code. For example, the pattern\n
\n (abc|def){2,4}\n\nis compiled as if it were\n\n (abc|def)(abc|def)((abc|def)(abc|def)?)?\n\n(Technical aside: It is done this way so that backtrack points within each of\nthe repetitions can be independently maintained.)\n\n
\nFor regular expressions whose quantifiers use only small numbers, this is not\nusually a problem. However, if the numbers are large, and particularly if such\nrepetitions are nested, the memory usage can become an embarrassment. For\nexample, the very simple pattern\n
\n ((ab){1,1000}c){1,3}\n\nuses over 50KiB when compiled using the 8-bit library. When PCRE2 is\ncompiled with its default internal pointer size of two bytes, the size limit on\na compiled pattern is 65535 code units in the 8-bit and 16-bit libraries, and\nthis is reached with the above pattern if the outer repetition is increased\nfrom 3 to 4. PCRE2 can be compiled to use larger internal pointers and thus\nhandle larger compiled patterns, but it is better to try to rewrite your\npattern to use less memory if you can.\n\n\nOne way of reducing the memory usage for such patterns is to make use of\nPCRE2's\n\"subroutine\"\nfacility. Re-writing the above pattern as\n
\n ((ab)(?2){0,999}c)(?1){0,2}\n\nreduces the memory requirements to around 16KiB, and indeed it remains under\n20KiB even with the outer repetition increased to 100. However, this kind of\npattern is not always exactly equivalent, because any captures within\nsubroutine calls are lost when the subroutine completes. If this is not a\nproblem, this kind of rewriting will allow you to process patterns that PCRE2\ncannot otherwise handle. The matching performance of the two different versions\nof the pattern are roughly the same. (This applies from release 10.30 - things\nwere different in earlier releases.)\n\nSTACK AND HEAP USAGE AT RUN TIME
\n\nFrom release 10.30, the interpretive (non-JIT) version of pcre2_match()\nuses very little system stack at run time. In earlier releases recursive\nfunction calls could use a great deal of stack, and this could cause problems,\nbut this usage has been eliminated. Backtracking positions are now explicitly\nremembered in memory frames controlled by the code.\n
\n\nThe size of each frame depends on the size of pointer variables and the number\nof capturing parenthesized groups in the pattern being matched. On a 64-bit\nsystem the frame size for a pattern with no captures is 128 bytes. For each\ncapturing group the size increases by 16 bytes.\n
\n\nUntil release 10.41, an initial 20KiB frames vector was allocated on the system\nstack, but this still caused some issues for multi-thread applications where\neach thread has a very small stack. From release 10.41 backtracking memory\nframes are always held in heap memory. An initial heap allocation is obtained\nthe first time any match data block is passed to pcre2_match(). This is\nremembered with the match data block and re-used if that block is used for\nanother match. It is freed when the match data block itself is freed.\n
\n\nThe size of the initial block is the larger of 20KiB or ten times the pattern's\nframe size, unless the heap limit is less than this, in which case the heap\nlimit is used. If the initial block proves to be too small during matching, it\nis replaced by a larger block, subject to the heap limit. The heap limit is\nchecked only when a new block is to be allocated. Reducing the heap limit\nbetween calls to pcre2_match() with the same match data block does not\naffect the saved block.\n
\n\nIn contrast to pcre2_match(), pcre2_dfa_match() does use recursive\nfunction calls, but only for processing atomic groups, lookaround assertions,\nand recursion within the pattern. The original version of the code used to\nallocate quite large internal workspace vectors on the stack, which caused some\nproblems for some patterns in environments with small stacks. From release\n10.32 the code for pcre2_dfa_match() has been re-factored to use heap\nmemory when necessary for internal workspace when recursing, though recursive\nfunction calls are still used.\n
\n\nThe \"match depth\" parameter can be used to limit the depth of function\nrecursion, and the \"match heap\" parameter to limit heap memory in\npcre2_dfa_match().\n
\nPROCESSING TIME
\n\nCertain items in regular expression patterns are processed more efficiently\nthan others. It is more efficient to use a character class like [aeiou] than a\nset of single-character alternatives such as (a|e|i|o|u). In general, the\nsimplest construction that provides the required behaviour is usually the most\nefficient. Jeffrey Friedl's book contains a lot of useful general discussion\nabout optimizing regular expressions for efficient performance. This document\ncontains a few observations about PCRE2.\n
\n\nUsing Unicode character properties (the \\p, \\P, and \\X escapes) is slow,\nbecause PCRE2 has to use a multi-stage table lookup whenever it needs a\ncharacter's property. If you can find an alternative pattern that does not use\ncharacter properties, it will probably be faster.\n
\n\nBy default, the escape sequences \\b, \\d, \\s, and \\w, and the POSIX\ncharacter classes such as [:alpha:] do not use Unicode properties, partly for\nbackwards compatibility, and partly for performance reasons. However, you can\nset the PCRE2_UCP option or start the pattern with (*UCP) if you want Unicode\ncharacter properties to be used. This can double the matching time for items\nsuch as \\d, when matched with pcre2_match(); the performance loss is\nless with a DFA matching function, and in both cases there is not much\ndifference for \\b.\n
\n\nWhen a pattern begins with .* not in atomic parentheses, nor in parentheses\nthat are the subject of a backreference, and the PCRE2_DOTALL option is set,\nthe pattern is implicitly anchored by PCRE2, since it can match only at the\nstart of a subject string. If the pattern has multiple top-level branches, they\nmust all be anchorable. The optimization can be disabled by the\nPCRE2_NO_DOTSTAR_ANCHOR option, and is automatically disabled if the pattern\ncontains (*PRUNE) or (*SKIP).\n
\n\nIf PCRE2_DOTALL is not set, PCRE2 cannot make this optimization, because the\ndot metacharacter does not then match a newline, and if the subject string\ncontains newlines, the pattern may match from the character immediately\nfollowing one of them instead of from the very start. For example, the pattern\n
\n .*second\n\nmatches the subject \"first\\nand second\" (where \\n stands for a newline\ncharacter), with the match starting at the seventh character. In order to do\nthis, PCRE2 has to retry the match starting after every newline in the subject.\n\n
\nIf you are using such a pattern with subject strings that do not contain\nnewlines, the best performance is obtained by setting PCRE2_DOTALL, or starting\nthe pattern with ^.* or ^.*? to indicate explicit anchoring. That saves PCRE2\nfrom having to scan along the subject looking for a newline to restart at.\n
\n\nBeware of patterns that contain nested indefinite repeats. These can take a\nlong time to run when applied to a string that does not match. Consider the\npattern fragment\n
\n ^(a+)*\n\nThis can match \"aaaa\" in 16 different ways, and this number increases very\nrapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4\ntimes, and for each of those cases other than 0 or 4, the + repeats can match\ndifferent numbers of times.) When the remainder of the pattern is such that the\nentire match is going to fail, PCRE2 has in principle to try every possible\nvariation, and this can take an extremely long time, even for relatively short\nstrings.\n\n
\nAn optimization catches some of the more simple cases such as\n
\n (a+)*b\n\nwhere a literal character follows. Before embarking on the standard matching\nprocedure, PCRE2 checks that there is a \"b\" later in the subject string, and if\nthere is not, it fails the match immediately. However, when there is no\nfollowing literal this optimization cannot be used. You can see the difference\nby comparing the behaviour of\n
\n (a+)*\\d\n\nwith the pattern above. The former gives a failure almost instantly when\napplied to a whole line of \"a\" characters, whereas the latter takes an\nappreciable time with strings longer than about 20 characters.\n\n
\nIn many cases, the solution to this kind of performance issue is to use an\natomic group or a possessive quantifier. This can often reduce memory\nrequirements as well. As another example, consider this pattern:\n
\n ([^<]|<(?!inet))+\n\nIt matches from wherever it starts until it encounters \"<inet\" or the end of\nthe data, and is the kind of pattern that might be used when processing an XML\nfile. Each iteration of the outer parentheses matches either one character that\nis not \"<\" or a \"<\" that is not followed by \"inet\". However, each time a\nparenthesis is processed, a backtracking position is passed, so this\nformulation uses a memory frame for each matched character. For a long string,\na lot of memory is required. Consider now this rewritten pattern, which matches\nexactly the same strings:\n
\n ([^<]++|<(?!inet))+\n\nThis runs much faster, because sequences of characters that do not contain \"<\"\nare \"swallowed\" in one item inside the parentheses, and a possessive quantifier\nis used to stop any backtracking into the runs of non-\"<\" characters. This\nversion also uses a lot less memory because entry to a new set of parentheses\nhappens only when a \"<\" character that is not followed by \"inet\" is encountered\n(and we assume this is relatively rare).\n\n
\nThis example shows that one way of optimizing performance when matching long\nsubject strings is to write repeated parenthesized subpatterns to match more\nthan one character whenever possible.\n
\n\nSETTING RESOURCE LIMITS\n
\n\nYou can set limits on the amount of processing that takes place when matching,\nand on the amount of heap memory that is used. The default values of the limits\nare very large, and unlikely ever to operate. They can be changed when PCRE2 is\nbuilt, and they can also be set when pcre2_match() or\npcre2_dfa_match() is called. For details of these interfaces, see the\npcre2build\ndocumentation and the section entitled\n\"The match context\"\nin the\npcre2api\ndocumentation.\n
\n\nThe pcre2test test program has a modifier called \"find_limits\" which, if\napplied to a subject line, causes it to find the smallest limits that allow a\npattern to match. This is done by repeatedly matching with different limits.\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 06 December 2022\n
\nCopyright © 1997-2022 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2posix.html", "content": "\n\npcre2posix man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- SYNOPSIS\n
- DESCRIPTION\n
- USING THE POSIX FUNCTIONS\n
- COMPILING A PATTERN\n
- MATCHING NEWLINE CHARACTERS\n
- MATCHING A PATTERN\n
- ERROR MESSAGES\n
- MEMORY USAGE\n
- AUTHOR\n
- REVISION\n
SYNOPSIS
\n\n#include <pcre2posix.h>\n
\n\nint pcre2_regcomp(regex_t *preg, const char *pattern,\n int cflags);\n
\n
\nint pcre2_regexec(const regex_t *preg, const char *string,\n size_t nmatch, regmatch_t pmatch[], int eflags);\n
\n
\nsize_t pcre2_regerror(int errcode, const regex_t *preg,\n char *errbuf, size_t errbuf_size);\n
\n
\nvoid pcre2_regfree(regex_t *preg);\n
DESCRIPTION
\n\nThis set of functions provides a POSIX-style API for the PCRE2 regular\nexpression 8-bit library. There are no POSIX-style wrappers for PCRE2's 16-bit\nand 32-bit libraries. See the\npcre2api\ndocumentation for a description of PCRE2's native API, which contains much\nadditional functionality.\n
\n\nIMPORTANT NOTE: The functions described here are NOT thread-safe, and\nshould not be used in multi-threaded applications. They are also limited to\nprocessing subjects that are not bigger than 2GB. Use the native API instead.\n
\n\nThese functions are wrapper functions that ultimately call the PCRE2 native\nAPI. Their prototypes are defined in the pcre2posix.h header file, and\nthey all have unique names starting with pcre2_. However, the\npcre2posix.h header also contains macro definitions that convert the\nstandard POSIX names such regcomp() into pcre2_regcomp() etc. This\nmeans that a program can use the usual POSIX names without running the risk of\naccidentally linking with POSIX functions from a different library.\n
\n\nOn Unix-like systems the PCRE2 POSIX library is called libpcre2-posix, so\ncan be accessed by adding -lpcre2-posix to the command for linking an\napplication. Because the POSIX functions call the native ones, it is also\nnecessary to add -lpcre2-8.\n
\n\nOn Windows systems, if you are linking to a DLL version of the library, it is\nrecommended that PCRE2POSIX_SHARED is defined before including the\npcre2posix.h header, as it will allow for a more efficient way to\ninvoke the functions by adding the __declspec(dllimport) decorator.\n
\n\nAlthough they were not defined as prototypes in pcre2posix.h, releases\n10.33 to 10.36 of the library contained functions with the POSIX names\nregcomp() etc. These simply passed their arguments to the PCRE2\nfunctions. These functions were provided for backwards compatibility with\nearlier versions of PCRE2, which had only POSIX names. However, this has proved\ntroublesome in situations where a program links with several libraries, some of\nwhich use PCRE2's POSIX interface while others use the real POSIX functions.\nFor this reason, the POSIX names have been removed since release 10.37.\n
\n\nCalling the header file pcre2posix.h avoids any conflict with other POSIX\nlibraries. It can, of course, be renamed or aliased as regex.h, which is\nthe \"correct\" name, if there is no clash. It provides two structure types,\nregex_t for compiled internal forms, and regmatch_t for returning\ncaptured substrings. It also defines some constants whose names start with\n\"REG_\"; these are used for setting options and identifying error codes.\n
\nUSING THE POSIX FUNCTIONS
\n\nNote that these functions are just POSIX-style wrappers for PCRE2's native API.\nThey do not give POSIX regular expression behaviour, and they are not\nthread-safe or even POSIX compatible.\n
\n\nThose POSIX option bits that can reasonably be mapped to PCRE2 native options\nhave been implemented. In addition, the option REG_EXTENDED is defined with the\nvalue zero. This has no effect, but since programs that are written to the\nPOSIX interface often use it, this makes it easier to slot in PCRE2 as a\nreplacement library. Other POSIX options are not even defined.\n
\n\nThere are also some options that are not defined by POSIX. These have been\nadded at the request of users who want to make use of certain PCRE2-specific\nfeatures via the POSIX calling interface or to add BSD or GNU functionality.\n
\n\nWhen PCRE2 is called via these functions, it is only the API that is POSIX-like\nin style. The syntax and semantics of the regular expressions themselves are\nstill those of Perl, subject to the setting of various PCRE2 options, as\ndescribed below. \"POSIX-like in style\" means that the API approximates to the\nPOSIX definition; it is not fully POSIX-compatible, and in multi-unit encoding\ndomains it is probably even less compatible.\n
\n\nThe descriptions below use the actual names of the functions, but, as described\nabove, the standard POSIX names (without the pcre2_ prefix) may also be\nused.\n
\nCOMPILING A PATTERN
\n\nThe function pcre2_regcomp() is called to compile a pattern into an\ninternal form. By default, the pattern is a C string terminated by a binary\nzero (but see REG_PEND below). The preg argument is a pointer to a\nregex_t structure that is used as a base for storing information about\nthe compiled regular expression. It is also used for input when REG_PEND is\nset. The regex_t structure used by pcre2_regcomp() is defined in\npcre2posix.h and is not the same as the structure used by other libraries\nthat provide POSIX-style matching.\n
\n\nThe argument cflags is either zero, or contains one or more of the bits\ndefined by the following macros:\n
\n REG_DOTALL\n\nThe PCRE2_DOTALL option is set when the regular expression is passed for\ncompilation to the native function. Note that REG_DOTALL is not part of the\nPOSIX standard.\n
\n REG_ICASE\n\nThe PCRE2_CASELESS option is set when the regular expression is passed for\ncompilation to the native function.\n
\n REG_NEWLINE\n\nThe PCRE2_MULTILINE option is set when the regular expression is passed for\ncompilation to the native function. Note that this does not mimic the\ndefined POSIX behaviour for REG_NEWLINE (see the following section).\n
\n REG_NOSPEC\n\nThe PCRE2_LITERAL option is set when the regular expression is passed for\ncompilation to the native function. This disables all meta characters in the\npattern, causing it to be treated as a literal string. The only other options\nthat are allowed with REG_NOSPEC are REG_ICASE, REG_NOSUB, REG_PEND, and\nREG_UTF. Note that REG_NOSPEC is not part of the POSIX standard.\n
\n REG_NOSUB\n\nWhen a pattern that is compiled with this flag is passed to\npcre2_regexec() for matching, the nmatch and pmatch arguments\nare ignored, and no captured strings are returned. Versions of the PCRE2 library\nprior to 10.22 used to set the PCRE2_NO_AUTO_CAPTURE compile option, but this\nno longer happens because it disables the use of backreferences.\n
\n REG_PEND\n\nIf this option is set, the reg_endp field in the preg structure\n(which has the type const char *) must be set to point to the character beyond\nthe end of the pattern before calling pcre2_regcomp(). The pattern itself\nmay now contain binary zeros, which are treated as data characters. Without\nREG_PEND, a binary zero terminates the pattern and the re_endp field is\nignored. This is a GNU extension to the POSIX standard and should be used with\ncaution in software intended to be portable to other systems.\n
\n REG_UCP\n\nThe PCRE2_UCP option is set when the regular expression is passed for\ncompilation to the native function. This causes PCRE2 to use Unicode properties\nwhen matching \\d, \\w, etc., instead of just recognizing ASCII values. Note\nthat REG_UCP is not part of the POSIX standard.\n
\n REG_UNGREEDY\n\nThe PCRE2_UNGREEDY option is set when the regular expression is passed for\ncompilation to the native function. Note that REG_UNGREEDY is not part of the\nPOSIX standard.\n
\n REG_UTF\n\nThe PCRE2_UTF option is set when the regular expression is passed for\ncompilation to the native function. This causes the pattern itself and all data\nstrings used for matching it to be treated as UTF-8 strings. Note that REG_UTF\nis not part of the POSIX standard.\n\n
\nIn the absence of these flags, no options are passed to the native function.\nThis means that the regex is compiled with PCRE2 default semantics. In\nparticular, the way it handles newline characters in the subject string is the\nPerl way, not the POSIX way. Note that setting PCRE2_MULTILINE has only\nsome of the effects specified for REG_NEWLINE. It does not affect the way\nnewlines are matched by the dot metacharacter (they are not) or by a negative\nclass such as [^a] (they are).\n
\n\nThe yield of pcre2_regcomp() is zero on success, and non-zero otherwise.\nThe preg structure is filled in on success, and one other member of the\nstructure (as well as re_endp) is public: re_nsub contains the\nnumber of capturing subpatterns in the regular expression. Various error codes\nare defined in the header file.\n
\n\nNOTE: If the yield of pcre2_regcomp() is non-zero, you must not attempt\nto use the contents of the preg structure. If, for example, you pass it\nto pcre2_regexec(), the result is undefined and your program is likely to\ncrash.\n
\nMATCHING NEWLINE CHARACTERS
\n\nThis area is not simple, because POSIX and Perl take different views of things.\nIt is not possible to get PCRE2 to obey POSIX semantics, but then PCRE2 was\nnever intended to be a POSIX engine. The following table lists the different\npossibilities for matching newline characters in Perl and PCRE2:\n
\n Default Change with\n\n . matches newline no PCRE2_DOTALL\n newline matches [^a] yes not changeable\n $ matches \\n at end yes PCRE2_DOLLAR_ENDONLY\n $ matches \\n in middle no PCRE2_MULTILINE\n ^ matches \\n in middle no PCRE2_MULTILINE\n\nThis is the equivalent table for a POSIX-compatible pattern matcher:\n
\n Default Change with\n\n . matches newline yes REG_NEWLINE\n newline matches [^a] yes REG_NEWLINE\n $ matches \\n at end no REG_NEWLINE\n $ matches \\n in middle no REG_NEWLINE\n ^ matches \\n in middle no REG_NEWLINE\n\nThis behaviour is not what happens when PCRE2 is called via its POSIX\nAPI. By default, PCRE2's behaviour is the same as Perl's, except that there is\nno equivalent for PCRE2_DOLLAR_ENDONLY in Perl. In both PCRE2 and Perl, there\nis no way to stop newline from matching [^a].\n\n
\nDefault POSIX newline handling can be obtained by setting PCRE2_DOTALL and\nPCRE2_DOLLAR_ENDONLY when calling pcre2_compile() directly, but there is\nno way to make PCRE2 behave exactly as for the REG_NEWLINE action. When using\nthe POSIX API, passing REG_NEWLINE to PCRE2's pcre2_regcomp() function\ncauses PCRE2_MULTILINE to be passed to pcre2_compile(), and REG_DOTALL\npasses PCRE2_DOTALL. There is no way to pass PCRE2_DOLLAR_ENDONLY.\n
\nMATCHING A PATTERN
\n\nThe function pcre2_regexec() is called to match a compiled pattern\npreg against a given string, which is by default terminated by a\nzero byte (but see REG_STARTEND below), subject to the options in eflags.\nThese can be:\n
\n REG_NOTBOL\n\nThe PCRE2_NOTBOL option is set when calling the underlying PCRE2 matching\nfunction.\n
\n REG_NOTEMPTY\n\nThe PCRE2_NOTEMPTY option is set when calling the underlying PCRE2 matching\nfunction. Note that REG_NOTEMPTY is not part of the POSIX standard. However,\nsetting this option can give more POSIX-like behaviour in some situations.\n
\n REG_NOTEOL\n\nThe PCRE2_NOTEOL option is set when calling the underlying PCRE2 matching\nfunction.\n
\n REG_STARTEND\n\nWhen this option is set, the subject string starts at string +\npmatch[0].rm_so and ends at string + pmatch[0].rm_eo, which\nshould point to the first character beyond the string. There may be binary\nzeros within the subject string, and indeed, using REG_STARTEND is the only\nway to pass a subject string that contains a binary zero.\n\n
\nWhatever the value of pmatch[0].rm_so, the offsets of the matched string\nand any captured substrings are still given relative to the start of\nstring itself. (Before PCRE2 release 10.30 these were given relative to\nstring + pmatch[0].rm_so, but this differs from other\nimplementations.)\n
\n\nThis is a BSD extension, compatible with but not specified by IEEE Standard\n1003.2 (POSIX.2), and should be used with caution in software intended to be\nportable to other systems. Note that a non-zero rm_so does not imply\nREG_NOTBOL; REG_STARTEND affects only the location and length of the string,\nnot how it is matched. Setting REG_STARTEND and passing pmatch as NULL\nare mutually exclusive; the error REG_INVARG is returned.\n
\n\nIf the pattern was compiled with the REG_NOSUB flag, no data about any matched\nstrings is returned. The nmatch and pmatch arguments of\npcre2_regexec() are ignored (except possibly as input for REG_STARTEND).\n
\n\nThe value of nmatch may be zero, and the value pmatch may be NULL\n(unless REG_STARTEND is set); in both these cases no data about any matched\nstrings is returned.\n
\n\nOtherwise, the portion of the string that was matched, and also any captured\nsubstrings, are returned via the pmatch argument, which points to an\narray of nmatch structures of type regmatch_t, containing the\nmembers rm_so and rm_eo. These contain the byte offset to the first\ncharacter of each substring and the offset to the first character after the end\nof each substring, respectively. The 0th element of the vector relates to the\nentire portion of string that was matched; subsequent elements relate to\nthe capturing subpatterns of the regular expression. Unused entries in the\narray have both structure members set to -1.\n
\n\nregmatch_t as well as the regoff_t typedef it uses are defined in\npcre2posix.h and are not warranted to have the same size or layout as other\nsimilarly named types from other libraries that provide POSIX-style matching.\n
\n\nA successful match yields a zero return; various error codes are defined in the\nheader file, of which REG_NOMATCH is the \"expected\" failure code.\n
\nERROR MESSAGES
\n\nThe pcre2_regerror() function maps a non-zero errorcode from either\npcre2_regcomp() or pcre2_regexec() to a printable message. If\npreg is not NULL, the error should have arisen from the use of that\nstructure. A message terminated by a binary zero is placed in errbuf. If\nthe buffer is too short, only the first errbuf_size - 1 characters of the\nerror message are used. The yield of the function is the size of buffer needed\nto hold the whole message, including the terminating zero. This value is\ngreater than errbuf_size if the message was truncated.\n
\nMEMORY USAGE
\n\nCompiling a regular expression causes memory to be allocated and associated\nwith the preg structure. The function pcre2_regfree() frees all\nsuch memory, after which preg may no longer be used as a compiled\nexpression.\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 27 November 2024\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2sample.html", "content": "\n\npcre2sample man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nPCRE2 SAMPLE PROGRAM\n
\n\nA simple, complete demonstration program to get you started with using PCRE2 is\nsupplied in the file pcre2demo.c in the src directory in the PCRE2\ndistribution. A listing of this program is given in the\npcre2demo\ndocumentation. If you do not have a copy of the PCRE2 distribution, you can\nsave this listing to recreate the contents of pcre2demo.c.\n
\n\nThe demonstration program compiles the regular expression that is its\nfirst argument, and matches it against the subject string in its second\nargument. No PCRE2 options are set, and default character tables are used. If\nmatching succeeds, the program outputs the portion of the subject that matched,\ntogether with the contents of any captured substrings.\n
\n\nIf the -g option is given on the command line, the program then goes on to\ncheck for further matches of the same regular expression in the same subject\nstring. The logic is a little bit tricky because of the possibility of matching\nan empty string. Comments in the code explain what is going on.\n
\n\nThe code in pcre2demo.c is an 8-bit program that uses the PCRE2 8-bit\nlibrary. It handles strings and characters that are stored in 8-bit code units.\nBy default, one character corresponds to one code unit, but if the pattern\nstarts with \"(*UTF)\", both it and the subject are treated as UTF-8 strings,\nwhere characters may occupy multiple code units.\n
\n\nIf PCRE2 is installed in the standard include and library directories for your\noperating system, you should be able to compile the demonstration program using\na command like this:\n
\n cc -o pcre2demo pcre2demo.c -lpcre2-8\n\nIf PCRE2 is installed elsewhere, you may need to add additional options to the\ncommand line. For example, on a Unix-like system that has PCRE2 installed in\n/usr/local, you can compile the demonstration program using a command\nlike this:\n
\n cc -o pcre2demo -I/usr/local/include pcre2demo.c -L/usr/local/lib -lpcre2-8\n\nOnce you have built the demonstration program, you can run simple tests like\nthis:\n
\n ./pcre2demo 'cat|dog' 'the cat sat on the mat'\n ./pcre2demo -g 'cat|dog' 'the dog sat on the cat'\n ./pcre2demo -i 'cat' 'the dog sat on the CAT'\n\nNote that there is a much more comprehensive test program, called\npcre2test,\nwhich supports many more facilities for testing regular expressions using all\nthree PCRE2 libraries (8-bit, 16-bit, and 32-bit, though not all three need be\ninstalled). The\npcre2demo\nprogram is provided as a relatively simple coding example.\n\n
\nIf you try to run\npcre2demo\nwhen PCRE2 is not installed in the standard library directory, you may get an\nerror like this on some operating systems (e.g. Solaris):\n
\n ld.so.1: pcre2demo: fatal: libpcre2-8.so.0: open failed: No such file or directory\n\nThis is caused by the way shared library support works on those systems. You\nneed to add\n
\n -R/usr/local/lib\n\n(for example) to the compile command to get round this problem.\n\n
\nAUTHOR\n
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
\nREVISION\n
\n\nLast updated: 28 February 2025\n
\nCopyright © 1997-2016 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2serialize.html", "content": "\n\npcre2serialize man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- SAVING AND RE-USING PRECOMPILED PCRE2 PATTERNS\n
- SECURITY CONCERNS\n
- SAVING COMPILED PATTERNS\n
- RE-USING PRECOMPILED PATTERNS\n
- AUTHOR\n
- REVISION\n
SAVING AND RE-USING PRECOMPILED PCRE2 PATTERNS
\n\nint32_t pcre2_serialize_decode(pcre2_code **codes,\n int32_t number_of_codes, const uint8_t *bytes,\n pcre2_general_context *gcontext);\n
\n
\nint32_t pcre2_serialize_encode(const pcre2_code **codes,\n int32_t number_of_codes, uint8_t **serialized_bytes,\n PCRE2_SIZE *serialized_size, pcre2_general_context *gcontext);\n
\n
\nvoid pcre2_serialize_free(uint8_t *bytes);\n
\n
\nint32_t pcre2_serialize_get_number_of_codes(const uint8_t *bytes);\n
\n
\nIf you are running an application that uses a large number of regular\nexpression patterns, it may be useful to store them in a precompiled form\ninstead of having to compile them every time the application is run. However,\nif you are using the just-in-time optimization feature, it is not possible to\nsave and reload the JIT data, because it is position-dependent. The host on\nwhich the patterns are reloaded must be running the same version of PCRE2, with\nthe same code unit width, and must also have the same endianness, pointer width\nand PCRE2_SIZE type. For example, patterns compiled on a 32-bit system using\nPCRE2's 16-bit library cannot be reloaded on a 64-bit system, nor can they be\nreloaded using the 8-bit library.\n
\nNote that \"serialization\" in PCRE2 does not convert compiled patterns to an\nabstract format like Java or .NET serialization. The serialized output is\nreally just a bytecode dump, which is why it can only be reloaded in the same\nenvironment as the one that created it. Hence the restrictions mentioned above.\nApplications that are not statically linked with a fixed version of PCRE2 must\nbe prepared to recompile patterns from their sources, in order to be immune to\nPCRE2 upgrades.\n
\nSECURITY CONCERNS
\n\nThe facility for saving and restoring compiled patterns is intended for use\nwithin individual applications. As such, the data supplied to\npcre2_serialize_decode() is expected to be trusted data, not data from\narbitrary external sources. There is only some simple consistency checking, not\ncomplete validation of what is being re-loaded. Corrupted data may cause\nundefined results. For example, if the length field of a pattern in the\nserialized data is corrupted, the deserializing code may read beyond the end of\nthe byte stream that is passed to it.\n
\nSAVING COMPILED PATTERNS
\n\nBefore compiled patterns can be saved they must be serialized, which in PCRE2\nmeans converting the pattern to a stream of bytes. A single byte stream may\ncontain any number of compiled patterns, but they must all use the same\ncharacter tables. A single copy of the tables is included in the byte stream\n(its size is 1088 bytes). For more details of character tables, see the\nsection on locale support\nin the\npcre2api\ndocumentation.\n
\n\nThe function pcre2_serialize_encode() creates a serialized byte stream\nfrom a list of compiled patterns. Its first two arguments specify the list,\nbeing a pointer to a vector of pointers to compiled patterns, and the length of\nthe vector. The third and fourth arguments point to variables which are set to\npoint to the created byte stream and its length, respectively. The final\nargument is a pointer to a general context, which can be used to specify custom\nmemory management functions. If this argument is NULL, malloc() is used\nto obtain memory for the byte stream. The yield of the function is the number\nof serialized patterns, or one of the following negative error codes:\n
\n PCRE2_ERROR_BADDATA the number of patterns is zero or less\n PCRE2_ERROR_BADMAGIC mismatch of id bytes in one of the patterns\n PCRE2_ERROR_NOMEMORY memory allocation failed\n PCRE2_ERROR_MIXEDTABLES the patterns do not all use the same tables\n PCRE2_ERROR_NULL the 1st, 3rd, or 4th argument is NULL\n\nPCRE2_ERROR_BADMAGIC means either that a pattern's code has been corrupted, or\nthat a slot in the vector does not point to a compiled pattern.\n\n
\nOnce a set of patterns has been serialized you can save the data in any\nappropriate manner. Here is sample code that compiles two patterns and writes\nthem to a file. It assumes that the variable fd refers to a file that is\nopen for output. The error checking that should be present in a real\napplication has been omitted for simplicity.\n
\n int errorcode;\n uint8_t *bytes;\n PCRE2_SIZE erroroffset;\n PCRE2_SIZE bytescount;\n pcre2_code *list_of_codes[2];\n list_of_codes[0] = pcre2_compile(\"first pattern\",\n PCRE2_ZERO_TERMINATED, 0, &errorcode, &erroroffset, NULL);\n list_of_codes[1] = pcre2_compile(\"second pattern\",\n PCRE2_ZERO_TERMINATED, 0, &errorcode, &erroroffset, NULL);\n errorcode = pcre2_serialize_encode(list_of_codes, 2, &bytes,\n &bytescount, NULL);\n errorcode = fwrite(bytes, 1, bytescount, fd);\n\nNote that the serialized data is binary data that may contain any of the 256\npossible byte values. On systems that make a distinction between binary and\nnon-binary data, be sure that the file is opened for binary output.\n\n
\nSerializing a set of patterns leaves the original data untouched, so they can\nstill be used for matching. Their memory must eventually be freed in the usual\nway by calling pcre2_code_free(). When you have finished with the byte\nstream, it too must be freed by calling pcre2_serialize_free(). If this\nfunction is called with a NULL argument, it returns immediately without doing\nanything.\n
\nRE-USING PRECOMPILED PATTERNS
\n\nIn order to re-use a set of saved patterns you must first make the serialized\nbyte stream available in main memory (for example, by reading from a file). The\nmanagement of this memory block is up to the application. You can use the\npcre2_serialize_get_number_of_codes() function to find out how many\ncompiled patterns are in the serialized data without actually decoding the\npatterns:\n
\n uint8_t *bytes = <serialized data>;\n int32_t number_of_codes = pcre2_serialize_get_number_of_codes(bytes);\n\nThe pcre2_serialize_decode() function reads a byte stream and recreates\nthe compiled patterns in new memory blocks, setting pointers to them in a\nvector. The first two arguments are a pointer to a suitable vector and its\nlength, and the third argument points to a byte stream. The final argument is a\npointer to a general context, which can be used to specify custom memory\nmanagement functions for the decoded patterns. If this argument is NULL,\nmalloc() and free() are used. After deserialization, the byte\nstream is no longer needed and can be discarded.\n
\n pcre2_code *list_of_codes[2];\n uint8_t *bytes = <serialized data>;\n int32_t number_of_codes =\n pcre2_serialize_decode(list_of_codes, 2, bytes, NULL);\n\nIf the vector is not large enough for all the patterns in the byte stream, it\nis filled with those that fit, and the remainder are ignored. The yield of the\nfunction is the number of decoded patterns, or one of the following negative\nerror codes:\n
\n PCRE2_ERROR_BADDATA second argument is zero or less\n PCRE2_ERROR_BADMAGIC mismatch of id bytes in the data\n PCRE2_ERROR_BADMODE mismatch of code unit size or PCRE2 version\n PCRE2_ERROR_BADSERIALIZEDDATA other sanity check failure\n PCRE2_ERROR_MEMORY memory allocation failed\n PCRE2_ERROR_NULL first or third argument is NULL\n\nPCRE2_ERROR_BADMAGIC may mean that the data is corrupt, or that it was compiled\non a system with different endianness.\n\n
\nDecoded patterns can be used for matching in the usual way, and must be freed\nby calling pcre2_code_free(). However, be aware that there is a potential\nrace issue if you are using multiple patterns that were decoded from a single\nbyte stream in a multithreaded application. A single copy of the character\ntables is used by all the decoded patterns and a reference count is used to\narrange for its memory to be automatically freed when the last pattern is\nfreed, but there is no locking on this reference count. Therefore, if you want\nto call pcre2_code_free() for these patterns in different threads, you\nmust arrange your own locking, and ensure that pcre2_code_free() cannot\nbe called by two threads at the same time.\n
\n\nIf a pattern was processed by pcre2_jit_compile() before being\nserialized, the JIT data is discarded and so is no longer available after a\nsave/restore cycle. You can, however, process a restored pattern with\npcre2_jit_compile() if you wish.\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 19 January 2024\n
\nCopyright © 1997-2018 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2syntax.html", "content": "\n\npcre2syntax man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- PCRE2 REGULAR EXPRESSION SYNTAX SUMMARY\n
- QUOTING\n
- BRACED ITEMS\n
- ESCAPED CHARACTERS\n
- CHARACTER TYPES\n
- GENERAL CATEGORY PROPERTIES FOR \\p and \\P\n
- PCRE2 SPECIAL CATEGORY PROPERTIES FOR \\p and \\P\n
- BINARY PROPERTIES FOR \\p AND \\P\n
- SCRIPT MATCHING WITH \\p AND \\P\n
- THE BIDI_CLASS PROPERTY FOR \\p AND \\P\n
- CHARACTER CLASSES\n
- PERL EXTENDED CHARACTER CLASSES\n
- QUANTIFIERS\n
- ANCHORS AND SIMPLE ASSERTIONS\n
- REPORTED MATCH POINT SETTING\n
- ALTERNATION\n
- CAPTURING\n
- ATOMIC GROUPS\n
- COMMENT\n
- OPTION SETTING\n
- NEWLINE CONVENTION\n
- WHAT \\R MATCHES\n
- LOOKAHEAD AND LOOKBEHIND ASSERTIONS\n
- NON-ATOMIC LOOKAROUND ASSERTIONS\n
- SUBSTRING SCAN ASSERTION\n
- SCRIPT RUNS\n
- BACKREFERENCES\n
- SUBROUTINE REFERENCES (POSSIBLY RECURSIVE)\n
- CONDITIONAL PATTERNS\n
- BACKTRACKING CONTROL\n
- CALLOUTS\n
- REPLACEMENT STRINGS\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
PCRE2 REGULAR EXPRESSION SYNTAX SUMMARY
\n\nThe full syntax and semantics of the regular expression patterns that are\nsupported by PCRE2 are described in the\npcre2pattern\ndocumentation. This document contains a quick-reference summary of the pattern\nsyntax followed by the syntax of replacement strings in substitution function.\nThe full description of the latter is in the\npcre2api\ndocumentation.\n
\nQUOTING
\n\n
\n \\x where x is non-alphanumeric is a literal x\n \\Q...\\E treat enclosed characters as literal\n\nNote that white space inside \\Q...\\E is always treated as literal, even if\nPCRE2_EXTENDED is set, causing most other white space to be ignored. Note also\nthat PCRE2's handling of \\Q...\\E has some differences from Perl's. See the\npcre2pattern\ndocumentation for details.\n\n
BRACED ITEMS
\n\nWith one exception, wherever brace characters { and } are required to enclose\ndata for constructions such as \\g{2} or \\k{name}, space and/or horizontal tab\ncharacters that follow { or precede } are allowed and are ignored. In the case\nof quantifiers, they may also appear before or after the comma. The exception\nis \\u{...} which is not Perl-compatible and is recognized only when\nPCRE2_EXTRA_ALT_BSUX is set. This is an ECMAScript compatibility feature, and\nfollows ECMAScript's behaviour.\n
\nESCAPED CHARACTERS
\n\nThis table applies to ASCII and Unicode environments. An unrecognized escape\nsequence causes an error.\n
\n \\a alarm, that is, the BEL character (hex 07)\n \\cx \"control-x\", where x is a non-control ASCII character\n \\e escape (hex 1B)\n \\f form feed (hex 0C)\n \\n newline (hex 0A)\n \\r carriage return (hex 0D)\n \\t tab (hex 09)\n \\0dd character with octal code 0dd\n \\ddd character with octal code ddd, or backreference\n \\o{ddd..} character with octal code ddd..\n \\N{U+hh..} character with Unicode code point hh.. (Unicode mode only)\n \\xhh character with hex code hh\n \\x{hh..} character with hex code hh..\n\n\\N{U+hh..} is synonymous with \\x{hh..} but is not supported in environments\nthat use EBCDIC code (mainly IBM mainframes). Note that \\N not followed by an\nopening curly bracket has a different meaning (see below).\n\n\nIf PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set (\"ALT_BSUX mode\"), the\nfollowing are also recognized:\n
\n \\U the character \"U\"\n \\uhhhh character with hex code hhhh\n \\u{hh..} character with hex code hh.. but only for EXTRA_ALT_BSUX\n\nWhen \\x is not followed by {, one or two hexadecimal digits are read,\nbut in ALT_BSUX mode \\x must be followed by two hexadecimal digits to be\nrecognized as a hexadecimal escape; otherwise it matches a literal \"x\".\nLikewise, if \\u (in ALT_BSUX mode) is not followed by four hexadecimal digits\nor (in EXTRA_ALT_BSUX mode) a sequence of hex digits in curly brackets, it\nmatches a literal \"u\".\n\n\nNote that \\0dd is always an octal code. The treatment of backslash followed by\na non-zero digit is complicated; for details see the section\n\"Non-printing characters\"\nin the\npcre2pattern\ndocumentation, where details of escape processing in EBCDIC environments are\nalso given.\n
\nCHARACTER TYPES
\n\n
\n . any character except newline;\n in dotall mode, any character whatsoever\n \\C one code unit, even in UTF mode (best avoided)\n \\d a decimal digit\n \\D a character that is not a decimal digit\n \\h a horizontal white space character\n \\H a character that is not a horizontal white space character\n \\N a character that is not a newline\n \\p{xx} a character with the xx property\n \\P{xx} a character without the xx property\n \\R a newline sequence\n \\s a white space character\n \\S a character that is not a white space character\n \\v a vertical white space character\n \\V a character that is not a vertical white space character\n \\w a \"word\" character\n \\W a \"non-word\" character\n \\X a Unicode extended grapheme cluster\n\n\\C is dangerous because it may leave the current matching point in the middle\nof a UTF-8 or UTF-16 character. The application can lock out the use of \\C by\nsetting the PCRE2_NEVER_BACKSLASH_C option. It is also possible to build PCRE2\nwith the use of \\C permanently disabled.\n\n\nBy default, \\d, \\s, and \\w match only ASCII characters, even in UTF-8 mode\nor in the 16-bit and 32-bit libraries. However, if locale-specific matching is\nhappening, \\s and \\w may also match characters with code points in the range\n128-255. If the PCRE2_UCP option is set, the behaviour of these escape\nsequences is changed to use Unicode properties and they match many more\ncharacters, but there are some option settings that can restrict individual\nsequences to matching only ASCII characters.\n
\n\nProperty descriptions in \\p and \\P are matched caselessly; hyphens,\nunderscores, and ASCII white space characters are ignored, in accordance with\nUnicode's \"loose matching\" rules. For example, \\p{Bidi_Class=al} is the same\nas \\p{ bidi class = AL }.\n
\nGENERAL CATEGORY PROPERTIES FOR \\p and \\P
\n\n
\n C Other\n Cc Control\n Cf Format\n Cn Unassigned\n Co Private use\n Cs Surrogate\n\n L Letter\n Lc Cased letter, the union of Ll, Lu, and Lt\n L& Synonym of Lc\n Ll Lower case letter\n Lm Modifier letter\n Lo Other letter\n Lt Title case letter\n Lu Upper case letter\n\n M Mark\n Mc Spacing mark\n Me Enclosing mark\n Mn Non-spacing mark\n\n N Number\n Nd Decimal number\n Nl Letter number\n No Other number\n\n P Punctuation\n Pc Connector punctuation\n Pd Dash punctuation\n Pe Close punctuation\n Pf Final punctuation\n Pi Initial punctuation\n Po Other punctuation\n Ps Open punctuation\n\n S Symbol\n Sc Currency symbol\n Sk Modifier symbol\n Sm Mathematical symbol\n So Other symbol\n\n Z Separator\n Zl Line separator\n Zp Paragraph separator\n Zs Space separator\n\nFrom release 10.45, when caseless matching is set, Ll, Lu, and Lt are all\nequivalent to Lc.\n\n
PCRE2 SPECIAL CATEGORY PROPERTIES FOR \\p and \\P
\n\n
\n Xan Alphanumeric: union of properties L and N\n Xps POSIX space: property Z or tab, NL, VT, FF, CR\n Xsp Perl space: property Z or tab, NL, VT, FF, CR\n Xuc Universally-named character: one that can be\n represented by a Universal Character Name\n Xwd Perl word: property Xan or underscore\n\nPerl and POSIX space are now the same. Perl added VT to its space character set\nat release 5.18.\n\n
BINARY PROPERTIES FOR \\p AND \\P
\n\nUnicode defines a number of binary properties, that is, properties whose only\nvalues are true or false. You can obtain a list of those that are recognized by\n\\p and \\P, along with their abbreviations, by running this command:\n
\n pcre2test -LP\n\n\n
SCRIPT MATCHING WITH \\p AND \\P
\n\nMany script names and their 4-letter abbreviations are recognized in\n\\p{sc:...} or \\p{scx:...} items, or on their own with \\p (and also \\P of\ncourse). You can obtain a list of these scripts by running this command:\n
\n pcre2test -LS\n\n\n
THE BIDI_CLASS PROPERTY FOR \\p AND \\P
\n\n
\n \\p{Bidi_Class:<class>} matches a character with the given class\n \\p{BC:<class>} matches a character with the given class\n\nThe recognized classes are:\n\n AL Arabic letter\n AN Arabic number\n B paragraph separator\n BN boundary neutral\n CS common separator\n EN European number\n ES European separator\n ET European terminator\n FSI first strong isolate\n L left-to-right\n LRE left-to-right embedding\n LRI left-to-right isolate\n LRO left-to-right override\n NSM non-spacing mark\n ON other neutral\n PDF pop directional format\n PDI pop directional isolate\n R right-to-left\n RLE right-to-left embedding\n RLI right-to-left isolate\n RLO right-to-left override\n S segment separator\n WS white space\n\n\n
CHARACTER CLASSES
\n\n
\n [...] positive character class\n [^...] negative character class\n [x-y] range (can be used for hex characters)\n [[:xxx:]] positive POSIX named set\n [[:^xxx:]] negative POSIX named set\n\n alnum alphanumeric\n alpha alphabetic\n ascii 0-127\n blank space or tab\n cntrl control character\n digit decimal digit\n graph printing, excluding space\n lower lower case letter\n print printing, including space\n punct printing, excluding alphanumeric\n space white space\n upper upper case letter\n word same as \\w\n xdigit hexadecimal digit\n\nIn PCRE2, POSIX character set names recognize only ASCII characters by default,\nbut some of them use Unicode properties if PCRE2_UCP is set. You can use\n\\Q...\\E inside a character class.\n\n
\nWhen PCRE2_ALT_EXTENDED_CLASS is set, UTS#18 extended character classes may be\nused, allowing nested character classes, combined using set operators.\n
\n [x&&[^y]] UTS#18 extended character class\n\n x||y set union (OR)\n x&&y set intersection (AND)\n x--y set difference (AND NOT)\n x~~y set symmetric difference (XOR)\n\n\n\n
PERL EXTENDED CHARACTER CLASSES
\n\n
\n (?[...]) Perl extended character class\n (?[\\p{Thai} & \\p{Nd}]) operators; white space ignored\n (?[(x - y) & z]) parentheses for grouping\n\n (?[ [^3] & \\p{Nd} ]) [...] is a nested ordinary class\n (?[ [:alpha:] - [z] ]) POSIX set is allowed outside [...]\n (?[ \\d - [3] ]) backslash-escaped set is allowed outside [...]\n (?[ !\\n & [:ascii:] ]) backslash-escaped character is allowed outside [...]\n all other characters or ranges must be enclosed in [...]\n\n x|y, x+y set union (OR)\n x&y set intersection (AND)\n x-y set difference (AND NOT)\n x^y set symmetric difference (XOR)\n !x set complement (NOT)\n\nInside a Perl extended character class, [...] switches mode to be interpreted\nas an ordinary character class. Outside of a nested [...], the only items\npermitted are backslash-escapes, POSIX sets, operators, and parentheses. Inside\na nested ordinary class, ^ has its usual meaning (inverts the class when used\nas the first character); outside of a nested class, ^ is the XOR operator.\n\nQUANTIFIERS
\n\n
\n ? 0 or 1, greedy\n ?+ 0 or 1, possessive\n ?? 0 or 1, lazy\n * 0 or more, greedy\n *+ 0 or more, possessive\n *? 0 or more, lazy\n + 1 or more, greedy\n ++ 1 or more, possessive\n +? 1 or more, lazy\n {n} exactly n\n {n,m} at least n, no more than m, greedy\n {n,m}+ at least n, no more than m, possessive\n {n,m}? at least n, no more than m, lazy\n {n,} n or more, greedy\n {n,}+ n or more, possessive\n {n,}? n or more, lazy\n {,m} zero up to m, greedy\n {,m}+ zero up to m, possessive\n {,m}? zero up to m, lazy\n\n\nANCHORS AND SIMPLE ASSERTIONS
\n\n
\n \\b word boundary\n \\B not a word boundary\n ^ start of subject\n also after an internal newline in multiline mode\n (after any newline if PCRE2_ALT_CIRCUMFLEX is set)\n \\A start of subject\n $ end of subject\n also before newline at end of subject\n also before internal newline in multiline mode\n \\Z end of subject\n also before newline at end of subject\n \\z end of subject\n \\G first matching position in subject\n\n\n
REPORTED MATCH POINT SETTING
\n\n
\n \\K set reported start of match\n\nFrom release 10.38 \\K is not permitted by default in lookaround assertions,\nfor compatibility with Perl. However, if the PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK\noption is set, the previous behaviour is re-enabled. When this option is set,\n\\K is honoured in positive assertions, but ignored in negative ones.\n\n
ALTERNATION
\n\n
\n expr|expr|expr...\n\n\n
CAPTURING
\n\n
\n (...) capture group\n (?<name>...) named capture group (Perl)\n (?'name'...) named capture group (Perl)\n (?P<name>...) named capture group (Python)\n (?:...) non-capture group\n (?|...) non-capture group; reset group numbers for\n capture groups in each alternative\n\nIn non-UTF modes, names may contain underscores and ASCII letters and digits;\nin UTF modes, any Unicode letters and Unicode decimal digits are permitted. In\nboth cases, a name must not start with a digit.\n\n
ATOMIC GROUPS
\n\n
\n (?>...) atomic non-capture group\n (*atomic:...) atomic non-capture group\n\n\n
COMMENT
\n\n
\n (?#....) comment (not nestable)\n\n\n
OPTION SETTING
\n\nChanges of these options within a group are automatically cancelled at the end\nof the group.\n
\n (?a) all ASCII options\n (?aD) restrict \\d to ASCII in UCP mode\n (?aS) restrict \\s to ASCII in UCP mode\n (?aW) restrict \\w to ASCII in UCP mode\n (?aP) restrict all POSIX classes to ASCII in UCP mode\n (?aT) restrict POSIX digit classes to ASCII in UCP mode\n (?i) caseless\n (?J) allow duplicate named groups\n (?m) multiline\n (?n) no auto capture\n (?r) restrict caseless to either ASCII or non-ASCII\n (?s) single line (dotall)\n (?U) default ungreedy (lazy)\n (?x) ignore white space except in classes or \\Q...\\E\n (?xx) as (?x) but also ignore space and tab in classes\n (?-...) unset the given option(s)\n (?^) unset imnrsx options\n\n(?aP) implies (?aT) as well, though this has no additional effect. However, it\nmeans that (?-aP) also implies (?-aT) and disables all ASCII restrictions for\nPOSIX classes.\n\n
\nUnsetting x or xx unsets both. Several options may be set at once, and a\nmixture of setting and unsetting such as (?i-x) is allowed, but there may be\nonly one hyphen. Setting (but no unsetting) is allowed after (?^ for example\n(?^in). An option setting may appear at the start of a non-capture group, for\nexample (?i:...).\n
\n\nThe following are recognized only at the very start of a pattern or after one\nof the newline or \\R sequences or options with similar syntax. More than one\nof them may appear. For the first three, d is a decimal number.\n
\n (*LIMIT_DEPTH=d) set the backtracking limit to d\n (*LIMIT_HEAP=d) set the heap size limit to d * 1024 bytes\n (*LIMIT_MATCH=d) set the match limit to d\n (*CASELESS_RESTRICT) set PCRE2_EXTRA_CASELESS_RESTRICT when matching\n (*NOTEMPTY) set PCRE2_NOTEMPTY when matching\n (*NOTEMPTY_ATSTART) set PCRE2_NOTEMPTY_ATSTART when matching\n (*NO_AUTO_POSSESS) no auto-possessification (PCRE2_NO_AUTO_POSSESS)\n (*NO_DOTSTAR_ANCHOR) no .* anchoring (PCRE2_NO_DOTSTAR_ANCHOR)\n (*NO_JIT) disable JIT optimization\n (*NO_START_OPT) no start-match optimization (PCRE2_NO_START_OPTIMIZE)\n (*TURKISH_CASING) set PCRE2_EXTRA_TURKISH_CASING when matching\n (*UTF) set appropriate UTF mode for the library in use\n (*UCP) set PCRE2_UCP (use Unicode properties for \\d etc)\n\nNote that LIMIT_DEPTH, LIMIT_HEAP, and LIMIT_MATCH can only reduce the value of\nthe limits set by the caller of pcre2_match() or pcre2_dfa_match(),\nnot increase them. LIMIT_RECURSION is an obsolete synonym for LIMIT_DEPTH. The\napplication can lock out the use of (*UTF) and (*UCP) by setting the\nPCRE2_NEVER_UTF or PCRE2_NEVER_UCP options, respectively, at compile time.\n\n
NEWLINE CONVENTION
\n\nThese are recognized only at the very start of the pattern or after option\nsettings with a similar syntax.\n
\n (*CR) carriage return only\n (*LF) linefeed only\n (*CRLF) carriage return followed by linefeed\n (*ANYCRLF) all three of the above\n (*ANY) any Unicode newline sequence\n (*NUL) the NUL character (binary zero)\n\n\n
WHAT \\R MATCHES
\n\nThese are recognized only at the very start of the pattern or after option\nsetting with a similar syntax.\n
\n (*BSR_ANYCRLF) CR, LF, or CRLF\n (*BSR_UNICODE) any Unicode newline sequence\n\n\n
LOOKAHEAD AND LOOKBEHIND ASSERTIONS
\n\n
\n (?=...) )\n (*pla:...) ) positive lookahead\n (*positive_lookahead:...) )\n\n (?!...) )\n (*nla:...) ) negative lookahead\n (*negative_lookahead:...) )\n\n (?<=...) )\n (*plb:...) ) positive lookbehind\n (*positive_lookbehind:...) )\n\n (?<!...) )\n (*nlb:...) ) negative lookbehind\n (*negative_lookbehind:...) )\n\nEach top-level branch of a lookbehind must have a limit for the number of\ncharacters it matches. If any branch can match a variable number of characters,\nthe maximum for each branch is limited to a value set by the caller of\npcre2_compile() or defaulted. The default is set when PCRE2 is built\n(ultimate default 255). If every branch matches a fixed number of characters,\nthe limit for each branch is 65535 characters.\n\n
NON-ATOMIC LOOKAROUND ASSERTIONS
\n\nThese assertions are specific to PCRE2 and are not Perl-compatible.\n
\n (?*...) )\n (*napla:...) ) synonyms\n (*non_atomic_positive_lookahead:...) )\n\n (?<*...) )\n (*naplb:...) ) synonyms\n (*non_atomic_positive_lookbehind:...) )\n\n\n
SUBSTRING SCAN ASSERTION
\n\nThis feature is not Perl-compatible.\n
\n (*scan_substring:(grouplist)...) scan captured substring\n (*scs:(grouplist)...) scan captured substring\n\nThe comma-separated list \"grouplist\" may identify groups in any of the\nfollowing ways:\n
\n n absolute reference\n +n relative reference\n -n relative reference\n <name> name\n 'name' name\n\n\n
SCRIPT RUNS
\n\n
\n (*script_run:...) ) script run, can be backtracked into\n (*sr:...) )\n\n (*atomic_script_run:...) ) atomic script run\n (*asr:...) )\n\n\n
BACKREFERENCES
\n\n
\n \\n reference by number (can be ambiguous)\n \\gn reference by number\n \\g{n} reference by number\n \\g+n relative reference by number (PCRE2 extension)\n \\g-n relative reference by number\n \\g{+n} relative reference by number (PCRE2 extension)\n \\g{-n} relative reference by number\n \\k<name> reference by name (Perl)\n \\k'name' reference by name (Perl)\n \\g{name} reference by name (Perl)\n \\k{name} reference by name (.NET)\n (?P=name) reference by name (Python)\n\n\nSUBROUTINE REFERENCES (POSSIBLY RECURSIVE)
\n\n
\n (?R) recurse whole pattern\n (?n) call subroutine by absolute number\n (?+n) call subroutine by relative number\n (?-n) call subroutine by relative number\n (?&name) call subroutine by name (Perl)\n (?P>name) call subroutine by name (Python)\n \\g<name> call subroutine by name (Oniguruma)\n \\g'name' call subroutine by name (Oniguruma)\n \\g<n> call subroutine by absolute number (Oniguruma)\n \\g'n' call subroutine by absolute number (Oniguruma)\n \\g<+n> call subroutine by relative number (PCRE2 extension)\n \\g'+n' call subroutine by relative number (PCRE2 extension)\n \\g<-n> call subroutine by relative number (PCRE2 extension)\n \\g'-n' call subroutine by relative number (PCRE2 extension)\n\nThe variants using parentheses (?...) may also specify a list of capture groups\nto return, which shall be retained in the calling subexpression if set during\nthe recursion (this feature is not supported by Perl).\n
\n (?R(grouplist)) recurse whole pattern, returning capture groups\n (PCRE2 extension)\n (?n(grouplist)) )\n (?+n(grouplist)) ) call subroutine, returning capture groups\n (?-n(grouplist)) ) (PCRE2 extension)\n (?&name(grouplist)) )\n (?P>name(grouplist)) )\n\nThe comma-separated list \"grouplist\" uses the same syntax as\n(*scan_substring:(grouplist)...), and may identify groups in any of the\nfollowing ways:\n
\n n absolute reference\n +n relative reference\n -n relative reference\n <name> name\n 'name' name\n\n\n
CONDITIONAL PATTERNS
\n\n
\n (?(condition)yes-pattern)\n (?(condition)yes-pattern|no-pattern)\n\n (?(n) absolute reference condition\n (?(+n) relative reference condition (PCRE2 extension)\n (?(-n) relative reference condition (PCRE2 extension)\n (?(<name>) named reference condition (Perl)\n (?('name') named reference condition (Perl)\n (?(name) named reference condition (PCRE2, deprecated)\n (?(R) overall recursion condition\n (?(Rn) specific numbered group recursion condition\n (?(R&name) specific named group recursion condition\n (?(DEFINE) define groups for reference\n (?(VERSION[>]=n[.m]) test PCRE2 version\n (?(assert) assertion condition\n\nNote the ambiguity of (?(R) and (?(Rn) which might be named reference\nconditions or recursion tests. Such a condition is interpreted as a reference\ncondition if the relevant named group exists.\n\n
\nThe parts within brackets for the VERSION conditional syntax could be ommited.\nThe fractional part of the version number defaults to 0 in that case.\n\n
BACKTRACKING CONTROL
\n\nAll backtracking control verbs may be in the form (*VERB:NAME). For (*MARK) the\nname is mandatory, for the others it is optional. (*SKIP) changes its behaviour\nif :NAME is present. The others just set a name for passing back to the caller,\nbut this is not a name that (*SKIP) can see. The following act immediately they\nare reached:\n
\n (*ACCEPT) force successful match\n (*FAIL) force backtrack; synonym (*F)\n (*MARK:NAME) set name to be passed back; synonym (*:NAME)\n\nThe following act only when a subsequent match failure causes a backtrack to\nreach them. They all force a match failure, but they differ in what happens\nafterwards. Those that advance the start-of-match point do so only if the\npattern is not anchored.\n
\n (*COMMIT) overall failure, no advance of starting point\n (*PRUNE) advance to next starting character\n (*SKIP) advance to current matching position\n (*SKIP:NAME) advance to position corresponding to an earlier\n (*MARK:NAME); if not found, the (*SKIP) is ignored\n (*THEN) local failure, backtrack to next alternation\n\nThe effect of one of these verbs in a group called as a subroutine is confined\nto the subroutine call.\n\n
CALLOUTS
\n\n
\n (?C) callout (assumed number 0)\n (?Cn) callout with numerical data n\n (?C\"text\") callout with string data\n\nThe allowed string delimiters are ` ' \" ^ % # $ (which are the same for the\nstart and the end), and the starting delimiter { matched with the ending\ndelimiter }. To encode the ending delimiter within the string, double it.\n\n
REPLACEMENT STRINGS
\n\nIf the PCRE2_SUBSTITUTE_LITERAL option is set, a replacement string for\npcre2_substitute() is not interpreted. Otherwise, by default, the only\nspecial character is the dollar character in one of the following forms:\n
\n $$ insert a dollar character\n $n or ${n} insert the contents of group n\n $<name> insert the contents of named group\n $0 or $& insert the entire matched substring\n $` insert the substring that precedes the match\n $' insert the substring that follows the match\n $_ insert the entire input string\n $+ insert the highest-numbered capture group which matched\n $*MARK or ${*MARK} insert a control verb name\n\nFor ${n}, n can be a name or a number. If PCRE2_SUBSTITUTE_EXTENDED is set,\nthere is additional interpretation:\n\n\n1. Backslash is an escape character, and the forms described in \"ESCAPED\nCHARACTERS\" above are recognized. Also:\n
\n \\Q...\\E can be used to suppress interpretation\n \\l force the next character to lower case\n \\u force the next character to upper case\n \\L force subsequent characters to lower case\n \\U force subsequent characters to upper case\n \\u\\L force next character to upper case, then all lower\n \\l\\U force next character to lower case, then all upper\n \\E end \\L or \\U case forcing\n \\b backspace character (note: as in character class in pattern)\n \\v vertical tab character (note: not the same as in a pattern)\n\n2. The Python form \\g<n>, where the angle brackets are part of the syntax and\nn is either a group name or a number, is recognized as an alternative way\nof inserting the contents of a group, for example \\g<3>.\n\n
\n3. Capture substitution supports the following additional forms:\n
\n ${n:-string} default for unset group\n ${n:+string1:string2} values for set/unset group\n\nThe substitution strings themselves are expanded. Backslash can be used to\nescape colons and closing curly brackets.\n\nSEE ALSO
\n\npcre2pattern(3), pcre2api(3), pcre2callout(3),\npcre2matching(3), pcre2(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 14 October 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2test.html", "content": "\n\npcre2test man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
- \n
- SYNOPSIS\n
- PCRE2's 8-BIT, 16-BIT AND 32-BIT LIBRARIES\n
- INPUT ENCODING\n
- COMMAND LINE OPTIONS\n
- DESCRIPTION\n
- COMMAND LINES\n
- MODIFIER SYNTAX\n
- PATTERN SYNTAX\n
- SUBJECT LINE SYNTAX\n
- PATTERN MODIFIERS\n
- SUBJECT MODIFIERS\n
- THE ALTERNATIVE MATCHING FUNCTION\n
- DEFAULT OUTPUT FROM pcre2test\n
- OUTPUT FROM THE ALTERNATIVE MATCHING FUNCTION\n
- RESTARTING AFTER A PARTIAL MATCH\n
- CALLOUTS\n
- NON-PRINTING CHARACTERS\n
- SAVING AND RESTORING COMPILED PATTERNS\n
- SEE ALSO\n
- AUTHOR\n
- REVISION\n
SYNOPSIS
\n\npcre2test [options] [input file [output file]]\n
\n
\npcre2test is a test program for the PCRE2 regular expression libraries,\nbut it can also be used for experimenting with regular expressions. This\ndocument describes the features of the test program; for details of the regular\nexpressions themselves, see the\npcre2pattern\ndocumentation. For details of the PCRE2 library function calls and their\noptions, see the\npcre2api\ndocumentation.\n
\nThe input for pcre2test is a sequence of regular expression patterns and\nsubject strings to be matched. There are also command lines for setting\ndefaults and controlling some special actions. The output shows the result of\neach match attempt. Modifiers on external or internal command lines, the\npatterns, and the subject lines specify PCRE2 function options, control how the\nsubject is processed, and what output is produced.\n
\n\nThere are many obscure modifiers, some of which are specifically designed for\nuse in conjunction with the test script and data files that are distributed as\npart of PCRE2. All the modifiers are documented here, some without much\njustification, but many of them are unlikely to be of use except when testing\nthe libraries.\n
\nPCRE2's 8-BIT, 16-BIT AND 32-BIT LIBRARIES
\n\nDifferent versions of the PCRE2 library can be built to support character\nstrings that are encoded in 8-bit, 16-bit, or 32-bit code units. One, two, or\nall three of these libraries may be simultaneously installed. The\npcre2test program can be used to test all the libraries. However, its own\ninput and output are always in 8-bit format. When testing the 16-bit or 32-bit\nlibraries, patterns and subject strings are converted to 16-bit or 32-bit\nformat before being passed to the library functions. Results are converted back\nto 8-bit code units for output.\n
\n\nIn the rest of this document, the names of library functions and structures\nare given in generic form, for example, pcre2_compile(). The actual\nnames used in the libraries have a suffix _8, _16, or _32, as appropriate.\n
\nINPUT ENCODING
\n\nInput to pcre2test is processed line by line, either by calling the C\nlibrary's fgets() function, or via the libreadline or libedit\nlibrary. In some Windows environments character 26 (hex 1A) causes an immediate\nend of file, and no further data is read, so this character should be avoided\nunless you really want that action.\n
\n\nThe input is processed using C's string functions, so must not contain binary\nzeros, even though in Unix-like environments, fgets() treats any bytes\nother than newline as data characters. An error is generated if a binary zero\nis encountered. By default subject lines are processed for backslash escapes,\nwhich makes it possible to include any data value in strings that are passed to\nthe library for matching. For patterns, there is a facility for specifying some\nor all of the 8-bit input characters as hexadecimal pairs, which makes it\npossible to include binary zeros.\n
\n\nInput for the 16-bit and 32-bit libraries\n
\n\nWhen testing the 16-bit or 32-bit libraries, there is a need to be able to\ngenerate character code points greater than 255 in the strings that are passed\nto the library. For subject lines and some patterns, backslash escapes can be\nused. In addition, when the utf modifier (see\n\"Setting compilation options\"\nbelow) is set, the pattern and any following subject lines are interpreted as\nUTF-8 strings and translated to UTF-16 or UTF-32 as appropriate.\n
\n\nFor non-UTF testing of wide characters, the utf8_input modifier can be\nused. This is mutually exclusive with utf, and is allowed only in 16-bit\nor 32-bit mode. It causes the pattern and following subject lines to be treated\nas UTF-8 according to the original definition (RFC 2279), which allows for\ncharacter values up to 0x7fffffff. Each character is placed in one 16-bit or\n32-bit code unit (in the 16-bit case, values greater than 0xffff cause an error\nto occur).\n
\n\nUTF-8 (in its original definition) is not capable of encoding values greater\nthan 0x7fffffff, but such values can be handled by the 32-bit library. When\ntesting this library in non-UTF mode with utf8_input set, if any\ncharacter is preceded by the byte 0xff (which is an invalid byte in UTF-8)\n0x80000000 is added to the character's value. For subject strings, using an\nescape sequence is preferable.\n
\nCOMMAND LINE OPTIONS
\n\n-8\nIf the 8-bit library has been built, this option causes it to be used (this is\nthe default). If the 8-bit library has not been built, this option causes an\nerror.\n
\n\n-16\nIf the 16-bit library has been built, this option causes it to be used. If the\n8-bit library has not been built, this is the default. If the 16-bit library\nhas not been built, this option causes an error.\n
\n\n-32\nIf the 32-bit library has been built, this option causes it to be used. If no\nother library has been built, this is the default. If the 32-bit library has\nnot been built, this option causes an error.\n
\n\n-ac\nBehave as if each pattern has the auto_callout modifier, that is, insert\nautomatic callouts into every pattern that is compiled.\n
\n\n-AC\nAs for -ac, but in addition behave as if each subject line has the\ncallout_extra modifier, that is, show additional information from\ncallouts.\n
\n\n-b\nBehave as if each pattern has the fullbincode modifier; the full\ninternal binary form of the pattern is output after compilation.\n
\n\n-C\nOutput the version number of the PCRE2 library, and all available information\nabout the optional features that are included, and then exit with zero exit\ncode. All other options are ignored. If both -C and -LM are present, whichever\nis first is recognized.\n
\n\n-C option\nOutput information about a specific build-time option, then exit. This\nfunctionality is intended for use in scripts such as RunTest. The\nfollowing options output the value and set the exit code as indicated:\n
\n linksize the configured internal link size (2, 3, or 4)\n exit code is set to the link size\n newline the default newline setting:\n CR, LF, CRLF, ANYCRLF, ANY, or NUL\n exit code is always 0\n bsr the default setting for what \\R matches:\n ANYCRLF or ANY\n exit code is always 0\n\nThe following options output 1 for true or 0 for false, and set the exit code\nto the same value:\n
\n backslash-C \\C is supported (not locked out)\n ebcdic compiled for an EBCDIC environment\n ebcdic-io if PCRE2 is compiled for EBCDIC, whether pcre2test's input and\n output is EBCDIC or ASCII\n ebcdic-nl25 if PCRE2 is compiled for EBCDIC, whether NL (= LF) is 0x25\n (otherwise it is 0x15, the default)\n jit just-in-time support is available\n pcre2-16 the 16-bit library was built\n pcre2-32 the 32-bit library was built\n pcre2-8 the 8-bit library was built\n unicode Unicode support is available\n\nNote that the availability of JIT support in the library does not guarantee\nthat it can actually be used because in some environments it is unable to\nallocate executable memory. The option \"jitusable\" gives more detailed\ninformation. It returns one of the following values:\n
\n 0 JIT is available and usable\n 1 JIT is available but cannot allocate executable memory\n 2 JIT is not available\n 3 Unexpected return from test call to pcre2_jit_compile()\n\nIf an unknown option is given, an error message is output; the exit code is 0.\n\n
\n--colo[u]r[=<always,auto,never>]\nBy default, the output is coloured if the output file is a terminal (auto).\nForce or suppress output of ANSI colour escapes with always and never\nrespectively.\n
\n\n-d\nBehave as if each pattern has the debug modifier; the internal\nform and information about the compiled pattern is output after compilation;\n-d is equivalent to -b -i.\n
\n\n-dfa\nBehave as if each subject line has the dfa modifier; matching is done\nusing the pcre2_dfa_match() function instead of the default\npcre2_match().\n
\n\n-E\nRun in \"preprocess only\" mode (similar to \"gcc -E\"). The \"#if ... #endif\"\ncommands are processed, and all other lines are printed verbatim.\n
\n\n-error number[,number,...]\nCall pcre2_get_error_message() for each of the error numbers in the\ncomma-separated list, display the resulting messages on the standard output,\nthen exit with zero exit code. The numbers may be positive or negative. This is\na convenience facility for PCRE2 maintainers.\n
\n\n-help\nOutput a brief summary these options and then exit.\n
\n\n-i\nBehave as if each pattern has the info modifier; information about the\ncompiled pattern is given after compilation.\n
\n\n-jit\nBehave as if each pattern line has the jit modifier; after successful\ncompilation, each pattern is passed to the just-in-time compiler, if available.\n
\n\n-jitfast\nBehave as if each pattern line has the jitfast modifier; after\nsuccessful compilation, each pattern is passed to the just-in-time compiler, if\navailable, and each subject line is passed directly to the JIT matcher via its\n\"fast path\".\n
\n\n-jitverify\nBehave as if each pattern line has the jitverify modifier; after\nsuccessful compilation, each pattern is passed to the just-in-time compiler, if\navailable, and the use of JIT for matching is verified.\n
\n\n-LM\nList modifiers: write a list of available pattern and subject modifiers to the\nstandard output, then exit with zero exit code. All other options are ignored.\nIf both -C and any -Lx options are present, whichever is first is recognized.\n
\n\n-LP\nList properties: write a list of recognized Unicode properties to the standard\noutput, then exit with zero exit code. All other options are ignored. If both\n-C and any -Lx options are present, whichever is first is recognized.\n
\n\n-LS\nList scripts: write a list of recognized Unicode script names to the standard\noutput, then exit with zero exit code. All other options are ignored. If both\n-C and any -Lx options are present, whichever is first is recognized.\n
\n\n-malloc\nExercise malloc() failures, by first counting the number of calls made to malloc\nduring pattern compilation and matching, then re-running the compilation and\nmatching that many times, exercising a failure of each malloc() call.\n
\n\n-pattern modifier-list\nBehave as if each pattern line contains the given modifiers.\n
\n\n-q\nDo not output the version number of pcre2test at the start of execution.\n
\n\n-S size\nOn Unix-like systems, set the size of the run-time stack to size\nmebibytes (units of 1024*1024 bytes).\n
\n\n-subject modifier-list\nBehave as if each subject line contains the given modifiers.\n
\n\n-t\nRun each compile and match many times with a timer, and output the resulting\ntimes per compile or match. When JIT is used, separate times are given for the\ninitial compile and the JIT compile. You can control the number of iterations\nthat are used for timing by following -t with a number (as a separate\nitem on the command line). For example, \"-t 1000\" iterates 1000 times. The\ndefault is to iterate 500,000 times.\n
\n\n-tm\nThis is like -t except that it times only the matching phase, not the\ncompile phase.\n
\n\n-T -TM\nThese behave like -t and -tm, but in addition, at the end of a run,\nthe total times for all compiles and matches are output.\n
\n\n-unittest\nRun a fixed set of additional tests of the PCRE2 API which are not driven by\nthe test input files, and then exit.\n
\n\n-version\nOutput the PCRE2 version number and then exit.\n
\nDESCRIPTION
\n\nIf pcre2test is given two filename arguments, it reads from the first and\nwrites to the second. If the first name is \"-\", input is taken from the\nstandard input. If pcre2test is given only one argument, it reads from\nthat file and writes to stdout. Otherwise, it reads from stdin and writes to\nstdout.\n
\n\nWhen pcre2test is built, a configuration option can specify that it\nshould be linked with the libreadline or libedit library. When this\nis done, if the input is from a terminal, it is read using the readline()\nfunction. This provides line-editing and history facilities. The output from\nthe -help option states whether or not readline() will be used.\n
\n\nThe program handles any number of tests, each of which consists of a set of\ninput lines. Each set starts with a regular expression pattern, followed by any\nnumber of subject lines to be matched against that pattern. In between sets of\ntest data, command lines that begin with # may appear. This file format, with\nsome restrictions, can also be processed by the perltest.sh script that\nis distributed with PCRE2 as a means of checking that the behaviour of PCRE2\nand Perl is the same. For a specification of perltest.sh, see the\ncomments near its beginning. See also the #perltest command below.\n
\n\nWhen the input is a terminal, pcre2test prompts for each line of input,\nusing \"re>\" to prompt for regular expression patterns, and \"data>\" to prompt\nfor subject lines. Command lines starting with # can be entered only in\nresponse to the \"re>\" prompt.\n
\n\nEach subject line is matched separately and independently. If you want to do\nmulti-line matches, you have to use the \\n escape sequence (or \\r or \\r\\n,\netc., depending on the newline setting) in a single line of input to encode the\nnewline sequences. There is no limit on the length of subject lines; the input\nbuffer is automatically extended if it is too small. There are replication\nfeatures that makes it possible to generate long repetitive pattern or subject\nlines without having to supply them explicitly.\n
\n\nAn empty line or the end of the file signals the end of the subject lines for a\ntest, at which point a new pattern or command line is expected if there is\nstill input to be read.\n
\nCOMMAND LINES
\n\nIn between sets of test data, a line that begins with # is interpreted as a\ncommand line. If the first character is followed by white space or an\nexclamation mark, the line is treated as a comment, and ignored. Otherwise, the\nfollowing commands are recognized:\n
\n #forbid_utf\n\nSubsequent patterns automatically have the PCRE2_NEVER_UTF and PCRE2_NEVER_UCP\noptions set, which locks out the use of the PCRE2_UTF and PCRE2_UCP options and\nthe use of (*UTF) and (*UCP) at the start of patterns. This command also forces\nan error if a subsequent pattern contains any occurrences of \\P, \\p, or \\X,\nwhich are still supported when PCRE2_UTF is not set, but which require Unicode\nproperty support to be included in the library.\n\n
\nThis is a trigger guard that is used in test files to ensure that UTF or\nUnicode property tests are not accidentally added to files that are used when\nUnicode support is not included in the library. Setting PCRE2_NEVER_UTF and\nPCRE2_NEVER_UCP as a default can also be obtained by the use of #pattern;\nthe difference is that #forbid_utf cannot be unset, and the automatic\noptions are not displayed in pattern information, to avoid cluttering up test\noutput.\n
\n #load <filename>\n\nThis command is used to load a set of precompiled patterns from a file, as\ndescribed in the section entitled \"Saving and restoring compiled patterns\"\nbelow.\n
\n #loadtables <filename>\n\nThis command is used to load a set of binary character tables that can be\naccessed by the tables=3 qualifier. Such tables can be created by the\npcre2_dftables program with the -b option.\n
\n #newline_default [<newline-list>]\n\nWhen PCRE2 is built, a default newline convention can be specified. This\ndetermines which characters and/or character pairs are recognized as indicating\na newline in a pattern or subject string. The default can be overridden when a\npattern is compiled. The standard test files contain tests of various newline\nconventions, but the majority of the tests expect a single linefeed to be\nrecognized as a newline by default. Without special action the tests would fail\nwhen PCRE2 is compiled with either CR or CRLF as the default newline.\n\n
\nThe #newline_default command specifies a list of newline types that are\nacceptable as the default. The types must be one of CR, LF, CRLF, ANYCRLF,\nANY, or NUL (in upper or lower case), for example:\n
\n #newline_default LF Any anyCRLF\n\nIf the default newline is in the list, this command has no effect. Otherwise,\nexcept when testing the POSIX API, a newline modifier that specifies the\nfirst newline convention in the list (LF in the above example) is added to any\npattern that does not already have a newline modifier. If the newline\nlist is empty, the feature is turned off. This command is present in a number\nof the standard test input files.\n\n
\nWhen the POSIX API is being tested there is no way to override the default\nnewline convention, though it is possible to set the newline convention from\nwithin the pattern. A warning is given if the posix or posix_nosub\nmodifier is used when #newline_default would set a default for the\nnon-POSIX API.\n
\n #pattern <modifier-list>\n\nThis command sets a default modifier list that applies to all subsequent\npatterns. Modifiers on a pattern can change these settings.\n
\n #perltest\n\nThis line is used in test files that can also be processed by perltest.sh\nto confirm that Perl gives the same results as PCRE2. Subsequent tests are\nchecked for the use of pcre2test features that are incompatible with the\nperltest.sh script.\n\n
\nPatterns must use '/' as their delimiter, and only certain modifiers are\nsupported. Comment lines, #pattern commands, and #subject commands that set or\nunset \"mark\" are recognized and acted on. The #perltest, #forbid_utf, and\n#newline_default commands, which are needed in the relevant pcre2test files,\nare silently ignored. All other command lines are ignored, but give a warning\nmessage. The #perltest command helps detect tests that are accidentally\nput in the wrong file or use the wrong delimiter. For more details of the\nperltest.sh script see the comments it contains.\n
\n #pop [<modifiers>]\n #popcopy [<modifiers>]\n\nThese commands are used to manipulate the stack of compiled patterns, as\ndescribed in the section entitled \"Saving and restoring compiled patterns\"\nbelow.\n
\n #save <filename>\n\nThis command is used to save a set of compiled patterns to a file, as described\nin the section entitled \"Saving and restoring compiled patterns\"\nbelow.\n
\n #subject <modifier-list>\n\nThis command sets a default modifier list that applies to all subsequent\nsubject lines. Modifiers on a subject line can change these settings.\n
\n #if CONDITION\n ...\n #endif\n\nIf CONDITION is true, then the command is printed, and its contents are\nprocessed as normal, including printing the commandlines to the output. If\nCONDITION is false, then all lines between the \"#if\" and \"#endif\" are skipped\nand not printed. The CONDITION can be any of the conditions which are tested by\nthe \"-C\" commandline option and which set pcre2test's exit code to a boolean\nvalue. The CONDITION may also be preceded by \"!\".\n\n
MODIFIER SYNTAX
\n\nModifier lists are used with both pattern and subject lines. Items in a list\nare separated by commas followed by optional white space. Trailing white space\nin a modifier list is ignored. Some modifiers may be given for both patterns\nand subject lines, whereas others are valid only for one or the other. Each\nmodifier has a long name, for example \"anchored\", and some of them must be\nfollowed by an equals sign and a value, for example, \"offset=12\". Values cannot\ncontain comma characters, but may contain spaces. Modifiers that do not take\nvalues may be preceded by a minus sign to turn off a previous setting.\n
\n\nA few of the more common modifiers can also be specified as single letters, for\nexample \"i\" for \"caseless\". In documentation, following the Perl convention,\nthese are written with a slash (\"the /i modifier\") for clarity. Abbreviated\nmodifiers must all be concatenated in the first item of a modifier list. If the\nfirst item is not recognized as a long modifier name, it is interpreted as a\nsequence of these abbreviations. For example:\n
\n /abc/ig,newline=cr,jit=3\n\nThis is a pattern line whose modifier list starts with two one-letter modifiers\n(/i and /g). The lower-case abbreviated modifiers are the same as used in Perl.\n\n
PATTERN SYNTAX
\n\nA pattern line must start with one of the following characters (common symbols,\nexcluding pattern meta-characters):\n
\n / ! \" ' ` - = _ : ; , % & @ ~\n\nThis is interpreted as the pattern's delimiter. A regular expression may be\ncontinued over several input lines, in which case the newline characters are\nincluded within it. It is possible to include the delimiter as a literal within\nthe pattern by escaping it with a backslash, for example\n
\n /abc\\/def/\n\nIf you do this, the escape and the delimiter form part of the pattern, but\nsince the delimiters are all non-alphanumeric, the inclusion of the backslash\ndoes not affect the pattern's interpretation. Note, however, that this trick\ndoes not work within \\Q...\\E literal bracketing because the backslash will\nitself be interpreted as a literal. If the terminating delimiter is immediately\nfollowed by a backslash, for example,\n
\n /abc/\\\n\na backslash is added to the end of the pattern. This is done to provide a way\nof testing the error condition that arises if a pattern finishes with a\nbackslash, because\n
\n /abc\\/\n\nis interpreted as the first line of a pattern that starts with \"abc/\", causing\npcre2test to read the next line as a continuation of the regular expression.\n\n
\nA pattern can be followed by a modifier list (details below).\n
\nSUBJECT LINE SYNTAX
\n\nBefore each subject line is passed to pcre2_match(),\npcre2_dfa_match(), or pcre2_jit_match(), leading and trailing white\nspace is removed, and the line is scanned for backslash escapes, unless the\nsubject_literal modifier was set for the pattern. The following provide a\nmeans of encoding non-printing characters in a visible way:\n
\n \\a alarm (BEL, \\x07)\n \\b backspace (\\x08)\n \\e escape (\\x27)\n \\f form feed (\\x0c)\n \\n newline (\\x0a)\n \\N{U+hh...} unicode character (any number of hex digits)\n \\r carriage return (\\x0d)\n \\t tab (\\x09)\n \\v vertical tab (\\x0b)\n \\ddd octal number (up to 3 octal digits); represent a single\n code point unless larger than 255 with the 8-bit library\n \\o{dd...} octal number (any number of octal digits} representing a\n character in UTF mode or a code point\n \\xhh hexadecimal byte (up to 2 hex digits)\n \\x{hh...} hexadecimal number (up to 8 hex digits) representing a\n character in UTF mode or a code point\n\nInvoking \\N{U+hh...} or \\x{hh...} doesn't require the use of the utf\nmodifier on the pattern. It is always recognized. There may be any number of\nhexadecimal digits inside the braces; invalid values provoke error messages\nbut when using \\N{U+hh...} with some invalid unicode characters they will\nbe accepted with a warning instead.\n\n\nNote that even in UTF-8 mode, \\xhh (and depending of how large, \\ddd)\ndescribe one byte rather than one character; this makes it possible to\nconstruct invalid UTF-8 sequences for testing purposes. On the other hand,\n\\x{hh...} is interpreted as a UTF-8 character in UTF-8 mode, only generating\nmore than one byte if the value is greater than 127. To avoid the ambiguity\nit is preferred to use \\N{U+hh...} when describing characters. When testing\nthe 8-bit library not in UTF-8 mode, \\x{hh} generates one byte for values\nthat could fit on it, and causes an error for greater values.\n
\n\nWhen testing the 16-bit library, not in UTF-16 mode, all 4-digit \\x{hhhh}\nvalues are accepted. This makes it possible to construct invalid UTF-16\nsequences for testing purposes.\n
\n\nWhen testing the 32-bit library, not in UTF-32 mode, all 4 to 8-digit \\x{...}\nvalues are accepted. This makes it possible to construct invalid UTF-32\nsequences for testing purposes.\n
\n\nThere is a special backslash sequence that specifies replication of one or more\ncharacters:\n
\n \\[<characters>]{<count>}\n\nThis makes it possible to test long strings without having to provide them as\npart of the file. For example:\n\n \\[abc]{4}\n\nis converted to \"abcabcabcabc\". This feature does not support nesting. To\ninclude a closing square bracket in the characters, code it as \\x5D.\n\n\nA backslash followed by an equals sign marks the end of the subject string and\nthe start of a modifier list. For example:\n
\n abc\\=notbol,notempty\n\nIf the subject string is empty and \\= is followed by white space, the line is\ntreated as a comment line, and is not used for matching. For example:\n
\n \\= This is a comment.\n abc\\= This is an invalid modifier list.\n\nA backslash followed by any other non-alphanumeric character just escapes that\ncharacter. A backslash followed by anything else causes an error. However, if\nthe very last character in the line is a backslash (and there is no modifier\nlist), it is ignored. This gives a way of passing an empty line as data, since\na real empty line terminates the data input.\n\n
\nIf the subject_literal modifier is set for a pattern, all subject lines\nthat follow are treated as literals, with no special treatment of backslashes.\nNo replication is possible, and any subject modifiers must be set as defaults\nby a #subject command.\n
\nPATTERN MODIFIERS
\n\nThere are several types of modifier that can appear in pattern lines. Except\nwhere noted below, they may also be used in #pattern commands. A\npattern's modifier list can add to or override default modifiers that were set\nby a previous #pattern command.\n
\n\nSetting compilation options\n
\n\nThe following modifiers set options for pcre2_compile(). Most of them set\nbits in the options argument of that function, but those whose names start with\nPCRE2_EXTRA are additional options that are set in the compile context.\nSome of these options have single-letter abbreviations. There is special\nhandling for /x: if a second x is present, PCRE2_EXTENDED is converted into\nPCRE2_EXTENDED_MORE as in Perl. A third appearance adds PCRE2_EXTENDED as well,\nthough this makes no difference to the way pcre2_compile() behaves. See\npcre2api\nfor a description of the effects of these options.\n
\n allow_empty_class set PCRE2_ALLOW_EMPTY_CLASS\n allow_lookaround_bsk set PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK\n allow_surrogate_escapes set PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES\n alt_bsux set PCRE2_ALT_BSUX\n alt_circumflex set PCRE2_ALT_CIRCUMFLEX\n alt_extended_class set PCRE2_ALT_EXTENDED_CLASS\n alt_verbnames set PCRE2_ALT_VERBNAMES\n anchored set PCRE2_ANCHORED\n /a ascii_all set all ASCII options\n ascii_bsd set PCRE2_EXTRA_ASCII_BSD\n ascii_bss set PCRE2_EXTRA_ASCII_BSS\n ascii_bsw set PCRE2_EXTRA_ASCII_BSW\n ascii_digit set PCRE2_EXTRA_ASCII_DIGIT\n ascii_posix set PCRE2_EXTRA_ASCII_POSIX\n auto_callout set PCRE2_AUTO_CALLOUT\n bad_escape_is_literal set PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL\n /i caseless set PCRE2_CASELESS\n /r caseless_restrict set PCRE2_EXTRA_CASELESS_RESTRICT\n dollar_endonly set PCRE2_DOLLAR_ENDONLY\n /s dotall set PCRE2_DOTALL\n dupnames set PCRE2_DUPNAMES\n endanchored set PCRE2_ENDANCHORED\n escaped_cr_is_lf set PCRE2_EXTRA_ESCAPED_CR_IS_LF\n /x extended set PCRE2_EXTENDED\n /xx extended_more set PCRE2_EXTENDED_MORE\n extra_alt_bsux set PCRE2_EXTRA_ALT_BSUX\n firstline set PCRE2_FIRSTLINE\n literal set PCRE2_LITERAL\n match_line set PCRE2_EXTRA_MATCH_LINE\n match_invalid_utf set PCRE2_MATCH_INVALID_UTF\n match_unset_backref set PCRE2_MATCH_UNSET_BACKREF\n match_word set PCRE2_EXTRA_MATCH_WORD\n /m multiline set PCRE2_MULTILINE\n never_backslash_c set PCRE2_NEVER_BACKSLASH_C\n never_callout set PCRE2_EXTRA_NEVER_CALLOUT\n never_ucp set PCRE2_NEVER_UCP\n never_utf set PCRE2_NEVER_UTF\n /n no_auto_capture set PCRE2_NO_AUTO_CAPTURE\n no_auto_possess set PCRE2_NO_AUTO_POSSESS\n no_bs0 set PCRE2_EXTRA_NO_BS0\n no_dotstar_anchor set PCRE2_NO_DOTSTAR_ANCHOR\n no_start_optimize set PCRE2_NO_START_OPTIMIZE\n no_utf_check set PCRE2_NO_UTF_CHECK\n python_octal set PCRE2_EXTRA_PYTHON_OCTAL\n turkish_casing set PCRE2_EXTRA_TURKISH_CASING\n ucp set PCRE2_UCP\n ungreedy set PCRE2_UNGREEDY\n use_offset_limit set PCRE2_USE_OFFSET_LIMIT\n utf set PCRE2_UTF\n\nAs well as turning on the PCRE2_UTF option, the utf modifier causes all\nnon-printing characters in output strings to be printed using the \\x{hh...}\nnotation. Otherwise, those less than 0x100 are output in hex without the curly\nbrackets. Setting utf in 16-bit or 32-bit mode also causes pattern and\nsubject strings to be translated to UTF-16 or UTF-32, respectively, before\nbeing passed to library functions.\n
\n
\nThe following modifiers enable or disable performance optimizations by\ncalling pcre2_set_optimize() before invoking the regex compiler.\n
\n optimization_full enable all optional optimizations\n optimization_none disable all optional optimizations\n auto_possess auto-possessify variable quantifiers\n auto_possess_off don't auto-possessify variable quantifiers\n dotstar_anchor anchor patterns starting with .*\n dotstar_anchor_off don't anchor patterns starting with .*\n start_optimize enable pre-scan of subject string\n start_optimize_off disable pre-scan of subject string\n\nSee the\npcre2_set_optimize\ndocumentation for details on these optimizations.\n\n
\nSetting compilation controls\n
\n\nThe following modifiers affect the compilation process or request information\nabout the pattern. There are single-letter abbreviations for some that are\nheavily used in the test files.\n
\n /B bincode show binary code without lengths\n bsr=[anycrlf|unicode] specify \\R handling\n callout_info show callout information\n convert=<options> request foreign pattern conversion\n convert_glob_escape=c set glob escape character\n convert_glob_separator=c set glob separator character\n convert_length set convert buffer length\n debug same as info,fullbincode\n expand expand repetition syntax in pattern\n framesize show matching frame size\n fullbincode show binary code with lengths\n /I info show info about compiled pattern\n hex unquoted characters are hexadecimal\n jit[=<number>] use JIT\n jitfast use JIT fast path\n jitverify verify JIT use\n locale=<name> use this locale\n max_pattern_compiled ) set maximum compiled pattern\n _length=<n> ) length (bytes)\n max_pattern_length=<n> set maximum pattern length (code units)\n max_varlookbehind=<n> set maximum variable lookbehind length\n memory show memory used\n newline=<type> set newline type\n null_context compile with a NULL context\n null_pattern pass pattern as NULL\n parens_nest_limit=<n> set maximum parentheses depth\n posix use the POSIX API\n posix_nosub use the POSIX API with REG_NOSUB\n push push compiled pattern onto the stack\n pushcopy push a copy onto the stack\n pushtablescopy push a copy with tables onto the stack\n stackguard=<number> test the stackguard feature\n subject_literal treat all subject lines as literal\n tables=[0|1|2|3] select internal tables\n use_length do not zero-terminate the pattern\n utf8_input treat input as UTF-8\n\nThe effects of these modifiers are described in the following sections.\n\n
\nNewline and \\R handling\n
\n\nThe bsr modifier specifies what \\R in a pattern should match. If it is\nset to \"anycrlf\", \\R matches CR, LF, or CRLF only. If it is set to \"unicode\",\n\\R matches any Unicode newline sequence. The default can be specified when\nPCRE2 is built; if it is not, the default is set to Unicode.\n
\n\nThe newline modifier specifies which characters are to be interpreted as\nnewlines, both in the pattern and in subject lines. The type must be one of CR,\nLF, CRLF, ANYCRLF, ANY, or NUL (in upper or lower case).\n
\n\nInformation about a pattern\n
\n\nThe debug modifier is a shorthand for info,fullbincode, requesting\nall available information.\n
\n\nThe bincode modifier causes a representation of the compiled code to be\noutput after compilation. This information does not contain length and offset\nvalues, which ensures that the same output is generated for different internal\nlink sizes and different code unit widths. By using bincode, the same\nregression tests can be used in different environments.\n
\n\nThe fullbincode modifier, by contrast, does include length and\noffset values. This is used in a few special tests that run only for specific\ncode unit widths and link sizes, and is also useful for one-off tests.\n
\n\nThe info modifier requests information about the compiled pattern\n(whether it is anchored, has a fixed first character, and so on). The\ninformation is obtained from the pcre2_pattern_info() function. Here are\nsome typical examples:\n
\n re> /(?i)(^a|^b)/m,info\n Capture group count = 1\n Compile options: multiline\n Overall options: caseless multiline\n First code unit at start or follows newline\n Subject length lower bound = 1\n\n re> /(?i)abc/info\n Capture group count = 0\n Compile options: <none>\n Overall options: caseless\n First code unit = 'a' (caseless)\n Last code unit = 'c' (caseless)\n Subject length lower bound = 3\n\n\"Compile options\" are those specified by modifiers; \"overall options\" have\nadded options that are taken or deduced from the pattern. If both sets of\noptions are the same, just a single \"options\" line is output; if there are no\noptions, the line is omitted. \"First code unit\" is where any match must start;\nif there is more than one they are listed as \"starting code units\". \"Last code\nunit\" is the last literal code unit that must be present in any match. This is\nnot necessarily the last character. These lines are omitted if no starting or\nending code units are recorded. The subject length line is omitted when\nno_start_optimize is set because the minimum length is not calculated\nwhen it can never be used.\n\n
\nThe framesize modifier shows the size, in bytes, of each storage frame\nused by pcre2_match() for handling backtracking. The size depends on the\nnumber of capturing parentheses in the pattern. A vector of these frames is\nused at matching time; its overall size is shown when the heaframes_size\nsubject modifier is set.\n
\n\nThe callout_info modifier requests information about all the callouts in\nthe pattern. A list of them is output at the end of any other information that\nis requested. For each callout, either its number or string is given, followed\nby the item that follows it in the pattern.\n
\n\nPassing a NULL context\n
\n\nNormally, pcre2test passes a context block to pcre2_compile(). If\nthe null_context modifier is set, however, NULL is passed. This is for\ntesting that pcre2_compile() behaves correctly in this case (it uses\ndefault values).\n
\n\nPassing a NULL pattern\n
\n\nThe null_pattern modifier is for testing the behaviour of\npcre2_compile() when the pattern argument is NULL. The length value\npassed is the default PCRE2_ZERO_TERMINATED unless use_length is set.\nAny length other than zero causes an error.\n
\n\nSpecifying pattern characters in hexadecimal\n
\n\nThe hex modifier specifies that the characters of the pattern, except for\nsubstrings enclosed in single or double quotes, are to be interpreted as pairs\nof hexadecimal digits. This feature is provided as a way of creating patterns\nthat contain binary zeros and other non-printing characters. White space is\npermitted between pairs of digits. For example, this pattern contains three\ncharacters:\n
\n /ab 32 59/hex\n\nParts of such a pattern are taken literally if quoted. This pattern contains\nnine characters, only two of which are specified in hexadecimal:\n
\n /ab \"literal\" 32/hex\n\nEither single or double quotes may be used. There is no way of including\nthe delimiter within a substring. The hex and expand modifiers are\nmutually exclusive.\n\n
\nSpecifying the pattern's length\n
\n\nBy default, patterns are passed to the compiling functions as zero-terminated\nstrings but can be passed by length instead of being zero-terminated. The\nuse_length modifier causes this to happen. Using a length happens\nautomatically (whether or not use_length is set) when hex is set,\nbecause patterns specified in hexadecimal may contain binary zeros.\n
\n\nIf hex or use_length is used with the POSIX wrapper API (see\n\"Using the POSIX wrapper API\"\nbelow), the REG_PEND extension is used to pass the pattern's length.\n
\n\nSpecifying a maximum for variable lookbehinds\n
\n\nVariable lookbehind assertions are supported only if, for each one, there is a\nmaximum length (in characters) that it can match. There is a limit on this,\nwhose default can be set at build time, with an ultimate default of 255. The\nmax_varlookbehind modifier uses the pcre2_set_max_varlookbehind()\nfunction to change the limit. Lookbehinds whose branches each match a fixed\nlength are limited to 65535 characters per branch.\n
\n\nSpecifying wide characters in 16-bit and 32-bit modes\n
\n\nIn 16-bit and 32-bit modes, all input is automatically treated as UTF-8 and\ntranslated to UTF-16 or UTF-32 when the utf modifier is set. For testing\nthe 16-bit and 32-bit libraries in non-UTF mode, the utf8_input modifier\ncan be used. It is mutually exclusive with utf. Input lines are\ninterpreted as UTF-8 as a means of specifying wide characters. More details are\ngiven in\n\"Input encoding\"\nabove.\n
\n\nGenerating long repetitive patterns\n
\n\nSome tests use long patterns that are very repetitive. Instead of creating a\nvery long input line for such a pattern, you can use a special repetition\nfeature, similar to the one described for subject lines above. If the\nexpand modifier is present on a pattern, parts of the pattern that have\nthe form\n
\n \\[<characters>]{<count>}\n\nare expanded before the pattern is passed to pcre2_compile(). For\nexample, \\[AB]{6000} is expanded to \"ABAB...\" 6000 times. This construction\ncannot be nested. An initial \"\\[\" sequence is recognized only if \"]{\" followed\nby decimal digits and \"}\" is found later in the pattern. If not, the characters\nremain in the pattern unaltered. The expand and hex modifiers are\nmutually exclusive.\n\n\nIf part of an expanded pattern looks like an expansion, but is really part of\nthe actual pattern, unwanted expansion can be avoided by giving two values in\nthe quantifier. For example, \\[AB]{6000,6000} is not recognized as an\nexpansion item.\n
\n\nIf the info modifier is set on an expanded pattern, the result of the\nexpansion is included in the information that is output.\n
\n\nJIT compilation\n
\n\nJust-in-time (JIT) compiling is a heavyweight optimization that can greatly\nspeed up pattern matching. See the\npcre2jit\ndocumentation for details. JIT compiling happens, optionally, after a pattern\nhas been successfully compiled into an internal form. The JIT compiler converts\nthis to optimized machine code. It needs to know whether the match-time options\nPCRE2_PARTIAL_HARD and PCRE2_PARTIAL_SOFT are going to be used, because\ndifferent code is generated for the different cases. See the partial\nmodifier in \"Subject Modifiers\"\nbelow\nfor details of how these options are specified for each match attempt.\n
\n\nJIT compilation is requested by the jit pattern modifier, which may\noptionally be followed by an equals sign and a number in the range 0 to 7.\nThe three bits that make up the number specify which of the three JIT operating\nmodes are to be compiled:\n
\n 1 compile JIT code for non-partial matching\n 2 compile JIT code for soft partial matching\n 4 compile JIT code for hard partial matching\n\nThe possible values for the jit modifier are therefore:\n
\n 0 disable JIT\n 1 normal matching only\n 2 soft partial matching only\n 3 normal and soft partial matching\n 4 hard partial matching only\n 6 soft and hard partial matching only\n 7 all three modes\n\nIf no number is given, 7 is assumed. The phrase \"partial matching\" means a call\nto pcre2_match() with either the PCRE2_PARTIAL_SOFT or the\nPCRE2_PARTIAL_HARD option set. Note that such a call may return a complete\nmatch; the options enable the possibility of a partial match, but do not\nrequire it. Note also that if you request JIT compilation only for partial\nmatching (for example, jit=2) but do not set the partial modifier on a\nsubject line, that match will not use JIT code because none was compiled for\nnon-partial matching.\n\n
\nIf JIT compilation is successful, the compiled JIT code will automatically be\nused when an appropriate type of match is run, except when incompatible\nrun-time options are specified. For more details, see the\npcre2jit\ndocumentation. See also the jitstack modifier below for a way of\nsetting the size of the JIT stack.\n
\n\nIf the jitfast modifier is specified, matching is done using the JIT\n\"fast path\" interface, pcre2_jit_match(), which skips some of the sanity\nchecks that are done by pcre2_match(), and of course does not work when\nJIT is not supported. If jitfast is specified without jit, jit=7 is\nassumed.\n
\n\nIf the jitverify modifier is specified, information about the compiled\npattern shows whether JIT compilation was or was not successful. If\njitverify is specified without jit, jit=7 is assumed. If JIT\ncompilation is successful when jitverify is set, the text \"(JIT)\" is\nadded to the first output line after a match or non match when JIT-compiled\ncode was actually used in the match.\n
\n\nSetting a locale\n
\n\nThe locale modifier must specify the name of a locale, for example:\n
\n /pattern/locale=fr_FR\n\nThe given locale is set, pcre2_maketables() is called to build a set of\ncharacter tables for the locale, and this is then passed to\npcre2_compile() when compiling the regular expression. The same tables\nare used when matching the following subject lines. The locale modifier\napplies only to the pattern on which it appears, but can be given in a\n#pattern command if a default is needed. Setting a locale and alternate\ncharacter tables are mutually exclusive.\n\n
\nShowing pattern memory\n
\n\nThe memory modifier causes the size in bytes of the memory used to hold\nthe compiled pattern to be output. This does not include the size of the\npcre2_code block; it is just the actual compiled data. If the pattern is\nsubsequently passed to the JIT compiler, the size of the JIT compiled code is\nalso output. Here is an example:\n
\n re> /a(b)c/jit,memory\n Memory allocation (code space): 21\n Memory allocation (JIT code): 1910\n\n\n\n
\nLimiting nested parentheses\n
\n\nThe parens_nest_limit modifier sets a limit on the depth of nested\nparentheses in a pattern. Breaching the limit causes a compilation error.\nThe default for the library is set when PCRE2 is built, but pcre2test\nsets its own default of 220, which is required for running the standard test\nsuite.\n
\n\nLimiting the pattern length\n
\n\nThe max_pattern_length modifier sets a limit, in code units, to the\nlength of pattern that pcre2_compile() will accept. Breaching the limit\ncauses a compilation error. The default is the largest number a PCRE2_SIZE\nvariable can hold (essentially unlimited).\n
\n\nLimiting the size of a compiled pattern\n
\n\nThe max_pattern_compiled_length modifier sets a limit, in bytes, to the\namount of memory used by a compiled pattern. Breaching the limit causes a\ncompilation error. The default is the largest number a PCRE2_SIZE variable can\nhold (essentially unlimited).\n
\n\nUsing the POSIX wrapper API\n
\n\nThe posix and posix_nosub modifiers cause pcre2test to call\nPCRE2 via the POSIX wrapper API rather than its native API. When\nposix_nosub is used, the POSIX option REG_NOSUB is passed to\nregcomp(). The POSIX wrapper supports only the 8-bit library. Note that\nit does not imply POSIX matching semantics; for more detail see the\npcre2posix\ndocumentation. The following pattern modifiers set options for the\nregcomp() function:\n
\n caseless REG_ICASE\n multiline REG_NEWLINE\n dotall REG_DOTALL )\n ungreedy REG_UNGREEDY ) These options are not part of\n ucp REG_UCP ) the POSIX standard\n utf REG_UTF8 )\n\nThe regerror_buffsize modifier specifies a size for the error buffer that\nis passed to regerror() in the event of a compilation error. For example:\n
\n /abc/posix,regerror_buffsize=20\n\nThis provides a means of testing the behaviour of regerror() when the\nbuffer is too small for the error message. If this modifier has not been set, a\nlarge buffer is used.\n\n
\nThe aftertext and allaftertext subject modifiers work as described\nbelow. All other modifiers are either ignored, with a warning message, or cause\nan error.\n
\n\nThe pattern is passed to regcomp() as a zero-terminated string by\ndefault, but if the use_length or hex modifiers are set, the\nREG_PEND extension is used to pass it by length.\n
\n\nTesting the stack guard feature\n
\n\nThe stackguard modifier is used to test the use of\npcre2_set_compile_recursion_guard(), a function that is provided to\nenable stack availability to be checked during compilation (see the\npcre2api\ndocumentation for details). If the number specified by the modifier is greater\nthan zero, pcre2_set_compile_recursion_guard() is called to set up\ncallback from pcre2_compile() to a local function. The argument it\nreceives is the current nesting parenthesis depth; if this is greater than the\nvalue given by the modifier, non-zero is returned, causing the compilation to\nbe aborted.\n
\n\nUsing alternative character tables\n
\n\nThe value specified for the tables modifier must be one of the digits 0,\n1, 2, or 3. It causes a specific set of built-in character tables to be passed\nto pcre2_compile(). This is used in the PCRE2 tests to check behaviour\nwith different character tables. The digit specifies the tables as follows:\n
\n 0 do not pass any special character tables\n 1 the default ASCII tables, as distributed in\n pcre2_chartables.c.dist\n 2 a set of tables defining ISO 8859 characters\n 3 a set of tables loaded by the #loadtables command\n\nIn tables 2, some characters whose codes are greater than 128 are identified as\nletters, digits, spaces, etc. Tables 3 can be used only after a\n#loadtables command has loaded them from a binary file. Setting alternate\ncharacter tables and a locale are mutually exclusive.\n\n
\nSetting certain match controls\n
\n\nThe following modifiers are really subject modifiers, and are described under\n\"Subject Modifiers\" below. However, they may be included in a pattern's\nmodifier list, in which case they are applied to every subject line that is\nprocessed with that pattern. These modifiers do not affect the compilation\nprocess.\n
\n aftertext show text after match\n allaftertext show text after captures\n allcaptures show all captures\n allvector show the entire ovector\n allusedtext show all consulted text\n altglobal alternative global matching\n /g global global matching\n heapframes_size show match data heapframes size\n jitstack=<n> set size of JIT stack\n mark show mark values\n null_substitute_match_data substitute with NULL match data\n replace=<str> specify a replacement string\n startchar show starting character when relevant\n substitute_callout use substitution callouts\n substitute_case_callout use substitution case callouts\n substitute_extended use PCRE2_SUBSTITUTE_EXTENDED\n substitute_literal use PCRE2_SUBSTITUTE_LITERAL\n substitute_matched use PCRE2_SUBSTITUTE_MATCHED\n substitute_overflow_length use PCRE2_SUBSTITUTE_OVERFLOW_LENGTH\n substitute_replacement_only use PCRE2_SUBSTITUTE_REPLACEMENT_ONLY\n substitute_skip=<n> skip substitution <n>\n substitute_stop=<n> skip substitution <n> and following\n substitute_unknown_unset use PCRE2_SUBSTITUTE_UNKNOWN_UNSET\n substitute_unset_empty use PCRE2_SUBSTITUTE_UNSET_EMPTY\n\nThese modifiers may not appear in a #pattern command. If you want them as\ndefaults, set them in a #subject command.\n\n
\nSpecifying literal subject lines\n
\n\nIf the subject_literal modifier is present on a pattern, all the subject\nlines that it matches are taken as literal strings, with no interpretation of\nbackslashes. It is not possible to set subject modifiers on such lines, but any\nthat are set as defaults by a #subject command are recognized.\n
\n\nSaving a compiled pattern\n
\n\nWhen a pattern with the push modifier is successfully compiled, it is\npushed onto a stack of compiled patterns, and pcre2test expects the next\nline to contain a new pattern (or a command) instead of a subject line. This\nfacility is used when saving compiled patterns to a file, as described in the\nsection entitled \"Saving and restoring compiled patterns\"\nbelow.\nIf pushcopy is used instead of push, a copy of the compiled\npattern is stacked, leaving the original as current, ready to match the\nfollowing input lines. This provides a way of testing the\npcre2_code_copy() function.\nThe push and pushcopy modifiers are incompatible with compilation\nmodifiers such as global that act at match time. Any that are specified\nare ignored (for the stacked copy), with a warning message, except for\nreplace, which causes an error. Note that jitverify, which is\nallowed, does not carry through to any subsequent matching that uses a stacked\npattern.\n
\n\nTesting foreign pattern conversion\n
\n\nThe experimental foreign pattern conversion functions in PCRE2 can be tested by\nsetting the convert modifier. Its argument is a colon-separated list of\noptions, which set the equivalent option for the pcre2_pattern_convert()\nfunction:\n
\n glob PCRE2_CONVERT_GLOB\n glob_no_starstar PCRE2_CONVERT_GLOB_NO_STARSTAR\n glob_no_wild_separator PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR\n posix_basic PCRE2_CONVERT_POSIX_BASIC\n posix_extended PCRE2_CONVERT_POSIX_EXTENDED\n unset Unset all options\n\nThe \"unset\" value is useful for turning off a default that has been set by a\n#pattern command. When one of these options is set, the input pattern is\npassed to pcre2_pattern_convert(). If the conversion is successful, the\nresult is reflected in the output and then passed to pcre2_compile(). The\nnormal utf and no_utf_check options, if set, cause the\nPCRE2_CONVERT_UTF and PCRE2_CONVERT_NO_UTF_CHECK options to be passed to\npcre2_pattern_convert().\n\n
\nBy default, the conversion function is allowed to allocate a buffer for its\noutput. However, if the convert_length modifier is set to a value greater\nthan zero, pcre2test passes a buffer of the given length. This makes it\npossible to test the length check.\n
\n\nThe convert_glob_escape and convert_glob_separator modifiers can be\nused to specify the escape and separator characters for glob processing,\noverriding the defaults, which are operating-system dependent.\n
\nSUBJECT MODIFIERS
\n\nThe modifiers that can appear in subject lines and the #subject\ncommand are of two types.\n
\n\nSetting match options\n
\n\nThe following modifiers set options for pcre2_match() or\npcre2_dfa_match(). See\npcre2api\nfor a description of their effects.\n
\n anchored set PCRE2_ANCHORED\n copy_matched_subject set PCRE2_COPY_MATCHED_SUBJECT\n endanchored set PCRE2_ENDANCHORED\n dfa_restart set PCRE2_DFA_RESTART\n dfa_shortest set PCRE2_DFA_SHORTEST\n disable_recurseloop_check set PCRE2_DISABLE_RECURSELOOP_CHECK\n no_jit set PCRE2_NO_JIT\n no_utf_check set PCRE2_NO_UTF_CHECK\n notbol set PCRE2_NOTBOL\n notempty set PCRE2_NOTEMPTY\n notempty_atstart set PCRE2_NOTEMPTY_ATSTART\n noteol set PCRE2_NOTEOL\n partial_hard (or ph) set PCRE2_PARTIAL_HARD\n partial_soft (or ps) set PCRE2_PARTIAL_SOFT\n\nThe partial matching modifiers are provided with abbreviations because they\nappear frequently in tests.\n\n
\nIf the posix or posix_nosub modifier was present on the pattern,\ncausing the POSIX wrapper API to be used, the only option-setting modifiers\nthat have any effect are notbol, notempty, and noteol,\ncausing REG_NOTBOL, REG_NOTEMPTY, and REG_NOTEOL, respectively, to be passed to\nregexec(). The other modifiers are ignored, with a warning message.\n
\n\nThere is one additional modifier that can be used with the POSIX wrapper. It is\nignored (with a warning) if used for non-POSIX matching.\n
\n posix_startend=<n>[:<m>]\n\nThis causes the subject string to be passed to regexec() using the\nREG_STARTEND option, which uses offsets to specify which part of the string is\nsearched. If only one number is given, the end offset is passed as the end of\nthe subject string. For more detail of REG_STARTEND, see the\npcre2posix\ndocumentation. If the subject string contains binary zeros (coded as escapes\nsuch as \\x{00} because pcre2test does not support actual binary zeros in\nits input), you must use posix_startend to specify its length.\n\n
\nSetting match controls\n
\n\nThe following modifiers affect the matching process or request additional\ninformation. Some of them may also be specified on a pattern line (see above),\nin which case they apply to every subject line that is matched against that\npattern, but can be overridden by modifiers on the subject.\n
\n aftertext show text after match\n allaftertext show text after captures\n allcaptures show all captures\n allusedtext show all consulted text (non-JIT only)\n allvector show the entire ovector\n altglobal alternative global matching\n callout_capture show captures at callout time\n callout_data=<n> set a value to pass via callouts\n callout_error=<n>[:<m>] control callout error\n callout_extra show extra callout information\n callout_fail=<n>[:<m>] control callout failure\n callout_no_where do not show position of a callout\n callout_none do not supply a callout function\n copy=<number or name> copy captured substring\n depth_limit=<n> set a depth limit\n dfa use pcre2_dfa_match()\n find_limits find heap, match and depth limits\n find_limits_noheap find match and depth limits\n get=<number or name> extract captured substring\n getall extract all captured substrings\n /g global global matching\n heapframes_size show match data heapframes size\n heap_limit=<n> set a limit on heap memory (Kbytes)\n jitstack=<n> set size of JIT stack\n mark show mark values\n match_limit=<n> set a match limit\n memory show heap memory usage\n null_context match with a NULL context\n null_replacement substitute with NULL replacement\n null_subject match with NULL subject\n null_substitute_match_data substitute with NULL match data\n offset=<n> set starting offset\n offset_limit=<n> set offset limit\n ovector=<n> set size of output vector\n recursion_limit=<n> obsolete synonym for depth_limit\n replace=<str> specify a replacement string\n startchar show startchar when relevant\n startoffset=<n> same as offset=<n>\n substitute_callout use substitution callouts\n substitute_case_callout use substitution case callouts\n substitute_extended use PCRE2_SUBSTITUTE_EXTENDED\n substitute_literal use PCRE2_SUBSTITUTE_LITERAL\n substitute_matched use PCRE2_SUBSTITUTE_MATCHED\n substitute_overflow_length use PCRE2_SUBSTITUTE_OVERFLOW_LENGTH\n substitute_replacement_only use PCRE2_SUBSTITUTE_REPLACEMENT_ONLY\n substitute_skip=<n> skip substitution number n\n substitute_stop=<n> skip substitution number n and greater\n substitute_subject=<str> specify a different subject for substitution\n substitute_unknown_unset use PCRE2_SUBSTITUTE_UNKNOWN_UNSET\n substitute_unset_empty use PCRE2_SUBSTITUTE_UNSET_EMPTY\n zero_terminate pass the subject as zero-terminated\n\nThe effects of these modifiers are described in the following sections. When\nmatching via the POSIX wrapper API, the aftertext, allaftertext,\nand ovector subject modifiers work as described below. All other\nmodifiers are either ignored, with a warning message, or cause an error.\n\n
\nShowing more text\n
\n\nThe aftertext modifier requests that as well as outputting the part of\nthe subject string that matched the entire pattern, pcre2test should in\naddition output the remainder of the subject string. This is useful for tests\nwhere the subject contains multiple copies of the same substring. The\nallaftertext modifier requests the same action for captured substrings as\nwell as the main matched substring. In each case the remainder is output on the\nfollowing line with a plus character following the capture number.\n
\n\nThe allusedtext modifier requests that all the text that was consulted\nduring a successful pattern match by the interpreter should be shown, for both\nfull and partial matches. This feature is not supported for JIT matching, and\nif requested with JIT it is ignored (with a warning message). Setting this\nmodifier affects the output if there is a lookbehind at the start of a match,\nor, for a complete match, a lookahead at the end, or if \\K is used in the\npattern. Characters that precede or follow the start and end of the actual\nmatch are indicated in the output by '<' or '>' characters underneath them.\nHere is an example:\n
\n re> /(?<=pqr)abc(?=xyz)/\n data> 123pqrabcxyz456\\=allusedtext\n 0: pqrabcxyz\n <<< >>>\n data> 123pqrabcxy\\=ph,allusedtext\n Partial match: pqrabcxy\n <<<\n\nThe first, complete match shows that the matched string is \"abc\", with the\npreceding and following strings \"pqr\" and \"xyz\" having been consulted during\nthe match (when processing the assertions). The partial match can indicate only\nthe preceding string.\n\n
\nThe startchar modifier requests that the starting character for the match\nbe indicated, if it is different to the start of the matched string. The only\ntime when this occurs is when \\K has been processed as part of the match. In\nthis situation, the output for the matched string is displayed from the\nstarting character instead of from the match point, with circumflex characters\nunder the earlier characters. For example:\n
\n re> /abc\\Kxyz/\n data> abcxyz\\=startchar\n 0: abcxyz\n ^^^\n\nUnlike allusedtext, the startchar modifier can be used with JIT.\nHowever, these two modifiers are mutually exclusive.\n\n
\nShowing the value of all capture groups\n
\n\nThe allcaptures modifier requests that the values of all potential\ncaptured parentheses be output after a match. By default, only those up to the\nhighest one actually used in the match are output (corresponding to the return\ncode from pcre2_match()). Groups that did not take part in the match\nare output as \"<unset>\". This modifier is not relevant for DFA matching (which\ndoes no capturing) and does not apply when replace is specified; it is\nignored, with a warning message, if present.\n
\n\nShowing the entire ovector, for all outcomes\n
\n\nThe allvector modifier requests that the entire ovector be shown,\nwhatever the outcome of the match. Compare allcaptures, which shows only\nup to the maximum number of capture groups for the pattern, and then only for a\nsuccessful complete non-DFA match. This modifier, which acts after any match\nresult, and also for DFA matching, provides a means of checking that there are\nno unexpected modifications to ovector fields. Before each match attempt, the\novector is filled with a special value, and if this is found in both elements\nof a capturing pair, \"<unchanged>\" is output. After a successful match, this\napplies to all groups after the maximum capture group for the pattern. In other\ncases it applies to the entire ovector. After a partial match, the first two\nelements are the only ones that should be set. After a DFA match, the amount of\novector that is used depends on the number of matches that were found.\n
\n\nTesting pattern callouts\n
\n\nA callout function is supplied when pcre2test calls the library matching\nfunctions, unless callout_none is specified. Its behaviour can be\ncontrolled by various modifiers listed above whose names begin with\ncallout_. Details are given in the section entitled \"Callouts\"\nbelow.\nTesting callouts from pcre2_substitute() is described separately in\n\"Testing the substitution function\"\nbelow.\n
\n\nFinding all matches in a string\n
\n\nSearching for all possible matches within a subject can be requested by the\nglobal or altglobal modifier. After finding a match, the matching\nfunction is called again to search the remainder of the subject. The difference\nbetween global and altglobal is that the former uses the\nstart_offset argument to pcre2_match() or pcre2_dfa_match()\nto start searching at a new point within the entire string (which is what Perl\ndoes), whereas the latter passes over a shortened subject. This makes a\ndifference to the matching process if the pattern begins with a lookbehind\nassertion (including \\b or \\B).\n
\n\nIf an empty string is matched, the next match is done with the\nPCRE2_NOTEMPTY_ATSTART flag set, in order to search for another, non-empty,\nmatch at the same point in the subject. This imitates the way Perl handles such\ncases when using the /g modifier or the split() function.\n
\n\nTesting substring extraction functions\n
\n\nThe copy and get modifiers can be used to test the\npcre2_substring_copy_xxx() and pcre2_substring_get_xxx() functions.\nThey can be given more than once, and each can specify a capture group name or\nnumber, for example:\n
\n abcd\\=copy=1,copy=3,get=G1\n\nIf the #subject command is used to set default copy and/or get lists,\nthese can be unset by specifying a negative number to cancel all numbered\ngroups and an empty name to cancel all named groups.\n\n
\nThe getall modifier tests pcre2_substring_list_get(), which\nextracts all captured substrings.\n
\n\nIf the subject line is successfully matched, the substrings extracted by the\nconvenience functions are output with C, G, or L after the string number\ninstead of a colon. This is in addition to the normal full list. The string\nlength (that is, the return from the extraction function) is given in\nparentheses after each substring, followed by the name when the extraction was\nby name.\n
\n\nTesting the substitution function\n
\n\nIf the replace modifier is set, the pcre2_substitute() function is\ncalled instead of one of the matching functions (or after one call of\npcre2_match() in the case of PCRE2_SUBSTITUTE_MATCHED). Note that\nreplacement strings cannot contain commas, because a comma signifies the end of\na modifier. This is not thought to be an issue in a test program.\n
\n\nSpecifying a completely empty replacement string disables this modifier.\nHowever, it is possible to specify an empty replacement by providing a buffer\nlength, as described below, for an otherwise empty replacement.\n
\n\nUnlike subject strings, pcre2test does not process replacement strings\nfor escape sequences. In UTF mode, a replacement string is checked to see if it\nis a valid UTF-8 string. If so, it is correctly converted to a UTF string of\nthe appropriate code unit width. If it is not a valid UTF-8 string, the\nindividual code units are copied directly. This provides a means of passing an\ninvalid UTF-8 string for testing purposes.\n
\n\nThe following modifiers set options (in additional to the normal match options)\nfor pcre2_substitute():\n
\n global PCRE2_SUBSTITUTE_GLOBAL\n substitute_extended PCRE2_SUBSTITUTE_EXTENDED\n substitute_literal PCRE2_SUBSTITUTE_LITERAL\n substitute_matched PCRE2_SUBSTITUTE_MATCHED\n substitute_overflow_length PCRE2_SUBSTITUTE_OVERFLOW_LENGTH\n substitute_replacement_only PCRE2_SUBSTITUTE_REPLACEMENT_ONLY\n substitute_unknown_unset PCRE2_SUBSTITUTE_UNKNOWN_UNSET\n substitute_unset_empty PCRE2_SUBSTITUTE_UNSET_EMPTY\n\nSee the\npcre2api\ndocumentation for details of these options.\n\n
\nAfter a successful substitution, the modified string is output, preceded by the\nnumber of replacements. This may be zero if there were no matches. Here is a\nsimple example of a substitution test:\n
\n /abc/replace=xxx\n =abc=abc=\n 1: =xxx=abc=\n =abc=abc=\\=global\n 2: =xxx=xxx=\n\nSubject and replacement strings should be kept relatively short (fewer than 256\ncharacters) for substitution tests, as fixed-size buffers are used. To make it\neasy to test for buffer overflow, if the replacement string starts with a\nnumber in square brackets, that number is passed to pcre2_substitute() as\nthe size of the output buffer, with the replacement string starting at the next\ncharacter. Here is an example that tests the edge case:\n
\n /abc/\n 123abc123\\=replace=[10]XYZ\n 1: 123XYZ123\n 123abc123\\=replace=[9]XYZ\n Failed: error -48: no more memory\n\nThe default action of pcre2_substitute() is to return\nPCRE2_ERROR_NOMEMORY when the output buffer is too small. However, if the\nPCRE2_SUBSTITUTE_OVERFLOW_LENGTH option is set (by using the\nsubstitute_overflow_length modifier), pcre2_substitute() continues\nto go through the motions of matching and substituting (but not doing any\ncallouts), in order to compute the size of buffer that is required. When this\nhappens, pcre2test shows the required buffer length (which includes space\nfor the trailing zero) as part of the error message. For example:\n
\n /abc/substitute_overflow_length\n 123abc123\\=replace=[9]XYZ\n Failed: error -48: no more memory: 10 code units are needed\n\nA replacement string is ignored with POSIX and DFA matching. Specifying partial\nmatching provokes an error return (\"bad option value\") from\npcre2_substitute().\n
\n
\nThe substitute_subject modifier may be used to test the use of the PCRE2\nAPI, in which a client calls pcre2_match() followed by pcre2_substitute()\nwith PCRE2_SUBSTITUTE_MATCHED, but the client performs an unexpected and\nunsupported modification of the subject buffer in-place, in between the match\nand substitution.\n\n
\nTesting substitute callouts\n
\n\nIf the substitute_callout modifier is set, a substitution callout\nfunction is set up. The null_context modifier must not be set, because\nthe address of the callout function is passed in a match context. When the\ncallout function is called (after each substitution), details of the input\nand output strings are output. For example:\n
\n /abc/g,replace=<$0>,substitute_callout\n abcdefabcpqr\n 1(1) Old 0 3 \"abc\" New 0 5 \"<abc>\"\n 2(1) Old 6 9 \"abc\" New 8 13 \"<abc>\"\n 2: <abc>def<abc>pqr\n\nThe first number on each callout line is the count of matches. The\nparenthesized number is the number of pairs that are set in the ovector (that\nis, one more than the number of capturing groups that were set). Then are\nlisted the offsets of the old substring, its contents, and the same for the\nreplacement.\n\n
\nBy default, the substitution callout function returns zero, which accepts the\nreplacement and causes matching to continue if /g was used. Two further\nmodifiers can be used to test other return values. If substitute_skip is\nset to a value greater than zero the callout function returns +1 for the match\nof that number, and similarly substitute_stop returns -1. These cause the\nreplacement to be rejected, and -1 causes no further matching to take place. If\neither of them are set, substitute_callout is assumed. For example:\n
\n /abc/g,replace=<$0>,substitute_skip=1\n abcdefabcpqr\n 1(1) Old 0 3 \"abc\" New 0 5 \"<abc> SKIPPED\"\n 2(1) Old 6 9 \"abc\" New 6 11 \"<abc>\"\n 2: abcdef<abc>pqr\n abcdefabcpqr\\=substitute_stop=1\n 1(1) Old 0 3 \"abc\" New 0 5 \"<abc> STOPPED\"\n 1: abcdefabcpqr\n\nIf both are set for the same number, stop takes precedence. Only a single skip\nor stop is supported, which is sufficient for testing that the feature works.\n\n
\nTesting substitute case callouts\n
\n\nIf the substitute_case_callout modifier is set, a substitution\ncase callout function is set up. The callout function is called for each\nsubstituted chunk which is to be case-transformed.\n
\n\nThe callout function passed is a fixed function with implementation for certain\nbehaviours: inputs which shrink when case-transformed; inputs which grow; inputs\nwith distinct upper/lower/titlecase forms. The characters which are not\nspecial-cased for testing purposes are left unmodified, as if they are caseless\ncharacters.\n
\n\nSetting the JIT stack size\n
\n\nThe jitstack modifier provides a way of setting the maximum stack size\nthat is used by the just-in-time optimization code. It is ignored if JIT\noptimization is not being used. The value is a number of kibibytes (units of\n1024 bytes). Setting zero reverts to the default of 32KiB. Providing a stack\nthat is larger than the default is necessary only for very complicated\npatterns. If jitstack is set non-zero on a subject line it overrides any\nvalue that was set on the pattern.\n
\n\nSetting heap, match, and depth limits\n
\n\nThe heap_limit, match_limit, and depth_limit modifiers set\nthe appropriate limits in the match context. These values are ignored when the\nfind_limits or find_limits_noheap modifier is specified.\n
\n\nFinding minimum limits\n
\n\nIf the find_limits modifier is present on a subject line, pcre2test\ncalls the relevant matching function several times, setting different values in\nthe match context via pcre2_set_heap_limit(),\npcre2_set_match_limit(), or pcre2_set_depth_limit() until it finds\nthe smallest value for each parameter that allows the match to complete without\na \"limit exceeded\" error. The match itself may succeed or fail. An alternative\nmodifier, find_limits_noheap, omits the heap limit. This is used in the\nstandard tests, because the minimum heap limit varies between systems. If JIT\nis being used, only the match limit is relevant, and the other two are\nautomatically omitted.\n
\n\nWhen using this modifier, the pattern should not contain any limit settings\nsuch as (*LIMIT_MATCH=...) within it. If such a setting is present and is\nlower than the minimum matching value, the minimum value cannot be found\nbecause pcre2_set_match_limit() etc. are only able to reduce the value of\nan in-pattern limit; they cannot increase it.\n
\n\nFor non-DFA matching, the minimum depth_limit number is a measure of how\nmuch nested backtracking happens (that is, how deeply the pattern's tree is\nsearched). In the case of DFA matching, depth_limit controls the depth of\nrecursive calls of the internal function that is used for handling pattern\nrecursion, lookaround assertions, and atomic groups.\n
\n\nFor non-DFA matching, the match_limit number is a measure of the amount\nof backtracking that takes place, and learning the minimum value can be\ninstructive. For most simple matches, the number is quite small, but for\npatterns with very large numbers of matching possibilities, it can become large\nvery quickly with increasing length of subject string. In the case of DFA\nmatching, match_limit controls the total number of calls, both recursive\nand non-recursive, to the internal matching function, thus controlling the\noverall amount of computing resource that is used.\n
\n\nFor both kinds of matching, the heap_limit number, which is in kibibytes\n(units of 1024 bytes), limits the amount of heap memory used for matching.\n
\n\nShowing MARK names\n
\n\nThe mark modifier causes the names from backtracking control verbs that\nare returned from calls to pcre2_match() to be displayed. If a mark is\nreturned for a match, non-match, or partial match, pcre2test shows it.\nFor a match, it is on a line by itself, tagged with \"MK:\". Otherwise, it\nis added to the non-match message.\n
\n\nShowing memory usage\n
\n\nThe memory modifier causes pcre2test to log the sizes of all heap\nmemory allocation and freeing calls that occur during a call to\npcre2_match() or pcre2_dfa_match(). In the latter case, heap memory\nis used only when a match requires more internal workspace that the default\nallocation on the stack, so in many cases there will be no output. No heap\nmemory is allocated during matching with JIT. For this modifier to work, the\nnull_context modifier must not be set on both the pattern and the\nsubject, though it can be set on one or the other.\n
\n\nShowing the heap frame overall vector size\n
\n\nThe heapframes_size modifier is relevant for matches using\npcre2_match() without JIT. After a match has run (whether successful or\nnot) the size, in bytes, of the allocated heap frames vector that is left\nattached to the match data block is shown. If the matching action involved\nseveral calls to pcre2_match() (for example, global matching or for\ntiming) only the final value is shown.\n
\n\nThis modifier is ignored, with a warning, for POSIX or DFA matching. JIT\nmatching does not use the heap frames vector, so the size is always zero,\nunless there was a previous non-JIT match. Note that specifing a size of zero\nfor the output vector (see below) causes pcre2test to free its match data\nblock (and associated heap frames vector) and allocate a new one.\n
\n\nSetting a starting offset\n
\n\nThe offset modifier sets an offset in the subject string at which\nmatching starts. Its value is a number of code units, not characters.\n
\n\nSetting an offset limit\n
\n\nThe offset_limit modifier sets a limit for unanchored matches. If a match\ncannot be found starting at or before this offset in the subject, a \"no match\"\nreturn is given. The data value is a number of code units, not characters. When\nthis modifier is used, the use_offset_limit modifier must have been set\nfor the pattern; if not, an error is generated.\n
\n\nSetting the size of the output vector\n
\n\nThe ovector modifier applies only to the subject line in which it\nappears, though of course it can also be used to set a default in a\n#subject command. It specifies the number of pairs of offsets that are\navailable for storing matching information. The default is 15.\n
\n\nA value of zero is useful when testing the POSIX API because it causes\nregexec() to be called with a NULL capture vector. When not testing the\nPOSIX API, a value of zero is used to cause\npcre2_match_data_create_from_pattern() to be called, in order to create a\nnew match block of exactly the right size for the pattern. (It is not possible\nto create a match block with a zero-length ovector; there is always at least\none pair of offsets.) The old match data block is freed.\n
\n\nPassing the subject as zero-terminated\n
\n\nBy default, the subject string is passed to a native API matching function with\nits correct length. In order to test the facility for passing a zero-terminated\nstring, the zero_terminate modifier is provided. It causes the length to\nbe passed as PCRE2_ZERO_TERMINATED. When matching via the POSIX interface,\nthis modifier is ignored, with a warning.\n
\n\nWhen testing pcre2_substitute(), this modifier also has the effect of\npassing the replacement string as zero-terminated.\n
\n\nPassing a NULL context, subject, or replacement\n
\n\nNormally, pcre2test passes a context block to pcre2_match(),\npcre2_dfa_match(), pcre2_jit_match() or pcre2_substitute().\nIf the null_context modifier is set, however, NULL is passed. This is for\ntesting that the matching and substitution functions behave correctly in this\ncase (they use default values). This modifier cannot be used with the\nfind_limits, find_limits_noheap, or substitute_callout\nmodifiers.\n
\n\nSimilarly, for testing purposes, if the null_subject or\nnull_replacement modifier is set, the subject or replacement string\npointers are passed as NULL, respectively, to the relevant functions.\n
\nTHE ALTERNATIVE MATCHING FUNCTION
\n\nBy default, pcre2test uses the standard PCRE2 matching function,\npcre2_match() to match each subject line. PCRE2 also supports an\nalternative matching function, pcre2_dfa_match(), which operates in a\ndifferent way, and has some restrictions. The differences between the two\nfunctions are described in the\npcre2matching\ndocumentation.\n
\n\nIf the dfa modifier is set, the alternative matching function is used.\nThis function finds all possible matches at a given point in the subject. If,\nhowever, the dfa_shortest modifier is set, processing stops after the\nfirst match is found. This is always the shortest possible match.\n
\nDEFAULT OUTPUT FROM pcre2test
\n\nThis section describes the output when the normal matching function,\npcre2_match(), is being used.\n
\n\nWhen a match succeeds, pcre2test outputs the list of captured substrings,\nstarting with number 0 for the string that matched the whole pattern.\nOtherwise, it outputs \"No match\" when the return is PCRE2_ERROR_NOMATCH, or\n\"Partial match:\" followed by the partially matching substring when the\nreturn is PCRE2_ERROR_PARTIAL. (Note that this is the\nentire substring that was inspected during the partial match; it may include\ncharacters before the actual match start if a lookbehind assertion, \\K, \\b,\nor \\B was involved.)\n
\n\nFor any other return, pcre2test outputs the PCRE2 negative error number\nand a short descriptive phrase. If the error is a failed UTF string check, the\ncode unit offset of the start of the failing character is also output. Here is\nan example of an interactive pcre2test run.\n
\n $ pcre2test\n PCRE2 version 10.22 2016-07-29\n\n re> /^abc(\\d+)/\n data> abc123\n 0: abc123\n 1: 123\n data> xyz\n No match\n\nUnset capturing substrings that are not followed by one that is set are not\nshown by pcre2test unless the allcaptures modifier is specified. In\nthe following example, there are two capturing substrings, but when the first\ndata line is matched, the second, unset substring is not shown. An \"internal\"\nunset substring is shown as \"<unset>\", as for the second data line.\n
\n re> /(a)|(b)/\n data> a\n 0: a\n 1: a\n data> b\n 0: b\n 1: <unset>\n 2: b\n\nIf the strings contain any non-printing characters, they are output as \\xhh\nescapes if the value is less than 256 and UTF mode is not set. Otherwise they\nare output as \\x{hh...} escapes. See below for the definition of non-printing\ncharacters. If the aftertext modifier is set, the output for substring 0\nis followed by the rest of the subject string, identified by \"0+\" like this:\n
\n re> /cat/aftertext\n data> cataract\n 0: cat\n 0+ aract\n\nIf global matching is requested, the results of successive matching attempts\nare output in sequence, like this:\n
\n re> /\\Bi(\\w\\w)/g\n data> Mississippi\n 0: iss\n 1: ss\n 0: iss\n 1: ss\n 0: ipp\n 1: pp\n\n\"No match\" is output only if the first match attempt fails. Here is an example\nof a failure message (the offset 4 that is specified by the offset\nmodifier is past the end of the subject string):\n
\n re> /xyz/\n data> xyz\\=offset=4\n Error -24 (bad offset value)\n\n\n
\nNote that whereas patterns can be continued over several lines (a plain \">\"\nprompt is used for continuations), subject lines may not. However newlines can\nbe included in a subject by means of the \\n escape (or \\r, \\r\\n, etc.,\ndepending on the newline sequence setting).\n
\nOUTPUT FROM THE ALTERNATIVE MATCHING FUNCTION
\n\nWhen the alternative matching function, pcre2_dfa_match(), is used, the\noutput consists of a list of all the matches that start at the first point in\nthe subject where there is at least one match. For example:\n
\n re> /(tang|tangerine|tan)/\n data> yellow tangerine\\=dfa\n 0: tangerine\n 1: tang\n 2: tan\n\nUsing the normal matching function on this data finds only \"tang\". The\nlongest matching string is always given first (and numbered zero). After a\nPCRE2_ERROR_PARTIAL return, the output is \"Partial match:\", followed by the\npartially matching substring. Note that this is the entire substring that was\ninspected during the partial match; it may include characters before the actual\nmatch start if a lookbehind assertion, \\b, or \\B was involved. (\\K is not\nsupported for DFA matching.)\n\n
\nIf global matching is requested, the search for further matches resumes\nat the end of the longest match. For example:\n
\n re> /(tang|tangerine|tan)/g\n data> yellow tangerine and tangy sultana\\=dfa\n 0: tangerine\n 1: tang\n 2: tan\n 0: tang\n 1: tan\n 0: tan\n\nThe alternative matching function does not support substring capture, so the\nmodifiers that are concerned with captured substrings are not relevant.\n\n
RESTARTING AFTER A PARTIAL MATCH
\n\nWhen the alternative matching function has given the PCRE2_ERROR_PARTIAL\nreturn, indicating that the subject partially matched the pattern, you can\nrestart the match with additional subject data by means of the\ndfa_restart modifier. For example:\n
\n re> /^\\d?\\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\d\\d$/\n data> 23ja\\=ps,dfa\n Partial match: 23ja\n data> n05\\=dfa,dfa_restart\n 0: n05\n\nFor further information about partial matching, see the\npcre2partial\ndocumentation.\n\n
CALLOUTS
\n\nIf the pattern contains any callout requests, pcre2test's callout\nfunction is called during matching unless callout_none is specified. This\nworks with both matching functions, and with JIT, though there are some\ndifferences in behaviour. The output for callouts with numerical arguments and\nthose with string arguments is slightly different.\n
\n\nCallouts with numerical arguments\n
\n\nBy default, the callout function displays the callout number, the start and\ncurrent positions in the subject text at the callout time, and the next pattern\nitem to be tested. For example:\n
\n --->pqrabcdef\n 0 ^ ^ \\d\n\nThis output indicates that callout number 0 occurred for a match attempt\nstarting at the fourth character of the subject string, when the pointer was at\nthe seventh character, and when the next pattern item was \\d. Just\none circumflex is output if the start and current positions are the same, or if\nthe current position precedes the start position, which can happen if the\ncallout is in a lookbehind assertion.\n\n
\nCallouts numbered 255 are assumed to be automatic callouts, inserted as a\nresult of the auto_callout pattern modifier. In this case, instead of\nshowing the callout number, the offset in the pattern, preceded by a plus, is\noutput. For example:\n
\n re> /\\d?[A-E]\\*/auto_callout\n data> E*\n --->E*\n +0 ^ \\d?\n +3 ^ [A-E]\n +8 ^^ \\*\n +10 ^ ^\n 0: E*\n\nIf a pattern contains (*MARK) items, an additional line is output whenever\na change of latest mark is passed to the callout function. For example:\n
\n re> /a(*MARK:X)bc/auto_callout\n data> abc\n --->abc\n +0 ^ a\n +1 ^^ (*MARK:X)\n +10 ^^ b\n Latest Mark: X\n +11 ^ ^ c\n +12 ^ ^\n 0: abc\n\nThe mark changes between matching \"a\" and \"b\", but stays the same for the rest\nof the match, so nothing more is output. If, as a result of backtracking, the\nmark reverts to being unset, the text \"<unset>\" is output.\n\n
\nCallouts with string arguments\n
\n\nThe output for a callout with a string argument is similar, except that instead\nof outputting a callout number before the position indicators, the callout\nstring and its offset in the pattern string are output before the reflection of\nthe subject string, and the subject string is reflected for each callout. For\nexample:\n
\n re> /^ab(?C'first')cd(?C\"second\")ef/\n data> abcdefg\n Callout (7): 'first'\n --->abcdefg\n ^ ^ c\n Callout (20): \"second\"\n --->abcdefg\n ^ ^ e\n 0: abcdef\n\n\n\n
\nCallout modifiers\n
\n\nThe callout function in pcre2test returns zero (carry on matching) by\ndefault, but you can use a callout_fail modifier in a subject line to\nchange this and other parameters of the callout (see below).\n
\n\nIf the callout_capture modifier is set, the current captured groups are\noutput when a callout occurs. This is useful only for non-DFA matching, as\npcre2_dfa_match() does not support capturing, so no captures are ever\nshown.\n
\n\nThe normal callout output, showing the callout number or pattern offset (as\ndescribed above) is suppressed if the callout_no_where modifier is set.\n
\n\nWhen using the interpretive matching function pcre2_match() without JIT,\nsetting the callout_extra modifier causes additional output from\npcre2test's callout function to be generated. For the first callout in a\nmatch attempt at a new starting position in the subject, \"New match attempt\" is\noutput. If there has been a backtrack since the last callout (or start of\nmatching if this is the first callout), \"Backtrack\" is output, followed by \"No\nother matching paths\" if the backtrack ended the previous match attempt. For\nexample:\n
\n re> /(a+)b/auto_callout,no_start_optimize,no_auto_possess\n data> aac\\=callout_extra\n New match attempt\n --->aac\n +0 ^ (\n +1 ^ a+\n +3 ^ ^ )\n +4 ^ ^ b\n Backtrack\n --->aac\n +3 ^^ )\n +4 ^^ b\n Backtrack\n No other matching paths\n New match attempt\n --->aac\n +0 ^ (\n +1 ^ a+\n +3 ^^ )\n +4 ^^ b\n Backtrack\n No other matching paths\n New match attempt\n --->aac\n +0 ^ (\n +1 ^ a+\n Backtrack\n No other matching paths\n New match attempt\n --->aac\n +0 ^ (\n +1 ^ a+\n No match\n\nNotice that various optimizations must be turned off if you want all possible\nmatching paths to be scanned. If no_start_optimize is not used, there is\nan immediate \"no match\", without any callouts, because the starting\noptimization fails to find \"b\" in the subject, which it knows must be present\nfor any match. If no_auto_possess is not used, the \"a+\" item is turned\ninto \"a++\", which reduces the number of backtracks.\n\n
\nThe callout_extra modifier has no effect if used with the DFA matching\nfunction, or with JIT.\n
\n\nReturn values from callouts\n
\n\nThe default return from the callout function is zero, which allows matching to\ncontinue. The callout_fail modifier can be given one or two numbers. If\nthere is only one number, 1 is returned instead of 0 (causing matching to\nbacktrack) when a callout of that number is reached. If two numbers (<n>:<m>)\nare given, 1 is returned when callout <n> is reached and there have been at\nleast <m> callouts. The callout_error modifier is similar, except that\nPCRE2_ERROR_CALLOUT is returned, causing the entire matching process to be\naborted. If both these modifiers are set for the same callout number,\ncallout_error takes precedence. Note that callouts with string arguments\nare always given the number zero.\n
\n\nThe callout_data modifier can be given an unsigned or a negative number.\nThis is set as the \"user data\" that is passed to the matching function, and\npassed back when the callout function is invoked. Any value other than zero is\nused as a return from pcre2test's callout function.\n
\n\nInserting callouts can be helpful when using pcre2test to check\ncomplicated regular expressions. For further information about callouts, see\nthe\npcre2callout\ndocumentation.\n
\nNON-PRINTING CHARACTERS
\n\nWhen pcre2test is outputting text in the compiled version of a pattern,\nbytes other than 32-126 are always treated as non-printing characters and are\ntherefore shown as hex escapes.\n
\n\nWhen pcre2test is outputting text that is a matched part of a subject\nstring, it behaves in the same way, unless a different locale has been set for\nthe pattern (using the locale modifier). In this case, the\nisprint() function is used to distinguish printing and non-printing\ncharacters.\n
\nSAVING AND RESTORING COMPILED PATTERNS
\n\nIt is possible to save compiled patterns on disc or elsewhere, and reload them\nlater, subject to a number of restrictions. JIT data cannot be saved. The host\non which the patterns are reloaded must be running the same version of PCRE2,\nwith the same code unit width, and must also have the same endianness, pointer\nwidth and PCRE2_SIZE type. Before compiled patterns can be saved they must be\nserialized, that is, converted to a stream of bytes. A single byte stream may\ncontain any number of compiled patterns, but they must all use the same\ncharacter tables. A single copy of the tables is included in the byte stream\n(its size is 1088 bytes).\n
\n\nThe functions whose names begin with pcre2_serialize_ are used\nfor serializing and de-serializing. They are described in the\npcre2serialize\ndocumentation. In this section we describe the features of pcre2test that\ncan be used to test these functions.\n
\n\nNote that \"serialization\" in PCRE2 does not convert compiled patterns to an\nabstract format like Java or .NET. It just makes a reloadable byte code stream.\nHence the restrictions on reloading mentioned above.\n
\n\nIn pcre2test, when a pattern with push modifier is successfully\ncompiled, it is pushed onto a stack of compiled patterns, and pcre2test\nexpects the next line to contain a new pattern (or command) instead of a\nsubject line. By contrast, the pushcopy modifier causes a copy of the\ncompiled pattern to be stacked, leaving the original available for immediate\nmatching. By using push and/or pushcopy, a number of patterns can\nbe compiled and retained. These modifiers are incompatible with posix,\nand control modifiers that act at match time are ignored (with a message) for\nthe stacked patterns. The jitverify modifier applies only at compile\ntime.\n
\n\nThe command\n
\n #save <filename>\n\ncauses all the stacked patterns to be serialized and the result written to the\nnamed file. Afterwards, all the stacked patterns are freed. The command\n
\n #load <filename>\n\nreads the data in the file, and then arranges for it to be de-serialized, with\nthe resulting compiled patterns added to the pattern stack. The pattern on the\ntop of the stack can be retrieved by the #pop command, which must be followed\nby lines of subjects that are to be matched with the pattern, terminated as\nusual by an empty line or end of file. This command may be followed by a\nmodifier list containing only\ncontrol modifiers\nthat act after a pattern has been compiled. In particular, hex,\nposix, posix_nosub, push, and pushcopy are not allowed,\nnor are any\noption-setting modifiers.\nThe JIT modifiers are, however permitted. Here is an example that saves and\nreloads two patterns.\n
\n /abc/push\n /xyz/push\n #save tempfile\n #load tempfile\n #pop info\n xyz\n\n #pop jit,bincode\n abc\n\nIf jitverify is used with #pop, it does not automatically imply\njit, which is different behaviour from when it is used on a pattern.\n\n
\nThe #popcopy command is analogous to the pushcopy modifier in that it\nmakes current a copy of the topmost stack pattern, leaving the original still\non the stack.\n
\nSEE ALSO
\n\npcre2(3), pcre2api(3), pcre2callout(3),\npcre2jit, pcre2matching(3), pcre2partial(d),\npcre2pattern(3), pcre2serialize(3).\n
\nAUTHOR
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
REVISION
\n\nLast updated: 12 October 2025\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/html/pcre2unicode.html", "content": "\n\npcre2unicode man page
\n\nReturn to the PCRE2 index page.\n
\n\nThis page is part of the PCRE2 HTML documentation. It was generated\nautomatically from the original man page. If there is any nonsense in it,\nplease consult the man page, in case the conversion went wrong.\n
\n
\nUNICODE AND UTF SUPPORT\n
\n\nPCRE2 is normally built with Unicode support, though if you do not need it, you\ncan build it without, in which case the library will be smaller. With Unicode\nsupport, PCRE2 has knowledge of Unicode character properties and can process\nstrings of text in UTF-8, UTF-16, and UTF-32 format (depending on the code unit\nwidth), but this is not the default. Unless specifically requested, PCRE2\ntreats each code unit in a string as one character.\n
\n\nThere are two ways of telling PCRE2 to switch to UTF mode, where characters may\nconsist of more than one code unit and the range of values is constrained. The\nprogram can call\npcre2_compile()\nwith the PCRE2_UTF option, or the pattern may start with the sequence (*UTF).\nHowever, the latter facility can be locked out by the PCRE2_NEVER_UTF option.\nThat is, the programmer can prevent the supplier of the pattern from switching\nto UTF mode.\n
\n\nNote that the PCRE2_MATCH_INVALID_UTF option (see\nbelow)\nforces PCRE2_UTF to be set.\n
\n\nIn UTF mode, both the pattern and any subject strings that are matched against\nit are treated as UTF strings instead of strings of individual one-code-unit\ncharacters. There are also some other changes to the way characters are\nhandled, as documented below.\n
\n\nUNICODE PROPERTY SUPPORT\n
\n\nWhen PCRE2 is built with Unicode support, the escape sequences \\p{..},\n\\P{..}, and \\X can be used. This is not dependent on the PCRE2_UTF setting.\nThe Unicode properties that can be tested are a subset of those that Perl\nsupports. Currently they are limited to the general category properties such as\nLu for an upper case letter or Nd for a decimal number, the derived properties\nAny and Lc (synonym L&), the Unicode script names such as Arabic or Han,\nBidi_Class, Bidi_Control, and a few binary properties.\n
\n\nThe full lists are given in the\npcre2pattern\nand\npcre2syntax\ndocumentation. In general, only the short names for properties are supported.\nFor example, \\p{L} matches a letter. Its longer synonym, \\p{Letter}, is not\nsupported. Furthermore, in Perl, many properties may optionally be prefixed by\n\"Is\", for compatibility with Perl 5.6. PCRE2 does not support this.\n
\n\nWIDE CHARACTERS AND UTF MODES\n
\n\nCode points less than 256 can be specified in patterns by either braced or\nunbraced hexadecimal escape sequences (for example, \\x{b3} or \\xb3). Larger\nvalues have to use braced sequences. Unbraced octal code points up to \\777 are\nalso recognized; larger ones can be coded using \\o{...}.\n
\n\nThe escape sequence \\N{U+<hex digits>} is recognized as another way of\nspecifying a Unicode character by code point in a UTF mode. It is not allowed\nin non-UTF mode.\n
\n\nIn UTF mode, repeat quantifiers apply to complete UTF characters, not to\nindividual code units.\n
\n\nIn UTF mode, the dot metacharacter matches one UTF character instead of a\nsingle code unit.\n
\n\nIn UTF mode, capture group names are not restricted to ASCII, and may contain\nany Unicode letters and decimal digits, as well as underscore.\n
\n\nThe escape sequence \\C can be used to match a single code unit in UTF mode,\nbut its use can lead to some strange effects because it breaks up multi-unit\ncharacters (see the description of \\C in the\npcre2pattern\ndocumentation). For this reason, there is a build-time option that disables\nsupport for \\C completely. There is also a less draconian compile-time option\nfor locking out the use of \\C when a pattern is compiled.\n
\n\nThe use of \\C is not supported by the alternative matching function\npcre2_dfa_match() when in UTF-8 or UTF-16 mode, that is, when a character\nmay consist of more than one code unit. The use of \\C in these modes provokes\na match-time error. Also, the JIT optimization does not support \\C in these\nmodes. If JIT optimization is requested for a UTF-8 or UTF-16 pattern that\ncontains \\C, it will not succeed, and so when pcre2_match() is called,\nthe matching will be carried out by the interpretive function.\n
\n\nThe character escapes \\b, \\B, \\d, \\D, \\s, \\S, \\w, and \\W correctly test\ncharacters of any code value, but, by default, the characters that PCRE2\nrecognizes as digits, spaces, or word characters remain the same set as in\nnon-UTF mode, all with code points less than 256. This remains true even when\nPCRE2 is built to include Unicode support, because to do otherwise would slow\ndown matching in many common cases. Note that this also applies to \\b\nand \\B, because they are defined in terms of \\w and \\W. If you want\nto test for a wider sense of, say, \"digit\", you can use explicit Unicode\nproperty tests such as \\p{Nd}. Alternatively, if you set the PCRE2_UCP option,\nthe way that the character escapes work is changed so that Unicode properties\nare used to determine which characters match, though there are some options\nthat suppress this for individual escapes. For details see the section on\ngeneric character types\nin the\npcre2pattern\ndocumentation.\n
\n\nLike the escapes, characters that match the POSIX named character classes are\nall low-valued characters unless the PCRE2_UCP option is set, but there is an\noption to override this.\n
\n\nIn contrast to the character escapes and character classes, the special\nhorizontal and vertical white space escapes (\\h, \\H, \\v, and \\V) do match\nall the appropriate Unicode characters, whether or not PCRE2_UCP is set.\n
\n\nUNICODE CASE-EQUIVALENCE\n
\n\nIf either PCRE2_UTF or PCRE2_UCP is set, upper/lower case processing makes use\nof Unicode properties except for characters whose code points are less than 128\nand that have at most two case-equivalent values. For these, a direct table\nlookup is used for speed. A few Unicode characters such as Greek sigma have\nmore than two code points that are case-equivalent, and these are treated\nspecially. Setting PCRE2_UCP without PCRE2_UTF allows Unicode-style case\nprocessing for non-UTF character encodings such as UCS-2.\n
\n\nThere are two ASCII characters (S and K) that, in addition to their ASCII lower\ncase equivalents, have a non-ASCII one as well (long S and Kelvin sign).\nRecognition of these non-ASCII characters as case-equivalent to their ASCII\ncounterparts can be disabled by setting the PCRE2_EXTRA_CASELESS_RESTRICT\noption. When this is set, all characters in a case equivalence must either be\nASCII or non-ASCII; there can be no mixing.\n
\n Without PCRE2_EXTRA_CASELESS_RESTRICT:\n 'k' = 'K' = U+212A (Kelvin sign)\n 's' = 'S' = U+017F (long S)\n With PCRE2_EXTRA_CASELESS_RESTRICT:\n 'k' = 'K'\n U+212A (Kelvin sign) only case-equivalent to itself\n 's' = 'S'\n U+017F (long S) only case-equivalent to itself\n\n\n
\nOne language family, Turkish and Azeri, has its own case-insensitivity rules,\nwhich can be selected by setting PCRE2_EXTRA_TURKISH_CASING. This alters the\nbehaviour of the 'i', 'I', U+0130 (capital I with dot above), and U+0131\n(small dotless i) characters.\n
\n Without PCRE2_EXTRA_TURKISH_CASING:\n 'i' = 'I'\n U+0130 (capital I with dot above) only case-equivalent to itself\n U+0131 (small dotless i) only case-equivalent to itself\n With PCRE2_EXTRA_TURKISH_CASING:\n 'i' = U+0130 (capital I with dot above)\n U+0131 (small dotless i) = 'I'\n\n\n
\nIt is not allowed to specify both PCRE2_EXTRA_CASELESS_RESTRICT and\nPCRE2_EXTRA_TURKISH_CASING together.\n
\n\nFrom release 10.45 the Unicode letter properties Lu (upper case), Ll (lower\ncase), and Lt (title case) are all treated as Lc (cased letter) when caseless\nmatching is set by the PCRE2_CASELESS option or (?i) within the pattern.\n
\n\nSCRIPT RUNS\n
\n\nThe pattern constructs (*script_run:...) and (*atomic_script_run:...), with\nsynonyms (*sr:...) and (*asr:...), verify that the string matched within the\nparentheses is a script run. In concept, a script run is a sequence of\ncharacters that are all from the same Unicode script. However, because some\nscripts are commonly used together, and because some diacritical and other\nmarks are used with multiple scripts, it is not that simple.\n
\n\nEvery Unicode character has a Script property, mostly with a value\ncorresponding to the name of a script, such as Latin, Greek, or Cyrillic. There\nare also three special values:\n
\n\n\"Unknown\" is used for code points that have not been assigned, and also for the\nsurrogate code points. In the PCRE2 32-bit library, characters whose code\npoints are greater than the Unicode maximum (U+10FFFF), which are accessible\nonly in non-UTF mode, are assigned the Unknown script.\n
\n\n\"Common\" is used for characters that are used with many scripts. These include\npunctuation, emoji, mathematical, musical, and currency symbols, and the ASCII\ndigits 0 to 9.\n
\n\n\"Inherited\" is used for characters such as diacritical marks that modify a\nprevious character. These are considered to take on the script of the character\nthat they modify.\n
\n\nSome Inherited characters are used with many scripts, but many of them are only\nnormally used with a small number of scripts. For example, U+102E0 (Coptic\nEpact thousands mark) is used only with Arabic and Coptic. In order to make it\npossible to check this, a Unicode property called Script Extension exists. Its\nvalue is a list of scripts that apply to the character. For the majority of\ncharacters, the list contains just one script, the same one as the Script\nproperty. However, for characters such as U+102E0 more than one Script is\nlisted. There are also some Common characters that have a single, non-Common\nscript in their Script Extension list.\n
\n\nThe next section describes the basic rules for deciding whether a given string\nof characters is a script run. Note, however, that there are some special cases\ninvolving the Chinese Han script, and an additional constraint for decimal\ndigits. These are covered in subsequent sections.\n
\n\nBasic script run rules\n
\n\nA string that is less than two characters long is a script run. This is the\nonly case in which an Unknown character can be part of a script run. Longer\nstrings are checked using only the Script Extensions property, not the basic\nScript property.\n
\n\nIf a character's Script Extension property is the single value \"Inherited\", it\nis always accepted as part of a script run. This is also true for the property\n\"Common\", subject to the checking of decimal digits described below. All the\nremaining characters in a script run must have at least one script in common in\ntheir Script Extension lists. In set-theoretic terminology, the intersection of\nall the sets of scripts must not be empty.\n
\n\nA simple example is an Internet name such as \"google.com\". The letters are all\nin the Latin script, and the dot is Common, so this string is a script run.\nHowever, the Cyrillic letter \"o\" looks exactly the same as the Latin \"o\"; a\nstring that looks the same, but with Cyrillic \"o\"s is not a script run.\n
\n\nMore interesting examples involve characters with more than one script in their\nScript Extension. Consider the following characters:\n
\n U+060C Arabic comma\n U+06D4 Arabic full stop\n\nThe first has the Script Extension list Arabic, Hanifi Rohingya, Syriac, and\nThaana; the second has just Arabic and Hanifi Rohingya. Both of them could\nappear in script runs of either Arabic or Hanifi Rohingya. The first could also\nappear in Syriac or Thaana script runs, but the second could not.\n\n
\nThe Chinese Han script\n
\n\nThe Chinese Han script is commonly used in conjunction with other scripts for\nwriting certain languages. Japanese uses the Hiragana and Katakana scripts\ntogether with Han; Korean uses Hangul and Han; Taiwanese Mandarin uses Bopomofo\nand Han. These three combinations are treated as special cases when checking\nscript runs and are, in effect, \"virtual scripts\". Thus, a script run may\ncontain a mixture of Hiragana, Katakana, and Han, or a mixture of Hangul and\nHan, or a mixture of Bopomofo and Han, but not, for example, a mixture of\nHangul and Bopomofo and Han. PCRE2 (like Perl) follows Unicode's Technical\nStandard 39 (\"Unicode Security Mechanisms\", http://unicode.org/reports/tr39/)\nin allowing such mixtures.\n
\n\nDecimal digits\n
\n\nUnicode contains many sets of 10 decimal digits in different scripts, and some\nscripts (including the Common script) contain more than one set. Some of these\ndecimal digits them are visually indistinguishable from the common ASCII\ndigits. In addition to the script checking described above, if a script run\ncontains any decimal digits, they must all come from the same set of 10\nadjacent characters.\n
\n\nVALIDITY OF UTF STRINGS\n
\n\nWhen the PCRE2_UTF option is set, the strings passed as patterns and subjects\nare (by default) checked for validity on entry to the relevant functions. If an\ninvalid UTF string is passed, a negative error code is returned. The code unit\noffset to the offending character can be extracted from the match data block by\ncalling pcre2_get_startchar(), which is used for this purpose after a UTF\nerror.\n
\n\nIn some situations, you may already know that your strings are valid, and\ntherefore want to skip these checks in order to improve performance, for\nexample in the case of a long subject string that is being scanned repeatedly.\nIf you set the PCRE2_NO_UTF_CHECK option at compile time or at match time,\nPCRE2 assumes that the pattern or subject it is given (respectively) contains\nonly valid UTF code unit sequences.\n
\n\nIf you pass an invalid UTF string when PCRE2_NO_UTF_CHECK is set, the result\nis undefined and your program may crash or loop indefinitely or give incorrect\nresults. There is, however, one mode of matching that can handle invalid UTF\nsubject strings. This is enabled by passing PCRE2_MATCH_INVALID_UTF to\npcre2_compile() and is discussed below in the next section. The rest of\nthis section covers the case when PCRE2_MATCH_INVALID_UTF is not set.\n
\n\nPassing PCRE2_NO_UTF_CHECK to pcre2_compile() just disables the UTF check\nfor the pattern; it does not also apply to subject strings. If you want to\ndisable the check for a subject string you must pass this same option to\npcre2_match() or pcre2_dfa_match().\n
\n\nUTF-16 and UTF-32 strings can indicate their endianness by special code knows\nas a byte-order mark (BOM). The PCRE2 functions do not handle this, expecting\nstrings to be in host byte order.\n
\n\nUnless PCRE2_NO_UTF_CHECK is set, a UTF string is checked before any other\nprocessing takes place. In the case of pcre2_match() and\npcre2_dfa_match() calls with a non-zero starting offset, the check is\napplied only to that part of the subject that could be inspected during\nmatching, and there is a check that the starting offset points to the first\ncode unit of a character or to the end of the subject. If there are no\nlookbehind assertions in the pattern, the check starts at the starting offset.\nOtherwise, it starts at the length of the longest lookbehind before the\nstarting offset, or at the start of the subject if there are not that many\ncharacters before the starting offset. Note that the sequences \\b and \\B are\none-character lookbehinds.\n
\n\nIn addition to checking the format of the string, there is a check to ensure\nthat all code points lie in the range U+0 to U+10FFFF, excluding the surrogate\narea. The so-called \"non-character\" code points are not excluded because\nUnicode corrigendum #9 makes it clear that they should not be.\n
\n\nCharacters in the \"Surrogate Area\" of Unicode are reserved for use by UTF-16,\nwhere they are used in pairs to encode code points with values greater than\n0xFFFF. The code points that are encoded by UTF-16 pairs are available\nindependently in the UTF-8 and UTF-32 encodings. (In other words, the whole\nsurrogate thing is a fudge for UTF-16 which unfortunately messes up UTF-8 and\nUTF-32.)\n
\n\nSetting PCRE2_NO_UTF_CHECK at compile time does not disable the error that is\ngiven if an escape sequence for an invalid Unicode code point is encountered in\nthe pattern. If you want to allow escape sequences such as \\x{d800} (a\nsurrogate code point) you can set the PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES extra\noption. However, this is possible only in UTF-8 and UTF-32 modes, because these\nvalues are not representable in UTF-16.\n
\n\nErrors in UTF-8 strings\n
\n\nThe following negative error codes are given for invalid UTF-8 strings:\n
\n PCRE2_ERROR_UTF8_ERR1\n PCRE2_ERROR_UTF8_ERR2\n PCRE2_ERROR_UTF8_ERR3\n PCRE2_ERROR_UTF8_ERR4\n PCRE2_ERROR_UTF8_ERR5\n\nThe string ends with a truncated UTF-8 character; the code specifies how many\nbytes are missing (1 to 5). Although RFC 3629 restricts UTF-8 characters to be\nno longer than 4 bytes, the encoding scheme (originally defined by RFC 2279)\nallows for up to 6 bytes, and this is checked first; hence the possibility of\n4 or 5 missing bytes.\n
\n PCRE2_ERROR_UTF8_ERR6\n PCRE2_ERROR_UTF8_ERR7\n PCRE2_ERROR_UTF8_ERR8\n PCRE2_ERROR_UTF8_ERR9\n PCRE2_ERROR_UTF8_ERR10\n\nThe two most significant bits of the 2nd, 3rd, 4th, 5th, or 6th byte of the\ncharacter do not have the binary value 0b10 (that is, either the most\nsignificant bit is 0, or the next bit is 1).\n
\n PCRE2_ERROR_UTF8_ERR11\n PCRE2_ERROR_UTF8_ERR12\n\nA character that is valid by the RFC 2279 rules is either 5 or 6 bytes long;\nthese code points are excluded by RFC 3629.\n
\n PCRE2_ERROR_UTF8_ERR13\n\nA 4-byte character has a value greater than 0x10ffff; these code points are\nexcluded by RFC 3629.\n
\n PCRE2_ERROR_UTF8_ERR14\n\nA 3-byte character has a value in the range 0xd800 to 0xdfff; this range of\ncode points are reserved by RFC 3629 for use with UTF-16, and so are excluded\nfrom UTF-8.\n
\n PCRE2_ERROR_UTF8_ERR15\n PCRE2_ERROR_UTF8_ERR16\n PCRE2_ERROR_UTF8_ERR17\n PCRE2_ERROR_UTF8_ERR18\n PCRE2_ERROR_UTF8_ERR19\n\nA 2-, 3-, 4-, 5-, or 6-byte character is \"overlong\", that is, it codes for a\nvalue that can be represented by fewer bytes, which is invalid. For example,\nthe two bytes 0xc0, 0xae give the value 0x2e, whose correct coding uses just\none byte.\n
\n PCRE2_ERROR_UTF8_ERR20\n\nThe two most significant bits of the first byte of a character have the binary\nvalue 0b10 (that is, the most significant bit is 1 and the second is 0). Such a\nbyte can only validly occur as the second or subsequent byte of a multi-byte\ncharacter.\n
\n PCRE2_ERROR_UTF8_ERR21\n\nThe first byte of a character has the value 0xfe or 0xff. These values can\nnever occur in a valid UTF-8 string.\n\n
\nErrors in UTF-16 strings\n
\n\nThe following negative error codes are given for invalid UTF-16 strings:\n
\n PCRE2_ERROR_UTF16_ERR1 Missing low surrogate at end of string\n PCRE2_ERROR_UTF16_ERR2 Invalid low surrogate follows high surrogate\n PCRE2_ERROR_UTF16_ERR3 Isolated low surrogate\n\n\n\n
\nErrors in UTF-32 strings\n
\n\nThe following negative error codes are given for invalid UTF-32 strings:\n
\n PCRE2_ERROR_UTF32_ERR1 Surrogate character (0xd800 to 0xdfff)\n PCRE2_ERROR_UTF32_ERR2 Code point is greater than 0x10ffff\n\n\n\n
\nMATCHING IN INVALID UTF STRINGS\n
\n\nYou can run pattern matches on subject strings that may contain invalid UTF\nsequences if you call pcre2_compile() with the PCRE2_MATCH_INVALID_UTF\noption. This is supported by pcre2_match(), including JIT matching, but\nnot by pcre2_dfa_match(). When PCRE2_MATCH_INVALID_UTF is set, it forces\nPCRE2_UTF to be set as well. Note, however, that the pattern itself must be a\nvalid UTF string.\n
\n\nIf you do not set PCRE2_MATCH_INVALID_UTF when calling pcre2_compile, and\nyou are not certain that your subject strings are valid UTF sequences, you\nshould not make use of the JIT \"fast path\" function pcre2_jit_match()\nbecause it bypasses sanity checks, including the one for UTF validity. An\ninvalid string may cause undefined behaviour, including looping, crashing, or\ngiving the wrong answer.\n
\n\nSetting PCRE2_MATCH_INVALID_UTF does not affect what pcre2_compile()\ngenerates, but if pcre2_jit_compile() is subsequently called, it does\ngenerate different code. If JIT is not used, the option affects the behaviour\nof the interpretive code in pcre2_match(). When PCRE2_MATCH_INVALID_UTF\nis set at compile time, PCRE2_NO_UTF_CHECK is ignored at match time.\n
\n\nIn this mode, an invalid code unit sequence in the subject never matches any\npattern item. It does not match dot, it does not match \\p{Any}, it does not\neven match negative items such as [^X]. A lookbehind assertion fails if it\nencounters an invalid sequence while moving the current point backwards. In\nother words, an invalid UTF code unit sequence acts as a barrier which no match\ncan cross.\n
\n\nYou can also think of this as the subject being split up into fragments of\nvalid UTF, delimited internally by invalid code unit sequences. The pattern is\nmatched fragment by fragment. The result of a successful match, however, is\ngiven as code unit offsets in the entire subject string in the usual way. There\nare a few points to consider:\n
\n\nThe internal boundaries are not interpreted as the beginnings or ends of lines\nand so do not match circumflex or dollar characters in the pattern.\n
\n\nIf pcre2_match() is called with an offset that points to an invalid\nUTF-sequence, that sequence is skipped, and the match starts at the next valid\nUTF character, or the end of the subject.\n
\n\nAt internal fragment boundaries, \\b and \\B behave in the same way as at the\nbeginning and end of the subject. For example, a sequence such as \\bWORD\\b\nwould match an instance of WORD that is surrounded by invalid UTF code units.\n
\n\nUsing PCRE2_MATCH_INVALID_UTF, an application can run matches on arbitrary\ndata, knowing that any matched strings that are returned are valid UTF. This\ncan be useful when searching for UTF text in executable or other binary files.\n
\n\nNote, however, that the 16-bit and 32-bit PCRE2 libraries process strings as\nsequences of uint16_t or uint32_t code points. They cannot find valid UTF\nsequences within an arbitrary string of bytes unless such sequences are\nsuitably aligned.\n
\n\nAUTHOR\n
\n\nPhilip Hazel\n
\nRetired from University Computing Service\n
\nCambridge, England.\n
\n
\nREVISION\n
\n\nLast updated: 27 November 2024\n
\nCopyright © 1997-2024 University of Cambridge.\n
\n
\nReturn to the PCRE2 index page.\n
\n" }, { "path": "doc/index.html.src", "content": "\n\n\nPerl-compatible Regular Expressions (revised API: PCRE2)
\n\nThe HTML documentation for PCRE2 consists of a number of pages that are listed\nbelow in alphabetical order. If you are new to PCRE2, please read the first one\nfirst.\n
\n\n| pcre2 | \nIntroductory page |
| pcre2-config | \nInformation about the installation configuration |
| pcre2api | \nPCRE2's native API |
| pcre2build | \nBuilding PCRE2 |
| pcre2callout | \nThe callout facility |
| pcre2compat | \nCompability with Perl |
| pcre2convert | \nExperimental foreign pattern conversion functions |
| pcre2demo | \nA demonstration C program that uses the PCRE2 library |
| pcre2grep | \nThe pcre2grep command |
| pcre2jit | \nDiscussion of the just-in-time optimization support |
| pcre2limits | \nDetails of size and other limits |
| pcre2matching | \nDiscussion of the two matching algorithms |
| pcre2partial | \nUsing PCRE2 for partial matching |
| pcre2pattern | \nSpecification of the regular expressions supported by PCRE2 |
| pcre2perform | \nSome comments on performance |
| pcre2posix | \nThe POSIX API to the PCRE2 8-bit library |
| pcre2sample | \nDiscussion of the pcre2demo program |
| pcre2serialize | \nSerializing functions for saving precompiled patterns |
| pcre2syntax | \nSyntax quick-reference summary |
| pcre2test | \nThe pcre2test command for testing PCRE2 |
| pcre2unicode | \nDiscussion of Unicode and UTF-8/UTF-16/UTF-32 support |
\nThere are also individual pages that summarize the interface for each function\nin the library.\n
\n\n| pcre2_callout_enumerate | \nEnumerate callouts in a compiled pattern |
| pcre2_code_copy | \nCopy a compiled pattern |
| pcre2_code_copy_with_tables | \nCopy a compiled pattern and its character tables |
| pcre2_code_free | \nFree a compiled pattern |
| pcre2_compile | \nCompile a regular expression pattern |
| pcre2_compile_context_copy | \nCopy a compile context |
| pcre2_compile_context_create | \nCreate a compile context |
| pcre2_compile_context_free | \nFree a compile context |
| pcre2_config | \nShow build-time related configuration options |
| pcre2_convert_context_copy | \nCopy a convert context |
| pcre2_convert_context_create | \nCreate a convert context |
| pcre2_convert_context_free | \nFree a convert context |
| pcre2_converted_pattern_free | \nFree converted foreign pattern |
| pcre2_dfa_match | \nMatch a compiled pattern to a subject string\n (DFA algorithm; not Perl compatible) |
| pcre2_general_context_copy | \nCopy a general context |
| pcre2_general_context_create | \nCreate a general context |
| pcre2_general_context_free | \nFree a general context |
| pcre2_get_error_message | \nGet textual error message for error number |
| pcre2_get_mark | \nGet a (*MARK) name |
| pcre2_get_match_data_size | \nGet the size of a match data block |
| pcre2_get_ovector_count | \nGet the ovector count |
| pcre2_get_ovector_pointer | \nGet a pointer to the ovector |
| pcre2_get_startchar | \nGet the starting character offset |
| pcre2_jit_compile | \nProcess a compiled pattern with the JIT compiler |
| pcre2_jit_free_unused_memory | \nFree unused JIT memory |
| pcre2_jit_match | \nFast path interface to JIT matching |
| pcre2_jit_stack_assign | \nAssign stack for JIT matching |
| pcre2_jit_stack_create | \nCreate a stack for JIT matching |
| pcre2_jit_stack_free | \nFree a JIT matching stack |
| pcre2_maketables | \nBuild character tables in current locale |
| pcre2_maketables_free | \nFree character tables |
| pcre2_match | \nMatch a compiled pattern to a subject string\n (Perl compatible) |
| pcre2_match_context_copy | \nCopy a match context |
| pcre2_match_context_create | \nCreate a match context |
| pcre2_match_context_free | \nFree a match context |
| pcre2_match_data_create | \nCreate a match data block |
| pcre2_match_data_create_from_pattern | \nCreate a match data block getting size from pattern |
| pcre2_match_data_free | \nFree a match data block |
| pcre2_next_match | \nGet the match parameters for the next match |
| pcre2_pattern_convert | \nExperimental foreign pattern converter |
| pcre2_pattern_info | \nExtract information about a pattern |
| pcre2_serialize_decode | \nDecode serialized compiled patterns |
| pcre2_serialize_encode | \nSerialize compiled patterns for save/restore |
| pcre2_serialize_free | \nFree serialized compiled patterns |
| pcre2_serialize_get_number_of_codes | \nGet number of serialized compiled patterns |
| pcre2_set_bsr | \nSet \\R convention |
| pcre2_set_callout | \nSet up a callout function |
| pcre2_set_character_tables | \nSet character tables |
| pcre2_set_compile_extra_options | \nSet compile time extra options |
| pcre2_set_compile_recursion_guard | \nSet up a compile recursion guard function |
| pcre2_set_depth_limit | \nSet the match backtracking depth limit |
| pcre2_set_glob_escape | \nSet glob escape character |
| pcre2_set_glob_separator | \nSet glob separator character |
| pcre2_set_heap_limit | \nSet the match backtracking heap limit |
| pcre2_set_match_limit | \nSet the match limit |
| pcre2_set_max_pattern_compiled_length | \nSet the maximum length of a compiled pattern |
| pcre2_set_max_pattern_length | \nSet the maximum length of a pattern |
| pcre2_set_max_varlookbehind | \nSet the maximum match length for a variable-length lookbehind |
| pcre2_set_newline | \nSet the newline convention |
| pcre2_set_offset_limit | \nSet the offset limit |
| pcre2_set_optimize | \nSet an optimization directive |
| pcre2_set_parens_nest_limit | \nSet the parentheses nesting limit |
| pcre2_set_recursion_limit | \nObsolete: use pcre2_set_depth_limit |
| pcre2_set_recursion_memory_management | \nObsolete function that (from 10.30 onwards) does nothing |
| pcre2_set_substitute_callout | \nSet a substitution callout function |
| pcre2_set_substitute_case_callout | \nSet a substitution case callout function |
| pcre2_substitute | \nMatch a compiled pattern to a subject string and do\n substitutions |
| pcre2_substring_copy_byname | \nExtract named substring into given buffer |
| pcre2_substring_copy_bynumber | \nExtract numbered substring into given buffer |
| pcre2_substring_free | \nFree extracted substring |
| pcre2_substring_get_byname | \nExtract named substring into new memory |
| pcre2_substring_get_bynumber | \nExtract numbered substring into new memory |
| pcre2_substring_length_byname | \nFind length of named substring |
| pcre2_substring_length_bynumber | \nFind length of numbered substring |
| pcre2_substring_list_free | \nFree list of extracted substrings |
| pcre2_substring_list_get | \nExtract all substrings into new memory |
| pcre2_substring_nametable_scan | \nFind table entries for given string name |
| pcre2_substring_number_from_name | \nConvert captured string name to number |