"Fossies" - the Fresh Open Source Software Archive

Member "pcre-8.42/doc/pcre.txt" (20 Mar 2018, 508585 Bytes) of package /linux/misc/pcre-8.42.tar.bz2:

As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "pcre.txt": 8.40_vs_8.41.

    1 -----------------------------------------------------------------------------
    2 This file contains a concatenation of the PCRE man pages, converted to plain
    3 text format for ease of searching with a text editor, or for use on systems
    4 that do not have a man page processor. The small individual files that give
    5 synopses of each function in the library have not been included. Neither has
    6 the pcredemo program. There are separate text files for the pcregrep and
    7 pcretest commands.
    8 -----------------------------------------------------------------------------
   11 PCRE(3)                    Library Functions Manual                    PCRE(3)
   15 NAME
   16        PCRE - Perl-compatible regular expressions (original API)
   20        This  document relates to PCRE releases that use the original API, with
   21        library names libpcre, libpcre16, and libpcre32. January 2015  saw  the
   22        first release of a new API, known as PCRE2, with release numbers start-
   23        ing  at  10.00  and  library   names   libpcre2-8,   libpcre2-16,   and
   24        libpcre2-32. The old libraries (now called PCRE1) are still being main-
   25        tained for bug fixes,  but  there  will  be  no  new  development.  New
   26        projects are advised to use the new PCRE2 libraries.
   31        The  PCRE  library is a set of functions that implement regular expres-
   32        sion pattern matching using the same syntax and semantics as Perl, with
   33        just  a few differences. Some features that appeared in Python and PCRE
   34        before they appeared in Perl are also available using the  Python  syn-
   35        tax,  there  is  some  support for one or two .NET and Oniguruma syntax
   36        items, and there is an option for requesting some  minor  changes  that
   37        give better JavaScript compatibility.
   39        Starting with release 8.30, it is possible to compile two separate PCRE
   40        libraries:  the  original,  which  supports  8-bit  character   strings
   41        (including  UTF-8  strings),  and a second library that supports 16-bit
   42        character strings (including UTF-16 strings). The build process  allows
   43        either  one  or both to be built. The majority of the work to make this
   44        possible was done by Zoltan Herczeg.
   46        Starting with release 8.32 it is possible to compile a  third  separate
   47        PCRE  library  that supports 32-bit character strings (including UTF-32
   48        strings). The build process allows any combination of the 8-,  16-  and
   49        32-bit  libraries. The work to make this possible was done by Christian
   50        Persch.
   52        The three libraries contain identical sets of  functions,  except  that
   53        the  names  in  the 16-bit library start with pcre16_ instead of pcre_,
   54        and the names in the 32-bit  library  start  with  pcre32_  instead  of
   55        pcre_.  To avoid over-complication and reduce the documentation mainte-
   56        nance load, most of the documentation describes the 8-bit library, with
   57        the  differences  for  the  16-bit and 32-bit libraries described sepa-
   58        rately in the pcre16 and  pcre32  pages.  References  to  functions  or
   59        structures  of  the  form  pcre[16|32]_xxx  should  be  read as meaning
   60        "pcre_xxx when using the  8-bit  library,  pcre16_xxx  when  using  the
   61        16-bit library, or pcre32_xxx when using the 32-bit library".
   63        The  current implementation of PCRE corresponds approximately with Perl
   64        5.12, including support for UTF-8/16/32  encoded  strings  and  Unicode
   65        general  category  properties. However, UTF-8/16/32 and Unicode support
   66        has to be explicitly enabled; it is not the default. The Unicode tables
   67        correspond to Unicode release 6.3.0.
   69        In  addition to the Perl-compatible matching function, PCRE contains an
   70        alternative function that matches the same compiled patterns in a  dif-
   71        ferent way. In certain circumstances, the alternative function has some
   72        advantages.  For a discussion of the two matching algorithms,  see  the
   73        pcrematching page.
   75        PCRE  is  written  in C and released as a C library. A number of people
   76        have written wrappers and interfaces of various kinds.  In  particular,
   77        Google  Inc.   have  provided a comprehensive C++ wrapper for the 8-bit
   78        library. This is now included as part of  the  PCRE  distribution.  The
   79        pcrecpp  page  has  details of this interface. Other people's contribu-
   80        tions can be found in the Contrib directory at the  primary  FTP  site,
   81        which is:
   83        ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
   85        Details  of  exactly which Perl regular expression features are and are
   86        not supported by PCRE are given in separate documents. See the pcrepat-
   87        tern  and pcrecompat pages. There is a syntax summary in the pcresyntax
   88        page.
   90        Some features of PCRE can be included, excluded, or  changed  when  the
   91        library  is  built.  The pcre_config() function makes it possible for a
   92        client to discover which features are  available.  The  features  them-
   93        selves  are described in the pcrebuild page. Documentation about build-
   94        ing PCRE for various operating systems can be found in the  README  and
   95        NON-AUTOTOOLS_BUILD files in the source distribution.
   97        The  libraries contains a number of undocumented internal functions and
   98        data tables that are used by more than one  of  the  exported  external
   99        functions,  but  which  are  not  intended for use by external callers.
  100        Their names all begin with "_pcre_" or "_pcre16_" or "_pcre32_",  which
  101        hopefully  will  not provoke any name clashes. In some environments, it
  102        is possible to control which  external  symbols  are  exported  when  a
  103        shared  library  is  built, and in these cases the undocumented symbols
  104        are not exported.
  109        If you are using PCRE in a non-UTF application that  permits  users  to
  110        supply  arbitrary  patterns  for  compilation, you should be aware of a
  111        feature that allows users to turn on UTF support from within a pattern,
  112        provided  that  PCRE  was built with UTF support. For example, an 8-bit
  113        pattern that begins with "(*UTF8)" or "(*UTF)"  turns  on  UTF-8  mode,
  114        which  interprets  patterns and subjects as strings of UTF-8 characters
  115        instead of individual 8-bit characters.  This causes both  the  pattern
  116        and any data against which it is matched to be checked for UTF-8 valid-
  117        ity. If the data string is very long, such a  check  might  use  suffi-
  118        ciently  many  resources  as  to cause your application to lose perfor-
  119        mance.
  121        One  way  of  guarding  against  this  possibility  is   to   use   the
  122        pcre_fullinfo()  function  to  check the compiled pattern's options for
  123        UTF.  Alternatively, from release 8.33, you can set the  PCRE_NEVER_UTF
  124        option  at compile time. This causes an compile time error if a pattern
  125        contains a UTF-setting sequence.
  127        If your application is one that supports UTF, be  aware  that  validity
  128        checking  can  take time. If the same data string is to be matched many
  129        times, you can use the PCRE_NO_UTF[8|16|32]_CHECK option for the second
  130        and subsequent matches to save redundant checks.
  132        Another  way  that  performance can be hit is by running a pattern that
  133        has a very large search tree against a string that  will  never  match.
  134        Nested  unlimited  repeats in a pattern are a common example. PCRE pro-
  135        vides some protection against this: see the PCRE_EXTRA_MATCH_LIMIT fea-
  136        ture in the pcreapi page.
  141        The  user  documentation  for PCRE comprises a number of different sec-
  142        tions. In the "man" format, each of these is a separate "man page".  In
  143        the  HTML  format, each is a separate page, linked from the index page.
  144        In the plain text format, the descriptions of the pcregrep and pcretest
  145        programs  are  in  files  called pcregrep.txt and pcretest.txt, respec-
  146        tively. The remaining sections, except for the pcredemo section  (which
  147        is  a  program  listing),  are  concatenated  in  pcre.txt, for ease of
  148        searching. The sections are as follows:
  150          pcre              this document
  151          pcre-config       show PCRE installation configuration information
  152          pcre16            details of the 16-bit library
  153          pcre32            details of the 32-bit library
  154          pcreapi           details of PCRE's native C API
  155          pcrebuild         building PCRE
  156          pcrecallout       details of the callout feature
  157          pcrecompat        discussion of Perl compatibility
  158          pcrecpp           details of the C++ wrapper for the 8-bit library
  159          pcredemo          a demonstration C program that uses PCRE
  160          pcregrep          description of the pcregrep command (8-bit only)
  161          pcrejit           discussion of the just-in-time optimization support
  162          pcrelimits        details of size and other limits
  163          pcrematching      discussion of the two matching algorithms
  164          pcrepartial       details of the partial matching facility
  165          pcrepattern       syntax and semantics of supported
  166                              regular expressions
  167          pcreperform       discussion of performance issues
  168          pcreposix         the POSIX-compatible C API for the 8-bit library
  169          pcreprecompile    details of saving and re-using precompiled patterns
  170          pcresample        discussion of the pcredemo program
  171          pcrestack         discussion of stack usage
  172          pcresyntax        quick syntax reference
  173          pcretest          description of the pcretest testing command
  174          pcreunicode       discussion of Unicode and UTF-8/16/32 support
  176        In the "man" and HTML formats, there is also a short page  for  each  C
  177        library function, listing its arguments and results.
  180 AUTHOR
  182        Philip Hazel
  183        University Computing Service
  184        Cambridge CB2 3QH, England.
  186        Putting  an actual email address here seems to have been a spam magnet,
  187        so I've taken it away. If you want to email me, use  my  two  initials,
  188        followed by the two digits 10, at the domain cam.ac.uk.
  193        Last updated: 10 February 2015
  194        Copyright (c) 1997-2015 University of Cambridge.
  195 ------------------------------------------------------------------------------
  198 PCRE(3)                    Library Functions Manual                    PCRE(3)
  202 NAME
  203        PCRE - Perl-compatible regular expressions
  205        #include <pcre.h>
  210        pcre16 *pcre16_compile(PCRE_SPTR16 pattern, int options,
  211             const char **errptr, int *erroffset,
  212             const unsigned char *tableptr);
  214        pcre16 *pcre16_compile2(PCRE_SPTR16 pattern, int options,
  215             int *errorcodeptr,
  216             const char **errptr, int *erroffset,
  217             const unsigned char *tableptr);
  219        pcre16_extra *pcre16_study(const pcre16 *code, int options,
  220             const char **errptr);
  222        void pcre16_free_study(pcre16_extra *extra);
  224        int pcre16_exec(const pcre16 *code, const pcre16_extra *extra,
  225             PCRE_SPTR16 subject, int length, int startoffset,
  226             int options, int *ovector, int ovecsize);
  228        int pcre16_dfa_exec(const pcre16 *code, const pcre16_extra *extra,
  229             PCRE_SPTR16 subject, int length, int startoffset,
  230             int options, int *ovector, int ovecsize,
  231             int *workspace, int wscount);
  236        int pcre16_copy_named_substring(const pcre16 *code,
  237             PCRE_SPTR16 subject, int *ovector,
  238             int stringcount, PCRE_SPTR16 stringname,
  239             PCRE_UCHAR16 *buffer, int buffersize);
  241        int pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector,
  242             int stringcount, int stringnumber, PCRE_UCHAR16 *buffer,
  243             int buffersize);
  245        int pcre16_get_named_substring(const pcre16 *code,
  246             PCRE_SPTR16 subject, int *ovector,
  247             int stringcount, PCRE_SPTR16 stringname,
  248             PCRE_SPTR16 *stringptr);
  250        int pcre16_get_stringnumber(const pcre16 *code,
  251             PCRE_SPTR16 name);
  253        int pcre16_get_stringtable_entries(const pcre16 *code,
  254             PCRE_SPTR16 name, PCRE_UCHAR16 **first, PCRE_UCHAR16 **last);
  256        int pcre16_get_substring(PCRE_SPTR16 subject, int *ovector,
  257             int stringcount, int stringnumber,
  258             PCRE_SPTR16 *stringptr);
  260        int pcre16_get_substring_list(PCRE_SPTR16 subject,
  261             int *ovector, int stringcount, PCRE_SPTR16 **listptr);
  263        void pcre16_free_substring(PCRE_SPTR16 stringptr);
  265        void pcre16_free_substring_list(PCRE_SPTR16 *stringptr);
  270        pcre16_jit_stack *pcre16_jit_stack_alloc(int startsize, int maxsize);
  272        void pcre16_jit_stack_free(pcre16_jit_stack *stack);
  274        void pcre16_assign_jit_stack(pcre16_extra *extra,
  275             pcre16_jit_callback callback, void *data);
  277        const unsigned char *pcre16_maketables(void);
  279        int pcre16_fullinfo(const pcre16 *code, const pcre16_extra *extra,
  280             int what, void *where);
  282        int pcre16_refcount(pcre16 *code, int adjust);
  284        int pcre16_config(int what, void *where);
  286        const char *pcre16_version(void);
  288        int pcre16_pattern_to_host_byte_order(pcre16 *code,
  289             pcre16_extra *extra, const unsigned char *tables);
  294        void *(*pcre16_malloc)(size_t);
  296        void (*pcre16_free)(void *);
  298        void *(*pcre16_stack_malloc)(size_t);
  300        void (*pcre16_stack_free)(void *);
  302        int (*pcre16_callout)(pcre16_callout_block *);
  307        int pcre16_utf16_to_host_byte_order(PCRE_UCHAR16 *output,
  308             PCRE_SPTR16 input, int length, int *byte_order,
  309             int keep_boms);
  314        Starting  with  release  8.30, it is possible to compile a PCRE library
  315        that supports 16-bit character strings, including  UTF-16  strings,  as
  316        well  as  or instead of the original 8-bit library. The majority of the
  317        work to make  this  possible  was  done  by  Zoltan  Herczeg.  The  two
  318        libraries contain identical sets of functions, used in exactly the same
  319        way. Only the names of the functions and the data types of their  argu-
  320        ments  and results are different. To avoid over-complication and reduce
  321        the documentation maintenance load,  most  of  the  PCRE  documentation
  322        describes  the  8-bit  library,  with only occasional references to the
  323        16-bit library. This page describes what is different when you use  the
  324        16-bit library.
  326        WARNING:  A  single  application can be linked with both libraries, but
  327        you must take care when processing any particular pattern to use  func-
  328        tions  from  just one library. For example, if you want to study a pat-
  329        tern that was compiled with  pcre16_compile(),  you  must  do  so  with
  330        pcre16_study(), not pcre_study(), and you must free the study data with
  331        pcre16_free_study().
  336        There is only one header file, pcre.h. It contains prototypes  for  all
  337        the functions in all libraries, as well as definitions of flags, struc-
  338        tures, error codes, etc.
  343        In Unix-like systems, the 16-bit library is called libpcre16,  and  can
  344        normally  be  accesss  by adding -lpcre16 to the command for linking an
  345        application that uses PCRE.
  350        In the 8-bit library, strings are passed to PCRE library  functions  as
  351        vectors  of  bytes  with  the  C  type "char *". In the 16-bit library,
  352        strings are passed as vectors of unsigned 16-bit quantities. The  macro
  353        PCRE_UCHAR16  specifies  an  appropriate  data type, and PCRE_SPTR16 is
  354        defined as "const PCRE_UCHAR16 *". In very  many  environments,  "short
  355        int" is a 16-bit data type. When PCRE is built, it defines PCRE_UCHAR16
  356        as "unsigned short int", but checks that it really  is  a  16-bit  data
  357        type.  If  it is not, the build fails with an error message telling the
  358        maintainer to modify the definition appropriately.
  363        The types of the opaque structures that are used  for  compiled  16-bit
  364        patterns  and  JIT stacks are pcre16 and pcre16_jit_stack respectively.
  365        The  type  of  the  user-accessible  structure  that  is  returned   by
  366        pcre16_study()  is  pcre16_extra, and the type of the structure that is
  367        used for passing data to a callout  function  is  pcre16_callout_block.
  368        These structures contain the same fields, with the same names, as their
  369        8-bit counterparts. The only difference is that pointers  to  character
  370        strings are 16-bit instead of 8-bit types.
  375        For  every function in the 8-bit library there is a corresponding func-
  376        tion in the 16-bit library with a name that starts with pcre16_ instead
  377        of  pcre_.  The  prototypes are listed above. In addition, there is one
  378        extra function, pcre16_utf16_to_host_byte_order(). This  is  a  utility
  379        function  that converts a UTF-16 character string to host byte order if
  380        necessary. The other 16-bit  functions  expect  the  strings  they  are
  381        passed to be in host byte order.
  383        The input and output arguments of pcre16_utf16_to_host_byte_order() may
  384        point to the same address, that is, conversion in place  is  supported.
  385        The output buffer must be at least as long as the input.
  387        The  length  argument  specifies the number of 16-bit data units in the
  388        input string; a negative value specifies a zero-terminated string.
  390        If byte_order is NULL, it is assumed that the string starts off in host
  391        byte  order. This may be changed by byte-order marks (BOMs) anywhere in
  392        the string (commonly as the first character).
  394        If byte_order is not NULL, a non-zero value of the integer to which  it
  395        points  means  that  the input starts off in host byte order, otherwise
  396        the opposite order is assumed. Again, BOMs in  the  string  can  change
  397        this. The final byte order is passed back at the end of processing.
  399        If  keep_boms  is  not  zero,  byte-order  mark characters (0xfeff) are
  400        copied into the output string. Otherwise they are discarded.
  402        The result of the function is the number of 16-bit  units  placed  into
  403        the  output  buffer,  including  the  zero terminator if the string was
  404        zero-terminated.
  409        The lengths and starting offsets of subject strings must  be  specified
  410        in  16-bit  data units, and the offsets within subject strings that are
  411        returned by the matching functions are in also 16-bit units rather than
  412        bytes.
  417        The  name-to-number translation table that is maintained for named sub-
  418        patterns uses 16-bit characters.  The  pcre16_get_stringtable_entries()
  419        function returns the length of each entry in the table as the number of
  420        16-bit data units.
  425        There   are   two   new   general   option   names,   PCRE_UTF16    and
  426        PCRE_NO_UTF16_CHECK,     which     correspond    to    PCRE_UTF8    and
  427        PCRE_NO_UTF8_CHECK in the 8-bit library. In  fact,  these  new  options
  428        define  the  same bits in the options word. There is a discussion about
  429        the validity of UTF-16 strings in the pcreunicode page.
  431        For the pcre16_config() function there is an  option  PCRE_CONFIG_UTF16
  432        that  returns  1  if UTF-16 support is configured, otherwise 0. If this
  433        option  is  given  to  pcre_config()  or  pcre32_config(),  or  if  the
  434        PCRE_CONFIG_UTF8  or  PCRE_CONFIG_UTF32  option is given to pcre16_con-
  435        fig(), the result is the PCRE_ERROR_BADOPTION error.
  440        In 16-bit mode, when  PCRE_UTF16  is  not  set,  character  values  are
  441        treated in the same way as in 8-bit, non UTF-8 mode, except, of course,
  442        that they can range from 0 to 0xffff instead of 0  to  0xff.  Character
  443        types  for characters less than 0xff can therefore be influenced by the
  444        locale in the same way as before.  Characters greater  than  0xff  have
  445        only one case, and no "type" (such as letter or digit).
  447        In  UTF-16  mode,  the  character  code  is  Unicode, in the range 0 to
  448        0x10ffff, with the exception of values in the range  0xd800  to  0xdfff
  449        because  those  are "surrogate" values that are used in pairs to encode
  450        values greater than 0xffff.
  452        A UTF-16 string can indicate its endianness by special code knows as  a
  453        byte-order mark (BOM). The PCRE functions do not handle this, expecting
  454        strings  to  be  in  host  byte  order.  A  utility   function   called
  455        pcre16_utf16_to_host_byte_order()  is  provided  to help with this (see
  456        above).
  461        The errors PCRE_ERROR_BADUTF16_OFFSET and PCRE_ERROR_SHORTUTF16  corre-
  462        spond  to  their  8-bit  counterparts.  The error PCRE_ERROR_BADMODE is
  463        given when a compiled pattern is passed to a  function  that  processes
  464        patterns  in  the  other  mode, for example, if a pattern compiled with
  465        pcre_compile() is passed to pcre16_exec().
  467        There are new error codes whose names  begin  with  PCRE_UTF16_ERR  for
  468        invalid  UTF-16  strings,  corresponding to the PCRE_UTF8_ERR codes for
  469        UTF-8 strings that are described in the section entitled "Reason  codes
  470        for  invalid UTF-8 strings" in the main pcreapi page. The UTF-16 errors
  471        are:
  473          PCRE_UTF16_ERR1  Missing low surrogate at end of string
  474          PCRE_UTF16_ERR2  Invalid low surrogate follows high surrogate
  475          PCRE_UTF16_ERR3  Isolated low surrogate
  476          PCRE_UTF16_ERR4  Non-character
  481        If there is an error while compiling a pattern, the error text that  is
  482        passed  back by pcre16_compile() or pcre16_compile2() is still an 8-bit
  483        character string, zero-terminated.
  488        The subject and mark fields in the callout block that is  passed  to  a
  489        callout function point to 16-bit vectors.
  494        The  pcretest  program continues to operate with 8-bit input and output
  495        files, but it can be used for testing the 16-bit library. If it is  run
  496        with the command line option -16, patterns and subject strings are con-
  497        verted from 8-bit to 16-bit before being passed to PCRE, and the 16-bit
  498        library  functions  are used instead of the 8-bit ones. Returned 16-bit
  499        strings are converted to 8-bit for output. If both the  8-bit  and  the
  500        32-bit libraries were not compiled, pcretest defaults to 16-bit and the
  501        -16 option is ignored.
  503        When PCRE is being built, the RunTest script that is  called  by  "make
  504        check"  uses  the  pcretest  -C  option to discover which of the 8-bit,
  505        16-bit and 32-bit libraries has been built, and runs the  tests  appro-
  506        priately.
  511        Not all the features of the 8-bit library are available with the 16-bit
  512        library. The C++ and POSIX wrapper functions  support  only  the  8-bit
  513        library, and the pcregrep program is at present 8-bit only.
  516 AUTHOR
  518        Philip Hazel
  519        University Computing Service
  520        Cambridge CB2 3QH, England.
  525        Last updated: 12 May 2013
  526        Copyright (c) 1997-2013 University of Cambridge.
  527 ------------------------------------------------------------------------------
  530 PCRE(3)                    Library Functions Manual                    PCRE(3)
  534 NAME
  535        PCRE - Perl-compatible regular expressions
  537        #include <pcre.h>
  542        pcre32 *pcre32_compile(PCRE_SPTR32 pattern, int options,
  543             const char **errptr, int *erroffset,
  544             const unsigned char *tableptr);
  546        pcre32 *pcre32_compile2(PCRE_SPTR32 pattern, int options,
  547             int *errorcodeptr,
  548             const unsigned char *tableptr);
  550        pcre32_extra *pcre32_study(const pcre32 *code, int options,
  551             const char **errptr);
  553        void pcre32_free_study(pcre32_extra *extra);
  555        int pcre32_exec(const pcre32 *code, const pcre32_extra *extra,
  556             PCRE_SPTR32 subject, int length, int startoffset,
  557             int options, int *ovector, int ovecsize);
  559        int pcre32_dfa_exec(const pcre32 *code, const pcre32_extra *extra,
  560             PCRE_SPTR32 subject, int length, int startoffset,
  561             int options, int *ovector, int ovecsize,
  562             int *workspace, int wscount);
  567        int pcre32_copy_named_substring(const pcre32 *code,
  568             PCRE_SPTR32 subject, int *ovector,
  569             int stringcount, PCRE_SPTR32 stringname,
  570             PCRE_UCHAR32 *buffer, int buffersize);
  572        int pcre32_copy_substring(PCRE_SPTR32 subject, int *ovector,
  573             int stringcount, int stringnumber, PCRE_UCHAR32 *buffer,
  574             int buffersize);
  576        int pcre32_get_named_substring(const pcre32 *code,
  577             PCRE_SPTR32 subject, int *ovector,
  578             int stringcount, PCRE_SPTR32 stringname,
  579             PCRE_SPTR32 *stringptr);
  581        int pcre32_get_stringnumber(const pcre32 *code,
  582             PCRE_SPTR32 name);
  584        int pcre32_get_stringtable_entries(const pcre32 *code,
  585             PCRE_SPTR32 name, PCRE_UCHAR32 **first, PCRE_UCHAR32 **last);
  587        int pcre32_get_substring(PCRE_SPTR32 subject, int *ovector,
  588             int stringcount, int stringnumber,
  589             PCRE_SPTR32 *stringptr);
  591        int pcre32_get_substring_list(PCRE_SPTR32 subject,
  592             int *ovector, int stringcount, PCRE_SPTR32 **listptr);
  594        void pcre32_free_substring(PCRE_SPTR32 stringptr);
  596        void pcre32_free_substring_list(PCRE_SPTR32 *stringptr);
  601        pcre32_jit_stack *pcre32_jit_stack_alloc(int startsize, int maxsize);
  603        void pcre32_jit_stack_free(pcre32_jit_stack *stack);
  605        void pcre32_assign_jit_stack(pcre32_extra *extra,
  606             pcre32_jit_callback callback, void *data);
  608        const unsigned char *pcre32_maketables(void);
  610        int pcre32_fullinfo(const pcre32 *code, const pcre32_extra *extra,
  611             int what, void *where);
  613        int pcre32_refcount(pcre32 *code, int adjust);
  615        int pcre32_config(int what, void *where);
  617        const char *pcre32_version(void);
  619        int pcre32_pattern_to_host_byte_order(pcre32 *code,
  620             pcre32_extra *extra, const unsigned char *tables);
  625        void *(*pcre32_malloc)(size_t);
  627        void (*pcre32_free)(void *);
  629        void *(*pcre32_stack_malloc)(size_t);
  631        void (*pcre32_stack_free)(void *);
  633        int (*pcre32_callout)(pcre32_callout_block *);
  638        int pcre32_utf32_to_host_byte_order(PCRE_UCHAR32 *output,
  639             PCRE_SPTR32 input, int length, int *byte_order,
  640             int keep_boms);
  645        Starting  with  release  8.32, it is possible to compile a PCRE library
  646        that supports 32-bit character strings, including  UTF-32  strings,  as
  647        well as or instead of the original 8-bit library. This work was done by
  648        Christian Persch, based on the work done  by  Zoltan  Herczeg  for  the
  649        16-bit  library.  All  three  libraries contain identical sets of func-
  650        tions, used in exactly the same way.  Only the names of  the  functions
  651        and  the  data  types  of their arguments and results are different. To
  652        avoid over-complication and reduce the documentation maintenance  load,
  653        most  of  the PCRE documentation describes the 8-bit library, with only
  654        occasional references to the 16-bit and  32-bit  libraries.  This  page
  655        describes what is different when you use the 32-bit library.
  657        WARNING:  A  single  application  can  be linked with all or any of the
  658        three libraries, but you must take care when processing any  particular
  659        pattern  to  use  functions  from just one library. For example, if you
  660        want to study a pattern that was compiled  with  pcre32_compile(),  you
  661        must do so with pcre32_study(), not pcre_study(), and you must free the
  662        study data with pcre32_free_study().
  667        There is only one header file, pcre.h. It contains prototypes  for  all
  668        the functions in all libraries, as well as definitions of flags, struc-
  669        tures, error codes, etc.
  674        In Unix-like systems, the 32-bit library is called libpcre32,  and  can
  675        normally  be  accesss  by adding -lpcre32 to the command for linking an
  676        application that uses PCRE.
  681        In the 8-bit library, strings are passed to PCRE library  functions  as
  682        vectors  of  bytes  with  the  C  type "char *". In the 32-bit library,
  683        strings are passed as vectors of unsigned 32-bit quantities. The  macro
  684        PCRE_UCHAR32  specifies  an  appropriate  data type, and PCRE_SPTR32 is
  685        defined as "const PCRE_UCHAR32 *". In very many environments, "unsigned
  686        int" is a 32-bit data type. When PCRE is built, it defines PCRE_UCHAR32
  687        as "unsigned int", but checks that it really is a 32-bit data type.  If
  688        it is not, the build fails with an error message telling the maintainer
  689        to modify the definition appropriately.
  694        The types of the opaque structures that are used  for  compiled  32-bit
  695        patterns  and  JIT stacks are pcre32 and pcre32_jit_stack respectively.
  696        The  type  of  the  user-accessible  structure  that  is  returned   by
  697        pcre32_study()  is  pcre32_extra, and the type of the structure that is
  698        used for passing data to a callout  function  is  pcre32_callout_block.
  699        These structures contain the same fields, with the same names, as their
  700        8-bit counterparts. The only difference is that pointers  to  character
  701        strings are 32-bit instead of 8-bit types.
  706        For  every function in the 8-bit library there is a corresponding func-
  707        tion in the 32-bit library with a name that starts with pcre32_ instead
  708        of  pcre_.  The  prototypes are listed above. In addition, there is one
  709        extra function, pcre32_utf32_to_host_byte_order(). This  is  a  utility
  710        function  that converts a UTF-32 character string to host byte order if
  711        necessary. The other 32-bit  functions  expect  the  strings  they  are
  712        passed to be in host byte order.
  714        The input and output arguments of pcre32_utf32_to_host_byte_order() may
  715        point to the same address, that is, conversion in place  is  supported.
  716        The output buffer must be at least as long as the input.
  718        The  length  argument  specifies the number of 32-bit data units in the
  719        input string; a negative value specifies a zero-terminated string.
  721        If byte_order is NULL, it is assumed that the string starts off in host
  722        byte  order. This may be changed by byte-order marks (BOMs) anywhere in
  723        the string (commonly as the first character).
  725        If byte_order is not NULL, a non-zero value of the integer to which  it
  726        points  means  that  the input starts off in host byte order, otherwise
  727        the opposite order is assumed. Again, BOMs in  the  string  can  change
  728        this. The final byte order is passed back at the end of processing.
  730        If  keep_boms  is  not  zero,  byte-order  mark characters (0xfeff) are
  731        copied into the output string. Otherwise they are discarded.
  733        The result of the function is the number of 32-bit  units  placed  into
  734        the  output  buffer,  including  the  zero terminator if the string was
  735        zero-terminated.
  740        The lengths and starting offsets of subject strings must  be  specified
  741        in  32-bit  data units, and the offsets within subject strings that are
  742        returned by the matching functions are in also 32-bit units rather than
  743        bytes.
  748        The  name-to-number translation table that is maintained for named sub-
  749        patterns uses 32-bit characters.  The  pcre32_get_stringtable_entries()
  750        function returns the length of each entry in the table as the number of
  751        32-bit data units.
  756        There   are   two   new   general   option   names,   PCRE_UTF32    and
  757        PCRE_NO_UTF32_CHECK,     which     correspond    to    PCRE_UTF8    and
  758        PCRE_NO_UTF8_CHECK in the 8-bit library. In  fact,  these  new  options
  759        define  the  same bits in the options word. There is a discussion about
  760        the validity of UTF-32 strings in the pcreunicode page.
  762        For the pcre32_config() function there is an  option  PCRE_CONFIG_UTF32
  763        that  returns  1  if UTF-32 support is configured, otherwise 0. If this
  764        option  is  given  to  pcre_config()  or  pcre16_config(),  or  if  the
  765        PCRE_CONFIG_UTF8  or  PCRE_CONFIG_UTF16  option is given to pcre32_con-
  766        fig(), the result is the PCRE_ERROR_BADOPTION error.
  771        In 32-bit mode, when  PCRE_UTF32  is  not  set,  character  values  are
  772        treated in the same way as in 8-bit, non UTF-8 mode, except, of course,
  773        that they can range from 0 to 0x7fffffff instead of 0 to 0xff.  Charac-
  774        ter  types for characters less than 0xff can therefore be influenced by
  775        the locale in the same way as before.   Characters  greater  than  0xff
  776        have only one case, and no "type" (such as letter or digit).
  778        In  UTF-32  mode,  the  character  code  is  Unicode, in the range 0 to
  779        0x10ffff, with the exception of values in the range  0xd800  to  0xdfff
  780        because those are "surrogate" values that are ill-formed in UTF-32.
  782        A  UTF-32 string can indicate its endianness by special code knows as a
  783        byte-order mark (BOM). The PCRE functions do not handle this, expecting
  784        strings   to   be  in  host  byte  order.  A  utility  function  called
  785        pcre32_utf32_to_host_byte_order() is provided to help  with  this  (see
  786        above).
  791        The  error  PCRE_ERROR_BADUTF32  corresponds  to its 8-bit counterpart.
  792        The error PCRE_ERROR_BADMODE is given when a compiled pattern is passed
  793        to  a  function that processes patterns in the other mode, for example,
  794        if a pattern compiled with pcre_compile() is passed to pcre32_exec().
  796        There are new error codes whose names  begin  with  PCRE_UTF32_ERR  for
  797        invalid  UTF-32  strings,  corresponding to the PCRE_UTF8_ERR codes for
  798        UTF-8 strings that are described in the section entitled "Reason  codes
  799        for  invalid UTF-8 strings" in the main pcreapi page. The UTF-32 errors
  800        are:
  802          PCRE_UTF32_ERR1  Surrogate character (range from 0xd800 to 0xdfff)
  803          PCRE_UTF32_ERR2  Non-character
  804          PCRE_UTF32_ERR3  Character > 0x10ffff
  809        If there is an error while compiling a pattern, the error text that  is
  810        passed  back by pcre32_compile() or pcre32_compile2() is still an 8-bit
  811        character string, zero-terminated.
  816        The subject and mark fields in the callout block that is  passed  to  a
  817        callout function point to 32-bit vectors.
  822        The  pcretest  program continues to operate with 8-bit input and output
  823        files, but it can be used for testing the 32-bit library. If it is  run
  824        with the command line option -32, patterns and subject strings are con-
  825        verted from 8-bit to 32-bit before being passed to PCRE, and the 32-bit
  826        library  functions  are used instead of the 8-bit ones. Returned 32-bit
  827        strings are converted to 8-bit for output. If both the  8-bit  and  the
  828        16-bit libraries were not compiled, pcretest defaults to 32-bit and the
  829        -32 option is ignored.
  831        When PCRE is being built, the RunTest script that is  called  by  "make
  832        check"  uses  the  pcretest  -C  option to discover which of the 8-bit,
  833        16-bit and 32-bit libraries has been built, and runs the  tests  appro-
  834        priately.
  839        Not all the features of the 8-bit library are available with the 32-bit
  840        library. The C++ and POSIX wrapper functions  support  only  the  8-bit
  841        library, and the pcregrep program is at present 8-bit only.
  844 AUTHOR
  846        Philip Hazel
  847        University Computing Service
  848        Cambridge CB2 3QH, England.
  853        Last updated: 12 May 2013
  854        Copyright (c) 1997-2013 University of Cambridge.
  855 ------------------------------------------------------------------------------
  858 PCREBUILD(3)               Library Functions Manual               PCREBUILD(3)
  862 NAME
  863        PCRE - Perl-compatible regular expressions
  867        PCRE  is  distributed with a configure script that can be used to build
  868        the library in Unix-like environments using the applications  known  as
  869        Autotools.   Also  in  the  distribution  are files to support building
  870        using CMake instead of configure. The text file README contains general
  871        information  about  building  with Autotools (some of which is repeated
  872        below), and also has some comments about building on various  operating
  873        systems.  There  is  a lot more information about building PCRE without
  874        using Autotools (including information about using CMake  and  building
  875        "by  hand")  in  the  text file called NON-AUTOTOOLS-BUILD.  You should
  876        consult this file as well as the README file if you are building  in  a
  877        non-Unix-like environment.
  882        The  rest of this document describes the optional features of PCRE that
  883        can be selected when the library is compiled. It  assumes  use  of  the
  884        configure  script,  where  the  optional features are selected or dese-
  885        lected by providing options to configure before running the  make  com-
  886        mand.  However,  the same options can be selected in both Unix-like and
  887        non-Unix-like environments using the GUI facility of cmake-gui  if  you
  888        are using CMake instead of configure to build PCRE.
  890        If  you  are not using Autotools or CMake, option selection can be done
  891        by editing the config.h file, or by passing parameter settings  to  the
  892        compiler, as described in NON-AUTOTOOLS-BUILD.
  894        The complete list of options for configure (which includes the standard
  895        ones such as the  selection  of  the  installation  directory)  can  be
  896        obtained by running
  898          ./configure --help
  900        The  following  sections  include  descriptions  of options whose names
  901        begin with --enable or --disable. These settings specify changes to the
  902        defaults  for  the configure command. Because of the way that configure
  903        works, --enable and --disable always come in pairs, so  the  complemen-
  904        tary  option always exists as well, but as it specifies the default, it
  905        is not described.
  910        By default, a library called libpcre  is  built,  containing  functions
  911        that  take  string  arguments  contained in vectors of bytes, either as
  912        single-byte characters, or interpreted as UTF-8 strings. You  can  also
  913        build  a  separate library, called libpcre16, in which strings are con-
  914        tained in vectors of 16-bit data units and interpreted either  as  sin-
  915        gle-unit characters or UTF-16 strings, by adding
  917          --enable-pcre16
  919        to  the  configure  command.  You  can  also build yet another separate
  920        library, called libpcre32, in which strings are contained in vectors of
  921        32-bit  data  units and interpreted either as single-unit characters or
  922        UTF-32 strings, by adding
  924          --enable-pcre32
  926        to the configure command. If you do not want the 8-bit library, add
  928          --disable-pcre8
  930        as well. At least one of the three libraries must be built.  Note  that
  931        the  C++  and  POSIX  wrappers are for the 8-bit library only, and that
  932        pcregrep is an 8-bit program. None of these are  built  if  you  select
  933        only the 16-bit or 32-bit libraries.
  938        The  Autotools  PCRE building process uses libtool to build both shared
  939        and static libraries by default. You  can  suppress  one  of  these  by
  940        adding one of
  942          --disable-shared
  943          --disable-static
  945        to the configure command, as required.
  948 C++ SUPPORT
  950        By  default,  if the 8-bit library is being built, the configure script
  951        will search for a C++ compiler and C++ header files. If it finds  them,
  952        it  automatically  builds  the C++ wrapper library (which supports only
  953        8-bit strings). You can disable this by adding
  955          --disable-cpp
  957        to the configure command.
  960 UTF-8, UTF-16 AND UTF-32 SUPPORT
  962        To build PCRE with support for UTF Unicode character strings, add
  964          --enable-utf
  966        to the configure command. This setting applies to all three  libraries,
  967        adding  support  for  UTF-8 to the 8-bit library, support for UTF-16 to
  968        the 16-bit library, and  support  for  UTF-32  to  the  to  the  32-bit
  969        library.  There  are no separate options for enabling UTF-8, UTF-16 and
  970        UTF-32 independently because that would allow ridiculous settings  such
  971        as  requesting UTF-16 support while building only the 8-bit library. It
  972        is not possible to build one library with UTF support and another with-
  973        out  in the same configuration. (For backwards compatibility, --enable-
  974        utf8 is a synonym of --enable-utf.)
  976        Of itself, this setting does not make  PCRE  treat  strings  as  UTF-8,
  977        UTF-16  or UTF-32. As well as compiling PCRE with this option, you also
  978        have have to set the PCRE_UTF8, PCRE_UTF16  or  PCRE_UTF32  option  (as
  979        appropriate) when you call one of the pattern compiling functions.
  981        If  you  set --enable-utf when compiling in an EBCDIC environment, PCRE
  982        expects its input to be either ASCII or UTF-8 (depending  on  the  run-
  983        time option). It is not possible to support both EBCDIC and UTF-8 codes
  984        in the same version of  the  library.  Consequently,  --enable-utf  and
  985        --enable-ebcdic are mutually exclusive.
  990        UTF  support allows the libraries to process character codepoints up to
  991        0x10ffff in the strings that they handle. On its own, however, it  does
  992        not provide any facilities for accessing the properties of such charac-
  993        ters. If you want to be able to use the pattern escapes \P, \p, and \X,
  994        which refer to Unicode character properties, you must add
  996          --enable-unicode-properties
  998        to  the  configure  command. This implies UTF support, even if you have
  999        not explicitly requested it.
 1001        Including Unicode property support adds around 30K  of  tables  to  the
 1002        PCRE  library.  Only  the general category properties such as Lu and Nd
 1003        are supported. Details are given in the pcrepattern documentation.
 1008        Just-in-time compiler support is included in the build by specifying
 1010          --enable-jit
 1012        This support is available only for certain hardware  architectures.  If
 1013        this  option  is  set  for  an unsupported architecture, a compile time
 1014        error occurs.  See the pcrejit documentation for a  discussion  of  JIT
 1015        usage. When JIT support is enabled, pcregrep automatically makes use of
 1016        it, unless you add
 1018          --disable-pcregrep-jit
 1020        to the "configure" command.
 1025        By default, PCRE interprets the linefeed (LF) character  as  indicating
 1026        the  end  of  a line. This is the normal newline character on Unix-like
 1027        systems. You can compile PCRE to use carriage return (CR)  instead,  by
 1028        adding
 1030          --enable-newline-is-cr
 1032        to  the  configure  command.  There  is  also  a --enable-newline-is-lf
 1033        option, which explicitly specifies linefeed as the newline character.
 1035        Alternatively, you can specify that line endings are to be indicated by
 1036        the two character sequence CRLF. If you want this, add
 1038          --enable-newline-is-crlf
 1040        to the configure command. There is a fourth option, specified by
 1042          --enable-newline-is-anycrlf
 1044        which  causes  PCRE  to recognize any of the three sequences CR, LF, or
 1045        CRLF as indicating a line ending. Finally, a fifth option, specified by
 1047          --enable-newline-is-any
 1049        causes PCRE to recognize any Unicode newline sequence.
 1051        Whatever line ending convention is selected when PCRE is built  can  be
 1052        overridden  when  the library functions are called. At build time it is
 1053        conventional to use the standard for your operating system.
 1058        By default, the sequence \R in a pattern matches  any  Unicode  newline
 1059        sequence,  whatever  has  been selected as the line ending sequence. If
 1060        you specify
 1062          --enable-bsr-anycrlf
 1064        the default is changed so that \R matches only CR, LF, or  CRLF.  What-
 1065        ever  is selected when PCRE is built can be overridden when the library
 1066        functions are called.
 1071        When the 8-bit library is called through the POSIX interface  (see  the
 1072        pcreposix  documentation),  additional  working storage is required for
 1073        holding the pointers to capturing  substrings,  because  PCRE  requires
 1074        three integers per substring, whereas the POSIX interface provides only
 1075        two. If the number of expected substrings is small, the  wrapper  func-
 1076        tion  uses  space  on the stack, because this is faster than using mal-
 1077        loc() for each call. The default threshold above which the stack is  no
 1078        longer used is 10; it can be changed by adding a setting such as
 1080          --with-posix-malloc-threshold=20
 1082        to the configure command.
 1087        Within  a  compiled  pattern,  offset values are used to point from one
 1088        part to another (for example, from an opening parenthesis to an  alter-
 1089        nation  metacharacter).  By default, in the 8-bit and 16-bit libraries,
 1090        two-byte values are used for these offsets, leading to a  maximum  size
 1091        for  a compiled pattern of around 64K. This is sufficient to handle all
 1092        but the most gigantic patterns.  Nevertheless, some people do  want  to
 1093        process  truly  enormous patterns, so it is possible to compile PCRE to
 1094        use three-byte or four-byte offsets by adding a setting such as
 1096          --with-link-size=3
 1098        to the configure command. The value given must be 2, 3, or 4.  For  the
 1099        16-bit  library,  a  value of 3 is rounded up to 4. In these libraries,
 1100        using longer offsets slows down the operation of PCRE because it has to
 1101        load  additional  data  when  handling them. For the 32-bit library the
 1102        value is always 4 and cannot be overridden; the value  of  --with-link-
 1103        size is ignored.
 1108        When matching with the pcre_exec() function, PCRE implements backtrack-
 1109        ing by making recursive calls to an internal function  called  match().
 1110        In  environments  where  the size of the stack is limited, this can se-
 1111        verely limit PCRE's operation. (The Unix environment does  not  usually
 1112        suffer from this problem, but it may sometimes be necessary to increase
 1113        the maximum stack size.  There is a discussion in the  pcrestack  docu-
 1114        mentation.)  An alternative approach to recursion that uses memory from
 1115        the heap to remember data, instead of using recursive  function  calls,
 1116        has  been  implemented to work round the problem of limited stack size.
 1117        If you want to build a version of PCRE that works this way, add
 1119          --disable-stack-for-recursion
 1121        to the configure command. With this configuration, PCRE  will  use  the
 1122        pcre_stack_malloc  and pcre_stack_free variables to call memory manage-
 1123        ment functions. By default these point to malloc() and free(), but  you
 1124        can replace the pointers so that your own functions are used instead.
 1126        Separate  functions  are  provided  rather  than  using pcre_malloc and
 1127        pcre_free because the  usage  is  very  predictable:  the  block  sizes
 1128        requested  are  always  the  same,  and  the blocks are always freed in
 1129        reverse order. A calling program might be able to  implement  optimized
 1130        functions  that  perform  better  than  malloc()  and free(). PCRE runs
 1131        noticeably more slowly when built in this way. This option affects only
 1132        the pcre_exec() function; it is not relevant for pcre_dfa_exec().
 1137        Internally,  PCRE has a function called match(), which it calls repeat-
 1138        edly  (sometimes  recursively)  when  matching  a  pattern   with   the
 1139        pcre_exec()  function.  By controlling the maximum number of times this
 1140        function may be called during a single matching operation, a limit  can
 1141        be  placed  on  the resources used by a single call to pcre_exec(). The
 1142        limit can be changed at run time, as described in the pcreapi  documen-
 1143        tation.  The default is 10 million, but this can be changed by adding a
 1144        setting such as
 1146          --with-match-limit=500000
 1148        to  the  configure  command.  This  setting  has  no  effect   on   the
 1149        pcre_dfa_exec() matching function.
 1151        In  some  environments  it is desirable to limit the depth of recursive
 1152        calls of match() more strictly than the total number of calls, in order
 1153        to  restrict  the maximum amount of stack (or heap, if --disable-stack-
 1154        for-recursion is specified) that is used. A second limit controls this;
 1155        it  defaults  to  the  value  that is set for --with-match-limit, which
 1156        imposes no additional constraints. However, you can set a  lower  limit
 1157        by adding, for example,
 1159          --with-match-limit-recursion=10000
 1161        to  the  configure  command.  This  value can also be overridden at run
 1162        time.
 1167        PCRE uses fixed tables for processing characters whose code values  are
 1168        less  than 256. By default, PCRE is built with a set of tables that are
 1169        distributed in the file pcre_chartables.c.dist. These  tables  are  for
 1170        ASCII codes only. If you add
 1172          --enable-rebuild-chartables
 1174        to  the  configure  command, the distributed tables are no longer used.
 1175        Instead, a program called dftables is compiled and  run.  This  outputs
 1176        the source for new set of tables, created in the default locale of your
 1177        C run-time system. (This method of replacing the tables does  not  work
 1178        if  you are cross compiling, because dftables is run on the local host.
 1179        If you need to create alternative tables when cross compiling, you will
 1180        have to do so "by hand".)
 1185        PCRE  assumes  by  default that it will run in an environment where the
 1186        character code is ASCII (or Unicode, which is  a  superset  of  ASCII).
 1187        This  is  the  case for most computer operating systems. PCRE can, how-
 1188        ever, be compiled to run in an EBCDIC environment by adding
 1190          --enable-ebcdic
 1192        to the configure command. This setting implies --enable-rebuild-charta-
 1193        bles.  You  should  only  use  it if you know that you are in an EBCDIC
 1194        environment (for example,  an  IBM  mainframe  operating  system).  The
 1195        --enable-ebcdic option is incompatible with --enable-utf.
 1197        The EBCDIC character that corresponds to an ASCII LF is assumed to have
 1198        the value 0x15 by default. However, in some EBCDIC  environments,  0x25
 1199        is used. In such an environment you should use
 1201          --enable-ebcdic-nl25
 1203        as well as, or instead of, --enable-ebcdic. The EBCDIC character for CR
 1204        has the same value as in ASCII, namely, 0x0d.  Whichever  of  0x15  and
 1205        0x25 is not chosen as LF is made to correspond to the Unicode NEL char-
 1206        acter (which, in Unicode, is 0x85).
 1208        The options that select newline behaviour, such as --enable-newline-is-
 1209        cr, and equivalent run-time options, refer to these character values in
 1210        an EBCDIC environment.
 1215        By default, pcregrep reads all files as plain text. You can build it so
 1216        that it recognizes files whose names end in .gz or .bz2, and reads them
 1217        with libz or libbz2, respectively, by adding one or both of
 1219          --enable-pcregrep-libz
 1220          --enable-pcregrep-libbz2
 1222        to the configure command. These options naturally require that the rel-
 1223        evant  libraries  are installed on your system. Configuration will fail
 1224        if they are not.
 1229        pcregrep uses an internal buffer to hold a "window" on the file  it  is
 1230        scanning, in order to be able to output "before" and "after" lines when
 1231        it finds a match. The size of the buffer is controlled by  a  parameter
 1232        whose default value is 20K. The buffer itself is three times this size,
 1233        but because of the way it is used for holding "before" lines, the long-
 1234        est  line  that  is guaranteed to be processable is the parameter size.
 1235        You can change the default parameter value by adding, for example,
 1237          --with-pcregrep-bufsize=50K
 1239        to the configure command. The caller of pcregrep can, however, override
 1240        this value by specifying a run-time option.
 1245        If you add
 1247          --enable-pcretest-libreadline
 1249        to  the  configure  command,  pcretest  is  linked with the libreadline
 1250        library, and when its input is from a terminal, it reads it  using  the
 1251        readline() function. This provides line-editing and history facilities.
 1252        Note that libreadline is GPL-licensed, so if you distribute a binary of
 1253        pcretest linked in this way, there may be licensing issues.
 1255        Setting  this  option  causes  the -lreadline option to be added to the
 1256        pcretest build. In many operating environments with  a  sytem-installed
 1257        libreadline this is sufficient. However, in some environments (e.g.  if
 1258        an unmodified distribution version of readline is in use),  some  extra
 1259        configuration  may  be necessary. The INSTALL file for libreadline says
 1260        this:
 1262          "Readline uses the termcap functions, but does not link with the
 1263          termcap or curses library itself, allowing applications which link
 1264          with readline the to choose an appropriate library."
 1266        If your environment has not been set up so that an appropriate  library
 1267        is automatically included, you may need to add something like
 1269          LIBS="-ncurses"
 1271        immediately before the configure command.
 1276        By adding the
 1278          --enable-valgrind
 1280        option  to to the configure command, PCRE will use valgrind annotations
 1281        to mark certain memory regions as  unaddressable.  This  allows  it  to
 1282        detect invalid memory accesses, and is mostly useful for debugging PCRE
 1283        itself.
 1288        If your C compiler is gcc, you can build a version  of  PCRE  that  can
 1289        generate a code coverage report for its test suite. To enable this, you
 1290        must install lcov version 1.6 or above. Then specify
 1292          --enable-coverage
 1294        to the configure command and build PCRE in the usual way.
 1296        Note that using ccache (a caching C compiler) is incompatible with code
 1297        coverage  reporting. If you have configured ccache to run automatically
 1298        on your system, you must set the environment variable
 1300          CCACHE_DISABLE=1
 1302        before running make to build PCRE, so that ccache is not used.
 1304        When --enable-coverage is used,  the  following  addition  targets  are
 1305        added to the Makefile:
 1307          make coverage
 1309        This  creates  a  fresh  coverage report for the PCRE test suite. It is
 1310        equivalent to running "make coverage-reset", "make  coverage-baseline",
 1311        "make check", and then "make coverage-report".
 1313          make coverage-reset
 1315        This zeroes the coverage counters, but does nothing else.
 1317          make coverage-baseline
 1319        This captures baseline coverage information.
 1321          make coverage-report
 1323        This creates the coverage report.
 1325          make coverage-clean-report
 1327        This  removes the generated coverage report without cleaning the cover-
 1328        age data itself.
 1330          make coverage-clean-data
 1332        This removes the captured coverage data without removing  the  coverage
 1333        files created at compile time (*.gcno).
 1335          make coverage-clean
 1337        This  cleans all coverage data including the generated coverage report.
 1338        For more information about code coverage, see the gcov and  lcov  docu-
 1339        mentation.
 1342 SEE ALSO
 1344        pcreapi(3), pcre16, pcre32, pcre_config(3).
 1347 AUTHOR
 1349        Philip Hazel
 1350        University Computing Service
 1351        Cambridge CB2 3QH, England.
 1356        Last updated: 12 May 2013
 1357        Copyright (c) 1997-2013 University of Cambridge.
 1358 ------------------------------------------------------------------------------
 1361 PCREMATCHING(3)            Library Functions Manual            PCREMATCHING(3)
 1365 NAME
 1366        PCRE - Perl-compatible regular expressions
 1370        This document describes the two different algorithms that are available
 1371        in PCRE for matching a compiled regular expression against a given sub-
 1372        ject  string.  The  "standard"  algorithm  is  the  one provided by the
 1373        pcre_exec(), pcre16_exec() and pcre32_exec() functions. These  work  in
 1374        the  same as as Perl's matching function, and provide a Perl-compatible
 1375        matching  operation.   The  just-in-time  (JIT)  optimization  that  is
 1376        described  in  the pcrejit documentation is compatible with these func-
 1377        tions.
 1379        An  alternative  algorithm  is   provided   by   the   pcre_dfa_exec(),
 1380        pcre16_dfa_exec()  and  pcre32_dfa_exec()  functions; they operate in a
 1381        different way, and are not Perl-compatible. This alternative has advan-
 1382        tages and disadvantages compared with the standard algorithm, and these
 1383        are described below.
 1385        When there is only one possible way in which a given subject string can
 1386        match  a pattern, the two algorithms give the same answer. A difference
 1387        arises, however, when there are multiple possibilities. For example, if
 1388        the pattern
 1390          ^<.*>
 1392        is matched against the string
 1394          <something> <something else> <something further>
 1396        there are three possible answers. The standard algorithm finds only one
 1397        of them, whereas the alternative algorithm finds all three.
 1402        The set of strings that are matched by a regular expression can be rep-
 1403        resented  as  a  tree structure. An unlimited repetition in the pattern
 1404        makes the tree of infinite size, but it is still a tree.  Matching  the
 1405        pattern  to a given subject string (from a given starting point) can be
 1406        thought of as a search of the tree.  There are two  ways  to  search  a
 1407        tree:  depth-first  and  breadth-first, and these correspond to the two
 1408        matching algorithms provided by PCRE.
 1413        In the terminology of Jeffrey Friedl's book "Mastering Regular  Expres-
 1414        sions",  the  standard  algorithm  is an "NFA algorithm". It conducts a
 1415        depth-first search of the pattern tree. That is, it  proceeds  along  a
 1416        single path through the tree, checking that the subject matches what is
 1417        required. When there is a mismatch, the algorithm  tries  any  alterna-
 1418        tives  at  the  current point, and if they all fail, it backs up to the
 1419        previous branch point in the  tree,  and  tries  the  next  alternative
 1420        branch  at  that  level.  This often involves backing up (moving to the
 1421        left) in the subject string as well.  The  order  in  which  repetition
 1422        branches  are  tried  is controlled by the greedy or ungreedy nature of
 1423        the quantifier.
 1425        If a leaf node is reached, a matching string has  been  found,  and  at
 1426        that  point the algorithm stops. Thus, if there is more than one possi-
 1427        ble match, this algorithm returns the first one that it finds.  Whether
 1428        this  is the shortest, the longest, or some intermediate length depends
 1429        on the way the greedy and ungreedy repetition quantifiers are specified
 1430        in the pattern.
 1432        Because  it  ends  up  with a single path through the tree, it is rela-
 1433        tively straightforward for this algorithm to keep  track  of  the  sub-
 1434        strings  that  are  matched  by portions of the pattern in parentheses.
 1435        This provides support for capturing parentheses and back references.
 1440        This algorithm conducts a breadth-first search of  the  tree.  Starting
 1441        from  the  first  matching  point  in the subject, it scans the subject
 1442        string from left to right, once, character by character, and as it does
 1443        this,  it remembers all the paths through the tree that represent valid
 1444        matches. In Friedl's terminology, this is a kind  of  "DFA  algorithm",
 1445        though  it is not implemented as a traditional finite state machine (it
 1446        keeps multiple states active simultaneously).
 1448        Although the general principle of this matching algorithm  is  that  it
 1449        scans  the subject string only once, without backtracking, there is one
 1450        exception: when a lookaround assertion is encountered,  the  characters
 1451        following  or  preceding  the  current  point  have to be independently
 1452        inspected.
 1454        The scan continues until either the end of the subject is  reached,  or
 1455        there  are  no more unterminated paths. At this point, terminated paths
 1456        represent the different matching possibilities (if there are none,  the
 1457        match  has  failed).   Thus,  if there is more than one possible match,
 1458        this algorithm finds all of them, and in particular, it finds the long-
 1459        est.  The  matches are returned in decreasing order of length. There is
 1460        an option to stop the algorithm after the first match (which is  neces-
 1461        sarily the shortest) is found.
 1463        Note that all the matches that are found start at the same point in the
 1464        subject. If the pattern
 1466          cat(er(pillar)?)?
 1468        is matched against the string "the caterpillar catchment",  the  result
 1469        will  be the three strings "caterpillar", "cater", and "cat" that start
 1470        at the fifth character of the subject. The algorithm does not automati-
 1471        cally move on to find matches that start at later positions.
 1473        PCRE's  "auto-possessification" optimization usually applies to charac-
 1474        ter repeats at the end of a pattern (as well as internally). For  exam-
 1475        ple, the pattern "a\d+" is compiled as if it were "a\d++" because there
 1476        is no point even considering the possibility of backtracking  into  the
 1477        repeated  digits.  For  DFA matching, this means that only one possible
 1478        match is found. If you really do want multiple matches in  such  cases,
 1479        either use an ungreedy repeat ("a\d+?") or set the PCRE_NO_AUTO_POSSESS
 1480        option when compiling.
 1482        There are a number of features of PCRE regular expressions that are not
 1483        supported by the alternative matching algorithm. They are as follows:
 1485        1.  Because  the  algorithm  finds  all possible matches, the greedy or
 1486        ungreedy nature of repetition quantifiers is not relevant.  Greedy  and
 1487        ungreedy quantifiers are treated in exactly the same way. However, pos-
 1488        sessive quantifiers can make a difference when what follows could  also
 1489        match what is quantified, for example in a pattern like this:
 1491          ^a++\w!
 1493        This  pattern matches "aaab!" but not "aaa!", which would be matched by
 1494        a non-possessive quantifier. Similarly, if an atomic group is  present,
 1495        it  is matched as if it were a standalone pattern at the current point,
 1496        and the longest match is then "locked in" for the rest of  the  overall
 1497        pattern.
 1499        2. When dealing with multiple paths through the tree simultaneously, it
 1500        is not straightforward to keep track of  captured  substrings  for  the
 1501        different  matching  possibilities,  and  PCRE's implementation of this
 1502        algorithm does not attempt to do this. This means that no captured sub-
 1503        strings are available.
 1505        3.  Because no substrings are captured, back references within the pat-
 1506        tern are not supported, and cause errors if encountered.
 1508        4. For the same reason, conditional expressions that use  a  backrefer-
 1509        ence  as  the  condition or test for a specific group recursion are not
 1510        supported.
 1512        5. Because many paths through the tree may be  active,  the  \K  escape
 1513        sequence, which resets the start of the match when encountered (but may
 1514        be on some paths and not on others), is not  supported.  It  causes  an
 1515        error if encountered.
 1517        6.  Callouts  are  supported, but the value of the capture_top field is
 1518        always 1, and the value of the capture_last field is always -1.
 1520        7. The \C escape sequence, which (in  the  standard  algorithm)  always
 1521        matches  a  single data unit, even in UTF-8, UTF-16 or UTF-32 modes, is
 1522        not supported in these modes, because the alternative  algorithm  moves
 1523        through the subject string one character (not data unit) at a time, for
 1524        all active paths through the tree.
 1526        8. Except for (*FAIL), the backtracking control verbs such as  (*PRUNE)
 1527        are  not  supported.  (*FAIL)  is supported, and behaves like a failing
 1528        negative assertion.
 1533        Using the alternative matching algorithm provides the following  advan-
 1534        tages:
 1536        1. All possible matches (at a single point in the subject) are automat-
 1537        ically found, and in particular, the longest match is  found.  To  find
 1538        more than one match using the standard algorithm, you have to do kludgy
 1539        things with callouts.
 1541        2. Because the alternative algorithm  scans  the  subject  string  just
 1542        once, and never needs to backtrack (except for lookbehinds), it is pos-
 1543        sible to pass very long subject strings to  the  matching  function  in
 1544        several pieces, checking for partial matching each time. Although it is
 1545        possible to do multi-segment matching using the standard  algorithm  by
 1546        retaining  partially  matched  substrings,  it is more complicated. The
 1547        pcrepartial documentation gives details of partial  matching  and  dis-
 1548        cusses multi-segment matching.
 1553        The alternative algorithm suffers from a number of disadvantages:
 1555        1.  It  is  substantially  slower  than the standard algorithm. This is
 1556        partly because it has to search for all possible matches, but  is  also
 1557        because it is less susceptible to optimization.
 1559        2. Capturing parentheses and back references are not supported.
 1561        3. Although atomic groups are supported, their use does not provide the
 1562        performance advantage that it does for the standard algorithm.
 1565 AUTHOR
 1567        Philip Hazel
 1568        University Computing Service
 1569        Cambridge CB2 3QH, England.
 1574        Last updated: 12 November 2013
 1575        Copyright (c) 1997-2012 University of Cambridge.
 1576 ------------------------------------------------------------------------------
 1579 PCREAPI(3)                 Library Functions Manual                 PCREAPI(3)
 1583 NAME
 1584        PCRE - Perl-compatible regular expressions
 1586        #include <pcre.h>
 1591        pcre *pcre_compile(const char *pattern, int options,
 1592             const char **errptr, int *erroffset,
 1593             const unsigned char *tableptr);
 1595        pcre *pcre_compile2(const char *pattern, int options,
 1596             int *errorcodeptr,
 1597             const char **errptr, int *erroffset,
 1598             const unsigned char *tableptr);
 1600        pcre_extra *pcre_study(const pcre *code, int options,
 1601             const char **errptr);
 1603        void pcre_free_study(pcre_extra *extra);
 1605        int pcre_exec(const pcre *code, const pcre_extra *extra,
 1606             const char *subject, int length, int startoffset,
 1607             int options, int *ovector, int ovecsize);
 1609        int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
 1610             const char *subject, int length, int startoffset,
 1611             int options, int *ovector, int ovecsize,
 1612             int *workspace, int wscount);
 1617        int pcre_copy_named_substring(const pcre *code,
 1618             const char *subject, int *ovector,
 1619             int stringcount, const char *stringname,
 1620             char *buffer, int buffersize);
 1622        int pcre_copy_substring(const char *subject, int *ovector,
 1623             int stringcount, int stringnumber, char *buffer,
 1624             int buffersize);
 1626        int pcre_get_named_substring(const pcre *code,
 1627             const char *subject, int *ovector,
 1628             int stringcount, const char *stringname,
 1629             const char **stringptr);
 1631        int pcre_get_stringnumber(const pcre *code,
 1632             const char *name);
 1634        int pcre_get_stringtable_entries(const pcre *code,
 1635             const char *name, char **first, char **last);
 1637        int pcre_get_substring(const char *subject, int *ovector,
 1638             int stringcount, int stringnumber,
 1639             const char **stringptr);
 1641        int pcre_get_substring_list(const char *subject,
 1642             int *ovector, int stringcount, const char ***listptr);
 1644        void pcre_free_substring(const char *stringptr);
 1646        void pcre_free_substring_list(const char **stringptr);
 1651        int pcre_jit_exec(const pcre *code, const pcre_extra *extra,
 1652             const char *subject, int length, int startoffset,
 1653             int options, int *ovector, int ovecsize,
 1654             pcre_jit_stack *jstack);
 1656        pcre_jit_stack *pcre_jit_stack_alloc(int startsize, int maxsize);
 1658        void pcre_jit_stack_free(pcre_jit_stack *stack);
 1660        void pcre_assign_jit_stack(pcre_extra *extra,
 1661             pcre_jit_callback callback, void *data);
 1663        const unsigned char *pcre_maketables(void);
 1665        int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
 1666             int what, void *where);
 1668        int pcre_refcount(pcre *code, int adjust);
 1670        int pcre_config(int what, void *where);
 1672        const char *pcre_version(void);
 1674        int pcre_pattern_to_host_byte_order(pcre *code,
 1675             pcre_extra *extra, const unsigned char *tables);
 1680        void *(*pcre_malloc)(size_t);
 1682        void (*pcre_free)(void *);
 1684        void *(*pcre_stack_malloc)(size_t);
 1686        void (*pcre_stack_free)(void *);
 1688        int (*pcre_callout)(pcre_callout_block *);
 1690        int (*pcre_stack_guard)(void);
 1695        As  well  as  support  for  8-bit character strings, PCRE also supports
 1696        16-bit strings (from release 8.30) and  32-bit  strings  (from  release
 1697        8.32),  by means of two additional libraries. They can be built as well
 1698        as, or instead of, the 8-bit library. To avoid too  much  complication,
 1699        this  document describes the 8-bit versions of the functions, with only
 1700        occasional references to the 16-bit and 32-bit libraries.
 1702        The 16-bit and 32-bit functions operate in the same way as their  8-bit
 1703        counterparts;  they  just  use different data types for their arguments
 1704        and results, and their names start with pcre16_ or pcre32_  instead  of
 1705        pcre_.  For  every  option  that  has  UTF8  in  its name (for example,
 1706        PCRE_UTF8), there are corresponding 16-bit and 32-bit names  with  UTF8
 1707        replaced by UTF16 or UTF32, respectively. This facility is in fact just
 1708        cosmetic; the 16-bit and 32-bit option names define the same  bit  val-
 1709        ues.
 1711        References to bytes and UTF-8 in this document should be read as refer-
 1712        ences to 16-bit data units and UTF-16 when using the 16-bit library, or
 1713        32-bit  data  units  and  UTF-32  when using the 32-bit library, unless
 1714        specified otherwise.  More details of the specific differences for  the
 1715        16-bit and 32-bit libraries are given in the pcre16 and pcre32 pages.
 1720        PCRE has its own native API, which is described in this document. There
 1721        are also some wrapper functions (for the 8-bit library only) that  cor-
 1722        respond  to  the  POSIX  regular  expression  API, but they do not give
 1723        access to all the functionality. They are described  in  the  pcreposix
 1724        documentation.  Both  of these APIs define a set of C function calls. A
 1725        C++ wrapper (again for the 8-bit library only) is also distributed with
 1726        PCRE. It is documented in the pcrecpp page.
 1728        The  native  API  C  function prototypes are defined in the header file
 1729        pcre.h, and on Unix-like systems the (8-bit) library itself  is  called
 1730        libpcre.  It  can  normally be accessed by adding -lpcre to the command
 1731        for linking an application that uses PCRE. The header file defines  the
 1732        macros PCRE_MAJOR and PCRE_MINOR to contain the major and minor release
 1733        numbers for the library. Applications can use these to include  support
 1734        for different releases of PCRE.
 1736        In a Windows environment, if you want to statically link an application
 1737        program against a non-dll pcre.a  file,  you  must  define  PCRE_STATIC
 1738        before  including  pcre.h or pcrecpp.h, because otherwise the pcre_mal-
 1739        loc()   and   pcre_free()   exported   functions   will   be   declared
 1740        __declspec(dllimport), with unwanted results.
 1742        The   functions   pcre_compile(),  pcre_compile2(),  pcre_study(),  and
 1743        pcre_exec() are used for compiling and matching regular expressions  in
 1744        a  Perl-compatible  manner. A sample program that demonstrates the sim-
 1745        plest way of using them is provided in the file  called  pcredemo.c  in
 1746        the PCRE source distribution. A listing of this program is given in the
 1747        pcredemo documentation, and the pcresample documentation describes  how
 1748        to compile and run it.
 1750        Just-in-time  compiler  support is an optional feature of PCRE that can
 1751        be built in appropriate hardware environments. It greatly speeds up the
 1752        matching  performance  of  many  patterns.  Simple  programs can easily
 1753        request that it be used if available, by  setting  an  option  that  is
 1754        ignored  when  it is not relevant. More complicated programs might need
 1755        to    make    use    of    the    functions     pcre_jit_stack_alloc(),
 1756        pcre_jit_stack_free(),  and pcre_assign_jit_stack() in order to control
 1757        the JIT code's memory usage.
 1759        From release 8.32 there is also a direct interface for  JIT  execution,
 1760        which  gives  improved performance. The JIT-specific functions are dis-
 1761        cussed in the pcrejit documentation.
 1763        A second matching function, pcre_dfa_exec(), which is not Perl-compati-
 1764        ble,  is  also provided. This uses a different algorithm for the match-
 1765        ing. The alternative algorithm finds all possible matches (at  a  given
 1766        point  in  the  subject), and scans the subject just once (unless there
 1767        are lookbehind assertions). However, this  algorithm  does  not  return
 1768        captured  substrings.  A description of the two matching algorithms and
 1769        their advantages and disadvantages is given in the  pcrematching  docu-
 1770        mentation.
 1772        In  addition  to  the  main compiling and matching functions, there are
 1773        convenience functions for extracting captured substrings from a subject
 1774        string that is matched by pcre_exec(). They are:
 1776          pcre_copy_substring()
 1777          pcre_copy_named_substring()
 1778          pcre_get_substring()
 1779          pcre_get_named_substring()
 1780          pcre_get_substring_list()
 1781          pcre_get_stringnumber()
 1782          pcre_get_stringtable_entries()
 1784        pcre_free_substring() and pcre_free_substring_list() are also provided,
 1785        to free the memory used for extracted strings.
 1787        The function pcre_maketables() is used to  build  a  set  of  character
 1788        tables   in   the   current   locale  for  passing  to  pcre_compile(),
 1789        pcre_exec(), or pcre_dfa_exec(). This is an optional facility  that  is
 1790        provided  for  specialist  use.  Most  commonly,  no special tables are
 1791        passed, in which case internal tables that are generated when  PCRE  is
 1792        built are used.
 1794        The  function  pcre_fullinfo()  is used to find out information about a
 1795        compiled pattern. The function pcre_version() returns a  pointer  to  a
 1796        string containing the version of PCRE and its date of release.
 1798        The  function  pcre_refcount()  maintains  a  reference count in a data
 1799        block containing a compiled pattern. This is provided for  the  benefit
 1800        of object-oriented applications.
 1802        The  global  variables  pcre_malloc and pcre_free initially contain the
 1803        entry points of the standard malloc()  and  free()  functions,  respec-
 1804        tively. PCRE calls the memory management functions via these variables,
 1805        so a calling program can replace them if it  wishes  to  intercept  the
 1806        calls. This should be done before calling any PCRE functions.
 1808        The  global  variables  pcre_stack_malloc  and pcre_stack_free are also
 1809        indirections to memory management functions.  These  special  functions
 1810        are  used  only  when  PCRE is compiled to use the heap for remembering
 1811        data, instead of recursive function calls, when running the pcre_exec()
 1812        function.  See  the  pcrebuild  documentation  for details of how to do
 1813        this. It is a non-standard way of building PCRE, for  use  in  environ-
 1814        ments  that  have  limited stacks. Because of the greater use of memory
 1815        management, it runs more slowly. Separate  functions  are  provided  so
 1816        that  special-purpose  external  code  can  be used for this case. When
 1817        used, these functions always allocate memory blocks of the  same  size.
 1818        There  is  a discussion about PCRE's stack usage in the pcrestack docu-
 1819        mentation.
 1821        The global variable pcre_callout initially contains NULL. It can be set
 1822        by  the  caller  to  a "callout" function, which PCRE will then call at
 1823        specified points during a matching operation. Details are given in  the
 1824        pcrecallout documentation.
 1826        The global variable pcre_stack_guard initially contains NULL. It can be
 1827        set by the caller to a function that is  called  by  PCRE  whenever  it
 1828        starts  to  compile a parenthesized part of a pattern. When parentheses
 1829        are nested, PCRE uses recursive function calls, which use up the system
 1830        stack.  This  function is provided so that applications with restricted
 1831        stacks can force a compilation error if the stack runs out.  The  func-
 1832        tion should return zero if all is well, or non-zero to force an error.
 1837        PCRE  supports five different conventions for indicating line breaks in
 1838        strings: a single CR (carriage return) character, a  single  LF  (line-
 1839        feed) character, the two-character sequence CRLF, any of the three pre-
 1840        ceding, or any Unicode newline sequence. The Unicode newline  sequences
 1841        are  the  three just mentioned, plus the single characters VT (vertical
 1842        tab, U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line
 1843        separator, U+2028), and PS (paragraph separator, U+2029).
 1845        Each  of  the first three conventions is used by at least one operating
 1846        system as its standard newline sequence. When PCRE is built, a  default
 1847        can  be  specified.  The default default is LF, which is the Unix stan-
 1848        dard. When PCRE is run, the default can be overridden,  either  when  a
 1849        pattern is compiled, or when it is matched.
 1851        At compile time, the newline convention can be specified by the options
 1852        argument of pcre_compile(), or it can be specified by special  text  at
 1853        the start of the pattern itself; this overrides any other settings. See
 1854        the pcrepattern page for details of the special character sequences.
 1856        In the PCRE documentation the word "newline" is used to mean "the char-
 1857        acter  or pair of characters that indicate a line break". The choice of
 1858        newline convention affects the handling of  the  dot,  circumflex,  and
 1859        dollar metacharacters, the handling of #-comments in /x mode, and, when
 1860        CRLF is a recognized line ending sequence, the match position  advance-
 1861        ment for a non-anchored pattern. There is more detail about this in the
 1862        section on pcre_exec() options below.
 1864        The choice of newline convention does not affect the interpretation  of
 1865        the  \n  or  \r  escape  sequences, nor does it affect what \R matches,
 1866        which is controlled in a similar way, but by separate options.
 1871        The PCRE functions can be used in  multi-threading  applications,  with
 1872        the  proviso  that  the  memory  management  functions  pointed  to  by
 1873        pcre_malloc, pcre_free, pcre_stack_malloc, and pcre_stack_free, and the
 1874        callout  and  stack-checking  functions  pointed to by pcre_callout and
 1875        pcre_stack_guard, are shared by all threads.
 1877        The compiled form of a regular expression is not altered during  match-
 1878        ing, so the same compiled pattern can safely be used by several threads
 1879        at once.
 1881        If the just-in-time optimization feature is being used, it needs  sepa-
 1882        rate  memory stack areas for each thread. See the pcrejit documentation
 1883        for more details.
 1888        The compiled form of a regular expression can be saved and re-used at a
 1889        later  time,  possibly by a different program, and even on a host other
 1890        than the one on which  it  was  compiled.  Details  are  given  in  the
 1891        pcreprecompile  documentation,  which  includes  a  description  of the
 1892        pcre_pattern_to_host_byte_order() function. However, compiling a  regu-
 1893        lar  expression  with one version of PCRE for use with a different ver-
 1894        sion is not guaranteed to work and may cause crashes.
 1899        int pcre_config(int what, void *where);
 1901        The function pcre_config() makes it possible for a PCRE client to  dis-
 1902        cover which optional features have been compiled into the PCRE library.
 1903        The pcrebuild documentation has more details about these optional  fea-
 1904        tures.
 1906        The  first  argument  for pcre_config() is an integer, specifying which
 1907        information is required; the second argument is a pointer to a variable
 1908        into  which  the  information  is placed. The returned value is zero on
 1909        success, or the negative error code PCRE_ERROR_BADOPTION if  the  value
 1910        in  the  first argument is not recognized. The following information is
 1911        available:
 1913          PCRE_CONFIG_UTF8
 1915        The output is an integer that is set to one if UTF-8 support is  avail-
 1916        able;  otherwise it is set to zero. This value should normally be given
 1917        to the 8-bit version of this function, pcre_config(). If it is given to
 1918        the   16-bit  or  32-bit  version  of  this  function,  the  result  is
 1921          PCRE_CONFIG_UTF16
 1923        The output is an integer that is set to one if UTF-16 support is avail-
 1924        able;  otherwise it is set to zero. This value should normally be given
 1925        to the 16-bit version of this function, pcre16_config(). If it is given
 1926        to  the  8-bit  or  32-bit  version  of  this  function,  the result is
 1929          PCRE_CONFIG_UTF32
 1931        The output is an integer that is set to one if UTF-32 support is avail-
 1932        able;  otherwise it is set to zero. This value should normally be given
 1933        to the 32-bit version of this function, pcre32_config(). If it is given
 1934        to  the  8-bit  or  16-bit  version  of  this  function,  the result is
 1939        The output is an integer that is set to  one  if  support  for  Unicode
 1940        character properties is available; otherwise it is set to zero.
 1942          PCRE_CONFIG_JIT
 1944        The output is an integer that is set to one if support for just-in-time
 1945        compiling is available; otherwise it is set to zero.
 1949        The output is a pointer to a zero-terminated "const char *" string.  If
 1950        JIT support is available, the string contains the name of the architec-
 1951        ture for which the JIT compiler is configured, for example  "x86  32bit
 1952        (little  endian  +  unaligned)".  If  JIT support is not available, the
 1953        result is NULL.
 1955          PCRE_CONFIG_NEWLINE
 1957        The output is an integer whose value specifies  the  default  character
 1958        sequence  that  is recognized as meaning "newline". The values that are
 1959        supported in ASCII/Unicode environments are: 10 for LF, 13 for CR, 3338
 1960        for  CRLF,  -2 for ANYCRLF, and -1 for ANY. In EBCDIC environments, CR,
 1961        ANYCRLF, and ANY yield the same values. However, the value  for  LF  is
 1962        normally  21, though some EBCDIC environments use 37. The corresponding
 1963        values for CRLF are 3349 and 3365. The default should  normally  corre-
 1964        spond to the standard sequence for your operating system.
 1966          PCRE_CONFIG_BSR
 1968        The output is an integer whose value indicates what character sequences
 1969        the \R escape sequence matches by default. A value of 0 means  that  \R
 1970        matches  any  Unicode  line ending sequence; a value of 1 means that \R
 1971        matches only CR, LF, or CRLF. The default can be overridden when a pat-
 1972        tern is compiled or matched.
 1974          PCRE_CONFIG_LINK_SIZE
 1976        The  output  is  an  integer that contains the number of bytes used for
 1977        internal  linkage  in  compiled  regular  expressions.  For  the  8-bit
 1978        library, the value can be 2, 3, or 4. For the 16-bit library, the value
 1979        is either 2 or 4 and is  still  a  number  of  bytes.  For  the  32-bit
 1980        library, the value is either 2 or 4 and is still a number of bytes. The
 1981        default value of 2 is sufficient for all but the most massive patterns,
 1982        since  it  allows  the compiled pattern to be up to 64K in size. Larger
 1983        values allow larger regular expressions to be compiled, at the  expense
 1984        of slower matching.
 1988        The  output  is  an integer that contains the threshold above which the
 1989        POSIX interface uses malloc() for output vectors. Further  details  are
 1990        given in the pcreposix documentation.
 1994        The output is a long integer that gives the maximum depth of nesting of
 1995        parentheses (of any kind) in a pattern. This limit is  imposed  to  cap
 1996        the amount of system stack used when a pattern is compiled. It is spec-
 1997        ified when PCRE is built; the default is 250. This limit does not  take
 1998        into account the stack that may already be used by the calling applica-
 1999        tion. For finer control over compilation stack usage,  you  can  set  a
 2000        pointer to an external checking function in pcre_stack_guard.
 2004        The  output is a long integer that gives the default limit for the num-
 2005        ber of internal matching function calls  in  a  pcre_exec()  execution.
 2006        Further details are given with pcre_exec() below.
 2010        The output is a long integer that gives the default limit for the depth
 2011        of  recursion  when  calling  the  internal  matching  function  in   a
 2012        pcre_exec()  execution.  Further  details  are  given  with pcre_exec()
 2013        below.
 2017        The output is an integer that is set to one if internal recursion  when
 2018        running pcre_exec() is implemented by recursive function calls that use
 2019        the stack to remember their state. This is the usual way that  PCRE  is
 2020        compiled. The output is zero if PCRE was compiled to use blocks of data
 2021        on the  heap  instead  of  recursive  function  calls.  In  this  case,
 2022        pcre_stack_malloc  and  pcre_stack_free  are  called  to  manage memory
 2023        blocks on the heap, thus avoiding the use of the stack.
 2028        pcre *pcre_compile(const char *pattern, int options,
 2029             const char **errptr, int *erroffset,
 2030             const unsigned char *tableptr);
 2032        pcre *pcre_compile2(const char *pattern, int options,
 2033             int *errorcodeptr,
 2034             const char **errptr, int *erroffset,
 2035             const unsigned char *tableptr);
 2037        Either of the functions pcre_compile() or pcre_compile2() can be called
 2038        to compile a pattern into an internal form. The only difference between
 2039        the two interfaces is that pcre_compile2() has an additional  argument,
 2040        errorcodeptr,  via  which  a  numerical  error code can be returned. To
 2041        avoid too much repetition, we refer just to pcre_compile()  below,  but
 2042        the information applies equally to pcre_compile2().
 2044        The pattern is a C string terminated by a binary zero, and is passed in
 2045        the pattern argument. A pointer to a single block  of  memory  that  is
 2046        obtained  via  pcre_malloc is returned. This contains the compiled code
 2047        and related data. The pcre type is defined for the returned block; this
 2048        is a typedef for a structure whose contents are not externally defined.
 2049        It is up to the caller to free the memory (via pcre_free) when it is no
 2050        longer required.
 2052        Although  the compiled code of a PCRE regex is relocatable, that is, it
 2053        does not depend on memory location, the complete pcre data block is not
 2054        fully  relocatable, because it may contain a copy of the tableptr argu-
 2055        ment, which is an address (see below).
 2057        The options argument contains various bit settings that affect the com-
 2058        pilation.  It  should be zero if no options are required. The available
 2059        options are described below. Some of them (in  particular,  those  that
 2060        are  compatible with Perl, but some others as well) can also be set and
 2061        unset from within the pattern (see  the  detailed  description  in  the
 2062        pcrepattern  documentation). For those options that can be different in
 2063        different parts of the pattern, the contents of  the  options  argument
 2064        specifies their settings at the start of compilation and execution. The
 2066        PCRE_NO_START_OPTIMIZE  options  can  be set at the time of matching as
 2067        well as at compile time.
 2069        If errptr is NULL, pcre_compile() returns NULL immediately.  Otherwise,
 2070        if  compilation  of  a  pattern fails, pcre_compile() returns NULL, and
 2071        sets the variable pointed to by errptr to point to a textual error mes-
 2072        sage. This is a static string that is part of the library. You must not
 2073        try to free it. Normally, the offset from the start of the  pattern  to
 2074        the data unit that was being processed when the error was discovered is
 2075        placed in the variable pointed to by erroffset, which must not be  NULL
 2076        (if  it is, an immediate error is given). However, for an invalid UTF-8
 2077        or UTF-16 string, the offset is that of the  first  data  unit  of  the
 2078        failing character.
 2080        Some  errors are not detected until the whole pattern has been scanned;
 2081        in these cases, the offset passed back is the length  of  the  pattern.
 2082        Note  that  the  offset is in data units, not characters, even in a UTF
 2083        mode. It may sometimes point into the middle of a UTF-8 or UTF-16 char-
 2084        acter.
 2086        If  pcre_compile2()  is  used instead of pcre_compile(), and the error-
 2087        codeptr argument is not NULL, a non-zero error code number is  returned
 2088        via  this argument in the event of an error. This is in addition to the
 2089        textual error message. Error codes and messages are listed below.
 2091        If the final argument, tableptr, is NULL, PCRE uses a  default  set  of
 2092        character  tables  that  are  built  when  PCRE  is compiled, using the
 2093        default C locale. Otherwise, tableptr must be an address  that  is  the
 2094        result  of  a  call to pcre_maketables(). This value is stored with the
 2095        compiled pattern, and used again  by  pcre_exec()  and  pcre_dfa_exec()
 2096        when  the  pattern  is matched. For more discussion, see the section on
 2097        locale support below.
 2099        This code fragment shows a typical straightforward  call  to  pcre_com-
 2100        pile():
 2102          pcre *re;
 2103          const char *error;
 2104          int erroffset;
 2105          re = pcre_compile(
 2106            "^A.*Z",          /* the pattern */
 2107            0,                /* default options */
 2108            &error,           /* for error message */
 2109            &erroffset,       /* for error offset */
 2110            NULL);            /* use default character tables */
 2112        The  following  names  for option bits are defined in the pcre.h header
 2113        file:
 2115          PCRE_ANCHORED
 2117        If this bit is set, the pattern is forced to be "anchored", that is, it
 2118        is  constrained to match only at the first matching point in the string
 2119        that is being searched (the "subject string"). This effect can also  be
 2120        achieved  by appropriate constructs in the pattern itself, which is the
 2121        only way to do it in Perl.
 2123          PCRE_AUTO_CALLOUT
 2125        If this bit is set, pcre_compile() automatically inserts callout items,
 2126        all  with  number  255, before each pattern item. For discussion of the
 2127        callout facility, see the pcrecallout documentation.
 2129          PCRE_BSR_ANYCRLF
 2130          PCRE_BSR_UNICODE
 2132        These options (which are mutually exclusive) control what the \R escape
 2133        sequence  matches.  The choice is either to match only CR, LF, or CRLF,
 2134        or to match any Unicode newline sequence. The default is specified when
 2135        PCRE is built. It can be overridden from within the pattern, or by set-
 2136        ting an option when a compiled pattern is matched.
 2138          PCRE_CASELESS
 2140        If this bit is set, letters in the pattern match both upper  and  lower
 2141        case  letters.  It  is  equivalent  to  Perl's /i option, and it can be
 2142        changed within a pattern by a (?i) option setting. In UTF-8 mode,  PCRE
 2143        always  understands the concept of case for characters whose values are
 2144        less than 128, so caseless matching is always possible. For  characters
 2145        with  higher  values,  the concept of case is supported if PCRE is com-
 2146        piled with Unicode property support, but not otherwise. If you want  to
 2147        use  caseless  matching  for  characters 128 and above, you must ensure
 2148        that PCRE is compiled with Unicode property support  as  well  as  with
 2149        UTF-8 support.
 2151          PCRE_DOLLAR_ENDONLY
 2153        If  this bit is set, a dollar metacharacter in the pattern matches only
 2154        at the end of the subject string. Without this option,  a  dollar  also
 2155        matches  immediately before a newline at the end of the string (but not
 2156        before any other newlines). The PCRE_DOLLAR_ENDONLY option  is  ignored
 2157        if  PCRE_MULTILINE  is  set.   There is no equivalent to this option in
 2158        Perl, and no way to set it within a pattern.
 2160          PCRE_DOTALL
 2162        If this bit is set, a dot metacharacter in the pattern matches a  char-
 2163        acter of any value, including one that indicates a newline. However, it
 2164        only ever matches one character, even if newlines are  coded  as  CRLF.
 2165        Without  this option, a dot does not match when the current position is
 2166        at a newline. This option is equivalent to Perl's /s option, and it can
 2167        be  changed within a pattern by a (?s) option setting. A negative class
 2168        such as [^a] always matches newline characters, independent of the set-
 2169        ting of this option.
 2171          PCRE_DUPNAMES
 2173        If  this  bit is set, names used to identify capturing subpatterns need
 2174        not be unique. This can be helpful for certain types of pattern when it
 2175        is  known  that  only  one instance of the named subpattern can ever be
 2176        matched. There are more details of named subpatterns  below;  see  also
 2177        the pcrepattern documentation.
 2179          PCRE_EXTENDED
 2181        If  this  bit  is  set,  most white space characters in the pattern are
 2182        totally ignored except when escaped or inside a character  class.  How-
 2183        ever,  white  space  is  not  allowed within sequences such as (?> that
 2184        introduce various parenthesized subpatterns,  nor  within  a  numerical
 2185        quantifier  such as {1,3}.  However, ignorable white space is permitted
 2186        between an item and a following quantifier and between a quantifier and
 2187        a following + that indicates possessiveness.
 2189        White space did not used to include the VT character (code 11), because
 2190        Perl did not treat this character as white space. However, Perl changed
 2191        at  release  5.18,  so  PCRE  followed  at  release 8.34, and VT is now
 2192        treated as white space.
 2194        PCRE_EXTENDED also causes characters between an unescaped #  outside  a
 2195        character  class  and  the  next  newline,  inclusive,  to  be ignored.
 2196        PCRE_EXTENDED is equivalent to Perl's /x option, and it can be  changed
 2197        within a pattern by a (?x) option setting.
 2199        Which  characters  are  interpreted  as  newlines  is controlled by the
 2200        options passed to pcre_compile() or by a special sequence at the  start
 2201        of  the  pattern, as described in the section entitled "Newline conven-
 2202        tions" in the pcrepattern documentation. Note that the end of this type
 2203        of  comment  is  a  literal  newline  sequence  in  the pattern; escape
 2204        sequences that happen to represent a newline do not count.
 2206        This option makes it possible to include  comments  inside  complicated
 2207        patterns.   Note,  however,  that this applies only to data characters.
 2208        White space  characters  may  never  appear  within  special  character
 2209        sequences in a pattern, for example within the sequence (?( that intro-
 2210        duces a conditional subpattern.
 2212          PCRE_EXTRA
 2214        This option was invented in order to turn on  additional  functionality
 2215        of  PCRE  that  is  incompatible with Perl, but it is currently of very
 2216        little use. When set, any backslash in a pattern that is followed by  a
 2217        letter  that  has  no  special  meaning causes an error, thus reserving
 2218        these combinations for future expansion. By  default,  as  in  Perl,  a
 2219        backslash  followed by a letter with no special meaning is treated as a
 2220        literal. (Perl can, however, be persuaded to give an error for this, by
 2221        running  it with the -w option.) There are at present no other features
 2222        controlled by this option. It can also be set by a (?X) option  setting
 2223        within a pattern.
 2225          PCRE_FIRSTLINE
 2227        If  this  option  is  set,  an  unanchored pattern is required to match
 2228        before or at the first  newline  in  the  subject  string,  though  the
 2229        matched text may continue over the newline.
 2233        If this option is set, PCRE's behaviour is changed in some ways so that
 2234        it is compatible with JavaScript rather than Perl. The changes  are  as
 2235        follows:
 2237        (1)  A  lone  closing square bracket in a pattern causes a compile-time
 2238        error, because this is illegal in JavaScript (by default it is  treated
 2239        as a data character). Thus, the pattern AB]CD becomes illegal when this
 2240        option is set.
 2242        (2) At run time, a back reference to an unset subpattern group  matches
 2243        an  empty  string (by default this causes the current matching alterna-
 2244        tive to fail). A pattern such as (\1)(a) succeeds when this  option  is
 2245        set  (assuming  it can find an "a" in the subject), whereas it fails by
 2246        default, for Perl compatibility.
 2248        (3) \U matches an upper case "U" character; by default \U causes a com-
 2249        pile time error (Perl uses \U to upper case subsequent characters).
 2251        (4) \u matches a lower case "u" character unless it is followed by four
 2252        hexadecimal digits, in which case the hexadecimal  number  defines  the
 2253        code  point  to match. By default, \u causes a compile time error (Perl
 2254        uses it to upper case the following character).
 2256        (5) \x matches a lower case "x" character unless it is followed by  two
 2257        hexadecimal  digits,  in  which case the hexadecimal number defines the
 2258        code point to match. By default, as in Perl, a  hexadecimal  number  is
 2259        always expected after \x, but it may have zero, one, or two digits (so,
 2260        for example, \xz matches a binary zero character followed by z).
 2262          PCRE_MULTILINE
 2264        By default, for the purposes of matching "start of line"  and  "end  of
 2265        line", PCRE treats the subject string as consisting of a single line of
 2266        characters, even if it actually contains newlines. The "start of  line"
 2267        metacharacter (^) matches only at the start of the string, and the "end
 2268        of line" metacharacter ($) matches only at the end of  the  string,  or
 2269        before  a terminating newline (except when PCRE_DOLLAR_ENDONLY is set).
 2270        Note, however, that unless PCRE_DOTALL  is  set,  the  "any  character"
 2271        metacharacter  (.)  does not match at a newline. This behaviour (for ^,
 2272        $, and dot) is the same as Perl.
 2274        When PCRE_MULTILINE it is set, the "start of line" and  "end  of  line"
 2275        constructs  match  immediately following or immediately before internal
 2276        newlines in the subject string, respectively, as well as  at  the  very
 2277        start  and  end.  This is equivalent to Perl's /m option, and it can be
 2278        changed within a pattern by a (?m) option setting. If there are no new-
 2279        lines  in  a  subject string, or no occurrences of ^ or $ in a pattern,
 2280        setting PCRE_MULTILINE has no effect.
 2282          PCRE_NEVER_UTF
 2284        This option locks out interpretation of the pattern as UTF-8 (or UTF-16
 2285        or  UTF-32  in the 16-bit and 32-bit libraries). In particular, it pre-
 2286        vents the creator of the pattern from switching to  UTF  interpretation
 2287        by starting the pattern with (*UTF). This may be useful in applications
 2288        that  process  patterns  from  external  sources.  The  combination  of
 2289        PCRE_UTF8 and PCRE_NEVER_UTF also causes an error.
 2291          PCRE_NEWLINE_CR
 2292          PCRE_NEWLINE_LF
 2293          PCRE_NEWLINE_CRLF
 2295          PCRE_NEWLINE_ANY
 2297        These  options  override the default newline definition that was chosen
 2298        when PCRE was built. Setting the first or the second specifies  that  a
 2299        newline  is  indicated  by a single character (CR or LF, respectively).
 2300        Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by  the
 2301        two-character  CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF specifies
 2302        that any of the three preceding sequences should be recognized. Setting
 2303        PCRE_NEWLINE_ANY  specifies that any Unicode newline sequence should be
 2304        recognized.
 2306        In an ASCII/Unicode environment, the Unicode newline sequences are  the
 2307        three  just  mentioned,  plus  the  single characters VT (vertical tab,
 2308        U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line sep-
 2309        arator,  U+2028),  and  PS (paragraph separator, U+2029). For the 8-bit
 2310        library, the last two are recognized only in UTF-8 mode.
 2312        When PCRE is compiled to run in an EBCDIC (mainframe) environment,  the
 2313        code for CR is 0x0d, the same as ASCII. However, the character code for
 2314        LF is normally 0x15, though in some EBCDIC environments 0x25  is  used.
 2315        Whichever  of  these  is  not LF is made to correspond to Unicode's NEL
 2316        character. EBCDIC codes are all less than 256. For  more  details,  see
 2317        the pcrebuild documentation.
 2319        The  newline  setting  in  the  options  word  uses three bits that are
 2320        treated as a number, giving eight possibilities. Currently only six are
 2321        used  (default  plus the five values above). This means that if you set
 2322        more than one newline option, the combination may or may not be  sensi-
 2323        ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
 2324        PCRE_NEWLINE_CRLF, but other combinations may yield unused numbers  and
 2325        cause an error.
 2327        The  only  time  that a line break in a pattern is specially recognized
 2328        when compiling is when PCRE_EXTENDED is set. CR and LF are white  space
 2329        characters,  and so are ignored in this mode. Also, an unescaped # out-
 2330        side a character class indicates a comment that lasts until  after  the
 2331        next  line break sequence. In other circumstances, line break sequences
 2332        in patterns are treated as literal data.
 2334        The newline option that is set at compile time becomes the default that
 2335        is used for pcre_exec() and pcre_dfa_exec(), but it can be overridden.
 2337          PCRE_NO_AUTO_CAPTURE
 2339        If this option is set, it disables the use of numbered capturing paren-
 2340        theses in the pattern. Any opening parenthesis that is not followed  by
 2341        ?  behaves as if it were followed by ?: but named parentheses can still
 2342        be used for capturing (and they acquire  numbers  in  the  usual  way).
 2343        There is no equivalent of this option in Perl.
 2345          PCRE_NO_AUTO_POSSESS
 2347        If  this option is set, it disables "auto-possessification". This is an
 2348        optimization that, for example, turns a+b into a++b in order  to  avoid
 2349        backtracks  into  a+ that can never be successful. However, if callouts
 2350        are in use, auto-possessification means that some  of  them  are  never
 2351        taken. You can set this option if you want the matching functions to do
 2352        a full unoptimized search and run all the callouts, but  it  is  mainly
 2353        provided for testing purposes.
 2357        This  is an option that acts at matching time; that is, it is really an
 2358        option for pcre_exec() or pcre_dfa_exec(). If  it  is  set  at  compile
 2359        time,  it is remembered with the compiled pattern and assumed at match-
 2360        ing time. This is necessary if you want to use JIT  execution,  because
 2361        the  JIT  compiler needs to know whether or not this option is set. For
 2362        details see the discussion of PCRE_NO_START_OPTIMIZE below.
 2364          PCRE_UCP
 2366        This option changes the way PCRE processes \B, \b, \D, \d, \S, \s,  \W,
 2367        \w,  and  some  of  the POSIX character classes. By default, only ASCII
 2368        characters are recognized, but if PCRE_UCP is set,  Unicode  properties
 2369        are  used instead to classify characters. More details are given in the
 2370        section on generic character types in the pcrepattern page. If you  set
 2371        PCRE_UCP,  matching  one of the items it affects takes much longer. The
 2372        option is available only if PCRE has been compiled with  Unicode  prop-
 2373        erty support.
 2375          PCRE_UNGREEDY
 2377        This  option  inverts  the "greediness" of the quantifiers so that they
 2378        are not greedy by default, but become greedy if followed by "?". It  is
 2379        not  compatible  with Perl. It can also be set by a (?U) option setting
 2380        within the pattern.
 2382          PCRE_UTF8
 2384        This option causes PCRE to regard both the pattern and the  subject  as
 2385        strings of UTF-8 characters instead of single-byte strings. However, it
 2386        is available only when PCRE is built to include UTF  support.  If  not,
 2387        the  use  of  this option provokes an error. Details of how this option
 2388        changes the behaviour of PCRE are given in the pcreunicode page.
 2390          PCRE_NO_UTF8_CHECK
 2392        When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
 2393        automatically  checked.  There  is  a  discussion about the validity of
 2394        UTF-8 strings in the pcreunicode page. If an invalid UTF-8 sequence  is
 2395        found,  pcre_compile()  returns an error. If you already know that your
 2396        pattern is valid, and you want to skip this check for performance  rea-
 2397        sons,  you  can set the PCRE_NO_UTF8_CHECK option.  When it is set, the
 2398        effect of passing an invalid UTF-8 string as a pattern is undefined. It
 2399        may cause your program to crash or loop. Note that this option can also
 2400        be passed to pcre_exec() and pcre_dfa_exec(), to suppress the  validity
 2401        checking  of  subject strings only. If the same string is being matched
 2402        many times, the option can be safely set for the second and  subsequent
 2403        matchings to improve performance.
 2408        The  following  table  lists  the  error  codes than may be returned by
 2409        pcre_compile2(), along with the error messages that may be returned  by
 2410        both  compiling  functions.  Note  that error messages are always 8-bit
 2411        ASCII strings, even in 16-bit or 32-bit mode. As  PCRE  has  developed,
 2412        some  error codes have fallen out of use. To avoid confusion, they have
 2413        not been re-used.
 2415           0  no error
 2416           1  \ at end of pattern
 2417           2  \c at end of pattern
 2418           3  unrecognized character follows \
 2419           4  numbers out of order in {} quantifier
 2420           5  number too big in {} quantifier
 2421           6  missing terminating ] for character class
 2422           7  invalid escape sequence in character class
 2423           8  range out of order in character class
 2424           9  nothing to repeat
 2425          10  [this code is not in use]
 2426          11  internal error: unexpected repeat
 2427          12  unrecognized character after (? or (?-
 2428          13  POSIX named classes are supported only within a class
 2429          14  missing )
 2430          15  reference to non-existent subpattern
 2431          16  erroffset passed as NULL
 2432          17  unknown option bit(s) set
 2433          18  missing ) after comment
 2434          19  [this code is not in use]
 2435          20  regular expression is too large
 2436          21  failed to get memory
 2437          22  unmatched parentheses
 2438          23  internal error: code overflow
 2439          24  unrecognized character after (?<
 2440          25  lookbehind assertion is not fixed length
 2441          26  malformed number or name after (?(
 2442          27  conditional group contains more than two branches
 2443          28  assertion expected after (?(
 2444          29  (?R or (?[+-]digits must be followed by )
 2445          30  unknown POSIX class name
 2446          31  POSIX collating elements are not supported
 2447          32  this version of PCRE is compiled without UTF support
 2448          33  [this code is not in use]
 2449          34  character value in \x{} or \o{} is too large
 2450          35  invalid condition (?(0)
 2451          36  \C not allowed in lookbehind assertion
 2452          37  PCRE does not support \L, \l, \N{name}, \U, or \u
 2453          38  number after (?C is > 255
 2454          39  closing ) for (?C expected
 2455          40  recursive call could loop indefinitely
 2456          41  unrecognized character after (?P
 2457          42  syntax error in subpattern name (missing terminator)
 2458          43  two named subpatterns have the same name
 2459          44  invalid UTF-8 string (specifically UTF-8)
 2460          45  support for \P, \p, and \X has not been compiled
 2461          46  malformed \P or \p sequence
 2462          47  unknown property name after \P or \p
 2463          48  subpattern name is too long (maximum 32 characters)
 2464          49  too many named subpatterns (maximum 10000)
 2465          50  [this code is not in use]
 2466          51  octal value is greater than \377 in 8-bit non-UTF-8 mode
 2467          52  internal error: overran compiling workspace
 2468          53  internal error: previously-checked referenced subpattern
 2469                not found
 2470          54  DEFINE group contains more than one branch
 2471          55  repeating a DEFINE group is not allowed
 2472          56  inconsistent NEWLINE options
 2473          57  \g is not followed by a braced, angle-bracketed, or quoted
 2474                name/number or by a plain number
 2475          58  a numbered reference must not be zero
 2476          59  an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)
 2477          60  (*VERB) not recognized or malformed
 2478          61  number is too big
 2479          62  subpattern name expected
 2480          63  digit expected after (?+
 2481          64  ] is an invalid data character in JavaScript compatibility mode
 2482          65  different names for subpatterns of the same number are
 2483                not allowed
 2484          66  (*MARK) must have an argument
 2485          67  this version of PCRE is not compiled with Unicode property
 2486                support
 2487          68  \c must be followed by an ASCII character
 2488          69  \k is not followed by a braced, angle-bracketed, or quoted name
 2489          70  internal error: unknown opcode in find_fixedlength()
 2490          71  \N is not supported in a class
 2491          72  too many forward references
 2492          73  disallowed Unicode code point (>= 0xd800 && <= 0xdfff)
 2493          74  invalid UTF-16 string (specifically UTF-16)
 2494          75  name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)
 2495          76  character value in \u.... sequence is too large
 2496          77  invalid UTF-32 string (specifically UTF-32)
 2497          78  setting UTF is disabled by the application
 2498          79  non-hex character in \x{} (closing brace missing?)
 2499          80  non-octal character in \o{} (closing brace missing?)
 2500          81  missing opening brace after \o
 2501          82  parentheses are too deeply nested
 2502          83  invalid range in character class
 2503          84  group name must start with a non-digit
 2504          85  parentheses are too deeply nested (stack check)
 2506        The numbers 32 and 10000 in errors 48 and 49  are  defaults;  different
 2507        values may be used if the limits were changed when PCRE was built.
 2512        pcre_extra *pcre_study(const pcre *code, int options,
 2513             const char **errptr);
 2515        If  a  compiled  pattern is going to be used several times, it is worth
 2516        spending more time analyzing it in order to speed up the time taken for
 2517        matching.  The function pcre_study() takes a pointer to a compiled pat-
 2518        tern as its first argument. If studying the pattern produces additional
 2519        information  that  will  help speed up matching, pcre_study() returns a
 2520        pointer to a pcre_extra block, in which the study_data field points  to
 2521        the results of the study.
 2523        The  returned  value  from  pcre_study()  can  be  passed  directly  to
 2524        pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block  also  con-
 2525        tains  other  fields  that can be set by the caller before the block is
 2526        passed; these are described below in the section on matching a pattern.
 2528        If studying the  pattern  does  not  produce  any  useful  information,
 2529        pcre_study()  returns  NULL  by  default.  In that circumstance, if the
 2530        calling program wants to pass any of the other fields to pcre_exec() or
 2531        pcre_dfa_exec(),  it  must set up its own pcre_extra block. However, if
 2532        pcre_study() is called  with  the  PCRE_STUDY_EXTRA_NEEDED  option,  it
 2533        returns a pcre_extra block even if studying did not find any additional
 2534        information. It may still return NULL, however, if an error  occurs  in
 2535        pcre_study().
 2537        The  second  argument  of  pcre_study() contains option bits. There are
 2538        three further options in addition to PCRE_STUDY_EXTRA_NEEDED:
 2544        If any of these are set, and the just-in-time  compiler  is  available,
 2545        the  pattern  is  further compiled into machine code that executes much
 2546        faster than the pcre_exec()  interpretive  matching  function.  If  the
 2547        just-in-time  compiler is not available, these options are ignored. All
 2548        undefined bits in the options argument must be zero.
 2550        JIT compilation is a heavyweight optimization. It can  take  some  time
 2551        for  patterns  to  be analyzed, and for one-off matches and simple pat-
 2552        terns the benefit of faster execution might be offset by a much  slower
 2553        study time.  Not all patterns can be optimized by the JIT compiler. For
 2554        those that cannot be handled, matching automatically falls back to  the
 2555        pcre_exec()  interpreter.  For more details, see the pcrejit documenta-
 2556        tion.
 2558        The third argument for pcre_study() is a pointer for an error  message.
 2559        If  studying  succeeds  (even  if no data is returned), the variable it
 2560        points to is set to NULL. Otherwise it is set to  point  to  a  textual
 2561        error message. This is a static string that is part of the library. You
 2562        must not try to free it. You should test the  error  pointer  for  NULL
 2563        after calling pcre_study(), to be sure that it has run successfully.
 2565        When  you are finished with a pattern, you can free the memory used for
 2566        the study data by calling pcre_free_study(). This function was added to
 2567        the  API  for  release  8.20. For earlier versions, the memory could be
 2568        freed with pcre_free(), just like the pattern itself. This  will  still
 2569        work  in  cases where JIT optimization is not used, but it is advisable
 2570        to change to the new function when convenient.
 2572        This is a typical way in which pcre_study() is used (except that  in  a
 2573        real application there should be tests for errors):
 2575          int rc;
 2576          pcre *re;
 2577          pcre_extra *sd;
 2578          re = pcre_compile("pattern", 0, &error, &erroroffset, NULL);
 2579          sd = pcre_study(
 2580            re,             /* result of pcre_compile() */
 2581            0,              /* no options */
 2582            &error);        /* set to NULL or points to a message */
 2583          rc = pcre_exec(   /* see below for details of pcre_exec() options */
 2584            re, sd, "subject", 7, 0, 0, ovector, 30);
 2585          ...
 2586          pcre_free_study(sd);
 2587          pcre_free(re);
 2589        Studying a pattern does two things: first, a lower bound for the length
 2590        of subject string that is needed to match the pattern is computed. This
 2591        does not mean that there are any strings of that length that match, but
 2592        it does guarantee that no shorter strings match. The value is  used  to
 2593        avoid wasting time by trying to match strings that are shorter than the
 2594        lower bound. You can find out the value in a calling  program  via  the
 2595        pcre_fullinfo() function.
 2597        Studying a pattern is also useful for non-anchored patterns that do not
 2598        have a single fixed starting character. A bitmap of  possible  starting
 2599        bytes  is  created. This speeds up finding a position in the subject at
 2600        which to start matching. (In 16-bit mode, the bitmap is used for 16-bit
 2601        values  less  than  256.  In 32-bit mode, the bitmap is used for 32-bit
 2602        values less than 256.)
 2604        These two optimizations apply to both pcre_exec() and  pcre_dfa_exec(),
 2605        and  the  information  is also used by the JIT compiler.  The optimiza-
 2606        tions can be disabled by  setting  the  PCRE_NO_START_OPTIMIZE  option.
 2607        You  might want to do this if your pattern contains callouts or (*MARK)
 2608        and you want to make use of these facilities in  cases  where  matching
 2609        fails.
 2611        PCRE_NO_START_OPTIMIZE  can be specified at either compile time or exe-
 2612        cution  time.  However,  if   PCRE_NO_START_OPTIMIZE   is   passed   to
 2613        pcre_exec(), (that is, after any JIT compilation has happened) JIT exe-
 2614        cution is disabled. For JIT execution to work with  PCRE_NO_START_OPTI-
 2615        MIZE, the option must be set at compile time.
 2617        There is a longer discussion of PCRE_NO_START_OPTIMIZE below.
 2622        PCRE  handles  caseless matching, and determines whether characters are
 2623        letters, digits, or whatever, by reference to a set of tables,  indexed
 2624        by  character  code point. When running in UTF-8 mode, or in the 16- or
 2625        32-bit libraries, this applies only to characters with code points less
 2626        than  256.  By  default,  higher-valued code points never match escapes
 2627        such as \w or \d. However, if PCRE is built with Unicode property  sup-
 2628        port,  all  characters can be tested with \p and \P, or, alternatively,
 2629        the PCRE_UCP option can be set when a pattern is compiled; this  causes
 2630        \w  and friends to use Unicode property support instead of the built-in
 2631        tables.
 2633        The use of locales with Unicode is discouraged.  If  you  are  handling
 2634        characters  with  code  points  greater than 128, you should either use
 2635        Unicode support, or use locales, but not try to mix the two.
 2637        PCRE contains an internal set of tables that are used  when  the  final
 2638        argument  of  pcre_compile()  is  NULL.  These  are sufficient for many
 2639        applications.  Normally, the internal tables recognize only ASCII char-
 2640        acters. However, when PCRE is built, it is possible to cause the inter-
 2641        nal tables to be rebuilt in the default "C" locale of the local system,
 2642        which may cause them to be different.
 2644        The  internal tables can always be overridden by tables supplied by the
 2645        application that calls PCRE. These may be created in a different locale
 2646        from  the  default.  As more and more applications change to using Uni-
 2647        code, the need for this locale support is expected to die away.
 2649        External tables are built by calling  the  pcre_maketables()  function,
 2650        which  has no arguments, in the relevant locale. The result can then be
 2651        passed to pcre_compile() as often as necessary. For example,  to  build
 2652        and  use  tables  that  are  appropriate  for  the French locale (where
 2653        accented characters with values greater than 128 are  treated  as  let-
 2654        ters), the following code could be used:
 2656          setlocale(LC_CTYPE, "fr_FR");
 2657          tables = pcre_maketables();
 2658          re = pcre_compile(..., tables);
 2660        The  locale  name "fr_FR" is used on Linux and other Unix-like systems;
 2661        if you are using Windows, the name for the French locale is "french".
 2663        When pcre_maketables() runs, the tables are built  in  memory  that  is
 2664        obtained  via  pcre_malloc. It is the caller's responsibility to ensure
 2665        that the memory containing the tables remains available for as long  as
 2666        it is needed.
 2668        The pointer that is passed to pcre_compile() is saved with the compiled
 2669        pattern, and the same tables are used via this pointer by  pcre_study()
 2670        and  also by pcre_exec() and pcre_dfa_exec(). Thus, for any single pat-
 2671        tern, compilation, studying and matching all happen in the same locale,
 2672        but different patterns can be processed in different locales.
 2674        It  is  possible to pass a table pointer or NULL (indicating the use of
 2675        the internal tables) to pcre_exec() or pcre_dfa_exec() (see the discus-
 2676        sion below in the section on matching a pattern). This facility is pro-
 2677        vided for use with pre-compiled  patterns  that  have  been  saved  and
 2678        reloaded.   Character  tables are not saved with patterns, so if a non-
 2679        standard table was used at compile time, it must be provided again when
 2680        the  reloaded  pattern  is  matched. Attempting to use this facility to
 2681        match a pattern in a different locale from the one in which it was com-
 2682        piled is likely to lead to anomalous (usually incorrect) results.
 2687        int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
 2688             int what, void *where);
 2690        The  pcre_fullinfo() function returns information about a compiled pat-
 2691        tern. It replaces the pcre_info() function, which was removed from  the
 2692        library at version 8.30, after more than 10 years of obsolescence.
 2694        The  first  argument  for  pcre_fullinfo() is a pointer to the compiled
 2695        pattern. The second argument is the result of pcre_study(), or NULL  if
 2696        the  pattern  was not studied. The third argument specifies which piece
 2697        of information is required, and the fourth argument is a pointer  to  a
 2698        variable  to  receive  the  data. The yield of the function is zero for
 2699        success, or one of the following negative numbers:
 2701          PCRE_ERROR_NULL           the argument code was NULL
 2702                                    the argument where was NULL
 2703          PCRE_ERROR_BADMAGIC       the "magic number" was not found
 2704          PCRE_ERROR_BADENDIANNESS  the pattern was compiled with different
 2705                                    endianness
 2706          PCRE_ERROR_BADOPTION      the value of what was invalid
 2707          PCRE_ERROR_UNSET          the requested field is not set
 2709        The "magic number" is placed at the start of each compiled  pattern  as
 2710        an  simple check against passing an arbitrary memory pointer. The endi-
 2711        anness error can occur if a compiled pattern is saved and reloaded on a
 2712        different  host.  Here  is a typical call of pcre_fullinfo(), to obtain
 2713        the length of the compiled pattern:
 2715          int rc;
 2716          size_t length;
 2717          rc = pcre_fullinfo(
 2718            re,               /* result of pcre_compile() */
 2719            sd,               /* result of pcre_study(), or NULL */
 2720            PCRE_INFO_SIZE,   /* what is required */
 2721            &length);         /* where to put the data */
 2723        The possible values for the third argument are defined in  pcre.h,  and
 2724        are as follows:
 2728        Return  the  number  of  the highest back reference in the pattern. The
 2729        fourth argument should point to an int variable. Zero  is  returned  if
 2730        there are no back references.
 2734        Return  the  number of capturing subpatterns in the pattern. The fourth
 2735        argument should point to an int variable.
 2739        Return a pointer to the internal default character tables within  PCRE.
 2740        The  fourth  argument should point to an unsigned char * variable. This
 2741        information call is provided for internal use by the pcre_study() func-
 2742        tion.  External  callers  can  cause PCRE to use its internal tables by
 2743        passing a NULL table pointer.
 2745          PCRE_INFO_FIRSTBYTE (deprecated)
 2747        Return information about the first data unit of any matched string, for
 2748        a  non-anchored  pattern.  The  name of this option refers to the 8-bit
 2749        library, where data units are bytes. The fourth argument  should  point
 2750        to  an  int  variable. Negative values are used for special cases. How-
 2751        ever, this means that when the 32-bit library is  in  non-UTF-32  mode,
 2752        the  full  32-bit range of characters cannot be returned. For this rea-
 2753        son, this value is deprecated;  use  PCRE_INFO_FIRSTCHARACTERFLAGS  and
 2754        PCRE_INFO_FIRSTCHARACTER instead.
 2756        If  there  is  a  fixed first value, for example, the letter "c" from a
 2757        pattern such as (cat|cow|coyote), its value is returned. In  the  8-bit
 2758        library,  the  value is always less than 256. In the 16-bit library the
 2759        value can be up to 0xffff. In the 32-bit library the value can be up to
 2760        0x10ffff.
 2762        If there is no fixed first value, and if either
 2764        (a)  the pattern was compiled with the PCRE_MULTILINE option, and every
 2765        branch starts with "^", or
 2767        (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
 2768        set (if it were set, the pattern would be anchored),
 2770        -1  is  returned, indicating that the pattern matches only at the start
 2771        of a subject string or after any newline within the  string.  Otherwise
 2772        -2 is returned. For anchored patterns, -2 is returned.
 2776        Return  the  value  of  the  first data unit (non-UTF character) of any
 2777        matched string in  the  situation  where  PCRE_INFO_FIRSTCHARACTERFLAGS
 2778        returns  1;  otherwise return 0. The fourth argument should point to an
 2779        uint_t variable.
 2781        In the 8-bit library, the value is always less than 256. In the  16-bit
 2782        library  the value can be up to 0xffff. In the 32-bit library in UTF-32
 2783        mode the value can be up to 0x10ffff, and up  to  0xffffffff  when  not
 2784        using UTF-32 mode.
 2788        Return information about the first data unit of any matched string, for
 2789        a non-anchored pattern. The fourth argument  should  point  to  an  int
 2790        variable.
 2792        If  there  is  a  fixed first value, for example, the letter "c" from a
 2793        pattern such as (cat|cow|coyote), 1  is  returned,  and  the  character
 2794        value  can  be retrieved using PCRE_INFO_FIRSTCHARACTER. If there is no
 2795        fixed first value, and if either
 2797        (a) the pattern was compiled with the PCRE_MULTILINE option, and  every
 2798        branch starts with "^", or
 2800        (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
 2801        set (if it were set, the pattern would be anchored),
 2803        2 is returned, indicating that the pattern matches only at the start of
 2804        a subject string or after any newline within the string. Otherwise 0 is
 2805        returned. For anchored patterns, 0 is returned.
 2809        If the pattern was studied, and this resulted in the construction of  a
 2810        256-bit  table indicating a fixed set of values for the first data unit
 2811        in any matching string, a pointer to the table is  returned.  Otherwise
 2812        NULL  is returned. The fourth argument should point to an unsigned char
 2813        * variable.
 2815          PCRE_INFO_HASCRORLF
 2817        Return 1 if the pattern contains any explicit  matches  for  CR  or  LF
 2818        characters,  otherwise  0.  The  fourth argument should point to an int
 2819        variable. An explicit match is either a literal CR or LF character,  or
 2820        \r or \n.
 2822          PCRE_INFO_JCHANGED
 2824        Return  1  if  the (?J) or (?-J) option setting is used in the pattern,
 2825        otherwise 0. The fourth argument should point to an int variable.  (?J)
 2826        and (?-J) set and unset the local PCRE_DUPNAMES option, respectively.
 2828          PCRE_INFO_JIT
 2830        Return  1  if  the pattern was studied with one of the JIT options, and
 2831        just-in-time compiling was successful. The fourth argument should point
 2832        to  an  int variable. A return value of 0 means that JIT support is not
 2833        available in this version of PCRE, or that the pattern was not  studied
 2834        with  a JIT option, or that the JIT compiler could not handle this par-
 2835        ticular pattern. See the pcrejit documentation for details of what  can
 2836        and cannot be handled.
 2838          PCRE_INFO_JITSIZE
 2840        If  the  pattern was successfully studied with a JIT option, return the
 2841        size of the JIT compiled code, otherwise return zero. The fourth  argu-
 2842        ment should point to a size_t variable.
 2846        Return  the value of the rightmost literal data unit that must exist in
 2847        any matched string, other than at its start, if such a value  has  been
 2848        recorded. The fourth argument should point to an int variable. If there
 2849        is no such value, -1 is returned. For anchored patterns, a last literal
 2850        value  is recorded only if it follows something of variable length. For
 2851        example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
 2852        /^a\dz\d/ the returned value is -1.
 2854        Since  for  the 32-bit library using the non-UTF-32 mode, this function
 2855        is unable to return the full 32-bit range of characters, this value  is
 2856        deprecated;     instead     the     PCRE_INFO_REQUIREDCHARFLAGS     and
 2857        PCRE_INFO_REQUIREDCHAR values should be used.
 2859          PCRE_INFO_MATCH_EMPTY
 2861        Return 1 if the pattern can match an empty  string,  otherwise  0.  The
 2862        fourth argument should point to an int variable.
 2866        If  the  pattern  set  a  match  limit by including an item of the form
 2867        (*LIMIT_MATCH=nnnn) at the start, the value  is  returned.  The  fourth
 2868        argument  should  point to an unsigned 32-bit integer. If no such value
 2869        has  been  set,  the  call  to  pcre_fullinfo()   returns   the   error
 2870        PCRE_ERROR_UNSET.
 2874        Return  the  number  of  characters  (NB not data units) in the longest
 2875        lookbehind assertion in the pattern. This information  is  useful  when
 2876        doing  multi-segment  matching  using  the partial matching facilities.
 2877        Note that the simple assertions \b and \B require a one-character look-
 2878        behind.  \A  also  registers a one-character lookbehind, though it does
 2879        not actually inspect the previous character. This is to ensure that  at
 2880        least one character from the old segment is retained when a new segment
 2881        is processed. Otherwise, if there are no lookbehinds in the pattern, \A
 2882        might match incorrectly at the start of a new segment.
 2884          PCRE_INFO_MINLENGTH
 2886        If  the  pattern  was studied and a minimum length for matching subject
 2887        strings was computed, its value is  returned.  Otherwise  the  returned
 2888        value is -1. The value is a number of characters, which in UTF mode may
 2889        be different from the number of data units. The fourth argument  should
 2890        point  to an int variable. A non-negative value is a lower bound to the
 2891        length of any matching string. There may not be  any  strings  of  that
 2892        length  that  do actually match, but every string that does match is at
 2893        least that long.
 2895          PCRE_INFO_NAMECOUNT
 2897          PCRE_INFO_NAMETABLE
 2899        PCRE supports the use of named as well as numbered capturing  parenthe-
 2900        ses.  The names are just an additional way of identifying the parenthe-
 2901        ses, which still acquire numbers. Several convenience functions such as
 2902        pcre_get_named_substring()  are  provided  for extracting captured sub-
 2903        strings by name. It is also possible to extract the data  directly,  by
 2904        first  converting  the  name to a number in order to access the correct
 2905        pointers in the output vector (described with pcre_exec() below). To do
 2906        the  conversion,  you  need  to  use  the  name-to-number map, which is
 2907        described by these three values.
 2909        The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
 2910        gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
 2911        of each entry; both of these  return  an  int  value.  The  entry  size
 2912        depends  on the length of the longest name. PCRE_INFO_NAMETABLE returns
 2913        a pointer to the first entry of the table. This is a pointer to char in
 2914        the 8-bit library, where the first two bytes of each entry are the num-
 2915        ber of the capturing parenthesis, most significant byte first.  In  the
 2916        16-bit  library,  the pointer points to 16-bit data units, the first of
 2917        which contains the parenthesis  number.  In  the  32-bit  library,  the
 2918        pointer  points  to  32-bit data units, the first of which contains the
 2919        parenthesis number. The rest of the entry is  the  corresponding  name,
 2920        zero terminated.
 2922        The  names are in alphabetical order. If (?| is used to create multiple
 2923        groups with the same number, as described in the section  on  duplicate
 2924        subpattern numbers in the pcrepattern page, the groups may be given the
 2925        same name, but there is only one entry in the  table.  Different  names
 2926        for  groups  of the same number are not permitted.  Duplicate names for
 2927        subpatterns with different numbers are permitted, but only if PCRE_DUP-
 2928        NAMES  is set. They appear in the table in the order in which they were
 2929        found in the pattern. In the absence  of  (?|  this  is  the  order  of
 2930        increasing  number;  when  (?| is used this is not necessarily the case
 2931        because later subpatterns may have lower numbers.
 2933        As a simple example of the name/number table,  consider  the  following
 2934        pattern after compilation by the 8-bit library (assume PCRE_EXTENDED is
 2935        set, so white space - including newlines - is ignored):
 2937          (?<date> (?<year>(\d\d)?\d\d) -
 2938          (?<month>\d\d) - (?<day>\d\d) )
 2940        There are four named subpatterns, so the table has  four  entries,  and
 2941        each  entry  in the table is eight bytes long. The table is as follows,
 2942        with non-printing bytes shows in hexadecimal, and undefined bytes shown
 2943        as ??:
 2945          00 01 d  a  t  e  00 ??
 2946          00 05 d  a  y  00 ?? ??
 2947          00 04 m  o  n  t  h  00
 2948          00 02 y  e  a  r  00 ??
 2950        When  writing  code  to  extract  data from named subpatterns using the
 2951        name-to-number map, remember that the length of the entries  is  likely
 2952        to be different for each compiled pattern.
 2954          PCRE_INFO_OKPARTIAL
 2956        Return  1  if  the  pattern  can  be  used  for  partial  matching with
 2957        pcre_exec(), otherwise 0. The fourth argument should point  to  an  int
 2958        variable.  From  release  8.00,  this  always  returns  1,  because the
 2959        restrictions that previously applied  to  partial  matching  have  been
 2960        lifted.  The  pcrepartial documentation gives details of partial match-
 2961        ing.
 2963          PCRE_INFO_OPTIONS
 2965        Return a copy of the options with which the pattern was  compiled.  The
 2966        fourth  argument  should  point to an unsigned long int variable. These
 2967        option bits are those specified in the call to pcre_compile(), modified
 2968        by any top-level option settings at the start of the pattern itself. In
 2969        other words, they are the options that will be in force  when  matching
 2970        starts.  For  example, if the pattern /(?im)abc(?-i)d/ is compiled with
 2971        the PCRE_EXTENDED option, the result is PCRE_CASELESS,  PCRE_MULTILINE,
 2972        and PCRE_EXTENDED.
 2974        A  pattern  is  automatically  anchored by PCRE if all of its top-level
 2975        alternatives begin with one of the following:
 2977          ^     unless PCRE_MULTILINE is set
 2978          \A    always
 2979          \G    always
 2980          .*    if PCRE_DOTALL is set and there are no back
 2981                  references to the subpattern in which .* appears
 2983        For such patterns, the PCRE_ANCHORED bit is set in the options returned
 2984        by pcre_fullinfo().
 2988        If  the  pattern set a recursion limit by including an item of the form
 2989        (*LIMIT_RECURSION=nnnn) at the start, the value is returned. The fourth
 2990        argument  should  point to an unsigned 32-bit integer. If no such value
 2991        has  been  set,  the  call  to  pcre_fullinfo()   returns   the   error
 2992        PCRE_ERROR_UNSET.
 2994          PCRE_INFO_SIZE
 2996        Return  the  size  of  the  compiled  pattern  in  bytes (for all three
 2997        libraries). The fourth argument should point to a size_t variable. This
 2998        value  does not include the size of the pcre structure that is returned
 2999        by pcre_compile().  The  value  that  is  passed  as  the  argument  to
 3000        pcre_malloc()  when  pcre_compile() is getting memory in which to place
 3001        the compiled data is the value returned by this option plus the size of
 3002        the  pcre  structure. Studying a compiled pattern, with or without JIT,
 3003        does not alter the value returned by this option.
 3005          PCRE_INFO_STUDYSIZE
 3007        Return the size in bytes (for all three libraries) of  the  data  block
 3008        pointed to by the study_data field in a pcre_extra block. If pcre_extra
 3009        is NULL, or there is no study data, zero is returned. The fourth  argu-
 3010        ment  should point to a size_t variable. The study_data field is set by
 3011        pcre_study() to record information that will speed up matching (see the
 3012        section  entitled  "Studying  a  pattern"  above).  The  format  of the
 3013        study_data block is private, but its length is made available via  this
 3014        option  so  that  it  can be saved and restored (see the pcreprecompile
 3015        documentation for details).
 3019        Returns 1 if there is a rightmost literal data unit that must exist  in
 3020        any matched string, other than at its start. The fourth argument should
 3021        point to an int variable. If there is no such value, 0 is returned.  If
 3022        returning  1,  the  character  value  itself  can  be  retrieved  using
 3025        For anchored patterns, a last literal value is recorded only if it fol-
 3026        lows  something  of  variable  length.  For  example,  for  the pattern
 3027        /^a\d+z\d+/  the   returned   value   1   (with   "z"   returned   from
 3028        PCRE_INFO_REQUIREDCHAR), but for /^a\dz\d/ the returned value is 0.
 3032        Return  the value of the rightmost literal data unit that must exist in
 3033        any matched string, other than at its start, if such a value  has  been
 3034        recorded.  The fourth argument should point to an uint32_t variable. If
 3035        there is no such value, 0 is returned.
 3040        int pcre_refcount(pcre *code, int adjust);
 3042        The pcre_refcount() function is used to maintain a reference  count  in
 3043        the data block that contains a compiled pattern. It is provided for the
 3044        benefit of applications that  operate  in  an  object-oriented  manner,
 3045        where different parts of the application may be using the same compiled
 3046        pattern, but you want to free the block when they are all done.
 3048        When a pattern is compiled, the reference count field is initialized to
 3049        zero.   It is changed only by calling this function, whose action is to
 3050        add the adjust value (which may be positive or  negative)  to  it.  The
 3051        yield of the function is the new value. However, the value of the count
 3052        is constrained to lie between 0 and 65535, inclusive. If the new  value
 3053        is outside these limits, it is forced to the appropriate limit value.
 3055        Except  when it is zero, the reference count is not correctly preserved
 3056        if a pattern is compiled on one host and then  transferred  to  a  host
 3057        whose byte-order is different. (This seems a highly unlikely scenario.)
 3062        int pcre_exec(const pcre *code, const pcre_extra *extra,
 3063             const char *subject, int length, int startoffset,
 3064             int options, int *ovector, int ovecsize);
 3066        The  function pcre_exec() is called to match a subject string against a
 3067        compiled pattern, which is passed in the code argument. If the  pattern
 3068        was  studied,  the  result  of  the study should be passed in the extra
 3069        argument. You can call pcre_exec() with the same code and  extra  argu-
 3070        ments  as  many  times as you like, in order to match different subject
 3071        strings with the same pattern.
 3073        This function is the main matching facility  of  the  library,  and  it
 3074        operates  in  a  Perl-like  manner. For specialist use there is also an
 3075        alternative matching function, which is described below in the  section
 3076        about the pcre_dfa_exec() function.
 3078        In  most applications, the pattern will have been compiled (and option-
 3079        ally studied) in the same process that calls pcre_exec().  However,  it
 3080        is possible to save compiled patterns and study data, and then use them
 3081        later in different processes, possibly even on different hosts.  For  a
 3082        discussion about this, see the pcreprecompile documentation.
 3084        Here is an example of a simple call to pcre_exec():
 3086          int rc;
 3087          int ovector[30];
 3088          rc = pcre_exec(
 3089            re,             /* result of pcre_compile() */
 3090            NULL,           /* we didn't study the pattern */
 3091            "some string",  /* the subject string */
 3092            11,             /* the length of the subject string */
 3093            0,              /* start at offset 0 in the subject */
 3094            0,              /* default options */
 3095            ovector,        /* vector of integers for substring information */
 3096            30);            /* number of elements (NOT size in bytes) */
 3098    Extra data for pcre_exec()
 3100        If  the  extra argument is not NULL, it must point to a pcre_extra data
 3101        block. The pcre_study() function returns such a block (when it  doesn't
 3102        return  NULL), but you can also create one for yourself, and pass addi-
 3103        tional information in it. The pcre_extra block contains  the  following
 3104        fields (not necessarily in this order):
 3106          unsigned long int flags;
 3107          void *study_data;
 3108          void *executable_jit;
 3109          unsigned long int match_limit;
 3110          unsigned long int match_limit_recursion;
 3111          void *callout_data;
 3112          const unsigned char *tables;
 3113          unsigned char **mark;
 3115        In  the  16-bit  version  of  this  structure,  the mark field has type
 3116        "PCRE_UCHAR16 **".
 3118        In the 32-bit version of  this  structure,  the  mark  field  has  type
 3119        "PCRE_UCHAR32 **".
 3121        The  flags  field is used to specify which of the other fields are set.
 3122        The flag bits are:
 3126          PCRE_EXTRA_MARK
 3129          PCRE_EXTRA_STUDY_DATA
 3130          PCRE_EXTRA_TABLES
 3132        Other flag bits should be set to zero. The study_data field  and  some-
 3133        times  the executable_jit field are set in the pcre_extra block that is
 3134        returned by pcre_study(), together with the appropriate flag bits.  You
 3135        should  not set these yourself, but you may add to the block by setting
 3136        other fields and their corresponding flag bits.
 3138        The match_limit field provides a means of preventing PCRE from using up
 3139        a  vast amount of resources when running patterns that are not going to
 3140        match, but which have a very large number  of  possibilities  in  their
 3141        search  trees. The classic example is a pattern that uses nested unlim-
 3142        ited repeats.
 3144        Internally, pcre_exec() uses a function called match(), which it  calls
 3145        repeatedly  (sometimes  recursively).  The  limit set by match_limit is
 3146        imposed on the number of times this function is called during a  match,
 3147        which  has  the  effect of limiting the amount of backtracking that can
 3148        take place. For patterns that are not anchored, the count restarts from
 3149        zero for each position in the subject string.
 3151        When pcre_exec() is called with a pattern that was successfully studied
 3152        with a JIT option, the way that the matching is  executed  is  entirely
 3153        different.  However, there is still the possibility of runaway matching
 3154        that goes on for a very long time, and so the match_limit value is also
 3155        used in this case (but in a different way) to limit how long the match-
 3156        ing can continue.
 3158        The default value for the limit can be set  when  PCRE  is  built;  the
 3159        default  default  is 10 million, which handles all but the most extreme
 3160        cases. You can override the default  by  suppling  pcre_exec()  with  a
 3161        pcre_extra     block    in    which    match_limit    is    set,    and
 3162        PCRE_EXTRA_MATCH_LIMIT is set in the  flags  field.  If  the  limit  is
 3163        exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT.
 3165        A  value  for  the  match  limit may also be supplied by an item at the
 3166        start of a pattern of the form
 3168          (*LIMIT_MATCH=d)
 3170        where d is a decimal number. However, such a setting is ignored  unless
 3171        d  is  less  than  the limit set by the caller of pcre_exec() or, if no
 3172        such limit is set, less than the default.
 3174        The match_limit_recursion field is similar to match_limit, but  instead
 3175        of limiting the total number of times that match() is called, it limits
 3176        the depth of recursion. The recursion depth is a  smaller  number  than
 3177        the  total number of calls, because not all calls to match() are recur-
 3178        sive.  This limit is of use only if it is set smaller than match_limit.
 3180        Limiting the recursion depth limits the amount of  machine  stack  that
 3181        can  be used, or, when PCRE has been compiled to use memory on the heap
 3182        instead of the stack, the amount of heap memory that can be used.  This
 3183        limit  is not relevant, and is ignored, when matching is done using JIT
 3184        compiled code.
 3186        The default value for match_limit_recursion can be  set  when  PCRE  is
 3187        built;  the  default  default  is  the  same  value  as the default for
 3188        match_limit. You can override the default by suppling pcre_exec()  with
 3189        a   pcre_extra   block  in  which  match_limit_recursion  is  set,  and
 3190        PCRE_EXTRA_MATCH_LIMIT_RECURSION is set in  the  flags  field.  If  the
 3191        limit is exceeded, pcre_exec() returns PCRE_ERROR_RECURSIONLIMIT.
 3193        A  value for the recursion limit may also be supplied by an item at the
 3194        start of a pattern of the form
 3196          (*LIMIT_RECURSION=d)
 3198        where d is a decimal number. However, such a setting is ignored  unless
 3199        d  is  less  than  the limit set by the caller of pcre_exec() or, if no
 3200        such limit is set, less than the default.
 3202        The callout_data field is used in conjunction with the  "callout"  fea-
 3203        ture, and is described in the pcrecallout documentation.
 3205        The  tables field is provided for use with patterns that have been pre-
 3206        compiled using custom character tables, saved to disc or elsewhere, and
 3207        then  reloaded,  because the tables that were used to compile a pattern
 3208        are not saved with it. See the pcreprecompile documentation for a  dis-
 3209        cussion  of  saving  compiled patterns for later use. If NULL is passed
 3210        using this mechanism, it forces PCRE's internal tables to be used.
 3212        Warning: The tables that pcre_exec() uses must be  the  same  as  those
 3213        that  were used when the pattern was compiled. If this is not the case,
 3214        the behaviour of pcre_exec() is undefined. Therefore, when a pattern is
 3215        compiled  and  matched  in the same process, this field should never be
 3216        set. In this (the most common) case, the correct table pointer is auto-
 3217        matically  passed  with  the  compiled  pattern  from pcre_compile() to
 3218        pcre_exec().
 3220        If PCRE_EXTRA_MARK is set in the flags field, the mark  field  must  be
 3221        set  to point to a suitable variable. If the pattern contains any back-
 3222        tracking control verbs such as (*MARK:NAME), and the execution ends  up
 3223        with  a  name  to  pass back, a pointer to the name string (zero termi-
 3224        nated) is placed in the variable pointed to  by  the  mark  field.  The
 3225        names  are  within  the  compiled pattern; if you wish to retain such a
 3226        name you must copy it before freeing the memory of a compiled  pattern.
 3227        If  there  is no name to pass back, the variable pointed to by the mark
 3228        field is set to NULL. For details of the  backtracking  control  verbs,
 3229        see the section entitled "Backtracking control" in the pcrepattern doc-
 3230        umentation.
 3232    Option bits for pcre_exec()
 3234        The unused bits of the options argument for pcre_exec() must  be  zero.
 3235        The  only  bits  that  may  be set are PCRE_ANCHORED, PCRE_NEWLINE_xxx,
 3238        PCRE_PARTIAL_SOFT.
 3240        If the pattern was successfully studied with one  of  the  just-in-time
 3241        (JIT) compile options, the only supported options for JIT execution are
 3244        unsupported option is used, JIT execution is disabled  and  the  normal
 3245        interpretive code in pcre_exec() is run.
 3247          PCRE_ANCHORED
 3249        The  PCRE_ANCHORED  option  limits pcre_exec() to matching at the first
 3250        matching position. If a pattern was  compiled  with  PCRE_ANCHORED,  or
 3251        turned  out to be anchored by virtue of its contents, it cannot be made
 3252        unachored at matching time.
 3254          PCRE_BSR_ANYCRLF
 3255          PCRE_BSR_UNICODE
 3257        These options (which are mutually exclusive) control what the \R escape
 3258        sequence  matches.  The choice is either to match only CR, LF, or CRLF,
 3259        or to match any Unicode newline sequence. These  options  override  the
 3260        choice that was made or defaulted when the pattern was compiled.
 3262          PCRE_NEWLINE_CR
 3263          PCRE_NEWLINE_LF
 3264          PCRE_NEWLINE_CRLF
 3266          PCRE_NEWLINE_ANY
 3268        These  options  override  the  newline  definition  that  was chosen or
 3269        defaulted when the pattern was compiled. For details, see the  descrip-
 3270        tion  of  pcre_compile()  above.  During  matching,  the newline choice
 3271        affects the behaviour of the dot, circumflex,  and  dollar  metacharac-
 3272        ters.  It may also alter the way the match position is advanced after a
 3273        match failure for an unanchored pattern.
 3276        set,  and a match attempt for an unanchored pattern fails when the cur-
 3277        rent position is at a  CRLF  sequence,  and  the  pattern  contains  no
 3278        explicit  matches  for  CR  or  LF  characters,  the  match position is
 3279        advanced by two characters instead of one, in other words, to after the
 3280        CRLF.
 3282        The above rule is a compromise that makes the most common cases work as
 3283        expected. For example, if the  pattern  is  .+A  (and  the  PCRE_DOTALL
 3284        option is not set), it does not match the string "\r\nA" because, after
 3285        failing at the start, it skips both the CR and the LF before  retrying.
 3286        However,  the  pattern  [\r\n]A does match that string, because it con-
 3287        tains an explicit CR or LF reference, and so advances only by one char-
 3288        acter after the first failure.
 3290        An explicit match for CR of LF is either a literal appearance of one of
 3291        those characters, or one of the \r or  \n  escape  sequences.  Implicit
 3292        matches  such  as [^X] do not count, nor does \s (which includes CR and
 3293        LF in the characters that it matches).
 3295        Notwithstanding the above, anomalous effects may still occur when  CRLF
 3296        is a valid newline sequence and explicit \r or \n escapes appear in the
 3297        pattern.
 3299          PCRE_NOTBOL
 3301        This option specifies that first character of the subject string is not
 3302        the  beginning  of  a  line, so the circumflex metacharacter should not
 3303        match before it. Setting this without PCRE_MULTILINE (at compile  time)
 3304        causes  circumflex  never to match. This option affects only the behav-
 3305        iour of the circumflex metacharacter. It does not affect \A.
 3307          PCRE_NOTEOL
 3309        This option specifies that the end of the subject string is not the end
 3310        of  a line, so the dollar metacharacter should not match it nor (except
 3311        in multiline mode) a newline immediately before it. Setting this  with-
 3312        out PCRE_MULTILINE (at compile time) causes dollar never to match. This
 3313        option affects only the behaviour of the dollar metacharacter. It  does
 3314        not affect \Z or \z.
 3316          PCRE_NOTEMPTY
 3318        An empty string is not considered to be a valid match if this option is
 3319        set. If there are alternatives in the pattern, they are tried.  If  all
 3320        the  alternatives  match  the empty string, the entire match fails. For
 3321        example, if the pattern
 3323          a?b?
 3325        is applied to a string not beginning with "a" or  "b",  it  matches  an
 3326        empty  string at the start of the subject. With PCRE_NOTEMPTY set, this
 3327        match is not valid, so PCRE searches further into the string for occur-
 3328        rences of "a" or "b".
 3332        This  is  like PCRE_NOTEMPTY, except that an empty string match that is
 3333        not at the start of  the  subject  is  permitted.  If  the  pattern  is
 3334        anchored, such a match can occur only if the pattern contains \K.
 3336        Perl     has    no    direct    equivalent    of    PCRE_NOTEMPTY    or
 3337        PCRE_NOTEMPTY_ATSTART, but it does make a special  case  of  a  pattern
 3338        match  of  the empty string within its split() function, and when using
 3339        the /g modifier. It is  possible  to  emulate  Perl's  behaviour  after
 3340        matching a null string by first trying the match again at the same off-
 3341        set with PCRE_NOTEMPTY_ATSTART and  PCRE_ANCHORED,  and  then  if  that
 3342        fails, by advancing the starting offset (see below) and trying an ordi-
 3343        nary match again. There is some code that demonstrates how to  do  this
 3344        in  the  pcredemo sample program. In the most general case, you have to
 3345        check to see if the newline convention recognizes CRLF  as  a  newline,
 3346        and  if so, and the current character is CR followed by LF, advance the
 3347        starting offset by two characters instead of one.
 3351        There are a number of optimizations that pcre_exec() uses at the  start
 3352        of  a  match,  in  order to speed up the process. For example, if it is
 3353        known that an unanchored match must start with a specific character, it
 3354        searches  the  subject  for that character, and fails immediately if it
 3355        cannot find it, without actually running the  main  matching  function.
 3356        This means that a special item such as (*COMMIT) at the start of a pat-
 3357        tern is not considered until after a suitable starting  point  for  the
 3358        match  has been found. Also, when callouts or (*MARK) items are in use,
 3359        these "start-up" optimizations can cause them to be skipped if the pat-
 3360        tern is never actually used. The start-up optimizations are in effect a
 3361        pre-scan of the subject that takes place before the pattern is run.
 3363        The PCRE_NO_START_OPTIMIZE option disables the start-up  optimizations,
 3364        possibly  causing  performance  to  suffer,  but ensuring that in cases
 3365        where the result is "no match", the callouts do occur, and  that  items
 3366        such as (*COMMIT) and (*MARK) are considered at every possible starting
 3367        position in the subject string. If  PCRE_NO_START_OPTIMIZE  is  set  at
 3368        compile  time,  it  cannot  be  unset  at  matching  time.  The  use of
 3369        PCRE_NO_START_OPTIMIZE  at  matching  time  (that  is,  passing  it  to
 3370        pcre_exec())  disables  JIT  execution;  in this situation, matching is
 3371        always done using interpretively.
 3373        Setting PCRE_NO_START_OPTIMIZE can change the  outcome  of  a  matching
 3374        operation.  Consider the pattern
 3376          (*COMMIT)ABC
 3378        When  this  is  compiled, PCRE records the fact that a match must start
 3379        with the character "A". Suppose the subject  string  is  "DEFABC".  The
 3380        start-up  optimization  scans along the subject, finds "A" and runs the
 3381        first match attempt from there. The (*COMMIT) item means that the  pat-
 3382        tern  must  match the current starting position, which in this case, it
 3383        does. However, if the same match  is  run  with  PCRE_NO_START_OPTIMIZE
 3384        set,  the  initial  scan  along the subject string does not happen. The
 3385        first match attempt is run starting  from  "D"  and  when  this  fails,
 3386        (*COMMIT)  prevents  any  further  matches  being tried, so the overall
 3387        result is "no match". If the pattern is studied,  more  start-up  opti-
 3388        mizations  may  be  used. For example, a minimum length for the subject
 3389        may be recorded. Consider the pattern
 3391          (*MARK:A)(X|Y)
 3393        The minimum length for a match is one  character.  If  the  subject  is
 3394        "ABC",  there  will  be  attempts  to  match "ABC", "BC", "C", and then
 3395        finally an empty string.  If the pattern is studied, the final  attempt
 3396        does  not take place, because PCRE knows that the subject is too short,
 3397        and so the (*MARK) is never encountered.  In this  case,  studying  the
 3398        pattern  does  not  affect the overall match result, which is still "no
 3399        match", but it does affect the auxiliary information that is returned.
 3401          PCRE_NO_UTF8_CHECK
 3403        When PCRE_UTF8 is set at compile time, the validity of the subject as a
 3404        UTF-8  string is automatically checked when pcre_exec() is subsequently
 3405        called.  The entire string is checked before any other processing takes
 3406        place.  The  value  of  startoffset  is  also checked to ensure that it
 3407        points to the start of a UTF-8 character. There is a  discussion  about
 3408        the  validity  of  UTF-8 strings in the pcreunicode page. If an invalid
 3409        sequence  of  bytes   is   found,   pcre_exec()   returns   the   error
 3410        PCRE_ERROR_BADUTF8 or, if PCRE_PARTIAL_HARD is set and the problem is a
 3411        truncated character at the end of the subject, PCRE_ERROR_SHORTUTF8. In
 3412        both  cases, information about the precise nature of the error may also
 3413        be returned (see the descriptions of these errors in the section  enti-
 3414        tled  Error return values from pcre_exec() below).  If startoffset con-
 3415        tains a value that does not point to the start of a UTF-8 character (or
 3416        to the end of the subject), PCRE_ERROR_BADUTF8_OFFSET is returned.
 3418        If  you  already  know that your subject is valid, and you want to skip
 3419        these   checks   for   performance   reasons,   you   can    set    the
 3420        PCRE_NO_UTF8_CHECK  option  when calling pcre_exec(). You might want to
 3421        do this for the second and subsequent calls to pcre_exec() if  you  are
 3422        making  repeated  calls  to  find  all  the matches in a single subject
 3423        string. However, you should be  sure  that  the  value  of  startoffset
 3424        points  to  the  start of a character (or the end of the subject). When
 3425        PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid string as a
 3426        subject  or  an invalid value of startoffset is undefined. Your program
 3427        may crash or loop.
 3429          PCRE_PARTIAL_HARD
 3430          PCRE_PARTIAL_SOFT
 3432        These options turn on the partial matching feature. For backwards  com-
 3433        patibility,  PCRE_PARTIAL is a synonym for PCRE_PARTIAL_SOFT. A partial
 3434        match occurs if the end of the subject string is reached  successfully,
 3435        but  there  are not enough subject characters to complete the match. If
 3436        this happens when PCRE_PARTIAL_SOFT (but not PCRE_PARTIAL_HARD) is set,
 3437        matching  continues  by  testing any remaining alternatives. Only if no
 3438        complete match can be found is PCRE_ERROR_PARTIAL returned  instead  of
 3439        PCRE_ERROR_NOMATCH.  In  other  words,  PCRE_PARTIAL_SOFT says that the
 3440        caller is prepared to handle a partial match, but only if  no  complete
 3441        match can be found.
 3443        If  PCRE_PARTIAL_HARD  is  set, it overrides PCRE_PARTIAL_SOFT. In this
 3444        case, if a partial match  is  found,  pcre_exec()  immediately  returns
 3445        PCRE_ERROR_PARTIAL,  without  considering  any  other  alternatives. In
 3446        other words, when PCRE_PARTIAL_HARD is set, a partial match is  consid-
 3447        ered to be more important that an alternative complete match.
 3449        In  both  cases,  the portion of the string that was inspected when the
 3450        partial match was found is set as the first matching string. There is a
 3451        more  detailed  discussion  of partial and multi-segment matching, with
 3452        examples, in the pcrepartial documentation.
 3454    The string to be matched by pcre_exec()
 3456        The subject string is passed to pcre_exec() as a pointer in subject,  a
 3457        length  in  length, and a starting offset in startoffset. The units for
 3458        length and startoffset are bytes for the  8-bit  library,  16-bit  data
 3459        items  for  the  16-bit  library,  and 32-bit data items for the 32-bit
 3460        library.
 3462        If startoffset is negative or greater than the length of  the  subject,
 3463        pcre_exec()  returns  PCRE_ERROR_BADOFFSET. When the starting offset is
 3464        zero, the search for a match starts at the beginning  of  the  subject,
 3465        and  this  is by far the most common case. In UTF-8 or UTF-16 mode, the
 3466        offset must point to the start of a character, or the end of  the  sub-
 3467        ject  (in  UTF-32 mode, one data unit equals one character, so all off-
 3468        sets are valid). Unlike the pattern string,  the  subject  may  contain
 3469        binary zeroes.
 3471        A  non-zero  starting offset is useful when searching for another match
 3472        in the same subject by calling pcre_exec() again after a previous  suc-
 3473        cess.   Setting  startoffset differs from just passing over a shortened
 3474        string and setting PCRE_NOTBOL in the case of  a  pattern  that  begins
 3475        with any kind of lookbehind. For example, consider the pattern
 3477          \Biss\B
 3479        which  finds  occurrences  of "iss" in the middle of words. (\B matches
 3480        only if the current position in the subject is not  a  word  boundary.)
 3481        When  applied  to the string "Mississipi" the first call to pcre_exec()
 3482        finds the first occurrence. If pcre_exec() is called  again  with  just
 3483        the  remainder  of  the  subject,  namely  "issipi", it does not match,
 3484        because \B is always false at the start of the subject, which is deemed
 3485        to  be  a  word  boundary. However, if pcre_exec() is passed the entire
 3486        string again, but with startoffset set to 4, it finds the second occur-
 3487        rence  of "iss" because it is able to look behind the starting point to
 3488        discover that it is preceded by a letter.
 3490        Finding all the matches in a subject is tricky  when  the  pattern  can
 3491        match an empty string. It is possible to emulate Perl's /g behaviour by
 3492        first  trying  the  match  again  at  the   same   offset,   with   the
 3493        PCRE_NOTEMPTY_ATSTART  and  PCRE_ANCHORED  options,  and  then  if that
 3494        fails, advancing the starting  offset  and  trying  an  ordinary  match
 3495        again. There is some code that demonstrates how to do this in the pcre-
 3496        demo sample program. In the most general case, you have to check to see
 3497        if  the newline convention recognizes CRLF as a newline, and if so, and
 3498        the current character is CR followed by LF, advance the starting offset
 3499        by two characters instead of one.
 3501        If  a  non-zero starting offset is passed when the pattern is anchored,
 3502        one attempt to match at the given offset is made. This can only succeed
 3503        if  the  pattern  does  not require the match to be at the start of the
 3504        subject.
 3506    How pcre_exec() returns captured substrings
 3508        In general, a pattern matches a certain portion of the subject, and  in
 3509        addition,  further  substrings  from  the  subject may be picked out by
 3510        parts of the pattern. Following the usage  in  Jeffrey  Friedl's  book,
 3511        this  is  called "capturing" in what follows, and the phrase "capturing
 3512        subpattern" is used for a fragment of a pattern that picks out  a  sub-
 3513        string.  PCRE  supports several other kinds of parenthesized subpattern
 3514        that do not cause substrings to be captured.
 3516        Captured substrings are returned to the caller via a vector of integers
 3517        whose  address is passed in ovector. The number of elements in the vec-
 3518        tor is passed in ovecsize, which must be a non-negative  number.  Note:
 3519        this argument is NOT the size of ovector in bytes.
 3521        The  first  two-thirds of the vector is used to pass back captured sub-
 3522        strings, each substring using a pair of integers. The  remaining  third
 3523        of  the  vector is used as workspace by pcre_exec() while matching cap-
 3524        turing subpatterns, and is not available for passing back  information.
 3525        The  number passed in ovecsize should always be a multiple of three. If
 3526        it is not, it is rounded down.
 3528        When a match is successful, information about  captured  substrings  is
 3529        returned  in  pairs  of integers, starting at the beginning of ovector,
 3530        and continuing up to two-thirds of its length at the  most.  The  first
 3531        element  of  each pair is set to the offset of the first character in a
 3532        substring, and the second is set to the offset of the  first  character
 3533        after  the  end  of a substring. These values are always data unit off-
 3534        sets, even in UTF mode. They are byte offsets  in  the  8-bit  library,
 3535        16-bit  data  item  offsets in the 16-bit library, and 32-bit data item
 3536        offsets in the 32-bit library. Note: they are not character counts.
 3538        The first pair of integers, ovector[0]  and  ovector[1],  identify  the
 3539        portion  of  the subject string matched by the entire pattern. The next
 3540        pair is used for the first capturing subpattern, and so on.  The  value
 3541        returned by pcre_exec() is one more than the highest numbered pair that
 3542        has been set.  For example, if two substrings have been  captured,  the
 3543        returned  value is 3. If there are no capturing subpatterns, the return
 3544        value from a successful match is 1, indicating that just the first pair
 3545        of offsets has been set.
 3547        If a capturing subpattern is matched repeatedly, it is the last portion
 3548        of the string that it matched that is returned.
 3550        If the vector is too small to hold all the captured substring  offsets,
 3551        it is used as far as possible (up to two-thirds of its length), and the
 3552        function returns a value of zero. If neither the actual string  matched
 3553        nor  any captured substrings are of interest, pcre_exec() may be called
 3554        with ovector passed as NULL and ovecsize as zero. However, if the  pat-
 3555        tern  contains  back  references  and  the ovector is not big enough to
 3556        remember the related substrings, PCRE has to get additional memory  for
 3557        use  during matching. Thus it is usually advisable to supply an ovector
 3558        of reasonable size.
 3560        There are some cases where zero is returned  (indicating  vector  over-
 3561        flow)  when  in fact the vector is exactly the right size for the final
 3562        match. For example, consider the pattern
 3564          (a)(?:(b)c|bd)
 3566        If a vector of 6 elements (allowing for only 1 captured  substring)  is
 3567        given with subject string "abd", pcre_exec() will try to set the second
 3568        captured string, thereby recording a vector overflow, before failing to
 3569        match  "c"  and  backing  up  to  try  the second alternative. The zero
 3570        return, however, does correctly indicate that  the  maximum  number  of
 3571        slots (namely 2) have been filled. In similar cases where there is tem-
 3572        porary overflow, but the final number of used slots  is  actually  less
 3573        than the maximum, a non-zero value is returned.
 3575        The pcre_fullinfo() function can be used to find out how many capturing
 3576        subpatterns there are in a compiled  pattern.  The  smallest  size  for
 3577        ovector  that  will allow for n captured substrings, in addition to the
 3578        offsets of the substring matched by the whole pattern, is (n+1)*3.
 3580        It is possible for capturing subpattern number n+1 to match  some  part
 3581        of the subject when subpattern n has not been used at all. For example,
 3582        if the string "abc" is matched  against  the  pattern  (a|(z))(bc)  the
 3583        return from the function is 4, and subpatterns 1 and 3 are matched, but
 3584        2 is not. When this happens, both values in  the  offset  pairs  corre-
 3585        sponding to unused subpatterns are set to -1.
 3587        Offset  values  that correspond to unused subpatterns at the end of the
 3588        expression are also set to -1. For example,  if  the  string  "abc"  is
 3589        matched  against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are not
 3590        matched. The return from the function is 2, because  the  highest  used
 3591        capturing  subpattern  number  is 1, and the offsets for for the second
 3592        and third capturing subpatterns (assuming the vector is  large  enough,
 3593        of course) are set to -1.
 3595        Note:  Elements  in  the first two-thirds of ovector that do not corre-
 3596        spond to capturing parentheses in the pattern are never  changed.  That
 3597        is,  if  a pattern contains n capturing parentheses, no more than ovec-
 3598        tor[0] to ovector[2n+1] are set by pcre_exec(). The other elements  (in
 3599        the first two-thirds) retain whatever values they previously had.
 3601        Some  convenience  functions  are  provided for extracting the captured
 3602        substrings as separate strings. These are described below.
 3604    Error return values from pcre_exec()
 3606        If pcre_exec() fails, it returns a negative number. The  following  are
 3607        defined in the header file:
 3609          PCRE_ERROR_NOMATCH        (-1)
 3611        The subject string did not match the pattern.
 3613          PCRE_ERROR_NULL           (-2)
 3615        Either  code  or  subject  was  passed as NULL, or ovector was NULL and
 3616        ovecsize was not zero.
 3618          PCRE_ERROR_BADOPTION      (-3)
 3620        An unrecognized bit was set in the options argument.
 3622          PCRE_ERROR_BADMAGIC       (-4)
 3624        PCRE stores a 4-byte "magic number" at the start of the compiled  code,
 3625        to catch the case when it is passed a junk pointer and to detect when a
 3626        pattern that was compiled in an environment of one endianness is run in
 3627        an  environment  with the other endianness. This is the error that PCRE
 3628        gives when the magic number is not present.
 3630          PCRE_ERROR_UNKNOWN_OPCODE (-5)
 3632        While running the pattern match, an unknown item was encountered in the
 3633        compiled  pattern.  This  error  could be caused by a bug in PCRE or by
 3634        overwriting of the compiled pattern.
 3636          PCRE_ERROR_NOMEMORY       (-6)
 3638        If a pattern contains back references, but the ovector that  is  passed
 3639        to pcre_exec() is not big enough to remember the referenced substrings,
 3640        PCRE gets a block of memory at the start of matching to  use  for  this
 3641        purpose.  If the call via pcre_malloc() fails, this error is given. The
 3642        memory is automatically freed at the end of matching.
 3644        This error is also given if pcre_stack_malloc() fails  in  pcre_exec().
 3645        This  can happen only when PCRE has been compiled with --disable-stack-
 3646        for-recursion.
 3648          PCRE_ERROR_NOSUBSTRING    (-7)
 3650        This error is used by the pcre_copy_substring(),  pcre_get_substring(),
 3651        and  pcre_get_substring_list()  functions  (see  below).  It  is  never
 3652        returned by pcre_exec().
 3654          PCRE_ERROR_MATCHLIMIT     (-8)
 3656        The backtracking limit, as specified by  the  match_limit  field  in  a
 3657        pcre_extra  structure  (or  defaulted) was reached. See the description
 3658        above.
 3660          PCRE_ERROR_CALLOUT        (-9)
 3662        This error is never generated by pcre_exec() itself. It is provided for
 3663        use  by  callout functions that want to yield a distinctive error code.
 3664        See the pcrecallout documentation for details.
 3666          PCRE_ERROR_BADUTF8        (-10)
 3668        A string that contains an invalid UTF-8 byte sequence was passed  as  a
 3669        subject,  and the PCRE_NO_UTF8_CHECK option was not set. If the size of
 3670        the output vector (ovecsize) is at least 2,  the  byte  offset  to  the
 3671        start  of  the  the invalid UTF-8 character is placed in the first ele-
 3672        ment, and a reason code is placed in the  second  element.  The  reason
 3673        codes are listed in the following section.  For backward compatibility,
 3674        if PCRE_PARTIAL_HARD is set and the problem is a truncated UTF-8  char-
 3675        acter   at   the   end   of   the   subject  (reason  codes  1  to  5),
 3676        PCRE_ERROR_SHORTUTF8 is returned instead of PCRE_ERROR_BADUTF8.
 3678          PCRE_ERROR_BADUTF8_OFFSET (-11)
 3680        The UTF-8 byte sequence that was passed as a subject  was  checked  and
 3681        found  to be valid (the PCRE_NO_UTF8_CHECK option was not set), but the
 3682        value of startoffset did not point to the beginning of a UTF-8  charac-
 3683        ter or the end of the subject.
 3685          PCRE_ERROR_PARTIAL        (-12)
 3687        The  subject  string did not match, but it did match partially. See the
 3688        pcrepartial documentation for details of partial matching.
 3690          PCRE_ERROR_BADPARTIAL     (-13)
 3692        This code is no longer in  use.  It  was  formerly  returned  when  the
 3693        PCRE_PARTIAL  option  was used with a compiled pattern containing items
 3694        that were  not  supported  for  partial  matching.  From  release  8.00
 3695        onwards, there are no restrictions on partial matching.
 3697          PCRE_ERROR_INTERNAL       (-14)
 3699        An  unexpected  internal error has occurred. This error could be caused
 3700        by a bug in PCRE or by overwriting of the compiled pattern.
 3702          PCRE_ERROR_BADCOUNT       (-15)
 3704        This error is given if the value of the ovecsize argument is negative.
 3706          PCRE_ERROR_RECURSIONLIMIT (-21)
 3708        The internal recursion limit, as specified by the match_limit_recursion
 3709        field  in  a  pcre_extra  structure (or defaulted) was reached. See the
 3710        description above.
 3712          PCRE_ERROR_BADNEWLINE     (-23)
 3714        An invalid combination of PCRE_NEWLINE_xxx options was given.
 3716          PCRE_ERROR_BADOFFSET      (-24)
 3718        The value of startoffset was negative or greater than the length of the
 3719        subject, that is, the value in length.
 3721          PCRE_ERROR_SHORTUTF8      (-25)
 3723        This  error  is returned instead of PCRE_ERROR_BADUTF8 when the subject
 3724        string ends with a truncated UTF-8 character and the  PCRE_PARTIAL_HARD
 3725        option  is  set.   Information  about  the  failure  is returned as for
 3726        PCRE_ERROR_BADUTF8. It is in fact sufficient to detect this  case,  but
 3727        this  special error code for PCRE_PARTIAL_HARD precedes the implementa-
 3728        tion of returned information; it is retained for backwards  compatibil-
 3729        ity.
 3731          PCRE_ERROR_RECURSELOOP    (-26)
 3733        This error is returned when pcre_exec() detects a recursion loop within
 3734        the pattern. Specifically, it means that either the whole pattern or  a
 3735        subpattern  has been called recursively for the second time at the same
 3736        position in the subject string. Some simple patterns that might do this
 3737        are  detected  and faulted at compile time, but more complicated cases,
 3738        in particular mutual recursions between two different subpatterns, can-
 3739        not be detected until run time.
 3741          PCRE_ERROR_JIT_STACKLIMIT (-27)
 3743        This  error  is  returned  when a pattern that was successfully studied
 3744        using a JIT compile option is being matched, but the  memory  available
 3745        for  the  just-in-time  processing  stack  is not large enough. See the
 3746        pcrejit documentation for more details.
 3748          PCRE_ERROR_BADMODE        (-28)
 3750        This error is given if a pattern that was compiled by the 8-bit library
 3751        is passed to a 16-bit or 32-bit library function, or vice versa.
 3753          PCRE_ERROR_BADENDIANNESS  (-29)
 3755        This  error  is  given  if  a  pattern  that  was compiled and saved is
 3756        reloaded on a host with  different  endianness.  The  utility  function
 3757        pcre_pattern_to_host_byte_order() can be used to convert such a pattern
 3758        so that it runs on the new host.
 3762        This error is returned when a pattern  that  was  successfully  studied
 3763        using  a  JIT  compile  option  is being matched, but the matching mode
 3764        (partial or complete match) does not correspond to any JIT  compilation
 3765        mode.  When  the JIT fast path function is used, this error may be also
 3766        given for invalid options.  See  the  pcrejit  documentation  for  more
 3767        details.
 3769          PCRE_ERROR_BADLENGTH      (-32)
 3771        This  error is given if pcre_exec() is called with a negative value for
 3772        the length argument.
 3774        Error numbers -16 to -20, -22, and 30 are not used by pcre_exec().
 3776    Reason codes for invalid UTF-8 strings
 3778        This section applies only  to  the  8-bit  library.  The  corresponding
 3779        information  for the 16-bit and 32-bit libraries is given in the pcre16
 3780        and pcre32 pages.
 3782        When pcre_exec() returns either PCRE_ERROR_BADUTF8 or PCRE_ERROR_SHORT-
 3783        UTF8,  and  the size of the output vector (ovecsize) is at least 2, the
 3784        offset of the start of the invalid UTF-8 character  is  placed  in  the
 3785        first output vector element (ovector[0]) and a reason code is placed in
 3786        the second element (ovector[1]). The reason codes are  given  names  in
 3787        the pcre.h header file:
 3789          PCRE_UTF8_ERR1
 3790          PCRE_UTF8_ERR2
 3791          PCRE_UTF8_ERR3
 3792          PCRE_UTF8_ERR4
 3793          PCRE_UTF8_ERR5
 3795        The  string  ends  with a truncated UTF-8 character; the code specifies
 3796        how many bytes are missing (1 to 5). Although RFC 3629 restricts  UTF-8
 3797        characters  to  be  no longer than 4 bytes, the encoding scheme (origi-
 3798        nally defined by RFC 2279) allows for  up  to  6  bytes,  and  this  is
 3799        checked first; hence the possibility of 4 or 5 missing bytes.
 3801          PCRE_UTF8_ERR6
 3802          PCRE_UTF8_ERR7
 3803          PCRE_UTF8_ERR8
 3804          PCRE_UTF8_ERR9
 3805          PCRE_UTF8_ERR10
 3807        The two most significant bits of the 2nd, 3rd, 4th, 5th, or 6th byte of
 3808        the character do not have the binary value 0b10 (that  is,  either  the
 3809        most significant bit is 0, or the next bit is 1).
 3811          PCRE_UTF8_ERR11
 3812          PCRE_UTF8_ERR12
 3814        A  character that is valid by the RFC 2279 rules is either 5 or 6 bytes
 3815        long; these code points are excluded by RFC 3629.
 3817          PCRE_UTF8_ERR13
 3819        A 4-byte character has a value greater than 0x10fff; these code  points
 3820        are excluded by RFC 3629.
 3822          PCRE_UTF8_ERR14
 3824        A  3-byte  character  has  a  value in the range 0xd800 to 0xdfff; this
 3825        range of code points are reserved by RFC 3629 for use with UTF-16,  and
 3826        so are excluded from UTF-8.
 3828          PCRE_UTF8_ERR15
 3829          PCRE_UTF8_ERR16
 3830          PCRE_UTF8_ERR17
 3831          PCRE_UTF8_ERR18
 3832          PCRE_UTF8_ERR19
 3834        A  2-, 3-, 4-, 5-, or 6-byte character is "overlong", that is, it codes
 3835        for a value that can be represented by fewer bytes, which  is  invalid.
 3836        For  example,  the two bytes 0xc0, 0xae give the value 0x2e, whose cor-
 3837        rect coding uses just one byte.
 3839          PCRE_UTF8_ERR20
 3841        The two most significant bits of the first byte of a character have the
 3842        binary  value 0b10 (that is, the most significant bit is 1 and the sec-
 3843        ond is 0). Such a byte can only validly occur as the second  or  subse-
 3844        quent byte of a multi-byte character.
 3846          PCRE_UTF8_ERR21
 3848        The  first byte of a character has the value 0xfe or 0xff. These values
 3849        can never occur in a valid UTF-8 string.
 3851          PCRE_UTF8_ERR22
 3853        This error code was formerly used when  the  presence  of  a  so-called
 3854        "non-character"  caused an error. Unicode corrigendum #9 makes it clear
 3855        that such characters should not cause a string to be rejected,  and  so
 3856        this code is no longer in use and is never returned.
 3861        int pcre_copy_substring(const char *subject, int *ovector,
 3862             int stringcount, int stringnumber, char *buffer,
 3863             int buffersize);
 3865        int pcre_get_substring(const char *subject, int *ovector,
 3866             int stringcount, int stringnumber,
 3867             const char **stringptr);
 3869        int pcre_get_substring_list(const char *subject,
 3870             int *ovector, int stringcount, const char ***listptr);
 3872        Captured  substrings  can  be  accessed  directly  by using the offsets
 3873        returned by pcre_exec() in  ovector.  For  convenience,  the  functions
 3874        pcre_copy_substring(),    pcre_get_substring(),    and    pcre_get_sub-
 3875        string_list() are provided for extracting captured substrings  as  new,
 3876        separate,  zero-terminated strings. These functions identify substrings
 3877        by number. The next section describes functions  for  extracting  named
 3878        substrings.
 3880        A  substring that contains a binary zero is correctly extracted and has
 3881        a further zero added on the end, but the result is not, of course, a  C
 3882        string.   However,  you  can  process such a string by referring to the
 3883        length that is  returned  by  pcre_copy_substring()  and  pcre_get_sub-
 3884        string().  Unfortunately, the interface to pcre_get_substring_list() is
 3885        not adequate for handling strings containing binary zeros, because  the
 3886        end of the final string is not independently indicated.
 3888        The  first  three  arguments  are the same for all three of these func-
 3889        tions: subject is the subject string that has  just  been  successfully
 3890        matched, ovector is a pointer to the vector of integer offsets that was
 3891        passed to pcre_exec(), and stringcount is the number of substrings that
 3892        were  captured  by  the match, including the substring that matched the
 3893        entire regular expression. This is the value returned by pcre_exec() if
 3894        it  is greater than zero. If pcre_exec() returned zero, indicating that
 3895        it ran out of space in ovector, the value passed as stringcount  should
 3896        be the number of elements in the vector divided by three.
 3898        The  functions pcre_copy_substring() and pcre_get_substring() extract a
 3899        single substring, whose number is given as  stringnumber.  A  value  of
 3900        zero  extracts  the  substring that matched the entire pattern, whereas
 3901        higher values  extract  the  captured  substrings.  For  pcre_copy_sub-
 3902        string(),  the  string  is  placed  in buffer, whose length is given by
 3903        buffersize, while for pcre_get_substring() a new  block  of  memory  is
 3904        obtained  via  pcre_malloc,  and its address is returned via stringptr.
 3905        The yield of the function is the length of the  string,  not  including
 3906        the terminating zero, or one of these error codes:
 3908          PCRE_ERROR_NOMEMORY       (-6)
 3910        The  buffer  was too small for pcre_copy_substring(), or the attempt to
 3911        get memory failed for pcre_get_substring().
 3913          PCRE_ERROR_NOSUBSTRING    (-7)
 3915        There is no substring whose number is stringnumber.
 3917        The pcre_get_substring_list()  function  extracts  all  available  sub-
 3918        strings  and  builds  a list of pointers to them. All this is done in a
 3919        single block of memory that is obtained via pcre_malloc. The address of
 3920        the  memory  block  is returned via listptr, which is also the start of
 3921        the list of string pointers. The end of the list is marked  by  a  NULL
 3922        pointer.  The  yield  of  the function is zero if all went well, or the
 3923        error code
 3925          PCRE_ERROR_NOMEMORY       (-6)
 3927        if the attempt to get the memory block failed.
 3929        When any of these functions encounter a substring that is unset,  which
 3930        can  happen  when  capturing subpattern number n+1 matches some part of
 3931        the subject, but subpattern n has not been used at all, they return  an
 3932        empty string. This can be distinguished from a genuine zero-length sub-
 3933        string by inspecting the appropriate offset in ovector, which is  nega-
 3934        tive for unset substrings.
 3936        The  two convenience functions pcre_free_substring() and pcre_free_sub-
 3937        string_list() can be used to free the memory  returned  by  a  previous
 3938        call  of  pcre_get_substring()  or  pcre_get_substring_list(),  respec-
 3939        tively. They do nothing more than  call  the  function  pointed  to  by
 3940        pcre_free,  which  of course could be called directly from a C program.
 3941        However, PCRE is used in some situations where it is linked via a  spe-
 3942        cial   interface  to  another  programming  language  that  cannot  use
 3943        pcre_free directly; it is for these cases that the functions  are  pro-
 3944        vided.
 3949        int pcre_get_stringnumber(const pcre *code,
 3950             const char *name);
 3952        int pcre_copy_named_substring(const pcre *code,
 3953             const char *subject, int *ovector,
 3954             int stringcount, const char *stringname,
 3955             char *buffer, int buffersize);
 3957        int pcre_get_named_substring(const pcre *code,
 3958             const char *subject, int *ovector,
 3959             int stringcount, const char *stringname,
 3960             const char **stringptr);
 3962        To  extract a substring by name, you first have to find associated num-
 3963        ber.  For example, for this pattern
 3965          (a+)b(?<xxx>\d+)...
 3967        the number of the subpattern called "xxx" is 2. If the name is known to
 3968        be unique (PCRE_DUPNAMES was not set), you can find the number from the
 3969        name by calling pcre_get_stringnumber(). The first argument is the com-
 3970        piled pattern, and the second is the name. The yield of the function is
 3971        the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if  there  is  no
 3972        subpattern of that name.
 3974        Given the number, you can extract the substring directly, or use one of
 3975        the functions described in the previous section. For convenience, there
 3976        are also two functions that do the whole job.
 3978        Most    of    the    arguments   of   pcre_copy_named_substring()   and
 3979        pcre_get_named_substring() are the same  as  those  for  the  similarly
 3980        named  functions  that extract by number. As these are described in the
 3981        previous section, they are not re-described here. There  are  just  two
 3982        differences:
 3984        First,  instead  of a substring number, a substring name is given. Sec-
 3985        ond, there is an extra argument, given at the start, which is a pointer
 3986        to  the compiled pattern. This is needed in order to gain access to the
 3987        name-to-number translation table.
 3989        These functions call pcre_get_stringnumber(), and if it succeeds,  they
 3990        then  call  pcre_copy_substring() or pcre_get_substring(), as appropri-
 3991        ate. NOTE: If PCRE_DUPNAMES is set and there are duplicate  names,  the
 3992        behaviour may not be what you want (see the next section).
 3994        Warning: If the pattern uses the (?| feature to set up multiple subpat-
 3995        terns with the same number, as described in the  section  on  duplicate
 3996        subpattern  numbers  in  the  pcrepattern page, you cannot use names to
 3997        distinguish the different subpatterns, because names are  not  included
 3998        in  the compiled code. The matching process uses only numbers. For this
 3999        reason, the use of different names for subpatterns of the  same  number
 4000        causes an error at compile time.
 4005        int pcre_get_stringtable_entries(const pcre *code,
 4006             const char *name, char **first, char **last);
 4008        When  a  pattern  is  compiled with the PCRE_DUPNAMES option, names for
 4009        subpatterns are not required to be unique. (Duplicate names are  always
 4010        allowed  for subpatterns with the same number, created by using the (?|
 4011        feature. Indeed, if such subpatterns are named, they  are  required  to
 4012        use the same names.)
 4014        Normally, patterns with duplicate names are such that in any one match,
 4015        only one of the named subpatterns participates. An example is shown  in
 4016        the pcrepattern documentation.
 4018        When    duplicates   are   present,   pcre_copy_named_substring()   and
 4019        pcre_get_named_substring() return the first substring corresponding  to
 4020        the  given  name  that  is set. If none are set, PCRE_ERROR_NOSUBSTRING
 4021        (-7) is returned; no  data  is  returned.  The  pcre_get_stringnumber()
 4022        function  returns one of the numbers that are associated with the name,
 4023        but it is not defined which it is.
 4025        If you want to get full details of all captured substrings for a  given
 4026        name,  you  must  use  the pcre_get_stringtable_entries() function. The
 4027        first argument is the compiled pattern, and the second is the name. The
 4028        third  and  fourth  are  pointers to variables which are updated by the
 4029        function. After it has run, they point to the first and last entries in
 4030        the  name-to-number  table  for  the  given  name.  The function itself
 4031        returns the length of each entry,  or  PCRE_ERROR_NOSUBSTRING  (-7)  if
 4032        there  are none. The format of the table is described above in the sec-
 4033        tion entitled Information about a pattern above.  Given all  the  rele-
 4034        vant  entries  for the name, you can extract each of their numbers, and
 4035        hence the captured data, if any.
 4040        The traditional matching function uses a  similar  algorithm  to  Perl,
 4041        which stops when it finds the first match, starting at a given point in
 4042        the subject. If you want to find all possible matches, or  the  longest
 4043        possible  match,  consider using the alternative matching function (see
 4044        below) instead. If you cannot use the alternative function,  but  still
 4045        need  to  find all possible matches, you can kludge it up by making use
 4046        of the callout facility, which is described in the pcrecallout documen-
 4047        tation.
 4049        What you have to do is to insert a callout right at the end of the pat-
 4050        tern.  When your callout function is called, extract and save the  cur-
 4051        rent  matched  substring.  Then  return  1, which forces pcre_exec() to
 4052        backtrack and try other alternatives. Ultimately, when it runs  out  of
 4053        matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
 4058        Matching  certain  patterns  using pcre_exec() can use a lot of process
 4059        stack, which in certain environments can be  rather  limited  in  size.
 4060        Some  users  find it helpful to have an estimate of the amount of stack
 4061        that is used by pcre_exec(), to help  them  set  recursion  limits,  as
 4062        described  in  the pcrestack documentation. The estimate that is output
 4063        by pcretest when called with the -m and -C options is obtained by call-
 4064        ing  pcre_exec with the values NULL, NULL, NULL, -999, and -999 for its
 4065        first five arguments.
 4067        Normally, if  its  first  argument  is  NULL,  pcre_exec()  immediately
 4068        returns  the negative error code PCRE_ERROR_NULL, but with this special
 4069        combination of arguments, it returns instead a  negative  number  whose
 4070        absolute  value  is the approximate stack frame size in bytes. (A nega-
 4071        tive number is used so that it is clear that no  match  has  happened.)
 4072        The  value  is  approximate  because  in some cases, recursive calls to
 4073        pcre_exec() occur when there are one or two additional variables on the
 4074        stack.
 4076        If  PCRE  has  been  compiled  to use the heap instead of the stack for
 4077        recursion, the value returned  is  the  size  of  each  block  that  is
 4078        obtained from the heap.
 4083        int pcre_dfa_exec(const pcre *code, const pcre_extra *extra,
 4084             const char *subject, int length, int startoffset,
 4085             int options, int *ovector, int ovecsize,
 4086             int *workspace, int wscount);
 4088        The  function  pcre_dfa_exec()  is  called  to  match  a subject string
 4089        against a compiled pattern, using a matching algorithm that  scans  the
 4090        subject  string  just  once, and does not backtrack. This has different
 4091        characteristics to the normal algorithm, and  is  not  compatible  with
 4092        Perl.  Some  of the features of PCRE patterns are not supported. Never-
 4093        theless, there are times when this kind of matching can be useful.  For
 4094        a  discussion  of  the  two matching algorithms, and a list of features
 4095        that pcre_dfa_exec() does not support, see the pcrematching  documenta-
 4096        tion.
 4098        The  arguments  for  the  pcre_dfa_exec()  function are the same as for
 4099        pcre_exec(), plus two extras. The ovector argument is used in a differ-
 4100        ent  way,  and  this is described below. The other common arguments are
 4101        used in the same way as for pcre_exec(), so their  description  is  not
 4102        repeated here.
 4104        The  two  additional  arguments provide workspace for the function. The
 4105        workspace vector should contain at least 20 elements. It  is  used  for
 4106        keeping  track  of  multiple  paths  through  the  pattern  tree.  More
 4107        workspace will be needed for patterns and subjects where  there  are  a
 4108        lot of potential matches.
 4110        Here is an example of a simple call to pcre_dfa_exec():
 4112          int rc;
 4113          int ovector[10];
 4114          int wspace[20];
 4115          rc = pcre_dfa_exec(
 4116            re,             /* result of pcre_compile() */
 4117            NULL,           /* we didn't study the pattern */
 4118            "some string",  /* the subject string */
 4119            11,             /* the length of the subject string */
 4120            0,              /* start at offset 0 in the subject */
 4121            0,              /* default options */
 4122            ovector,        /* vector of integers for substring information */
 4123            10,             /* number of elements (NOT size in bytes) */
 4124            wspace,         /* working space vector */
 4125            20);            /* number of elements (NOT size in bytes) */
 4127    Option bits for pcre_dfa_exec()
 4129        The  unused  bits  of  the options argument for pcre_dfa_exec() must be
 4130        zero. The only bits  that  may  be  set  are  PCRE_ANCHORED,  PCRE_NEW-
 4131        LINE_xxx,        PCRE_NOTBOL,        PCRE_NOTEOL,        PCRE_NOTEMPTY,
 4134        TIAL_SOFT, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART.  All but  the  last
 4135        four  of  these  are  exactly  the  same  as  for pcre_exec(), so their
 4136        description is not repeated here.
 4138          PCRE_PARTIAL_HARD
 4139          PCRE_PARTIAL_SOFT
 4141        These have the same general effect as they do for pcre_exec(), but  the
 4142        details  are  slightly  different.  When  PCRE_PARTIAL_HARD  is set for
 4143        pcre_dfa_exec(), it returns PCRE_ERROR_PARTIAL if the end of  the  sub-
 4144        ject  is  reached  and there is still at least one matching possibility
 4145        that requires additional characters. This happens even if some complete
 4146        matches have also been found. When PCRE_PARTIAL_SOFT is set, the return
 4147        code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if the end
 4148        of  the  subject  is  reached, there have been no complete matches, but
 4149        there is still at least one matching possibility. The  portion  of  the
 4150        string  that  was inspected when the longest partial match was found is
 4151        set as the first matching string  in  both  cases.   There  is  a  more
 4152        detailed  discussion  of partial and multi-segment matching, with exam-
 4153        ples, in the pcrepartial documentation.
 4155          PCRE_DFA_SHORTEST
 4157        Setting the PCRE_DFA_SHORTEST option causes the matching  algorithm  to
 4158        stop as soon as it has found one match. Because of the way the alterna-
 4159        tive algorithm works, this is necessarily the shortest  possible  match
 4160        at the first possible matching point in the subject string.
 4162          PCRE_DFA_RESTART
 4164        When pcre_dfa_exec() returns a partial match, it is possible to call it
 4165        again, with additional subject characters, and have  it  continue  with
 4166        the  same match. The PCRE_DFA_RESTART option requests this action; when
 4167        it is set, the workspace and wscount options must  reference  the  same
 4168        vector  as  before  because data about the match so far is left in them
 4169        after a partial match. There is more discussion of this facility in the
 4170        pcrepartial documentation.
 4172    Successful returns from pcre_dfa_exec()
 4174        When  pcre_dfa_exec()  succeeds, it may have matched more than one sub-
 4175        string in the subject. Note, however, that all the matches from one run
 4176        of  the  function  start  at the same point in the subject. The shorter
 4177        matches are all initial substrings of the longer matches. For  example,
 4178        if the pattern
 4180          <.*>
 4182        is matched against the string
 4184          This is <something> <something else> <something further> no more
 4186        the three matched strings are
 4188          <something>
 4189          <something> <something else>
 4190          <something> <something else> <something further>
 4192        On  success,  the  yield of the function is a number greater than zero,
 4193        which is the number of matched substrings.  The  substrings  themselves
 4194        are  returned  in  ovector. Each string uses two elements; the first is
 4195        the offset to the start, and the second is the offset to  the  end.  In
 4196        fact,  all  the  strings  have the same start offset. (Space could have
 4197        been saved by giving this only once, but it was decided to retain  some
 4198        compatibility  with  the  way pcre_exec() returns data, even though the
 4199        meaning of the strings is different.)
 4201        The strings are returned in reverse order of length; that is, the long-
 4202        est  matching  string is given first. If there were too many matches to
 4203        fit into ovector, the yield of the function is zero, and the vector  is
 4204        filled  with  the  longest matches. Unlike pcre_exec(), pcre_dfa_exec()
 4205        can use the entire ovector for returning matched strings.
 4207        NOTE: PCRE's "auto-possessification" optimization  usually  applies  to
 4208        character  repeats at the end of a pattern (as well as internally). For
 4209        example, the pattern "a\d+" is compiled as if it were  "a\d++"  because
 4210        there is no point even considering the possibility of backtracking into
 4211        the repeated digits. For DFA matching, this means that only one  possi-
 4212        ble  match  is  found.  If  you really do want multiple matches in such
 4213        cases,  either  use  an  ungreedy   repeat   ("a\d+?")   or   set   the
 4214        PCRE_NO_AUTO_POSSESS option when compiling.
 4216    Error returns from pcre_dfa_exec()
 4218        The  pcre_dfa_exec()  function returns a negative number when it fails.
 4219        Many of the errors are the same  as  for  pcre_exec(),  and  these  are
 4220        described  above.   There are in addition the following errors that are
 4221        specific to pcre_dfa_exec():
 4223          PCRE_ERROR_DFA_UITEM      (-16)
 4225        This return is given if pcre_dfa_exec() encounters an item in the  pat-
 4226        tern  that  it  does not support, for instance, the use of \C or a back
 4227        reference.
 4229          PCRE_ERROR_DFA_UCOND      (-17)
 4231        This return is given if pcre_dfa_exec()  encounters  a  condition  item
 4232        that  uses  a back reference for the condition, or a test for recursion
 4233        in a specific group. These are not supported.
 4235          PCRE_ERROR_DFA_UMLIMIT    (-18)
 4237        This return is given if pcre_dfa_exec() is called with an  extra  block
 4238        that  contains  a  setting  of the match_limit or match_limit_recursion
 4239        fields. This is not supported (these fields  are  meaningless  for  DFA
 4240        matching).
 4242          PCRE_ERROR_DFA_WSSIZE     (-19)
 4244        This  return  is  given  if  pcre_dfa_exec()  runs  out of space in the
 4245        workspace vector.
 4247          PCRE_ERROR_DFA_RECURSE    (-20)
 4249        When a recursive subpattern is processed, the matching  function  calls
 4250        itself  recursively,  using  private vectors for ovector and workspace.
 4251        This error is given if the output vector  is  not  large  enough.  This
 4252        should be extremely rare, as a vector of size 1000 is used.
 4254          PCRE_ERROR_DFA_BADRESTART (-30)
 4256        When  pcre_dfa_exec()  is called with the PCRE_DFA_RESTART option, some
 4257        plausibility checks are made on the contents of  the  workspace,  which
 4258        should  contain  data about the previous partial match. If any of these
 4259        checks fail, this error is given.
 4262 SEE ALSO
 4264        pcre16(3),  pcre32(3),  pcrebuild(3),  pcrecallout(3),   pcrecpp(3)(3),
 4265        pcrematching(3), pcrepartial(3), pcreposix(3), pcreprecompile(3), pcre-
 4266        sample(3), pcrestack(3).
 4269 AUTHOR
 4271        Philip Hazel
 4272        University Computing Service
 4273        Cambridge CB2 3QH, England.
 4278        Last updated: 18 December 2015
 4279        Copyright (c) 1997-2015 University of Cambridge.
 4280 ------------------------------------------------------------------------------
 4283 PCRECALLOUT(3)             Library Functions Manual             PCRECALLOUT(3)
 4287 NAME
 4288        PCRE - Perl-compatible regular expressions
 4292        #include <pcre.h>
 4294        int (*pcre_callout)(pcre_callout_block *);
 4296        int (*pcre16_callout)(pcre16_callout_block *);
 4298        int (*pcre32_callout)(pcre32_callout_block *);
 4303        PCRE provides a feature called "callout", which is a means of temporar-
 4304        ily passing control to the caller of PCRE  in  the  middle  of  pattern
 4305        matching.  The  caller of PCRE provides an external function by putting
 4306        its entry point in the global variable pcre_callout (pcre16_callout for
 4307        the 16-bit library, pcre32_callout for the 32-bit library). By default,
 4308        this variable contains NULL, which disables all calling out.
 4310        Within a regular expression, (?C) indicates the  points  at  which  the
 4311        external  function  is  to  be  called. Different callout points can be
 4312        identified by putting a number less than 256 after the  letter  C.  The
 4313        default  value  is  zero.   For  example,  this pattern has two callout
 4314        points:
 4316          (?C1)abc(?C2)def
 4318        If the PCRE_AUTO_CALLOUT option bit is set when a pattern is  compiled,
 4319        PCRE  automatically  inserts callouts, all with number 255, before each
 4320        item in the pattern. For example, if PCRE_AUTO_CALLOUT is used with the
 4321        pattern
 4323          A(\d{2}|--)
 4325        it is processed as if it were
 4327        (?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
 4329        Notice  that  there  is a callout before and after each parenthesis and
 4330        alternation bar. If the pattern contains a conditional group whose con-
 4331        dition  is  an  assertion, an automatic callout is inserted immediately
 4332        before the condition. Such a callout may also be  inserted  explicitly,
 4333        for example:
 4335          (?(?C9)(?=a)ab|de)
 4337        This  applies only to assertion conditions (because they are themselves
 4338        independent groups).
 4340        Automatic callouts can be used for tracking  the  progress  of  pattern
 4341        matching.   The pcretest program has a pattern qualifier (/C) that sets
 4342        automatic callouts; when it is used, the output indicates how the  pat-
 4343        tern  is  being matched. This is useful information when you are trying
 4344        to optimize the performance of a particular pattern.
 4349        You should be aware that, because of optimizations in the way PCRE com-
 4350        piles and matches patterns, callouts sometimes do not happen exactly as
 4351        you might expect.
 4353        At compile time, PCRE "auto-possessifies" repeated items when it  knows
 4354        that  what follows cannot be part of the repeat. For example, a+[bc] is
 4355        compiled as if it were a++[bc]. The pcretest output when  this  pattern
 4356        is  anchored  and  then  applied  with automatic callouts to the string
 4357        "aaaa" is:
 4359          --->aaaa
 4360           +0 ^        ^
 4361           +1 ^        a+
 4362           +3 ^   ^    [bc]
 4363          No match
 4365        This indicates that when matching [bc] fails, there is no  backtracking
 4366        into  a+  and  therefore the callouts that would be taken for the back-
 4367        tracks do not occur.  You can disable the  auto-possessify  feature  by
 4368        passing PCRE_NO_AUTO_POSSESS to pcre_compile(), or starting the pattern
 4369        with (*NO_AUTO_POSSESS). If this is done  in  pcretest  (using  the  /O
 4370        qualifier), the output changes to this:
 4372          --->aaaa
 4373           +0 ^        ^
 4374           +1 ^        a+
 4375           +3 ^   ^    [bc]
 4376           +3 ^  ^     [bc]
 4377           +3 ^ ^      [bc]
 4378           +3 ^^       [bc]
 4379          No match
 4381        This time, when matching [bc] fails, the matcher backtracks into a+ and
 4382        tries again, repeatedly, until a+ itself fails.
 4384        Other optimizations that provide fast "no match"  results  also  affect
 4385        callouts.  For example, if the pattern is
 4387          ab(?C4)cd
 4389        PCRE knows that any matching string must contain the letter "d". If the
 4390        subject string is "abyz", the lack of "d" means that  matching  doesn't
 4391        ever  start,  and  the  callout is never reached. However, with "abyd",
 4392        though the result is still no match, the callout is obeyed.
 4394        If the pattern is studied, PCRE knows the minimum length of a  matching
 4395        string,  and will immediately give a "no match" return without actually
 4396        running a match if the subject is not long enough, or,  for  unanchored
 4397        patterns, if it has been scanned far enough.
 4399        You  can disable these optimizations by passing the PCRE_NO_START_OPTI-
 4400        MIZE option to the matching function, or by starting the  pattern  with
 4401        (*NO_START_OPT).  This slows down the matching process, but does ensure
 4402        that callouts such as the example above are obeyed.
 4407        During matching, when PCRE reaches a callout point, the external  func-
 4408        tion defined by pcre_callout or pcre[16|32]_callout is called (if it is
 4409        set). This applies to both normal and DFA matching. The  only  argument
 4410        to   the   callout   function   is  a  pointer  to  a  pcre_callout  or
 4411        pcre[16|32]_callout block.  These  structures  contains  the  following
 4412        fields:
 4414          int           version;
 4415          int           callout_number;
 4416          int          *offset_vector;
 4417          const char   *subject;           (8-bit version)
 4418          PCRE_SPTR16   subject;           (16-bit version)
 4419          PCRE_SPTR32   subject;           (32-bit version)
 4420          int           subject_length;
 4421          int           start_match;
 4422          int           current_position;
 4423          int           capture_top;
 4424          int           capture_last;
 4425          void         *callout_data;
 4426          int           pattern_position;
 4427          int           next_item_length;
 4428          const unsigned char *mark;       (8-bit version)
 4429          const PCRE_UCHAR16  *mark;       (16-bit version)
 4430          const PCRE_UCHAR32  *mark;       (32-bit version)
 4432        The  version  field  is an integer containing the version number of the
 4433        block format. The initial version was 0; the current version is 2.  The
 4434        version  number  will  change  again in future if additional fields are
 4435        added, but the intention is never to remove any of the existing fields.
 4437        The callout_number field contains the number of the  callout,  as  com-
 4438        piled  into  the pattern (that is, the number after ?C for manual call-
 4439        outs, and 255 for automatically generated callouts).
 4441        The offset_vector field is a pointer to the vector of offsets that  was
 4442        passed  by  the  caller  to  the matching function. When pcre_exec() or
 4443        pcre[16|32]_exec() is used, the contents can be inspected, in order  to
 4444        extract  substrings  that  have been matched so far, in the same way as
 4445        for extracting substrings after a match  has  completed.  For  the  DFA
 4446        matching functions, this field is not useful.
 4448        The subject and subject_length fields contain copies of the values that
 4449        were passed to the matching function.
 4451        The start_match field normally contains the offset within  the  subject
 4452        at  which  the  current  match  attempt started. However, if the escape
 4453        sequence \K has been encountered, this value is changed to reflect  the
 4454        modified  starting  point.  If the pattern is not anchored, the callout
 4455        function may be called several times from the same point in the pattern
 4456        for different starting points in the subject.
 4458        The  current_position  field  contains the offset within the subject of
 4459        the current match pointer.
 4461        When the pcre_exec() or pcre[16|32]_exec()  is  used,  the  capture_top
 4462        field  contains  one  more than the number of the highest numbered cap-
 4463        tured substring so far. If no substrings have been captured, the  value
 4464        of  capture_top  is one. This is always the case when the DFA functions
 4465        are used, because they do not support captured substrings.
 4467        The capture_last field contains the number of the  most  recently  cap-
 4468        tured  substring. However, when a recursion exits, the value reverts to
 4469        what it was outside the recursion, as do the  values  of  all  captured
 4470        substrings.  If  no  substrings  have  been captured, the value of cap-
 4471        ture_last is -1. This is always the case for  the  DFA  matching  func-
 4472        tions.
 4474        The  callout_data  field  contains a value that is passed to a matching
 4475        function specifically so that it can be passed back in callouts. It  is
 4476        passed  in  the callout_data field of a pcre_extra or pcre[16|32]_extra
 4477        data structure. If no such data was passed, the value  of  callout_data
 4478        in  a  callout  block is NULL. There is a description of the pcre_extra
 4479        structure in the pcreapi documentation.
 4481        The pattern_position field is present from version  1  of  the  callout
 4482        structure. It contains the offset to the next item to be matched in the
 4483        pattern string.
 4485        The next_item_length field is present from version  1  of  the  callout
 4486        structure. It contains the length of the next item to be matched in the
 4487        pattern string. When the callout immediately  precedes  an  alternation
 4488        bar,  a  closing  parenthesis, or the end of the pattern, the length is
 4489        zero. When the callout precedes an opening parenthesis, the  length  is
 4490        that of the entire subpattern.
 4492        The  pattern_position  and next_item_length fields are intended to help
 4493        in distinguishing between different automatic callouts, which all  have
 4494        the same callout number. However, they are set for all callouts.
 4496        The  mark  field is present from version 2 of the callout structure. In
 4497        callouts from pcre_exec() or pcre[16|32]_exec() it contains  a  pointer
 4498        to  the  zero-terminated  name  of  the  most  recently passed (*MARK),
 4499        (*PRUNE), or (*THEN) item in the match, or NULL if no such  items  have
 4500        been  passed.  Instances  of  (*PRUNE) or (*THEN) without a name do not
 4501        obliterate a previous (*MARK). In callouts from the DFA matching  func-
 4502        tions this field always contains NULL.
 4507        The  external callout function returns an integer to PCRE. If the value
 4508        is zero, matching proceeds as normal. If  the  value  is  greater  than
 4509        zero,  matching  fails  at  the current point, but the testing of other
 4510        matching possibilities goes ahead, just as if a lookahead assertion had
 4511        failed.  If  the  value  is less than zero, the match is abandoned, the
 4512        matching function returns the negative value.
 4514        Negative  values  should  normally  be   chosen   from   the   set   of
 4515        PCRE_ERROR_xxx values. In particular, PCRE_ERROR_NOMATCH forces a stan-
 4516        dard "no  match"  failure.   The  error  number  PCRE_ERROR_CALLOUT  is
 4517        reserved  for  use  by callout functions; it will never be used by PCRE
 4518        itself.
 4521 AUTHOR
 4523        Philip Hazel
 4524        University Computing Service
 4525        Cambridge CB2 3QH, England.
 4530        Last updated: 12 November 2013
 4531        Copyright (c) 1997-2013 University of Cambridge.
 4532 ------------------------------------------------------------------------------
 4535 PCRECOMPAT(3)              Library Functions Manual              PCRECOMPAT(3)
 4539 NAME
 4540        PCRE - Perl-compatible regular expressions
 4544        This  document describes the differences in the ways that PCRE and Perl
 4545        handle regular expressions. The differences  described  here  are  with
 4546        respect to Perl versions 5.10 and above.
 4548        1. PCRE has only a subset of Perl's Unicode support. Details of what it
 4549        does have are given in the pcreunicode page.
 4551        2. PCRE allows repeat quantifiers only on parenthesized assertions, but
 4552        they  do  not mean what you might think. For example, (?!a){3} does not
 4553        assert that the next three characters are not "a". It just asserts that
 4554        the next character is not "a" three times (in principle: PCRE optimizes
 4555        this to run the assertion just once). Perl allows repeat quantifiers on
 4556        other assertions such as \b, but these do not seem to have any use.
 4558        3.  Capturing  subpatterns  that occur inside negative lookahead asser-
 4559        tions are counted, but their entries in the offsets  vector  are  never
 4560        set.  Perl sometimes (but not always) sets its numerical variables from
 4561        inside negative assertions.
 4563        4. Though binary zero characters are supported in the  subject  string,
 4564        they are not allowed in a pattern string because it is passed as a nor-
 4565        mal C string, terminated by zero. The escape sequence \0 can be used in
 4566        the pattern to represent a binary zero.
 4568        5.  The  following Perl escape sequences are not supported: \l, \u, \L,
 4569        \U, and \N when followed by a character name or Unicode value.  (\N  on
 4570        its own, matching a non-newline character, is supported.) In fact these
 4571        are implemented by Perl's general string-handling and are not  part  of
 4572        its  pattern  matching engine. If any of these are encountered by PCRE,
 4573        an error is generated by default. However, if the  PCRE_JAVASCRIPT_COM-
 4574        PAT  option  is set, \U and \u are interpreted as JavaScript interprets
 4575        them.
 4577        6. The Perl escape sequences \p, \P, and \X are supported only if  PCRE
 4578        is  built  with Unicode character property support. The properties that
 4579        can be tested with \p and \P are limited to the general category  prop-
 4580        erties  such  as  Lu and Nd, script names such as Greek or Han, and the
 4581        derived properties Any and L&. PCRE does  support  the  Cs  (surrogate)
 4582        property,  which  Perl  does  not; the Perl documentation says "Because
 4583        Perl hides the need for the user to understand the internal representa-
 4584        tion  of Unicode characters, there is no need to implement the somewhat
 4585        messy concept of surrogates."
 4587        7. PCRE does support the \Q...\E escape for quoting substrings. Charac-
 4588        ters  in  between  are  treated as literals. This is slightly different
 4589        from Perl in that $ and @ are  also  handled  as  literals  inside  the
 4590        quotes.  In Perl, they cause variable interpolation (but of course PCRE
 4591        does not have variables). Note the following examples:
 4593            Pattern            PCRE matches      Perl matches
 4595            \Qabc$xyz\E        abc$xyz           abc followed by the
 4596                                                   contents of $xyz
 4597            \Qabc\$xyz\E       abc\$xyz          abc\$xyz
 4598            \Qabc\E\$\Qxyz\E   abc$xyz           abc$xyz
 4600        The \Q...\E sequence is recognized both inside  and  outside  character
 4601        classes.
 4603        8. Fairly obviously, PCRE does not support the (?{code}) and (??{code})
 4604        constructions. However, there is support for recursive  patterns.  This
 4605        is  not  available  in Perl 5.8, but it is in Perl 5.10. Also, the PCRE
 4606        "callout" feature allows an external function to be called during  pat-
 4607        tern matching. See the pcrecallout documentation for details.
 4609        9.  Subpatterns  that  are called as subroutines (whether or not recur-
 4610        sively) are always treated as atomic  groups  in  PCRE.  This  is  like
 4611        Python,  but  unlike Perl.  Captured values that are set outside a sub-
 4612        routine call can be reference from inside in PCRE,  but  not  in  Perl.
 4613        There is a discussion that explains these differences in more detail in
 4614        the section on recursion differences from Perl in the pcrepattern page.
 4616        10. If any of the backtracking control verbs are used in  a  subpattern
 4617        that  is  called  as  a  subroutine (whether or not recursively), their
 4618        effect is confined to that subpattern; it does not extend to  the  sur-
 4619        rounding  pattern.  This is not always the case in Perl. In particular,
 4620        if (*THEN) is present in a group that is called as  a  subroutine,  its
 4621        action is limited to that group, even if the group does not contain any
 4622        | characters. Note that such subpatterns are processed as  anchored  at
 4623        the point where they are tested.
 4625        11.  If a pattern contains more than one backtracking control verb, the
 4626        first one that is backtracked onto acts. For example,  in  the  pattern
 4627        A(*COMMIT)B(*PRUNE)C  a  failure in B triggers (*COMMIT), but a failure
 4628        in C triggers (*PRUNE). Perl's behaviour is more complex; in many cases
 4629        it is the same as PCRE, but there are examples where it differs.
 4631        12.  Most  backtracking  verbs in assertions have their normal actions.
 4632        They are not confined to the assertion.
 4634        13. There are some differences that are concerned with the settings  of
 4635        captured  strings  when  part  of  a  pattern is repeated. For example,
 4636        matching "aba" against the  pattern  /^(a(b)?)+$/  in  Perl  leaves  $2
 4637        unset, but in PCRE it is set to "b".
 4639        14.  PCRE's handling of duplicate subpattern numbers and duplicate sub-
 4640        pattern names is not as general as Perl's. This is a consequence of the
 4641        fact the PCRE works internally just with numbers, using an external ta-
 4642        ble to translate between numbers and names. In  particular,  a  pattern
 4643        such  as  (?|(?<a>A)|(?<b>B),  where the two capturing parentheses have
 4644        the same number but different names, is not supported,  and  causes  an
 4645        error  at compile time. If it were allowed, it would not be possible to
 4646        distinguish which parentheses matched, because both names map  to  cap-
 4647        turing subpattern number 1. To avoid this confusing situation, an error
 4648        is given at compile time.
 4650        15. Perl recognizes comments in some places that  PCRE  does  not,  for
 4651        example,  between  the  ( and ? at the start of a subpattern. If the /x
 4652        modifier is set, Perl allows white space between ( and ?  (though  cur-
 4653        rent  Perls  warn that this is deprecated) but PCRE never does, even if
 4654        the PCRE_EXTENDED option is set.
 4656        16. Perl, when in warning mode, gives warnings  for  character  classes
 4657        such  as  [A-\d] or [a-[:digit:]]. It then treats the hyphens as liter-
 4658        als. PCRE has no warning features, so it gives an error in these  cases
 4659        because they are almost certainly user mistakes.
 4661        17.  In  PCRE,  the upper/lower case character properties Lu and Ll are
 4662        not affected when case-independent matching is specified. For  example,
 4663        \p{Lu} always matches an upper case letter. I think Perl has changed in
 4664        this respect; in the release at the time of writing (5.16), \p{Lu}  and
 4665        \p{Ll} match all letters, regardless of case, when case independence is
 4666        specified.
 4668        18. PCRE provides some extensions to the Perl regular expression facil-
 4669        ities.   Perl  5.10  includes new features that are not in earlier ver-
 4670        sions of Perl, some of which (such as named parentheses) have  been  in
 4671        PCRE for some time. This list is with respect to Perl 5.10:
 4673        (a)  Although  lookbehind  assertions  in  PCRE must match fixed length
 4674        strings, each alternative branch of a lookbehind assertion can match  a
 4675        different  length  of  string.  Perl requires them all to have the same
 4676        length.
 4678        (b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the  $
 4679        meta-character matches only at the very end of the string.
 4681        (c) If PCRE_EXTRA is set, a backslash followed by a letter with no spe-
 4682        cial meaning is faulted. Otherwise, like Perl, the backslash is quietly
 4683        ignored.  (Perl can be made to issue a warning.)
 4685        (d)  If  PCRE_UNGREEDY is set, the greediness of the repetition quanti-
 4686        fiers is inverted, that is, by default they are not greedy, but if fol-
 4687        lowed by a question mark they are.
 4689        (e) PCRE_ANCHORED can be used at matching time to force a pattern to be
 4690        tried only at the first matching position in the subject string.
 4693        and  PCRE_NO_AUTO_CAPTURE  options for pcre_exec() have no Perl equiva-
 4694        lents.
 4696        (g) The \R escape sequence can be restricted to match only CR,  LF,  or
 4697        CRLF by the PCRE_BSR_ANYCRLF option.
 4699        (h) The callout facility is PCRE-specific.
 4701        (i) The partial matching facility is PCRE-specific.
 4703        (j) Patterns compiled by PCRE can be saved and re-used at a later time,
 4704        even on different hosts that have the other endianness.  However,  this
 4705        does not apply to optimized data created by the just-in-time compiler.
 4707        (k)    The    alternative    matching    functions    (pcre_dfa_exec(),
 4708        pcre16_dfa_exec() and pcre32_dfa_exec(),) match in a different way  and
 4709        are not Perl-compatible.
 4711        (l)  PCRE  recognizes some special sequences such as (*CR) at the start
 4712        of a pattern that set overall options that cannot be changed within the
 4713        pattern.
 4716 AUTHOR
 4718        Philip Hazel
 4719        University Computing Service
 4720        Cambridge CB2 3QH, England.
 4725        Last updated: 10 November 2013
 4726        Copyright (c) 1997-2013 University of Cambridge.
 4727 ------------------------------------------------------------------------------
 4730 PCREPATTERN(3)             Library Functions Manual             PCREPATTERN(3)
 4734 NAME
 4735        PCRE - Perl-compatible regular expressions
 4739        The  syntax and semantics of the regular expressions that are supported
 4740        by PCRE are described in detail below. There is a quick-reference  syn-
 4741        tax summary in the pcresyntax page. PCRE tries to match Perl syntax and
 4742        semantics as closely as it can. PCRE  also  supports  some  alternative
 4743        regular  expression  syntax (which does not conflict with the Perl syn-
 4744        tax) in order to provide some compatibility with regular expressions in
 4745        Python, .NET, and Oniguruma.
 4747        Perl's  regular expressions are described in its own documentation, and
 4748        regular expressions in general are covered in a number of  books,  some
 4749        of  which  have  copious  examples. Jeffrey Friedl's "Mastering Regular
 4750        Expressions", published by  O'Reilly,  covers  regular  expressions  in
 4751        great  detail.  This  description  of  PCRE's  regular  expressions  is
 4752        intended as reference material.
 4754        This document discusses the patterns that are supported  by  PCRE  when
 4755        one    its    main   matching   functions,   pcre_exec()   (8-bit)   or
 4756        pcre[16|32]_exec() (16- or 32-bit), is used. PCRE also has  alternative
 4757        matching  functions,  pcre_dfa_exec()  and pcre[16|32_dfa_exec(), which
 4758        match using a different algorithm that is not Perl-compatible. Some  of
 4759        the  features  discussed  below  are not available when DFA matching is
 4760        used. The advantages and disadvantages of  the  alternative  functions,
 4761        and  how  they  differ  from the normal functions, are discussed in the
 4762        pcrematching page.
 4767        A number of options that can be passed to pcre_compile()  can  also  be
 4768        set by special items at the start of a pattern. These are not Perl-com-
 4769        patible, but are provided to make these options accessible  to  pattern
 4770        writers  who are not able to change the program that processes the pat-
 4771        tern. Any number of these items  may  appear,  but  they  must  all  be
 4772        together right at the start of the pattern string, and the letters must
 4773        be in upper case.
 4775    UTF support
 4777        The original operation of PCRE was on strings of  one-byte  characters.
 4778        However,  there  is  now also support for UTF-8 strings in the original
 4779        library, an extra library that supports  16-bit  and  UTF-16  character
 4780        strings,  and a third library that supports 32-bit and UTF-32 character
 4781        strings. To use these features, PCRE must be built to include appropri-
 4782        ate  support. When using UTF strings you must either call the compiling
 4783        function with the PCRE_UTF8, PCRE_UTF16, or PCRE_UTF32 option,  or  the
 4784        pattern must start with one of these special sequences:
 4786          (*UTF8)
 4787          (*UTF16)
 4788          (*UTF32)
 4789          (*UTF)
 4791        (*UTF)  is  a  generic  sequence  that  can  be  used  with  any of the
 4792        libraries.  Starting a pattern with such a sequence  is  equivalent  to
 4793        setting  the  relevant  option.  How setting a UTF mode affects pattern
 4794        matching is mentioned in several places below. There is also a  summary
 4795        of features in the pcreunicode page.
 4797        Some applications that allow their users to supply patterns may wish to
 4798        restrict  them  to  non-UTF  data  for   security   reasons.   If   the
 4799        PCRE_NEVER_UTF  option  is  set  at  compile  time, (*UTF) etc. are not
 4800        allowed, and their appearance causes an error.
 4802    Unicode property support
 4804        Another special sequence that may appear at the start of a  pattern  is
 4805        (*UCP).   This  has  the same effect as setting the PCRE_UCP option: it
 4806        causes sequences such as \d and \w to use Unicode properties to  deter-
 4807        mine character types, instead of recognizing only characters with codes
 4808        less than 128 via a lookup table.
 4810    Disabling auto-possessification
 4812        If a pattern starts with (*NO_AUTO_POSSESS), it has the same effect  as
 4813        setting  the  PCRE_NO_AUTO_POSSESS  option  at compile time. This stops
 4814        PCRE from making quantifiers possessive when what follows cannot  match
 4815        the  repeated item. For example, by default a+b is treated as a++b. For
 4816        more details, see the pcreapi documentation.
 4818    Disabling start-up optimizations
 4820        If a pattern starts with (*NO_START_OPT), it has  the  same  effect  as
 4821        setting the PCRE_NO_START_OPTIMIZE option either at compile or matching
 4822        time. This disables several  optimizations  for  quickly  reaching  "no
 4823        match" results. For more details, see the pcreapi documentation.
 4825    Newline conventions
 4827        PCRE  supports five different conventions for indicating line breaks in
 4828        strings: a single CR (carriage return) character, a  single  LF  (line-
 4829        feed) character, the two-character sequence CRLF, any of the three pre-
 4830        ceding, or any Unicode newline sequence. The pcreapi page  has  further
 4831        discussion  about newlines, and shows how to set the newline convention
 4832        in the options arguments for the compiling and matching functions.
 4834        It is also possible to specify a newline convention by starting a  pat-
 4835        tern string with one of the following five sequences:
 4837          (*CR)        carriage return
 4838          (*LF)        linefeed
 4839          (*CRLF)      carriage return, followed by linefeed
 4840          (*ANYCRLF)   any of the three above
 4841          (*ANY)       all Unicode newline sequences
 4843        These override the default and the options given to the compiling func-
 4844        tion. For example, on a Unix system where LF  is  the  default  newline
 4845        sequence, the pattern
 4847          (*CR)a.b
 4849        changes the convention to CR. That pattern matches "a\nb" because LF is
 4850        no longer a newline. If more than one of these settings is present, the
 4851        last one is used.
 4853        The  newline  convention affects where the circumflex and dollar asser-
 4854        tions are true. It also affects the interpretation of the dot metachar-
 4855        acter when PCRE_DOTALL is not set, and the behaviour of \N. However, it
 4856        does not affect what the \R escape sequence matches. By  default,  this
 4857        is  any Unicode newline sequence, for Perl compatibility. However, this
 4858        can be changed; see the description of \R in the section entitled "New-
 4859        line  sequences"  below.  A change of \R setting can be combined with a
 4860        change of newline convention.
 4862    Setting match and recursion limits
 4864        The caller of pcre_exec() can set a limit on the number  of  times  the
 4865        internal  match() function is called and on the maximum depth of recur-
 4866        sive calls. These facilities are provided to catch runaway matches that
 4867        are provoked by patterns with huge matching trees (a typical example is
 4868        a pattern with nested unlimited repeats) and to avoid  running  out  of
 4869        system  stack  by  too  much  recursion.  When  one  of these limits is
 4870        reached, pcre_exec() gives an error return. The limits can also be  set
 4871        by items at the start of the pattern of the form
 4873          (*LIMIT_MATCH=d)
 4874          (*LIMIT_RECURSION=d)
 4876        where d is any number of decimal digits. However, the value of the set-
 4877        ting must be less than the value set (or defaulted) by  the  caller  of
 4878        pcre_exec()  for  it  to  have  any effect. In other words, the pattern
 4879        writer can lower the limits set by the programmer, but not raise  them.
 4880        If  there  is  more  than one setting of one of these limits, the lower
 4881        value is used.
 4886        PCRE can be compiled to run in an environment that uses EBCDIC  as  its
 4887        character code rather than ASCII or Unicode (typically a mainframe sys-
 4888        tem). In the sections below, character code values are  ASCII  or  Uni-
 4889        code; in an EBCDIC environment these characters may have different code
 4890        values, and there are no code points greater than 255.
 4895        A regular expression is a pattern that is  matched  against  a  subject
 4896        string  from  left  to right. Most characters stand for themselves in a
 4897        pattern, and match the corresponding characters in the  subject.  As  a
 4898        trivial example, the pattern
 4900          The quick brown fox
 4902        matches a portion of a subject string that is identical to itself. When
 4903        caseless matching is specified (the PCRE_CASELESS option), letters  are
 4904        matched  independently  of case. In a UTF mode, PCRE always understands
 4905        the concept of case for characters whose values are less than  128,  so
 4906        caseless  matching  is always possible. For characters with higher val-
 4907        ues, the concept of case is supported if PCRE is compiled with  Unicode
 4908        property  support,  but  not  otherwise.   If  you want to use caseless
 4909        matching for characters 128 and above, you must  ensure  that  PCRE  is
 4910        compiled with Unicode property support as well as with UTF support.
 4912        The  power  of  regular  expressions  comes from the ability to include
 4913        alternatives and repetitions in the pattern. These are encoded  in  the
 4914        pattern by the use of metacharacters, which do not stand for themselves
 4915        but instead are interpreted in some special way.
 4917        There are two different sets of metacharacters: those that  are  recog-
 4918        nized  anywhere in the pattern except within square brackets, and those
 4919        that are recognized within square brackets.  Outside  square  brackets,
 4920        the metacharacters are as follows:
 4922          \      general escape character with several uses
 4923          ^      assert start of string (or line, in multiline mode)
 4924          $      assert end of string (or line, in multiline mode)
 4925          .      match any character except newline (by default)
 4926          [      start character class definition
 4927          |      start of alternative branch
 4928          (      start subpattern
 4929          )      end subpattern
 4930          ?      extends the meaning of (
 4931                 also 0 or 1 quantifier
 4932                 also quantifier minimizer
 4933          *      0 or more quantifier
 4934          +      1 or more quantifier
 4935                 also "possessive quantifier"
 4936          {      start min/max quantifier
 4938        Part  of  a  pattern  that is in square brackets is called a "character
 4939        class". In a character class the only metacharacters are:
 4941          \      general escape character
 4942          ^      negate the class, but only if the first character
 4943          -      indicates character range
 4944          [      POSIX character class (only if followed by POSIX
 4945                   syntax)
 4946          ]      terminates the character class
 4948        The following sections describe the use of each of the metacharacters.
 4953        The backslash character has several uses. Firstly, if it is followed by
 4954        a character that is not a number or a letter, it takes away any special
 4955        meaning that character may have. This use of  backslash  as  an  escape
 4956        character applies both inside and outside character classes.
 4958        For  example,  if  you want to match a * character, you write \* in the
 4959        pattern.  This escaping action applies whether  or  not  the  following
 4960        character  would  otherwise be interpreted as a metacharacter, so it is
 4961        always safe to precede a non-alphanumeric  with  backslash  to  specify
 4962        that  it stands for itself. In particular, if you want to match a back-
 4963        slash, you write \\.
 4965        In a UTF mode, only ASCII numbers and letters have any special  meaning
 4966        after  a  backslash.  All  other characters (in particular, those whose
 4967        codepoints are greater than 127) are treated as literals.
 4969        If a pattern is compiled with  the  PCRE_EXTENDED  option,  most  white
 4970        space  in the pattern (other than in a character class), and characters
 4971        between a # outside a character class and the next newline,  inclusive,
 4972        are ignored. An escaping backslash can be used to include a white space
 4973        or # character as part of the pattern.
 4975        If you want to remove the special meaning from a  sequence  of  charac-
 4976        ters,  you can do so by putting them between \Q and \E. This is differ-
 4977        ent from Perl in that $ and  @  are  handled  as  literals  in  \Q...\E
 4978        sequences  in  PCRE, whereas in Perl, $ and @ cause variable interpola-
 4979        tion. Note the following examples:
 4981          Pattern            PCRE matches   Perl matches
 4983          \Qabc$xyz\E        abc$xyz        abc followed by the
 4984                                              contents of $xyz
 4985          \Qabc\$xyz\E       abc\$xyz       abc\$xyz
 4986          \Qabc\E\$\Qxyz\E   abc$xyz        abc$xyz
 4988        The \Q...\E sequence is recognized both inside  and  outside  character
 4989        classes.   An  isolated \E that is not preceded by \Q is ignored. If \Q
 4990        is not followed by \E later in the pattern, the literal  interpretation
 4991        continues  to  the  end  of  the pattern (that is, \E is assumed at the
 4992        end). If the isolated \Q is inside a character class,  this  causes  an
 4993        error, because the character class is not terminated.
 4995    Non-printing characters
 4997        A second use of backslash provides a way of encoding non-printing char-
 4998        acters in patterns in a visible manner. There is no restriction on  the
 4999        appearance  of non-printing characters, apart from the binary zero that
 5000        terminates a pattern, but when a pattern  is  being  prepared  by  text
 5001        editing,  it  is  often  easier  to  use  one  of  the following escape
 5002        sequences than the binary character it represents.  In an ASCII or Uni-
 5003        code environment, these escapes are as follows:
 5005          \a        alarm, that is, the BEL character (hex 07)
 5006          \cx       "control-x", where x is any ASCII character
 5007          \e        escape (hex 1B)
 5008          \f        form feed (hex 0C)
 5009          \n        linefeed (hex 0A)
 5010          \r        carriage return (hex 0D)
 5011          \t        tab (hex 09)
 5012          \0dd      character with octal code 0dd
 5013          \ddd      character with octal code ddd, or back reference
 5014          \o{ddd..} character with octal code ddd..
 5015          \xhh      character with hex code hh
 5016          \x{hhh..} character with hex code hhh.. (non-JavaScript mode)
 5017          \uhhhh    character with hex code hhhh (JavaScript mode only)
 5019        The  precise effect of \cx on ASCII characters is as follows: if x is a
 5020        lower case letter, it is converted to upper case. Then  bit  6  of  the
 5021        character (hex 40) is inverted. Thus \cA to \cZ become hex 01 to hex 1A
 5022        (A is 41, Z is 5A), but \c{ becomes hex 3B ({ is 7B), and  \c;  becomes
 5023        hex  7B (; is 3B). If the data item (byte or 16-bit value) following \c
 5024        has a value greater than 127, a compile-time error occurs.  This  locks
 5025        out non-ASCII characters in all modes.
 5027        When PCRE is compiled in EBCDIC mode, \a, \e, \f, \n, \r, and \t gener-
 5028        ate the appropriate EBCDIC code values. The \c escape is  processed  as
 5029        specified for Perl in the perlebcdic document. The only characters that
 5030        are allowed after \c are A-Z, a-z, or one of @, [, \, ], ^,  _,  or  ?.
 5031        Any  other  character  provokes  a compile-time error. The sequence \c@
 5032        encodes character code 0; after \c the letters (in either case)  encode
 5033        characters 1-26 (hex 01 to hex 1A); [, \, ], ^, and _ encode characters
 5034        27-31 (hex 1B to hex 1F), and \c? becomes either 255  (hex  FF)  or  95
 5035        (hex 5F).
 5037        Thus,  apart  from  \c?, these escapes generate the same character code
 5038        values as they do in an ASCII environment, though the meanings  of  the
 5039        values  mostly  differ. For example, \cG always generates code value 7,
 5040        which is BEL in ASCII but DEL in EBCDIC.
 5042        The sequence \c? generates DEL (127, hex 7F) in an  ASCII  environment,
 5043        but  because  127  is  not a control character in EBCDIC, Perl makes it
 5044        generate the APC character. Unfortunately, there are  several  variants
 5045        of  EBCDIC.  In  most  of them the APC character has the value 255 (hex
 5046        FF), but in the one Perl calls POSIX-BC its value is 95  (hex  5F).  If
 5047        certain  other characters have POSIX-BC values, PCRE makes \c? generate
 5048        95; otherwise it generates 255.
 5050        After \0 up to two further octal digits are read. If  there  are  fewer
 5051        than  two  digits,  just  those  that  are  present  are used. Thus the
 5052        sequence \0\x\015 specifies two binary zeros followed by a CR character
 5053        (code value 13). Make sure you supply two digits after the initial zero
 5054        if the pattern character that follows is itself an octal digit.
 5056        The escape \o must be followed by a sequence of octal digits,  enclosed
 5057        in  braces.  An  error occurs if this is not the case. This escape is a
 5058        recent addition to Perl; it provides way of specifying  character  code
 5059        points  as  octal  numbers  greater than 0777, and it also allows octal
 5060        numbers and back references to be unambiguously specified.
 5062        For greater clarity and unambiguity, it is best to avoid following \ by
 5063        a digit greater than zero. Instead, use \o{} or \x{} to specify charac-
 5064        ter numbers, and \g{} to specify back references. The  following  para-
 5065        graphs describe the old, ambiguous syntax.
 5067        The handling of a backslash followed by a digit other than 0 is compli-
 5068        cated, and Perl has changed in recent releases, causing  PCRE  also  to
 5069        change. Outside a character class, PCRE reads the digit and any follow-
 5070        ing digits as a decimal number. If the number is less  than  8,  or  if
 5071        there  have been at least that many previous capturing left parentheses
 5072        in the expression, the entire sequence is taken as a back reference.  A
 5073        description  of how this works is given later, following the discussion
 5074        of parenthesized subpatterns.
 5076        Inside a character class, or if  the  decimal  number  following  \  is
 5077        greater than 7 and there have not been that many capturing subpatterns,
 5078        PCRE handles \8 and \9 as the literal characters "8" and "9", and  oth-
 5079        erwise re-reads up to three octal digits following the backslash, using
 5080        them to generate a data character.  Any  subsequent  digits  stand  for
 5081        themselves. For example:
 5083          \040   is another way of writing an ASCII space
 5084          \40    is the same, provided there are fewer than 40
 5085                    previous capturing subpatterns
 5086          \7     is always a back reference
 5087          \11    might be a back reference, or another way of
 5088                    writing a tab
 5089          \011   is always a tab
 5090          \0113  is a tab followed by the character "3"
 5091          \113   might be a back reference, otherwise the
 5092                    character with octal code 113
 5093          \377   might be a back reference, otherwise
 5094                    the value 255 (decimal)
 5095          \81    is either a back reference, or the two
 5096                    characters "8" and "1"
 5098        Note  that octal values of 100 or greater that are specified using this
 5099        syntax must not be introduced by a leading zero, because no  more  than
 5100        three octal digits are ever read.
 5102        By  default, after \x that is not followed by {, from zero to two hexa-
 5103        decimal digits are read (letters can be in upper or  lower  case).  Any
 5104        number of hexadecimal digits may appear between \x{ and }. If a charac-
 5105        ter other than a hexadecimal digit appears between \x{  and  },  or  if
 5106        there is no terminating }, an error occurs.
 5108        If  the  PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x
 5109        is as just described only when it is followed by two  hexadecimal  dig-
 5110        its.   Otherwise,  it  matches  a  literal "x" character. In JavaScript
 5111        mode, support for code points greater than 256 is provided by \u, which
 5112        must  be  followed  by  four hexadecimal digits; otherwise it matches a
 5113        literal "u" character.
 5115        Characters whose value is less than 256 can be defined by either of the
 5116        two  syntaxes for \x (or by \u in JavaScript mode). There is no differ-
 5117        ence in the way they are handled. For example, \xdc is exactly the same
 5118        as \x{dc} (or \u00dc in JavaScript mode).
 5120    Constraints on character values
 5122        Characters  that  are  specified using octal or hexadecimal numbers are
 5123        limited to certain values, as follows:
 5125          8-bit non-UTF mode    less than 0x100
 5126          8-bit UTF-8 mode      less than 0x10ffff and a valid codepoint
 5127          16-bit non-UTF mode   less than 0x10000
 5128          16-bit UTF-16 mode    less than 0x10ffff and a valid codepoint
 5129          32-bit non-UTF mode   less than 0x100000000
 5130          32-bit UTF-32 mode    less than 0x10ffff and a valid codepoint
 5132        Invalid Unicode codepoints are the range  0xd800  to  0xdfff  (the  so-
 5133        called "surrogate" codepoints), and 0xffef.
 5135    Escape sequences in character classes
 5137        All the sequences that define a single character value can be used both
 5138        inside and outside character classes. In addition, inside  a  character
 5139        class, \b is interpreted as the backspace character (hex 08).
 5141        \N  is not allowed in a character class. \B, \R, and \X are not special
 5142        inside a character class. Like  other  unrecognized  escape  sequences,
 5143        they  are  treated  as  the  literal  characters  "B",  "R", and "X" by
 5144        default, but cause an error if the PCRE_EXTRA option is set. Outside  a
 5145        character class, these sequences have different meanings.
 5147    Unsupported escape sequences
 5149        In  Perl, the sequences \l, \L, \u, and \U are recognized by its string
 5150        handler and used  to  modify  the  case  of  following  characters.  By
 5151        default,  PCRE does not support these escape sequences. However, if the
 5152        PCRE_JAVASCRIPT_COMPAT option is set, \U matches a "U"  character,  and
 5153        \u can be used to define a character by code point, as described in the
 5154        previous section.
 5156    Absolute and relative back references
 5158        The sequence \g followed by an unsigned or a negative  number,  option-
 5159        ally  enclosed  in braces, is an absolute or relative back reference. A
 5160        named back reference can be coded as \g{name}. Back references are dis-
 5161        cussed later, following the discussion of parenthesized subpatterns.
 5163    Absolute and relative subroutine calls
 5165        For  compatibility with Oniguruma, the non-Perl syntax \g followed by a
 5166        name or a number enclosed either in angle brackets or single quotes, is
 5167        an  alternative  syntax for referencing a subpattern as a "subroutine".
 5168        Details are discussed later.   Note  that  \g{...}  (Perl  syntax)  and
 5169        \g<...>  (Oniguruma  syntax)  are  not synonymous. The former is a back
 5170        reference; the latter is a subroutine call.
 5172    Generic character types
 5174        Another use of backslash is for specifying generic character types:
 5176          \d     any decimal digit
 5177          \D     any character that is not a decimal digit
 5178          \h     any horizontal white space character
 5179          \H     any character that is not a horizontal white space character
 5180          \s     any white space character
 5181          \S     any character that is not a white space character
 5182          \v     any vertical white space character
 5183          \V     any character that is not a vertical white space character
 5184          \w     any "word" character
 5185          \W     any "non-word" character
 5187        There is also the single sequence \N, which matches a non-newline char-
 5188        acter.   This  is the same as the "." metacharacter when PCRE_DOTALL is
 5189        not set. Perl also uses \N to match characters by name; PCRE  does  not
 5190        support this.
 5192        Each  pair of lower and upper case escape sequences partitions the com-
 5193        plete set of characters into two disjoint  sets.  Any  given  character
 5194        matches  one, and only one, of each pair. The sequences can appear both
 5195        inside and outside character classes. They each match one character  of
 5196        the  appropriate  type.  If the current matching point is at the end of
 5197        the subject string, all of them fail, because there is no character  to
 5198        match.
 5200        For  compatibility with Perl, \s did not used to match the VT character
 5201        (code 11), which made it different from the the  POSIX  "space"  class.
 5202        However,  Perl  added  VT  at  release  5.18, and PCRE followed suit at
 5203        release 8.34. The default \s characters are now HT  (9),  LF  (10),  VT
 5204        (11),  FF  (12),  CR  (13),  and space (32), which are defined as white
 5205        space in the "C" locale. This list may vary if locale-specific matching
 5206        is  taking place. For example, in some locales the "non-breaking space"
 5207        character (\xA0) is recognized as white space, and  in  others  the  VT
 5208        character is not.
 5210        A  "word"  character is an underscore or any character that is a letter
 5211        or digit.  By default, the definition of letters  and  digits  is  con-
 5212        trolled  by PCRE's low-valued character tables, and may vary if locale-
 5213        specific matching is taking place (see "Locale support" in the  pcreapi
 5214        page).  For  example,  in  a French locale such as "fr_FR" in Unix-like
 5215        systems, or "french" in Windows, some character codes greater than  127
 5216        are  used  for  accented letters, and these are then matched by \w. The
 5217        use of locales with Unicode is discouraged.
 5219        By default, characters whose code points are  greater  than  127  never
 5220        match \d, \s, or \w, and always match \D, \S, and \W, although this may
 5221        vary for characters in the range 128-255 when locale-specific  matching
 5222        is  happening.   These  escape sequences retain their original meanings
 5223        from before Unicode support was available, mainly for  efficiency  rea-
 5224        sons.  If  PCRE  is  compiled  with  Unicode  property support, and the
 5225        PCRE_UCP option is set, the behaviour is changed so that Unicode  prop-
 5226        erties are used to determine character types, as follows:
 5228          \d  any character that matches \p{Nd} (decimal digit)
 5229          \s  any character that matches \p{Z} or \h or \v
 5230          \w  any character that matches \p{L} or \p{N}, plus underscore
 5232        The  upper case escapes match the inverse sets of characters. Note that
 5233        \d matches only decimal digits, whereas \w matches any  Unicode  digit,
 5234        as  well as any Unicode letter, and underscore. Note also that PCRE_UCP
 5235        affects \b, and \B because they are defined in  terms  of  \w  and  \W.
 5236        Matching these sequences is noticeably slower when PCRE_UCP is set.
 5238        The  sequences  \h, \H, \v, and \V are features that were added to Perl
 5239        at release 5.10. In contrast to the other sequences, which  match  only
 5240        ASCII  characters  by  default,  these always match certain high-valued
 5241        code points, whether or not PCRE_UCP is set. The horizontal space char-
 5242        acters are:
 5244          U+0009     Horizontal tab (HT)
 5245          U+0020     Space
 5246          U+00A0     Non-break space
 5247          U+1680     Ogham space mark
 5248          U+180E     Mongolian vowel separator
 5249          U+2000     En quad
 5250          U+2001     Em quad
 5251          U+2002     En space
 5252          U+2003     Em space
 5253          U+2004     Three-per-em space
 5254          U+2005     Four-per-em space
 5255          U+2006     Six-per-em space
 5256          U+2007     Figure space
 5257          U+2008     Punctuation space
 5258          U+2009     Thin space
 5259          U+200A     Hair space
 5260          U+202F     Narrow no-break space
 5261          U+205F     Medium mathematical space
 5262          U+3000     Ideographic space
 5264        The vertical space characters are:
 5266          U+000A     Linefeed (LF)
 5267          U+000B     Vertical tab (VT)
 5268          U+000C     Form feed (FF)
 5269          U+000D     Carriage return (CR)
 5270          U+0085     Next line (NEL)
 5271          U+2028     Line separator
 5272          U+2029     Paragraph separator
 5274        In 8-bit, non-UTF-8 mode, only the characters with codepoints less than
 5275        256 are relevant.
 5277    Newline sequences
 5279        Outside a character class, by default, the escape sequence  \R  matches
 5280        any  Unicode newline sequence. In 8-bit non-UTF-8 mode \R is equivalent
 5281        to the following:
 5283          (?>\r\n|\n|\x0b|\f|\r|\x85)
 5285        This is an example of an "atomic group", details  of  which  are  given
 5286        below.  This particular group matches either the two-character sequence
 5287        CR followed by LF, or  one  of  the  single  characters  LF  (linefeed,
 5288        U+000A),  VT  (vertical  tab, U+000B), FF (form feed, U+000C), CR (car-
 5289        riage return, U+000D), or NEL (next line,  U+0085).  The  two-character
 5290        sequence is treated as a single unit that cannot be split.
 5292        In  other modes, two additional characters whose codepoints are greater
 5293        than 255 are added: LS (line separator, U+2028) and PS (paragraph sepa-
 5294        rator,  U+2029).   Unicode character property support is not needed for
 5295        these characters to be recognized.
 5297        It is possible to restrict \R to match only CR, LF, or CRLF (instead of
 5298        the  complete  set  of  Unicode  line  endings)  by  setting the option
 5299        PCRE_BSR_ANYCRLF either at compile time or when the pattern is matched.
 5300        (BSR is an abbrevation for "backslash R".) This can be made the default
 5301        when PCRE is built; if this is the case, the  other  behaviour  can  be
 5302        requested  via  the  PCRE_BSR_UNICODE  option.   It is also possible to
 5303        specify these settings by starting a pattern string  with  one  of  the
 5304        following sequences:
 5306          (*BSR_ANYCRLF)   CR, LF, or CRLF only
 5307          (*BSR_UNICODE)   any Unicode newline sequence
 5309        These override the default and the options given to the compiling func-
 5310        tion, but they can themselves be  overridden  by  options  given  to  a
 5311        matching  function.  Note  that  these  special settings, which are not
 5312        Perl-compatible, are recognized only at the very start  of  a  pattern,
 5313        and  that  they  must  be  in  upper  case. If more than one of them is
 5314        present, the last one is used. They can be combined with  a  change  of
 5315        newline convention; for example, a pattern can start with:
 5317          (*ANY)(*BSR_ANYCRLF)
 5319        They  can also be combined with the (*UTF8), (*UTF16), (*UTF32), (*UTF)
 5320        or (*UCP) special sequences. Inside a character class, \R is treated as
 5321        an  unrecognized  escape  sequence,  and  so  matches the letter "R" by
 5322        default, but causes an error if PCRE_EXTRA is set.
 5324    Unicode character properties
 5326        When PCRE is built with Unicode character property support, three addi-
 5327        tional  escape sequences that match characters with specific properties
 5328        are available.  When in 8-bit non-UTF-8 mode, these  sequences  are  of
 5329        course  limited  to  testing  characters whose codepoints are less than
 5330        256, but they do work in this mode.  The extra escape sequences are:
 5332          \p{xx}   a character with the xx property
 5333          \P{xx}   a character without the xx property
 5334          \X       a Unicode extended grapheme cluster
 5336        The property names represented by xx above are limited to  the  Unicode
 5337        script names, the general category properties, "Any", which matches any
 5338        character  (including  newline),  and  some  special  PCRE   properties
 5339        (described  in the next section).  Other Perl properties such as "InMu-
 5340        sicalSymbols" are not currently supported by PCRE.  Note  that  \P{Any}
 5341        does not match any characters, so always causes a match failure.
 5343        Sets of Unicode characters are defined as belonging to certain scripts.
 5344        A character from one of these sets can be matched using a script  name.
 5345        For example:
 5347          \p{Greek}
 5348          \P{Han}
 5350        Those  that are not part of an identified script are lumped together as
 5351        "Common". The current list of scripts is:
 5353        Arabic, Armenian, Avestan, Balinese, Bamum, Bassa_Vah, Batak,  Bengali,
 5354        Bopomofo,  Brahmi,  Braille, Buginese, Buhid, Canadian_Aboriginal, Car-
 5355        ian, Caucasian_Albanian, Chakma, Cham, Cherokee, Common, Coptic, Cunei-
 5356        form, Cypriot, Cyrillic, Deseret, Devanagari, Duployan, Egyptian_Hiero-
 5357        glyphs,  Elbasan,  Ethiopic,  Georgian,  Glagolitic,  Gothic,  Grantha,
 5358        Greek,  Gujarati,  Gurmukhi,  Han,  Hangul,  Hanunoo, Hebrew, Hiragana,
 5359        Imperial_Aramaic,    Inherited,     Inscriptional_Pahlavi,     Inscrip-
 5360        tional_Parthian,   Javanese,   Kaithi,   Kannada,  Katakana,  Kayah_Li,
 5361        Kharoshthi, Khmer, Khojki, Khudawadi, Lao, Latin, Lepcha,  Limbu,  Lin-
 5362        ear_A,  Linear_B,  Lisu,  Lycian, Lydian, Mahajani, Malayalam, Mandaic,
 5363        Manichaean,     Meetei_Mayek,     Mende_Kikakui,      Meroitic_Cursive,
 5364        Meroitic_Hieroglyphs,  Miao,  Modi, Mongolian, Mro, Myanmar, Nabataean,
 5365        New_Tai_Lue,  Nko,  Ogham,  Ol_Chiki,  Old_Italic,   Old_North_Arabian,
 5366        Old_Permic, Old_Persian, Old_South_Arabian, Old_Turkic, Oriya, Osmanya,
 5367        Pahawh_Hmong,    Palmyrene,    Pau_Cin_Hau,    Phags_Pa,    Phoenician,
 5368        Psalter_Pahlavi,  Rejang,  Runic,  Samaritan, Saurashtra, Sharada, Sha-
 5369        vian, Siddham, Sinhala, Sora_Sompeng, Sundanese, Syloti_Nagri,  Syriac,
 5370        Tagalog,  Tagbanwa,  Tai_Le,  Tai_Tham, Tai_Viet, Takri, Tamil, Telugu,
 5371        Thaana, Thai, Tibetan, Tifinagh, Tirhuta, Ugaritic,  Vai,  Warang_Citi,
 5372        Yi.
 5374        Each character has exactly one Unicode general category property, spec-
 5375        ified by a two-letter abbreviation. For compatibility with Perl,  nega-
 5376        tion  can  be  specified  by including a circumflex between the opening
 5377        brace and the property name.  For  example,  \p{^Lu}  is  the  same  as
 5378        \P{Lu}.
 5380        If only one letter is specified with \p or \P, it includes all the gen-
 5381        eral category properties that start with that letter. In this case,  in
 5382        the  absence of negation, the curly brackets in the escape sequence are
 5383        optional; these two examples have the same effect:
 5385          \p{L}
 5386          \pL
 5388        The following general category property codes are supported:
 5390          C     Other
 5391          Cc    Control
 5392          Cf    Format
 5393          Cn    Unassigned
 5394          Co    Private use
 5395          Cs    Surrogate
 5397          L     Letter
 5398          Ll    Lower case letter
 5399          Lm    Modifier letter
 5400          Lo    Other letter
 5401          Lt    Title case letter
 5402          Lu    Upper case letter
 5404          M     Mark
 5405          Mc    Spacing mark
 5406          Me    Enclosing mark
 5407          Mn    Non-spacing mark
 5409          N     Number
 5410          Nd    Decimal number
 5411          Nl    Letter number
 5412          No    Other number
 5414          P     Punctuation
 5415          Pc    Connector punctuation
 5416          Pd    Dash punctuation
 5417          Pe    Close punctuation
 5418          Pf    Final punctuation
 5419          Pi    Initial punctuation
 5420          Po    Other punctuation
 5421          Ps    Open punctuation
 5423          S     Symbol
 5424          Sc    Currency symbol
 5425          Sk    Modifier symbol
 5426          Sm    Mathematical symbol
 5427          So    Other symbol
 5429          Z     Separator
 5430          Zl    Line separator
 5431          Zp    Paragraph separator
 5432          Zs    Space separator
 5434        The special property L& is also supported: it matches a character  that
 5435        has  the  Lu,  Ll, or Lt property, in other words, a letter that is not
 5436        classified as a modifier or "other".
 5438        The Cs (Surrogate) property applies only to  characters  in  the  range
 5439        U+D800  to U+DFFF. Such characters are not valid in Unicode strings and
 5440        so cannot be tested by PCRE, unless  UTF  validity  checking  has  been
 5441        turned    off    (see    the    discussion    of    PCRE_NO_UTF8_CHECK,
 5442        PCRE_NO_UTF16_CHECK and PCRE_NO_UTF32_CHECK in the pcreapi page).  Perl
 5443        does not support the Cs property.
 5445        The  long  synonyms  for  property  names  that  Perl supports (such as
 5446        \p{Letter}) are not supported by PCRE, nor is it  permitted  to  prefix
 5447        any of these properties with "Is".
 5449        No character that is in the Unicode table has the Cn (unassigned) prop-
 5450        erty.  Instead, this property is assumed for any code point that is not
 5451        in the Unicode table.
 5453        Specifying  caseless  matching  does not affect these escape sequences.
 5454        For example, \p{Lu} always matches only upper  case  letters.  This  is
 5455        different from the behaviour of current versions of Perl.
 5457        Matching  characters  by Unicode property is not fast, because PCRE has
 5458        to do a multistage table lookup in order to find  a  character's  prop-
 5459        erty. That is why the traditional escape sequences such as \d and \w do
 5460        not use Unicode properties in PCRE by default, though you can make them
 5461        do  so  by  setting the PCRE_UCP option or by starting the pattern with
 5462        (*UCP).
 5464    Extended grapheme clusters
 5466        The \X escape matches any number of Unicode  characters  that  form  an
 5467        "extended grapheme cluster", and treats the sequence as an atomic group
 5468        (see below).  Up to and including release 8.31, PCRE  matched  an  ear-
 5469        lier, simpler definition that was equivalent to
 5471          (?>\PM\pM*)
 5473        That  is,  it matched a character without the "mark" property, followed
 5474        by zero or more characters with the "mark"  property.  Characters  with
 5475        the  "mark"  property are typically non-spacing accents that affect the
 5476        preceding character.
 5478        This simple definition was extended in Unicode to include more  compli-
 5479        cated  kinds of composite character by giving each character a grapheme
 5480        breaking property, and creating rules  that  use  these  properties  to
 5481        define  the  boundaries  of  extended grapheme clusters. In releases of
 5482        PCRE later than 8.31, \X matches one of these clusters.
 5484        \X always matches at least one character. Then it  decides  whether  to
 5485        add additional characters according to the following rules for ending a
 5486        cluster:
 5488        1. End at the end of the subject string.
 5490        2. Do not end between CR and LF; otherwise end after any control  char-
 5491        acter.
 5493        3.  Do  not  break  Hangul (a Korean script) syllable sequences. Hangul
 5494        characters are of five types: L, V, T, LV, and LVT. An L character  may
 5495        be  followed by an L, V, LV, or LVT character; an LV or V character may
 5496        be followed by a V or T character; an LVT or T character may be follwed
 5497        only by a T character.
 5499        4.  Do not end before extending characters or spacing marks. Characters
 5500        with the "mark" property always have  the  "extend"  grapheme  breaking
 5501        property.
 5503        5. Do not end after prepend characters.
 5505        6. Otherwise, end the cluster.
 5507    PCRE's additional properties
 5509        As  well  as the standard Unicode properties described above, PCRE sup-
 5510        ports four more that make it possible  to  convert  traditional  escape
 5511        sequences  such as \w and \s to use Unicode properties. PCRE uses these
 5512        non-standard, non-Perl properties internally when PCRE_UCP is set. How-
 5513        ever, they may also be used explicitly. These properties are:
 5515          Xan   Any alphanumeric character
 5516          Xps   Any POSIX space character
 5517          Xsp   Any Perl space character
 5518          Xwd   Any Perl "word" character
 5520        Xan  matches  characters that have either the L (letter) or the N (num-
 5521        ber) property. Xps matches the characters tab, linefeed, vertical  tab,
 5522        form  feed,  or carriage return, and any other character that has the Z
 5523        (separator) property.  Xsp is the same as Xps; it used to exclude  ver-
 5524        tical  tab,  for Perl compatibility, but Perl changed, and so PCRE fol-
 5525        lowed at release 8.34. Xwd matches the same  characters  as  Xan,  plus
 5526        underscore.
 5528        There  is another non-standard property, Xuc, which matches any charac-
 5529        ter that can be represented by a Universal Character Name  in  C++  and
 5530        other  programming  languages.  These are the characters $, @, ` (grave
 5531        accent), and all characters with Unicode code points  greater  than  or
 5532        equal  to U+00A0, except for the surrogates U+D800 to U+DFFF. Note that
 5533        most base (ASCII) characters are excluded. (Universal  Character  Names
 5534        are  of  the  form \uHHHH or \UHHHHHHHH where H is a hexadecimal digit.
 5535        Note that the Xuc property does not match these sequences but the char-
 5536        acters that they represent.)
 5538    Resetting the match start
 5540        The  escape sequence \K causes any previously matched characters not to
 5541        be included in the final matched sequence. For example, the pattern:
 5543          foo\Kbar
 5545        matches "foobar", but reports that it has matched "bar".  This  feature
 5546        is  similar  to  a lookbehind assertion (described below).  However, in
 5547        this case, the part of the subject before the real match does not  have
 5548        to  be of fixed length, as lookbehind assertions do. The use of \K does
 5549        not interfere with the setting of captured  substrings.   For  example,
 5550        when the pattern
 5552          (foo)\Kbar
 5554        matches "foobar", the first substring is still set to "foo".
 5556        Perl  documents  that  the  use  of  \K  within assertions is "not well
 5557        defined". In PCRE, \K is acted upon  when  it  occurs  inside  positive
 5558        assertions,  but  is  ignored  in negative assertions. Note that when a
 5559        pattern such as (?=ab\K) matches, the reported start of the  match  can
 5560        be greater than the end of the match.
 5562    Simple assertions
 5564        The  final use of backslash is for certain simple assertions. An asser-
 5565        tion specifies a condition that has to be met at a particular point  in
 5566        a  match, without consuming any characters from the subject string. The
 5567        use of subpatterns for more complicated assertions is described  below.
 5568        The backslashed assertions are:
 5570          \b     matches at a word boundary
 5571          \B     matches when not at a word boundary
 5572          \A     matches at the start of the subject
 5573          \Z     matches at the end of the subject
 5574                  also matches before a newline at the end of the subject
 5575          \z     matches only at the end of the subject
 5576          \G     matches at the first matching position in the subject
 5578        Inside  a  character  class, \b has a different meaning; it matches the
 5579        backspace character. If any other of  these  assertions  appears  in  a
 5580        character  class, by default it matches the corresponding literal char-
 5581        acter  (for  example,  \B  matches  the  letter  B).  However,  if  the
 5582        PCRE_EXTRA  option is set, an "invalid escape sequence" error is gener-
 5583        ated instead.
 5585        A word boundary is a position in the subject string where  the  current
 5586        character  and  the previous character do not both match \w or \W (i.e.
 5587        one matches \w and the other matches \W), or the start or  end  of  the
 5588        string  if  the  first or last character matches \w, respectively. In a
 5589        UTF mode, the meanings of \w and \W  can  be  changed  by  setting  the
 5590        PCRE_UCP  option. When this is done, it also affects \b and \B. Neither
 5591        PCRE nor Perl has a separate "start of word" or "end of  word"  metase-
 5592        quence.  However,  whatever follows \b normally determines which it is.
 5593        For example, the fragment \ba matches "a" at the start of a word.
 5595        The \A, \Z, and \z assertions differ from  the  traditional  circumflex
 5596        and dollar (described in the next section) in that they only ever match
 5597        at the very start and end of the subject string, whatever  options  are
 5598        set.  Thus,  they are independent of multiline mode. These three asser-
 5599        tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
 5600        affect  only the behaviour of the circumflex and dollar metacharacters.
 5601        However, if the startoffset argument of pcre_exec() is non-zero,  indi-
 5602        cating that matching is to start at a point other than the beginning of
 5603        the subject, \A can never match. The difference between \Z  and  \z  is
 5604        that \Z matches before a newline at the end of the string as well as at
 5605        the very end, whereas \z matches only at the end.
 5607        The \G assertion is true only when the current matching position is  at
 5608        the  start point of the match, as specified by the startoffset argument
 5609        of pcre_exec(). It differs from \A when the  value  of  startoffset  is
 5610        non-zero.  By calling pcre_exec() multiple times with appropriate argu-
 5611        ments, you can mimic Perl's /g option, and it is in this kind of imple-
 5612        mentation where \G can be useful.
 5614        Note,  however,  that  PCRE's interpretation of \G, as the start of the
 5615        current match, is subtly different from Perl's, which defines it as the
 5616        end  of  the  previous  match. In Perl, these can be different when the
 5617        previously matched string was empty. Because PCRE does just  one  match
 5618        at a time, it cannot reproduce this behaviour.
 5620        If  all  the alternatives of a pattern begin with \G, the expression is
 5621        anchored to the starting match position, and the "anchored" flag is set
 5622        in the compiled regular expression.
 5627        The  circumflex  and  dollar  metacharacters are zero-width assertions.
 5628        That is, they test for a particular condition being true  without  con-
 5629        suming any characters from the subject string.
 5631        Outside a character class, in the default matching mode, the circumflex
 5632        character is an assertion that is true only  if  the  current  matching
 5633        point  is  at the start of the subject string. If the startoffset argu-
 5634        ment of pcre_exec() is non-zero, circumflex  can  never  match  if  the
 5635        PCRE_MULTILINE  option  is  unset. Inside a character class, circumflex
 5636        has an entirely different meaning (see below).
 5638        Circumflex need not be the first character of the pattern if  a  number
 5639        of  alternatives are involved, but it should be the first thing in each
 5640        alternative in which it appears if the pattern is ever  to  match  that
 5641        branch.  If all possible alternatives start with a circumflex, that is,
 5642        if the pattern is constrained to match only at the start  of  the  sub-
 5643        ject,  it  is  said  to be an "anchored" pattern. (There are also other
 5644        constructs that can cause a pattern to be anchored.)
 5646        The dollar character is an assertion that is true only if  the  current
 5647        matching  point  is  at  the  end of the subject string, or immediately
 5648        before a newline at the end of the string (by default). Note,  however,
 5649        that  it  does  not  actually match the newline. Dollar need not be the
 5650        last character of the pattern if a number of alternatives are involved,
 5651        but  it should be the last item in any branch in which it appears. Dol-
 5652        lar has no special meaning in a character class.
 5654        The meaning of dollar can be changed so that it  matches  only  at  the
 5655        very  end  of  the string, by setting the PCRE_DOLLAR_ENDONLY option at
 5656        compile time. This does not affect the \Z assertion.
 5658        The meanings of the circumflex and dollar characters are changed if the
 5659        PCRE_MULTILINE  option  is  set.  When  this  is the case, a circumflex
 5660        matches immediately after internal newlines as well as at the start  of
 5661        the  subject  string.  It  does not match after a newline that ends the
 5662        string. A dollar matches before any newlines in the string, as well  as
 5663        at  the very end, when PCRE_MULTILINE is set. When newline is specified
 5664        as the two-character sequence CRLF, isolated CR and  LF  characters  do
 5665        not indicate newlines.
 5667        For  example, the pattern /^abc$/ matches the subject string "def\nabc"
 5668        (where \n represents a newline) in multiline mode, but  not  otherwise.
 5669        Consequently,  patterns  that  are anchored in single line mode because
 5670        all branches start with ^ are not anchored in  multiline  mode,  and  a
 5671        match  for  circumflex  is  possible  when  the startoffset argument of
 5672        pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is  ignored  if
 5673        PCRE_MULTILINE is set.
 5675        Note  that  the sequences \A, \Z, and \z can be used to match the start
 5676        and end of the subject in both modes, and if all branches of a  pattern
 5677        start  with  \A it is always anchored, whether or not PCRE_MULTILINE is
 5678        set.
 5683        Outside a character class, a dot in the pattern matches any one charac-
 5684        ter  in  the subject string except (by default) a character that signi-
 5685        fies the end of a line.
 5687        When a line ending is defined as a single character, dot never  matches
 5688        that  character; when the two-character sequence CRLF is used, dot does
 5689        not match CR if it is immediately followed  by  LF,  but  otherwise  it
 5690        matches  all characters (including isolated CRs and LFs). When any Uni-
 5691        code line endings are being recognized, dot does not match CR or LF  or
 5692        any of the other line ending characters.
 5694        The  behaviour  of  dot  with regard to newlines can be changed. If the
 5695        PCRE_DOTALL option is set, a dot matches  any  one  character,  without
 5696        exception. If the two-character sequence CRLF is present in the subject
 5697        string, it takes two dots to match it.
 5699        The handling of dot is entirely independent of the handling of  circum-
 5700        flex  and  dollar,  the  only relationship being that they both involve
 5701        newlines. Dot has no special meaning in a character class.
 5703        The escape sequence \N behaves like  a  dot,  except  that  it  is  not
 5704        affected  by  the  PCRE_DOTALL  option.  In other words, it matches any
 5705        character except one that signifies the end of a line. Perl  also  uses
 5706        \N to match characters by name; PCRE does not support this.
 5711        Outside  a character class, the escape sequence \C matches any one data
 5712        unit, whether or not a UTF mode is set. In the 8-bit library, one  data
 5713        unit  is  one  byte;  in the 16-bit library it is a 16-bit unit; in the
 5714        32-bit library it is a 32-bit unit. Unlike a  dot,  \C  always  matches
 5715        line-ending  characters.  The  feature  is provided in Perl in order to
 5716        match individual bytes in UTF-8 mode, but it is unclear how it can use-
 5717        fully  be  used.  Because  \C breaks up characters into individual data
 5718        units, matching one unit with \C in a UTF mode means that the  rest  of
 5719        the string may start with a malformed UTF character. This has undefined
 5720        results, because PCRE assumes that it is dealing with valid UTF strings
 5721        (and  by  default  it checks this at the start of processing unless the
 5722        PCRE_NO_UTF8_CHECK, PCRE_NO_UTF16_CHECK or  PCRE_NO_UTF32_CHECK  option
 5723        is used).
 5725        PCRE  does  not  allow \C to appear in lookbehind assertions (described
 5726        below) in a UTF mode, because this would make it impossible  to  calcu-
 5727        late the length of the lookbehind.
 5729        In general, the \C escape sequence is best avoided. However, one way of
 5730        using it that avoids the problem of malformed UTF characters is to  use
 5731        a  lookahead to check the length of the next character, as in this pat-
 5732        tern, which could be used with a UTF-8 string (ignore white  space  and
 5733        line breaks):
 5735          (?| (?=[\x00-\x7f])(\C) |
 5736              (?=[\x80-\x{7ff}])(\C)(\C) |
 5737              (?=[\x{800}-\x{ffff}])(\C)(\C)(\C) |
 5738              (?=[\x{10000}-\x{1fffff}])(\C)(\C)(\C)(\C))
 5740        A  group  that starts with (?| resets the capturing parentheses numbers
 5741        in each alternative (see "Duplicate  Subpattern  Numbers"  below).  The
 5742        assertions  at  the start of each branch check the next UTF-8 character
 5743        for values whose encoding uses 1, 2, 3, or 4 bytes,  respectively.  The
 5744        character's  individual bytes are then captured by the appropriate num-
 5745        ber of groups.
 5750        An opening square bracket introduces a character class, terminated by a
 5751        closing square bracket. A closing square bracket on its own is not spe-
 5752        cial by default.  However, if the PCRE_JAVASCRIPT_COMPAT option is set,
 5753        a lone closing square bracket causes a compile-time error. If a closing
 5754        square bracket is required as a member of the class, it should  be  the
 5755        first  data  character  in  the  class (after an initial circumflex, if
 5756        present) or escaped with a backslash.
 5758        A character class matches a single character in the subject. In  a  UTF
 5759        mode,  the  character  may  be  more than one data unit long. A matched
 5760        character must be in the set of characters defined by the class, unless
 5761        the  first  character in the class definition is a circumflex, in which
 5762        case the subject character must not be in the set defined by the class.
 5763        If  a  circumflex is actually required as a member of the class, ensure
 5764        it is not the first character, or escape it with a backslash.
 5766        For example, the character class [aeiou] matches any lower case  vowel,
 5767        while  [^aeiou]  matches  any character that is not a lower case vowel.
 5768        Note that a circumflex is just a convenient notation for specifying the
 5769        characters  that  are in the class by enumerating those that are not. A
 5770        class that starts with a circumflex is not an assertion; it still  con-
 5771        sumes  a  character  from the subject string, and therefore it fails if
 5772        the current pointer is at the end of the string.
 5774        In UTF-8 (UTF-16, UTF-32) mode, characters with values greater than 255
 5775        (0xffff)  can be included in a class as a literal string of data units,
 5776        or by using the \x{ escaping mechanism.
 5778        When caseless matching is set, any letters in a  class  represent  both
 5779        their  upper  case  and lower case versions, so for example, a caseless
 5780        [aeiou] matches "A" as well as "a", and a caseless  [^aeiou]  does  not
 5781        match  "A", whereas a caseful version would. In a UTF mode, PCRE always
 5782        understands the concept of case for characters whose  values  are  less
 5783        than  128, so caseless matching is always possible. For characters with
 5784        higher values, the concept of case is supported  if  PCRE  is  compiled
 5785        with  Unicode  property support, but not otherwise.  If you want to use
 5786        caseless matching in a UTF mode for characters 128 and above, you  must
 5787        ensure  that  PCRE is compiled with Unicode property support as well as
 5788        with UTF support.
 5790        Characters that might indicate line breaks are  never  treated  in  any
 5791        special  way  when  matching  character  classes,  whatever line-ending
 5792        sequence is in  use,  and  whatever  setting  of  the  PCRE_DOTALL  and
 5793        PCRE_MULTILINE options is used. A class such as [^a] always matches one
 5794        of these characters.
 5796        The minus (hyphen) character can be used to specify a range of  charac-
 5797        ters  in  a  character  class.  For  example,  [d-m] matches any letter
 5798        between d and m, inclusive. If a  minus  character  is  required  in  a
 5799        class,  it  must  be  escaped  with a backslash or appear in a position
 5800        where it cannot be interpreted as indicating a range, typically as  the
 5801        first or last character in the class, or immediately after a range. For
 5802        example, [b-d-z] matches letters in the range b to d, a hyphen  charac-
 5803        ter, or z.
 5805        It is not possible to have the literal character "]" as the end charac-
 5806        ter of a range. A pattern such as [W-]46] is interpreted as a class  of
 5807        two  characters ("W" and "-") followed by a literal string "46]", so it
 5808        would match "W46]" or "-46]". However, if the "]"  is  escaped  with  a
 5809        backslash  it is interpreted as the end of range, so [W-\]46] is inter-
 5810        preted as a class containing a range followed by two other  characters.
 5811        The  octal or hexadecimal representation of "]" can also be used to end
 5812        a range.
 5814        An error is generated if a POSIX character  class  (see  below)  or  an
 5815        escape  sequence other than one that defines a single character appears
 5816        at a point where a range ending character  is  expected.  For  example,
 5817        [z-\xff] is valid, but [A-\d] and [A-[:digit:]] are not.
 5819        Ranges  operate in the collating sequence of character values. They can
 5820        also  be  used  for  characters  specified  numerically,  for   example
 5821        [\000-\037].  Ranges  can include any characters that are valid for the
 5822        current mode.
 5824        If a range that includes letters is used when caseless matching is set,
 5825        it matches the letters in either case. For example, [W-c] is equivalent
 5826        to [][\\^_`wxyzabc], matched caselessly, and  in  a  non-UTF  mode,  if
 5827        character  tables  for  a French locale are in use, [\xc8-\xcb] matches
 5828        accented E characters in both cases. In UTF modes,  PCRE  supports  the
 5829        concept  of  case for characters with values greater than 128 only when
 5830        it is compiled with Unicode property support.
 5832        The character escape sequences \d, \D, \h, \H, \p, \P, \s, \S, \v,  \V,
 5833        \w, and \W may appear in a character class, and add the characters that
 5834        they match to the class. For example, [\dABCDEF] matches any  hexadeci-
 5835        mal  digit.  In  UTF modes, the PCRE_UCP option affects the meanings of
 5836        \d, \s, \w and their upper case partners, just as  it  does  when  they
 5837        appear  outside a character class, as described in the section entitled
 5838        "Generic character types" above. The escape sequence \b has a different
 5839        meaning  inside  a character class; it matches the backspace character.
 5840        The sequences \B, \N, \R, and \X are not  special  inside  a  character
 5841        class.  Like  any other unrecognized escape sequences, they are treated
 5842        as the literal characters "B", "N", "R", and "X" by default, but  cause
 5843        an error if the PCRE_EXTRA option is set.
 5845        A  circumflex  can  conveniently  be used with the upper case character
 5846        types to specify a more restricted set of characters than the  matching
 5847        lower  case  type.  For example, the class [^\W_] matches any letter or
 5848        digit, but not underscore, whereas [\w] includes underscore. A positive
 5849        character class should be read as "something OR something OR ..." and a
 5850        negative class as "NOT something AND NOT something AND NOT ...".
 5852        The only metacharacters that are recognized in  character  classes  are
 5853        backslash,  hyphen  (only  where  it can be interpreted as specifying a
 5854        range), circumflex (only at the start), opening  square  bracket  (only
 5855        when  it can be interpreted as introducing a POSIX class name, or for a
 5856        special compatibility feature - see the next  two  sections),  and  the
 5857        terminating  closing  square  bracket.  However,  escaping  other  non-
 5858        alphanumeric characters does no harm.
 5863        Perl supports the POSIX notation for character classes. This uses names
 5864        enclosed  by  [: and :] within the enclosing square brackets. PCRE also
 5865        supports this notation. For example,
 5867          [01[:alpha:]%]
 5869        matches "0", "1", any alphabetic character, or "%". The supported class
 5870        names are:
 5872          alnum    letters and digits
 5873          alpha    letters
 5874          ascii    character codes 0 - 127
 5875          blank    space or tab only
 5876          cntrl    control characters
 5877          digit    decimal digits (same as \d)
 5878          graph    printing characters, excluding space
 5879          lower    lower case letters
 5880          print    printing characters, including space
 5881          punct    printing characters, excluding letters and digits and space
 5882          space    white space (the same as \s from PCRE 8.34)
 5883          upper    upper case letters
 5884          word     "word" characters (same as \w)
 5885          xdigit   hexadecimal digits
 5887        The  default  "space" characters are HT (9), LF (10), VT (11), FF (12),
 5888        CR (13), and space (32). If locale-specific matching is  taking  place,
 5889        the  list  of  space characters may be different; there may be fewer or
 5890        more of them. "Space" used to be different to \s, which did not include
 5891        VT, for Perl compatibility.  However, Perl changed at release 5.18, and
 5892        PCRE followed at release 8.34.  "Space" and \s now match the  same  set
 5893        of characters.
 5895        The  name  "word"  is  a Perl extension, and "blank" is a GNU extension
 5896        from Perl 5.8. Another Perl extension is negation, which  is  indicated
 5897        by a ^ character after the colon. For example,
 5899          [12[:^digit:]]
 5901        matches  "1", "2", or any non-digit. PCRE (and Perl) also recognize the
 5902        POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
 5903        these are not supported, and an error is given if they are encountered.
 5905        By default, characters with values greater than 128 do not match any of
 5906        the POSIX character classes. However, if the PCRE_UCP option is  passed
 5907        to  pcre_compile(),  some  of  the  classes are changed so that Unicode
 5908        character properties are used. This is achieved  by  replacing  certain
 5909        POSIX classes by other sequences, as follows:
 5911          [:alnum:]  becomes  \p{Xan}
 5912          [:alpha:]  becomes  \p{L}
 5913          [:blank:]  becomes  \h
 5914          [:digit:]  becomes  \p{Nd}
 5915          [:lower:]  becomes  \p{Ll}
 5916          [:space:]  becomes  \p{Xps}
 5917          [:upper:]  becomes  \p{Lu}
 5918          [:word:]   becomes  \p{Xwd}
 5920        Negated  versions, such as [:^alpha:] use \P instead of \p. Three other
 5921        POSIX classes are handled specially in UCP mode:
 5923        [:graph:] This matches characters that have glyphs that mark  the  page
 5924                  when printed. In Unicode property terms, it matches all char-
 5925                  acters with the L, M, N, P, S, or Cf properties, except for:
 5927                    U+061C           Arabic Letter Mark
 5928                    U+180E           Mongolian Vowel Separator
 5929                    U+2066 - U+2069  Various "isolate"s
 5932        [:print:] This matches the same  characters  as  [:graph:]  plus  space
 5933                  characters  that  are  not controls, that is, characters with
 5934                  the Zs property.
 5936        [:punct:] This matches all characters that have the Unicode P (punctua-
 5937                  tion)  property,  plus those characters whose code points are
 5938                  less than 128 that have the S (Symbol) property.
 5940        The other POSIX classes are unchanged, and match only  characters  with
 5941        code points less than 128.
 5946        In  the POSIX.2 compliant library that was included in 4.4BSD Unix, the
 5947        ugly syntax [[:<:]] and [[:>:]] is used for matching  "start  of  word"
 5948        and "end of word". PCRE treats these items as follows:
 5950          [[:<:]]  is converted to  \b(?=\w)
 5951          [[:>:]]  is converted to  \b(?<=\w)
 5953        Only these exact character sequences are recognized. A sequence such as
 5954        [a[:<:]b] provokes error for an unrecognized  POSIX  class  name.  This
 5955        support  is not compatible with Perl. It is provided to help migrations
 5956        from other environments, and is best not used in any new patterns. Note
 5957        that  \b matches at the start and the end of a word (see "Simple asser-
 5958        tions" above), and in a Perl-style pattern the preceding  or  following
 5959        character  normally  shows  which  is  wanted, without the need for the
 5960        assertions that are used above in order to give exactly the  POSIX  be-
 5961        haviour.
 5966        Vertical  bar characters are used to separate alternative patterns. For
 5967        example, the pattern
 5969          gilbert|sullivan
 5971        matches either "gilbert" or "sullivan". Any number of alternatives  may
 5972        appear,  and  an  empty  alternative  is  permitted (matching the empty
 5973        string). The matching process tries each alternative in turn, from left
 5974        to  right, and the first one that succeeds is used. If the alternatives
 5975        are within a subpattern (defined below), "succeeds" means matching  the
 5976        rest of the main pattern as well as the alternative in the subpattern.
 5981        The  settings  of  the  PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
 5982        PCRE_EXTENDED options (which are Perl-compatible) can be  changed  from
 5983        within  the  pattern  by  a  sequence  of  Perl option letters enclosed
 5984        between "(?" and ")".  The option letters are
 5986          i  for PCRE_CASELESS
 5987          m  for PCRE_MULTILINE
 5988          s  for PCRE_DOTALL
 5989          x  for PCRE_EXTENDED
 5991        For example, (?im) sets caseless, multiline matching. It is also possi-
 5992        ble to unset these options by preceding the letter with a hyphen, and a
 5993        combined setting and unsetting such as (?im-sx), which sets  PCRE_CASE-
 5994        LESS  and PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED,
 5995        is also permitted. If a  letter  appears  both  before  and  after  the
 5996        hyphen, the option is unset.
 5998        The  PCRE-specific options PCRE_DUPNAMES, PCRE_UNGREEDY, and PCRE_EXTRA
 5999        can be changed in the same way as the Perl-compatible options by  using
 6000        the characters J, U and X respectively.
 6002        When  one  of  these  option  changes occurs at top level (that is, not
 6003        inside subpattern parentheses), the change applies to the remainder  of
 6004        the  pattern  that  follows.  An option change within a subpattern (see
 6005        below for a description of subpatterns) affects only that part  of  the
 6006        subpattern that follows it, so
 6008          (a(?i)b)c
 6010        matches abc and aBc and no other strings (assuming PCRE_CASELESS is not
 6011        used).  By this means, options can be made to have  different  settings
 6012        in  different parts of the pattern. Any changes made in one alternative
 6013        do carry on into subsequent branches within the  same  subpattern.  For
 6014        example,
 6016          (a(?i)b|c)
 6018        matches  "ab",  "aB",  "c",  and "C", even though when matching "C" the
 6019        first branch is abandoned before the option setting.  This  is  because
 6020        the  effects  of option settings happen at compile time. There would be
 6021        some very weird behaviour otherwise.
 6023        Note: There are other PCRE-specific options that  can  be  set  by  the
 6024        application  when  the  compiling  or matching functions are called. In
 6025        some cases the pattern can contain special leading  sequences  such  as
 6026        (*CRLF)  to  override  what  the  application  has set or what has been
 6027        defaulted.  Details  are  given  in  the  section   entitled   "Newline
 6028        sequences"  above.  There  are also the (*UTF8), (*UTF16),(*UTF32), and
 6029        (*UCP) leading sequences that can be used to set UTF and Unicode  prop-
 6030        erty  modes;  they are equivalent to setting the PCRE_UTF8, PCRE_UTF16,
 6031        PCRE_UTF32 and the PCRE_UCP options, respectively. The (*UTF)  sequence
 6032        is  a  generic version that can be used with any of the libraries. How-
 6033        ever, the application can set the PCRE_NEVER_UTF  option,  which  locks
 6034        out the use of the (*UTF) sequences.
 6039        Subpatterns are delimited by parentheses (round brackets), which can be
 6040        nested.  Turning part of a pattern into a subpattern does two things:
 6042        1. It localizes a set of alternatives. For example, the pattern
 6044          cat(aract|erpillar|)
 6046        matches "cataract", "caterpillar", or "cat". Without  the  parentheses,
 6047        it would match "cataract", "erpillar" or an empty string.
 6049        2.  It  sets  up  the  subpattern as a capturing subpattern. This means
 6050        that, when the whole pattern  matches,  that  portion  of  the  subject
 6051        string that matched the subpattern is passed back to the caller via the
 6052        ovector argument of the matching function. (This applies  only  to  the
 6053        traditional  matching functions; the DFA matching functions do not sup-
 6054        port capturing.)
 6056        Opening parentheses are counted from left to right (starting from 1) to
 6057        obtain  numbers  for  the  capturing  subpatterns.  For example, if the
 6058        string "the red king" is matched against the pattern
 6060          the ((red|white) (king|queen))
 6062        the captured substrings are "red king", "red", and "king", and are num-
 6063        bered 1, 2, and 3, respectively.
 6065        The  fact  that  plain  parentheses  fulfil two functions is not always
 6066        helpful.  There are often times when a grouping subpattern is  required
 6067        without  a capturing requirement. If an opening parenthesis is followed
 6068        by a question mark and a colon, the subpattern does not do any  captur-
 6069        ing,  and  is  not  counted when computing the number of any subsequent
 6070        capturing subpatterns. For example, if the string "the white queen"  is
 6071        matched against the pattern
 6073          the ((?:red|white) (king|queen))
 6075        the captured substrings are "white queen" and "queen", and are numbered
 6076        1 and 2. The maximum number of capturing subpatterns is 65535.
 6078        As a convenient shorthand, if any option settings are required  at  the
 6079        start  of  a  non-capturing  subpattern,  the option letters may appear
 6080        between the "?" and the ":". Thus the two patterns
 6082          (?i:saturday|sunday)
 6083          (?:(?i)saturday|sunday)
 6085        match exactly the same set of strings. Because alternative branches are
 6086        tried  from  left  to right, and options are not reset until the end of
 6087        the subpattern is reached, an option setting in one branch does  affect
 6088        subsequent  branches,  so  the above patterns match "SUNDAY" as well as
 6089        "Saturday".
 6094        Perl 5.10 introduced a feature whereby each alternative in a subpattern
 6095        uses  the same numbers for its capturing parentheses. Such a subpattern
 6096        starts with (?| and is itself a non-capturing subpattern. For  example,
 6097        consider this pattern:
 6099          (?|(Sat)ur|(Sun))day
 6101        Because  the two alternatives are inside a (?| group, both sets of cap-
 6102        turing parentheses are numbered one. Thus, when  the  pattern  matches,
 6103        you  can  look  at captured substring number one, whichever alternative
 6104        matched. This construct is useful when you want to  capture  part,  but
 6105        not all, of one of a number of alternatives. Inside a (?| group, paren-
 6106        theses are numbered as usual, but the number is reset at the  start  of
 6107        each  branch.  The numbers of any capturing parentheses that follow the
 6108        subpattern start after the highest number used in any branch. The  fol-
 6109        lowing example is taken from the Perl documentation. The numbers under-
 6110        neath show in which buffer the captured content will be stored.
 6112          # before  ---------------branch-reset----------- after
 6113          / ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
 6114          # 1            2         2  3        2     3     4
 6116        A back reference to a numbered subpattern uses the  most  recent  value
 6117        that  is  set  for that number by any subpattern. The following pattern
 6118        matches "abcabc" or "defdef":
 6120          /(?|(abc)|(def))\1/
 6122        In contrast, a subroutine call to a numbered subpattern  always  refers
 6123        to  the  first  one in the pattern with the given number. The following
 6124        pattern matches "abcabc" or "defabc":
 6126          /(?|(abc)|(def))(?1)/
 6128        If a condition test for a subpattern's having matched refers to a  non-
 6129        unique  number, the test is true if any of the subpatterns of that num-
 6130        ber have matched.
 6132        An alternative approach to using this "branch reset" feature is to  use
 6133        duplicate named subpatterns, as described in the next section.
 6138        Identifying  capturing  parentheses  by number is simple, but it can be
 6139        very hard to keep track of the numbers in complicated  regular  expres-
 6140        sions.  Furthermore,  if  an  expression  is  modified, the numbers may
 6141        change. To help with this difficulty, PCRE supports the naming of  sub-
 6142        patterns. This feature was not added to Perl until release 5.10. Python
 6143        had the feature earlier, and PCRE introduced it at release  4.0,  using
 6144        the  Python syntax. PCRE now supports both the Perl and the Python syn-
 6145        tax. Perl allows identically numbered  subpatterns  to  have  different
 6146        names, but PCRE does not.
 6148        In  PCRE,  a subpattern can be named in one of three ways: (?<name>...)
 6149        or (?'name'...) as in Perl, or (?P<name>...) as in  Python.  References
 6150        to  capturing parentheses from other parts of the pattern, such as back
 6151        references, recursion, and conditions, can be made by name as  well  as
 6152        by number.
 6154        Names  consist of up to 32 alphanumeric characters and underscores, but
 6155        must start with a non-digit.  Named  capturing  parentheses  are  still
 6156        allocated  numbers  as  well as names, exactly as if the names were not
 6157        present. The PCRE API provides function calls for extracting the  name-
 6158        to-number  translation  table  from a compiled pattern. There is also a
 6159        convenience function for extracting a captured substring by name.
 6161        By default, a name must be unique within a pattern, but it is  possible
 6162        to relax this constraint by setting the PCRE_DUPNAMES option at compile
 6163        time. (Duplicate names are also always permitted for  subpatterns  with
 6164        the  same  number, set up as described in the previous section.) Dupli-
 6165        cate names can be useful for patterns where only one  instance  of  the
 6166        named  parentheses  can  match. Suppose you want to match the name of a
 6167        weekday, either as a 3-letter abbreviation or as the full name, and  in
 6168        both cases you want to extract the abbreviation. This pattern (ignoring
 6169        the line breaks) does the job:
 6171          (?<DN>Mon|Fri|Sun)(?:day)?|
 6172          (?<DN>Tue)(?:sday)?|
 6173          (?<DN>Wed)(?:nesday)?|
 6174          (?<DN>Thu)(?:rsday)?|
 6175          (?<DN>Sat)(?:urday)?
 6177        There are five capturing substrings, but only one is ever set  after  a
 6178        match.  (An alternative way of solving this problem is to use a "branch
 6179        reset" subpattern, as described in the previous section.)
 6181        The convenience function for extracting the data by  name  returns  the
 6182        substring  for  the first (and in this example, the only) subpattern of
 6183        that name that matched. This saves searching  to  find  which  numbered
 6184        subpattern it was.
 6186        If  you  make  a  back  reference to a non-unique named subpattern from
 6187        elsewhere in the pattern, the subpatterns to which the name refers  are
 6188        checked  in  the order in which they appear in the overall pattern. The
 6189        first one that is set is used for the reference. For example, this pat-
 6190        tern matches both "foofoo" and "barbar" but not "foobar" or "barfoo":
 6192          (?:(?<n>foo)|(?<n>bar))\k<n>
 6195        If you make a subroutine call to a non-unique named subpattern, the one
 6196        that corresponds to the first occurrence of the name is  used.  In  the
 6197        absence of duplicate numbers (see the previous section) this is the one
 6198        with the lowest number.
 6200        If you use a named reference in a condition test (see the section about
 6201        conditions below), either to check whether a subpattern has matched, or
 6202        to check for recursion, all subpatterns with the same name are  tested.
 6203        If  the condition is true for any one of them, the overall condition is
 6204        true. This is the same behaviour as  testing  by  number.  For  further
 6205        details  of  the  interfaces  for  handling  named subpatterns, see the
 6206        pcreapi documentation.
 6208        Warning: You cannot use different names to distinguish between two sub-
 6209        patterns  with  the same number because PCRE uses only the numbers when
 6210        matching. For this reason, an error is given at compile time if differ-
 6211        ent  names  are given to subpatterns with the same number. However, you
 6212        can always give the same name to subpatterns with the same number, even
 6213        when PCRE_DUPNAMES is not set.
 6218        Repetition  is  specified  by  quantifiers, which can follow any of the
 6219        following items:
 6221          a literal data character
 6222          the dot metacharacter
 6223          the \C escape sequence
 6224          the \X escape sequence
 6225          the \R escape sequence
 6226          an escape such as \d or \pL that matches a single character
 6227          a character class
 6228          a back reference (see next section)
 6229          a parenthesized subpattern (including assertions)
 6230          a subroutine call to a subpattern (recursive or otherwise)
 6232        The general repetition quantifier specifies a minimum and maximum  num-
 6233        ber  of  permitted matches, by giving the two numbers in curly brackets
 6234        (braces), separated by a comma. The numbers must be  less  than  65536,
 6235        and the first must be less than or equal to the second. For example:
 6237          z{2,4}
 6239        matches  "zz",  "zzz",  or  "zzzz". A closing brace on its own is not a
 6240        special character. If the second number is omitted, but  the  comma  is
 6241        present,  there  is  no upper limit; if the second number and the comma
 6242        are both omitted, the quantifier specifies an exact number of  required
 6243        matches. Thus
 6245          [aeiou]{3,}
 6247        matches at least 3 successive vowels, but may match many more, while
 6249          \d{8}
 6251        matches  exactly  8  digits. An opening curly bracket that appears in a
 6252        position where a quantifier is not allowed, or one that does not  match
 6253        the  syntax of a quantifier, is taken as a literal character. For exam-
 6254        ple, {,6} is not a quantifier, but a literal string of four characters.
 6256        In UTF modes, quantifiers apply to characters rather than to individual
 6257        data  units. Thus, for example, \x{100}{2} matches two characters, each
 6258        of which is represented by a two-byte sequence in a UTF-8 string. Simi-
 6259        larly,  \X{3} matches three Unicode extended grapheme clusters, each of
 6260        which may be several data units long (and  they  may  be  of  different
 6261        lengths).
 6263        The quantifier {0} is permitted, causing the expression to behave as if
 6264        the previous item and the quantifier were not present. This may be use-
 6265        ful  for  subpatterns that are referenced as subroutines from elsewhere
 6266        in the pattern (but see also the section entitled "Defining subpatterns
 6267        for  use  by  reference only" below). Items other than subpatterns that
 6268        have a {0} quantifier are omitted from the compiled pattern.
 6270        For convenience, the three most common quantifiers have  single-charac-
 6271        ter abbreviations:
 6273          *    is equivalent to {0,}
 6274          +    is equivalent to {1,}
 6275          ?    is equivalent to {0,1}
 6277        It  is  possible  to construct infinite loops by following a subpattern
 6278        that can match no characters with a quantifier that has no upper limit,
 6279        for example:
 6281          (a?)*
 6283        Earlier versions of Perl and PCRE used to give an error at compile time
 6284        for such patterns. However, because there are cases where this  can  be
 6285        useful,  such  patterns  are now accepted, but if any repetition of the
 6286        subpattern does in fact match no characters, the loop is forcibly  bro-
 6287        ken.
 6289        By  default,  the quantifiers are "greedy", that is, they match as much
 6290        as possible (up to the maximum  number  of  permitted  times),  without
 6291        causing  the  rest of the pattern to fail. The classic example of where
 6292        this gives problems is in trying to match comments in C programs. These
 6293        appear  between  /*  and  */ and within the comment, individual * and /
 6294        characters may appear. An attempt to match C comments by  applying  the
 6295        pattern
 6297          /\*.*\*/
 6299        to the string
 6301          /* first comment */  not comment  /* second comment */
 6303        fails,  because it matches the entire string owing to the greediness of
 6304        the .*  item.
 6306        However, if a quantifier is followed by a question mark, it  ceases  to
 6307        be greedy, and instead matches the minimum number of times possible, so
 6308        the pattern
 6310          /\*.*?\*/
 6312        does the right thing with the C comments. The meaning  of  the  various
 6313        quantifiers  is  not  otherwise  changed,  just the preferred number of
 6314        matches.  Do not confuse this use of question mark with its  use  as  a
 6315        quantifier  in its own right. Because it has two uses, it can sometimes
 6316        appear doubled, as in
 6318          \d??\d
 6320        which matches one digit by preference, but can match two if that is the
 6321        only way the rest of the pattern matches.
 6323        If  the PCRE_UNGREEDY option is set (an option that is not available in
 6324        Perl), the quantifiers are not greedy by default, but  individual  ones
 6325        can  be  made  greedy  by following them with a question mark. In other
 6326        words, it inverts the default behaviour.
 6328        When a parenthesized subpattern is quantified  with  a  minimum  repeat
 6329        count  that is greater than 1 or with a limited maximum, more memory is
 6330        required for the compiled pattern, in proportion to  the  size  of  the
 6331        minimum or maximum.
 6333        If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equiv-
 6334        alent to Perl's /s) is set, thus allowing the dot  to  match  newlines,
 6335        the  pattern  is  implicitly anchored, because whatever follows will be
 6336        tried against every character position in the subject string, so  there
 6337        is  no  point  in  retrying the overall match at any position after the
 6338        first. PCRE normally treats such a pattern as though it  were  preceded
 6339        by \A.
 6341        In  cases  where  it  is known that the subject string contains no new-
 6342        lines, it is worth setting PCRE_DOTALL in order to  obtain  this  opti-
 6343        mization, or alternatively using ^ to indicate anchoring explicitly.
 6345        However,  there  are  some cases where the optimization cannot be used.
 6346        When .*  is inside capturing parentheses that are the subject of a back
 6347        reference elsewhere in the pattern, a match at the start may fail where
 6348        a later one succeeds. Consider, for example:
 6350          (.*)abc\1
 6352        If the subject is "xyz123abc123" the match point is the fourth  charac-
 6353        ter. For this reason, such a pattern is not implicitly anchored.
 6355        Another  case where implicit anchoring is not applied is when the lead-
 6356        ing .* is inside an atomic group. Once again, a match at the start  may
 6357        fail where a later one succeeds. Consider this pattern:
 6359          (?>.*?a)b
 6361        It  matches "ab" in the subject "aab". The use of the backtracking con-
 6362        trol verbs (*PRUNE) and (*SKIP) also disable this optimization.
 6364        When a capturing subpattern is repeated, the value captured is the sub-
 6365        string that matched the final iteration. For example, after
 6367          (tweedle[dume]{3}\s*)+
 6369        has matched "tweedledum tweedledee" the value of the captured substring
 6370        is "tweedledee". However, if there are  nested  capturing  subpatterns,
 6371        the  corresponding captured values may have been set in previous itera-
 6372        tions. For example, after
 6374          /(a|(b))+/
 6376        matches "aba" the value of the second captured substring is "b".
 6381        With both maximizing ("greedy") and minimizing ("ungreedy"  or  "lazy")
 6382        repetition,  failure  of what follows normally causes the repeated item
 6383        to be re-evaluated to see if a different number of repeats  allows  the
 6384        rest  of  the pattern to match. Sometimes it is useful to prevent this,
 6385        either to change the nature of the match, or to cause it  fail  earlier
 6386        than  it otherwise might, when the author of the pattern knows there is
 6387        no point in carrying on.
 6389        Consider, for example, the pattern \d+foo when applied to  the  subject
 6390        line
 6392          123456bar
 6394        After matching all 6 digits and then failing to match "foo", the normal
 6395        action of the matcher is to try again with only 5 digits  matching  the
 6396        \d+  item,  and  then  with  4,  and  so on, before ultimately failing.
 6397        "Atomic grouping" (a term taken from Jeffrey  Friedl's  book)  provides
 6398        the  means for specifying that once a subpattern has matched, it is not
 6399        to be re-evaluated in this way.
 6401        If we use atomic grouping for the previous example, the  matcher  gives
 6402        up  immediately  on failing to match "foo" the first time. The notation
 6403        is a kind of special parenthesis, starting with (?> as in this example:
 6405          (?>\d+)foo
 6407        This kind of parenthesis "locks up" the  part of the  pattern  it  con-
 6408        tains  once  it  has matched, and a failure further into the pattern is
 6409        prevented from backtracking into it. Backtracking past it  to  previous
 6410        items, however, works as normal.
 6412        An  alternative  description  is that a subpattern of this type matches
 6413        the string of characters that an  identical  standalone  pattern  would
 6414        match, if anchored at the current point in the subject string.
 6416        Atomic grouping subpatterns are not capturing subpatterns. Simple cases
 6417        such as the above example can be thought of as a maximizing repeat that
 6418        must  swallow  everything  it can. So, while both \d+ and \d+? are pre-
 6419        pared to adjust the number of digits they match in order  to  make  the
 6420        rest of the pattern match, (?>\d+) can only match an entire sequence of
 6421        digits.
 6423        Atomic groups in general can of course contain arbitrarily  complicated
 6424        subpatterns,  and  can  be  nested. However, when the subpattern for an
 6425        atomic group is just a single repeated item, as in the example above, a
 6426        simpler  notation,  called  a "possessive quantifier" can be used. This
 6427        consists of an additional + character  following  a  quantifier.  Using
 6428        this notation, the previous example can be rewritten as
 6430          \d++foo
 6432        Note that a possessive quantifier can be used with an entire group, for
 6433        example:
 6435          (abc|xyz){2,3}+
 6437        Possessive  quantifiers  are  always  greedy;  the   setting   of   the
 6438        PCRE_UNGREEDY option is ignored. They are a convenient notation for the
 6439        simpler forms of atomic group. However, there is no difference  in  the
 6440        meaning  of  a  possessive  quantifier and the equivalent atomic group,
 6441        though there may be a performance  difference;  possessive  quantifiers
 6442        should be slightly faster.
 6444        The  possessive  quantifier syntax is an extension to the Perl 5.8 syn-
 6445        tax.  Jeffrey Friedl originated the idea (and the name)  in  the  first
 6446        edition of his book. Mike McCloskey liked it, so implemented it when he
 6447        built Sun's Java package, and PCRE copied it from there. It  ultimately
 6448        found its way into Perl at release 5.10.
 6450        PCRE has an optimization that automatically "possessifies" certain sim-
 6451        ple pattern constructs. For example, the sequence  A+B  is  treated  as
 6452        A++B  because  there is no point in backtracking into a sequence of A's
 6453        when B must follow.
 6455        When a pattern contains an unlimited repeat inside  a  subpattern  that
 6456        can  itself  be  repeated  an  unlimited number of times, the use of an
 6457        atomic group is the only way to avoid some  failing  matches  taking  a
 6458        very long time indeed. The pattern
 6460          (\D+|<\d+>)*[!?]
 6462        matches  an  unlimited number of substrings that either consist of non-
 6463        digits, or digits enclosed in <>, followed by either ! or  ?.  When  it
 6464        matches, it runs quickly. However, if it is applied to
 6466          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 6468        it  takes  a  long  time  before reporting failure. This is because the
 6469        string can be divided between the internal \D+ repeat and the  external
 6470        *  repeat  in  a  large  number of ways, and all have to be tried. (The
 6471        example uses [!?] rather than a single character at  the  end,  because
 6472        both  PCRE  and  Perl have an optimization that allows for fast failure
 6473        when a single character is used. They remember the last single  charac-
 6474        ter  that  is required for a match, and fail early if it is not present
 6475        in the string.) If the pattern is changed so that  it  uses  an  atomic
 6476        group, like this:
 6478          ((?>\D+)|<\d+>)*[!?]
 6480        sequences of non-digits cannot be broken, and failure happens quickly.
 6485        Outside a character class, a backslash followed by a digit greater than
 6486        0 (and possibly further digits) is a back reference to a capturing sub-
 6487        pattern  earlier  (that is, to its left) in the pattern, provided there
 6488        have been that many previous capturing left parentheses.
 6490        However, if the decimal number following the backslash is less than 10,
 6491        it  is  always  taken  as a back reference, and causes an error only if
 6492        there are not that many capturing left parentheses in the  entire  pat-
 6493        tern.  In  other words, the parentheses that are referenced need not be
 6494        to the left of the reference for numbers less than 10. A "forward  back
 6495        reference"  of  this  type can make sense when a repetition is involved
 6496        and the subpattern to the right has participated in an  earlier  itera-
 6497        tion.
 6499        It  is  not  possible to have a numerical "forward back reference" to a
 6500        subpattern whose number is 10 or  more  using  this  syntax  because  a
 6501        sequence  such  as  \50 is interpreted as a character defined in octal.
 6502        See the subsection entitled "Non-printing characters" above for further
 6503        details  of  the  handling of digits following a backslash. There is no
 6504        such problem when named parentheses are used. A back reference  to  any
 6505        subpattern is possible using named parentheses (see below).
 6507        Another  way  of  avoiding  the ambiguity inherent in the use of digits
 6508        following a backslash is to use the \g  escape  sequence.  This  escape
 6509        must be followed by an unsigned number or a negative number, optionally
 6510        enclosed in braces. These examples are all identical:
 6512          (ring), \1
 6513          (ring), \g1
 6514          (ring), \g{1}
 6516        An unsigned number specifies an absolute reference without the  ambigu-
 6517        ity that is present in the older syntax. It is also useful when literal
 6518        digits follow the reference. A negative number is a relative reference.
 6519        Consider this example:
 6521          (abc(def)ghi)\g{-1}
 6523        The sequence \g{-1} is a reference to the most recently started captur-
 6524        ing subpattern before \g, that is, is it equivalent to \2 in this exam-
 6525        ple.   Similarly, \g{-2} would be equivalent to \1. The use of relative
 6526        references can be helpful in long patterns, and also in  patterns  that
 6527        are  created  by  joining  together  fragments  that contain references
 6528        within themselves.
 6530        A back reference matches whatever actually matched the  capturing  sub-
 6531        pattern  in  the  current subject string, rather than anything matching
 6532        the subpattern itself (see "Subpatterns as subroutines" below for a way
 6533        of doing that). So the pattern
 6535          (sens|respons)e and \1ibility
 6537        matches  "sense and sensibility" and "response and responsibility", but
 6538        not "sense and responsibility". If caseful matching is in force at  the
 6539        time  of the back reference, the case of letters is relevant. For exam-
 6540        ple,
 6542          ((?i)rah)\s+\1
 6544        matches "rah rah" and "RAH RAH", but not "RAH  rah",  even  though  the
 6545        original capturing subpattern is matched caselessly.
 6547        There  are  several  different ways of writing back references to named
 6548        subpatterns. The .NET syntax \k{name} and the Perl syntax  \k<name>  or
 6549        \k'name'  are supported, as is the Python syntax (?P=name). Perl 5.10's
 6550        unified back reference syntax, in which \g can be used for both numeric
 6551        and  named  references,  is  also supported. We could rewrite the above
 6552        example in any of the following ways:
 6554          (?<p1>(?i)rah)\s+\k<p1>
 6555          (?'p1'(?i)rah)\s+\k{p1}
 6556          (?P<p1>(?i)rah)\s+(?P=p1)
 6557          (?<p1>(?i)rah)\s+\g{p1}
 6559        A subpattern that is referenced by  name  may  appear  in  the  pattern
 6560        before or after the reference.
 6562        There  may be more than one back reference to the same subpattern. If a
 6563        subpattern has not actually been used in a particular match,  any  back
 6564        references to it always fail by default. For example, the pattern
 6566          (a|(bc))\2
 6568        always  fails  if  it starts to match "a" rather than "bc". However, if
 6569        the PCRE_JAVASCRIPT_COMPAT option is set at compile time, a back refer-
 6570        ence to an unset value matches an empty string.
 6572        Because  there may be many capturing parentheses in a pattern, all dig-
 6573        its following a backslash are taken as part of a potential back  refer-
 6574        ence  number.   If  the  pattern continues with a digit character, some
 6575        delimiter must  be  used  to  terminate  the  back  reference.  If  the
 6576        PCRE_EXTENDED  option  is  set, this can be white space. Otherwise, the
 6577        \g{ syntax or an empty comment (see "Comments" below) can be used.
 6579    Recursive back references
 6581        A back reference that occurs inside the parentheses to which it  refers
 6582        fails  when  the subpattern is first used, so, for example, (a\1) never
 6583        matches.  However, such references can be useful inside  repeated  sub-
 6584        patterns. For example, the pattern
 6586          (a|b\1)+
 6588        matches any number of "a"s and also "aba", "ababbaa" etc. At each iter-
 6589        ation of the subpattern,  the  back  reference  matches  the  character
 6590        string  corresponding  to  the previous iteration. In order for this to
 6591        work, the pattern must be such that the first iteration does  not  need
 6592        to  match the back reference. This can be done using alternation, as in
 6593        the example above, or by a quantifier with a minimum of zero.
 6595        Back references of this type cause the group that they reference to  be
 6596        treated  as  an atomic group.  Once the whole group has been matched, a
 6597        subsequent matching failure cannot cause backtracking into  the  middle
 6598        of the group.
 6603        An  assertion  is  a  test on the characters following or preceding the
 6604        current matching point that does not actually consume  any  characters.
 6605        The  simple  assertions  coded  as  \b, \B, \A, \G, \Z, \z, ^ and $ are
 6606        described above.
 6608        More complicated assertions are coded as  subpatterns.  There  are  two
 6609        kinds:  those  that  look  ahead of the current position in the subject
 6610        string, and those that look  behind  it.  An  assertion  subpattern  is
 6611        matched  in  the  normal way, except that it does not cause the current
 6612        matching position to be changed.
 6614        Assertion subpatterns are not capturing subpatterns. If such an  asser-
 6615        tion  contains  capturing  subpatterns within it, these are counted for
 6616        the purposes of numbering the capturing subpatterns in the  whole  pat-
 6617        tern.  However,  substring  capturing  is carried out only for positive
 6618        assertions. (Perl sometimes, but not always, does do capturing in nega-
 6619        tive assertions.)
 6621        WARNING:  If a positive assertion containing one or more capturing sub-
 6622        patterns succeeds, but failure to match later  in  the  pattern  causes
 6623        backtracking over this assertion, the captures within the assertion are
 6624        reset only if no higher numbered captures are  already  set.  This  is,
 6625        unfortunately,  a fundamental limitation of the current implementation,
 6626        and as PCRE1 is now in maintenance-only status, it is unlikely ever  to
 6627        change.
 6629        For  compatibility  with  Perl,  assertion subpatterns may be repeated;
 6630        though it makes no sense to assert the same thing  several  times,  the
 6631        side  effect  of  capturing  parentheses may occasionally be useful. In
 6632        practice, there only three cases:
 6634        (1) If the quantifier is {0}, the  assertion  is  never  obeyed  during
 6635        matching.   However,  it  may  contain internal capturing parenthesized
 6636        groups that are called from elsewhere via the subroutine mechanism.
 6638        (2) If quantifier is {0,n} where n is greater than zero, it is  treated
 6639        as  if  it  were  {0,1}.  At run time, the rest of the pattern match is
 6640        tried with and without the assertion, the order depending on the greed-
 6641        iness of the quantifier.
 6643        (3)  If  the minimum repetition is greater than zero, the quantifier is
 6644        ignored.  The assertion is obeyed just  once  when  encountered  during
 6645        matching.
 6647    Lookahead assertions
 6649        Lookahead assertions start with (?= for positive assertions and (?! for
 6650        negative assertions. For example,
 6652          \w+(?=;)
 6654        matches a word followed by a semicolon, but does not include the  semi-
 6655        colon in the match, and
 6657          foo(?!bar)
 6659        matches  any  occurrence  of  "foo" that is not followed by "bar". Note
 6660        that the apparently similar pattern
 6662          (?!foo)bar
 6664        does not find an occurrence of "bar"  that  is  preceded  by  something
 6665        other  than "foo"; it finds any occurrence of "bar" whatsoever, because
 6666        the assertion (?!foo) is always true when the next three characters are
 6667        "bar". A lookbehind assertion is needed to achieve the other effect.
 6669        If you want to force a matching failure at some point in a pattern, the
 6670        most convenient way to do it is  with  (?!)  because  an  empty  string
 6671        always  matches, so an assertion that requires there not to be an empty
 6672        string must always fail.  The backtracking control verb (*FAIL) or (*F)
 6673        is a synonym for (?!).
 6675    Lookbehind assertions
 6677        Lookbehind  assertions start with (?<= for positive assertions and (?<!
 6678        for negative assertions. For example,
 6680          (?<!foo)bar
 6682        does find an occurrence of "bar" that is not  preceded  by  "foo".  The
 6683        contents  of  a  lookbehind  assertion are restricted such that all the
 6684        strings it matches must have a fixed length. However, if there are sev-
 6685        eral  top-level  alternatives,  they  do  not all have to have the same
 6686        fixed length. Thus
 6688          (?<=bullock|donkey)
 6690        is permitted, but
 6692          (?<!dogs?|cats?)
 6694        causes an error at compile time. Branches that match  different  length
 6695        strings  are permitted only at the top level of a lookbehind assertion.
 6696        This is an extension compared with Perl, which requires all branches to
 6697        match the same length of string. An assertion such as
 6699          (?<=ab(c|de))
 6701        is  not  permitted,  because  its single top-level branch can match two
 6702        different lengths, but it is acceptable to PCRE if rewritten to use two
 6703        top-level branches:
 6705          (?<=abc|abde)
 6707        In  some  cases, the escape sequence \K (see above) can be used instead
 6708        of a lookbehind assertion to get round the fixed-length restriction.
 6710        The implementation of lookbehind assertions is, for  each  alternative,
 6711        to  temporarily  move the current position back by the fixed length and
 6712        then try to match. If there are insufficient characters before the cur-
 6713        rent position, the assertion fails.
 6715        In  a UTF mode, PCRE does not allow the \C escape (which matches a sin-
 6716        gle data unit even in a UTF mode) to appear in  lookbehind  assertions,
 6717        because  it  makes it impossible to calculate the length of the lookbe-
 6718        hind. The \X and \R escapes, which can match different numbers of  data
 6719        units, are also not permitted.
 6721        "Subroutine"  calls  (see below) such as (?2) or (?&X) are permitted in
 6722        lookbehinds, as long as the subpattern matches a  fixed-length  string.
 6723        Recursion, however, is not supported.
 6725        Possessive  quantifiers  can  be  used  in  conjunction with lookbehind
 6726        assertions to specify efficient matching of fixed-length strings at the
 6727        end of subject strings. Consider a simple pattern such as
 6729          abcd$
 6731        when  applied  to  a  long string that does not match. Because matching
 6732        proceeds from left to right, PCRE will look for each "a" in the subject
 6733        and  then  see  if what follows matches the rest of the pattern. If the
 6734        pattern is specified as
 6736          ^.*abcd$
 6738        the initial .* matches the entire string at first, but when this  fails
 6739        (because there is no following "a"), it backtracks to match all but the
 6740        last character, then all but the last two characters, and so  on.  Once
 6741        again  the search for "a" covers the entire string, from right to left,
 6742        so we are no better off. However, if the pattern is written as
 6744          ^.*+(?<=abcd)
 6746        there can be no backtracking for the .*+ item; it can  match  only  the
 6747        entire  string.  The subsequent lookbehind assertion does a single test
 6748        on the last four characters. If it fails, the match fails  immediately.
 6749        For  long  strings, this approach makes a significant difference to the
 6750        processing time.
 6752    Using multiple assertions
 6754        Several assertions (of any sort) may occur in succession. For example,
 6756          (?<=\d{3})(?<!999)foo
 6758        matches "foo" preceded by three digits that are not "999". Notice  that
 6759        each  of  the  assertions is applied independently at the same point in
 6760        the subject string. First there is a  check  that  the  previous  three
 6761        characters  are  all  digits,  and  then there is a check that the same
 6762        three characters are not "999".  This pattern does not match "foo" pre-
 6763        ceded  by  six  characters,  the first of which are digits and the last
 6764        three of which are not "999". For example, it  doesn't  match  "123abc-
 6765        foo". A pattern to do that is
 6767          (?<=\d{3}...)(?<!999)foo
 6769        This  time  the  first assertion looks at the preceding six characters,
 6770        checking that the first three are digits, and then the second assertion
 6771        checks that the preceding three characters are not "999".
 6773        Assertions can be nested in any combination. For example,
 6775          (?<=(?<!foo)bar)baz
 6777        matches  an occurrence of "baz" that is preceded by "bar" which in turn
 6778        is not preceded by "foo", while
 6780          (?<=\d{3}(?!999)...)foo
 6782        is another pattern that matches "foo" preceded by three digits and  any
 6783        three characters that are not "999".
 6788        It  is possible to cause the matching process to obey a subpattern con-
 6789        ditionally or to choose between two alternative subpatterns,  depending
 6790        on  the result of an assertion, or whether a specific capturing subpat-
 6791        tern has already been matched. The two possible  forms  of  conditional
 6792        subpattern are:
 6794          (?(condition)yes-pattern)
 6795          (?(condition)yes-pattern|no-pattern)
 6797        If  the  condition is satisfied, the yes-pattern is used; otherwise the
 6798        no-pattern (if present) is used. If there are more  than  two  alterna-
 6799        tives  in  the subpattern, a compile-time error occurs. Each of the two
 6800        alternatives may itself contain nested subpatterns of any form, includ-
 6801        ing  conditional  subpatterns;  the  restriction  to  two  alternatives
 6802        applies only at the level of the condition. This pattern fragment is an
 6803        example where the alternatives are complex:
 6805          (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
 6808        There  are  four  kinds of condition: references to subpatterns, refer-
 6809        ences to recursion, a pseudo-condition called DEFINE, and assertions.
 6811    Checking for a used subpattern by number
 6813        If the text between the parentheses consists of a sequence  of  digits,
 6814        the condition is true if a capturing subpattern of that number has pre-
 6815        viously matched. If there is more than one  capturing  subpattern  with
 6816        the  same  number  (see  the earlier section about duplicate subpattern
 6817        numbers), the condition is true if any of them have matched. An  alter-
 6818        native  notation is to precede the digits with a plus or minus sign. In
 6819        this case, the subpattern number is relative rather than absolute.  The
 6820        most  recently opened parentheses can be referenced by (?(-1), the next
 6821        most recent by (?(-2), and so on. Inside loops it can also  make  sense
 6822        to refer to subsequent groups. The next parentheses to be opened can be
 6823        referenced as (?(+1), and so on. (The value zero in any of these  forms
 6824        is not used; it provokes a compile-time error.)
 6826        Consider  the  following  pattern, which contains non-significant white
 6827        space to make it more readable (assume the PCRE_EXTENDED option) and to
 6828        divide it into three parts for ease of discussion:
 6830          ( \( )?    [^()]+    (?(1) \) )
 6832        The  first  part  matches  an optional opening parenthesis, and if that
 6833        character is present, sets it as the first captured substring. The sec-
 6834        ond  part  matches one or more characters that are not parentheses. The
 6835        third part is a conditional subpattern that tests whether  or  not  the
 6836        first  set  of  parentheses  matched.  If they did, that is, if subject
 6837        started with an opening parenthesis, the condition is true, and so  the
 6838        yes-pattern  is  executed and a closing parenthesis is required. Other-
 6839        wise, since no-pattern is not present, the subpattern matches  nothing.
 6840        In  other  words,  this  pattern matches a sequence of non-parentheses,
 6841        optionally enclosed in parentheses.
 6843        If you were embedding this pattern in a larger one,  you  could  use  a
 6844        relative reference:
 6846          ...other stuff... ( \( )?    [^()]+    (?(-1) \) ) ...
 6848        This  makes  the  fragment independent of the parentheses in the larger
 6849        pattern.
 6851    Checking for a used subpattern by name
 6853        Perl uses the syntax (?(<name>)...) or (?('name')...)  to  test  for  a
 6854        used  subpattern  by  name.  For compatibility with earlier versions of
 6855        PCRE, which had this facility before Perl, the syntax  (?(name)...)  is
 6856        also recognized.
 6858        Rewriting the above example to use a named subpattern gives this:
 6860          (?<OPEN> \( )?    [^()]+    (?(<OPEN>) \) )
 6862        If  the  name used in a condition of this kind is a duplicate, the test
 6863        is applied to all subpatterns of the same name, and is true if any  one
 6864        of them has matched.
 6866    Checking for pattern recursion
 6868        If the condition is the string (R), and there is no subpattern with the
 6869        name R, the condition is true if a recursive call to the whole  pattern
 6870        or any subpattern has been made. If digits or a name preceded by amper-
 6871        sand follow the letter R, for example:
 6873          (?(R3)...) or (?(R&name)...)
 6875        the condition is true if the most recent recursion is into a subpattern
 6876        whose number or name is given. This condition does not check the entire
 6877        recursion stack. If the name used in a condition  of  this  kind  is  a
 6878        duplicate, the test is applied to all subpatterns of the same name, and
 6879        is true if any one of them is the most recent recursion.
 6881        At "top level", all these recursion test  conditions  are  false.   The
 6882        syntax for recursive patterns is described below.
 6884    Defining subpatterns for use by reference only
 6886        If  the  condition  is  the string (DEFINE), and there is no subpattern
 6887        with the name DEFINE, the condition is  always  false.  In  this  case,
 6888        there  may  be  only  one  alternative  in the subpattern. It is always
 6889        skipped if control reaches this point  in  the  pattern;  the  idea  of
 6890        DEFINE  is that it can be used to define subroutines that can be refer-
 6891        enced from elsewhere. (The use of subroutines is described below.)  For
 6892        example,  a  pattern  to match an IPv4 address such as ""
 6893        could be written like this (ignore white space and line breaks):
 6895          (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
 6896          \b (?&byte) (\.(?&byte)){3} \b
 6898        The first part of the pattern is a DEFINE group inside which a  another
 6899        group  named "byte" is defined. This matches an individual component of
 6900        an IPv4 address (a number less than 256). When  matching  takes  place,
 6901        this  part  of  the pattern is skipped because DEFINE acts like a false
 6902        condition. The rest of the pattern uses references to the  named  group
 6903        to  match the four dot-separated components of an IPv4 address, insist-
 6904        ing on a word boundary at each end.
 6906    Assertion conditions
 6908        If the condition is not in any of the above  formats,  it  must  be  an
 6909        assertion.   This may be a positive or negative lookahead or lookbehind
 6910        assertion. Consider  this  pattern,  again  containing  non-significant
 6911        white space, and with the two alternatives on the second line:
 6913          (?(?=[^a-z]*[a-z])
 6914          \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} )
 6916        The  condition  is  a  positive  lookahead  assertion  that  matches an
 6917        optional sequence of non-letters followed by a letter. In other  words,
 6918        it  tests  for the presence of at least one letter in the subject. If a
 6919        letter is found, the subject is matched against the first  alternative;
 6920        otherwise  it  is  matched  against  the  second.  This pattern matches
 6921        strings in one of the two forms dd-aaa-dd or dd-dd-dd,  where  aaa  are
 6922        letters and dd are digits.
 6927        There are two ways of including comments in patterns that are processed
 6928        by PCRE. In both cases, the start of the comment must not be in a char-
 6929        acter class, nor in the middle of any other sequence of related charac-
 6930        ters such as (?: or a subpattern name or number.  The  characters  that
 6931        make up a comment play no part in the pattern matching.
 6933        The  sequence (?# marks the start of a comment that continues up to the
 6934        next closing parenthesis. Nested parentheses are not permitted. If  the
 6935        PCRE_EXTENDED option is set, an unescaped # character also introduces a
 6936        comment, which in this case continues to  immediately  after  the  next
 6937        newline  character  or character sequence in the pattern. Which charac-
 6938        ters are interpreted as newlines is controlled by the options passed to
 6939        a  compiling function or by a special sequence at the start of the pat-
 6940        tern, as described in the section entitled "Newline conventions" above.
 6941        Note that the end of this type of comment is a literal newline sequence
 6942        in the pattern; escape sequences that happen to represent a newline  do
 6943        not  count.  For  example,  consider this pattern when PCRE_EXTENDED is
 6944        set, and the default newline convention is in force:
 6946          abc #comment \n still comment
 6948        On encountering the # character, pcre_compile()  skips  along,  looking
 6949        for  a newline in the pattern. The sequence \n is still literal at this
 6950        stage, so it does not terminate the comment. Only an  actual  character
 6951        with the code value 0x0a (the default newline) does so.
 6956        Consider  the problem of matching a string in parentheses, allowing for
 6957        unlimited nested parentheses. Without the use of  recursion,  the  best
 6958        that  can  be  done  is  to use a pattern that matches up to some fixed
 6959        depth of nesting. It is not possible to  handle  an  arbitrary  nesting
 6960        depth.
 6962        For some time, Perl has provided a facility that allows regular expres-
 6963        sions to recurse (amongst other things). It does this by  interpolating
 6964        Perl  code in the expression at run time, and the code can refer to the
 6965        expression itself. A Perl pattern using code interpolation to solve the
 6966        parentheses problem can be created like this:
 6968          $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
 6970        The (?p{...}) item interpolates Perl code at run time, and in this case
 6971        refers recursively to the pattern in which it appears.
 6973        Obviously, PCRE cannot support the interpolation of Perl code. Instead,
 6974        it  supports  special  syntax  for recursion of the entire pattern, and
 6975        also for individual subpattern recursion.  After  its  introduction  in
 6976        PCRE  and  Python,  this  kind of recursion was subsequently introduced
 6977        into Perl at release 5.10.
 6979        A special item that consists of (? followed by a  number  greater  than
 6980        zero  and  a  closing parenthesis is a recursive subroutine call of the
 6981        subpattern of the given number, provided that  it  occurs  inside  that
 6982        subpattern.  (If  not,  it is a non-recursive subroutine call, which is
 6983        described in the next section.) The special item  (?R)  or  (?0)  is  a
 6984        recursive call of the entire regular expression.
 6986        This  PCRE  pattern  solves  the nested parentheses problem (assume the
 6987        PCRE_EXTENDED option is set so that white space is ignored):
 6989          \( ( [^()]++ | (?R) )* \)
 6991        First it matches an opening parenthesis. Then it matches any number  of
 6992        substrings  which  can  either  be  a sequence of non-parentheses, or a
 6993        recursive match of the pattern itself (that is, a  correctly  parenthe-
 6994        sized substring).  Finally there is a closing parenthesis. Note the use
 6995        of a possessive quantifier to avoid backtracking into sequences of non-
 6996        parentheses.
 6998        If  this  were  part of a larger pattern, you would not want to recurse
 6999        the entire pattern, so instead you could use this:
 7001          ( \( ( [^()]++ | (?1) )* \) )
 7003        We have put the pattern into parentheses, and caused the  recursion  to
 7004        refer to them instead of the whole pattern.
 7006        In  a  larger  pattern,  keeping  track  of  parenthesis numbers can be
 7007        tricky. This is made easier by the use of relative references.  Instead
 7008        of (?1) in the pattern above you can write (?-2) to refer to the second
 7009        most recently opened parentheses  preceding  the  recursion.  In  other
 7010        words,  a  negative  number counts capturing parentheses leftwards from
 7011        the point at which it is encountered.
 7013        It is also possible to refer to  subsequently  opened  parentheses,  by
 7014        writing  references  such  as (?+2). However, these cannot be recursive
 7015        because the reference is not inside the  parentheses  that  are  refer-
 7016        enced.  They are always non-recursive subroutine calls, as described in
 7017        the next section.
 7019        An alternative approach is to use named parentheses instead.  The  Perl
 7020        syntax  for  this  is (?&name); PCRE's earlier syntax (?P>name) is also
 7021        supported. We could rewrite the above example as follows:
 7023          (?<pn> \( ( [^()]++ | (?&pn) )* \) )
 7025        If there is more than one subpattern with the same name,  the  earliest
 7026        one is used.
 7028        This  particular  example pattern that we have been looking at contains
 7029        nested unlimited repeats, and so the use of a possessive quantifier for
 7030        matching strings of non-parentheses is important when applying the pat-
 7031        tern to strings that do not match. For example, when  this  pattern  is
 7032        applied to
 7034          (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
 7036        it  yields  "no  match" quickly. However, if a possessive quantifier is
 7037        not used, the match runs for a very long time indeed because there  are
 7038        so  many  different  ways the + and * repeats can carve up the subject,
 7039        and all have to be tested before failure can be reported.
 7041        At the end of a match, the values of capturing  parentheses  are  those
 7042        from  the outermost level. If you want to obtain intermediate values, a
 7043        callout function can be used (see below and the pcrecallout  documenta-
 7044        tion). If the pattern above is matched against
 7046          (ab(cd)ef)
 7048        the  value  for  the  inner capturing parentheses (numbered 2) is "ef",
 7049        which is the last value taken on at the top level. If a capturing  sub-
 7050        pattern  is  not  matched at the top level, its final captured value is
 7051        unset, even if it was (temporarily) set at a deeper  level  during  the
 7052        matching process.
 7054        If  there are more than 15 capturing parentheses in a pattern, PCRE has
 7055        to obtain extra memory to store data during a recursion, which it  does
 7056        by using pcre_malloc, freeing it via pcre_free afterwards. If no memory
 7057        can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
 7059        Do not confuse the (?R) item with the condition (R),  which  tests  for
 7060        recursion.   Consider  this pattern, which matches text in angle brack-
 7061        ets, allowing for arbitrary nesting. Only digits are allowed in  nested
 7062        brackets  (that is, when recursing), whereas any characters are permit-
 7063        ted at the outer level.
 7065          < (?: (?(R) \d++  | [^<>]*+) | (?R)) * >
 7067        In this pattern, (?(R) is the start of a conditional  subpattern,  with
 7068        two  different  alternatives for the recursive and non-recursive cases.
 7069        The (?R) item is the actual recursive call.
 7071    Differences in recursion processing between PCRE and Perl
 7073        Recursion processing in PCRE differs from Perl in two  important  ways.
 7074        In  PCRE (like Python, but unlike Perl), a recursive subpattern call is
 7075        always treated as an atomic group. That is, once it has matched some of
 7076        the subject string, it is never re-entered, even if it contains untried
 7077        alternatives and there is a subsequent matching failure.  This  can  be
 7078        illustrated  by the following pattern, which purports to match a palin-
 7079        dromic string that contains an odd number of characters  (for  example,
 7080        "a", "aba", "abcba", "abcdcba"):
 7082          ^(.|(.)(?1)\2)$
 7084        The idea is that it either matches a single character, or two identical
 7085        characters surrounding a sub-palindrome. In Perl, this  pattern  works;
 7086        in  PCRE  it  does  not if the pattern is longer than three characters.
 7087        Consider the subject string "abcba":
 7089        At the top level, the first character is matched, but as it is  not  at
 7090        the end of the string, the first alternative fails; the second alterna-
 7091        tive is taken and the recursion kicks in. The recursive call to subpat-
 7092        tern  1  successfully  matches the next character ("b"). (Note that the
 7093        beginning and end of line tests are not part of the recursion).
 7095        Back at the top level, the next character ("c") is compared  with  what
 7096        subpattern  2 matched, which was "a". This fails. Because the recursion
 7097        is treated as an atomic group, there are now  no  backtracking  points,
 7098        and  so  the  entire  match fails. (Perl is able, at this point, to re-
 7099        enter the recursion and try the second alternative.)  However,  if  the
 7100        pattern is written with the alternatives in the other order, things are
 7101        different:
 7103          ^((.)(?1)\2|.)$
 7105        This time, the recursing alternative is tried first, and  continues  to
 7106        recurse  until  it runs out of characters, at which point the recursion
 7107        fails. But this time we do have  another  alternative  to  try  at  the
 7108        higher  level.  That  is  the  big difference: in the previous case the
 7109        remaining alternative is at a deeper recursion level, which PCRE cannot
 7110        use.
 7112        To  change  the pattern so that it matches all palindromic strings, not
 7113        just those with an odd number of characters, it is tempting  to  change
 7114        the pattern to this:
 7116          ^((.)(?1)\2|.?)$
 7118        Again,  this  works  in Perl, but not in PCRE, and for the same reason.
 7119        When a deeper recursion has matched a single character,  it  cannot  be
 7120        entered  again  in  order  to match an empty string. The solution is to
 7121        separate the two cases, and write out the odd and even cases as  alter-
 7122        natives at the higher level:
 7124          ^(?:((.)(?1)\2|)|((.)(?3)\4|.))
 7126        If  you  want  to match typical palindromic phrases, the pattern has to
 7127        ignore all non-word characters, which can be done like this:
 7129          ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$
 7131        If run with the PCRE_CASELESS option, this pattern matches phrases such
 7132        as "A man, a plan, a canal: Panama!" and it works well in both PCRE and
 7133        Perl. Note the use of the possessive quantifier *+ to avoid  backtrack-
 7134        ing  into  sequences of non-word characters. Without this, PCRE takes a
 7135        great deal longer (ten times or more) to  match  typical  phrases,  and
 7136        Perl takes so long that you think it has gone into a loop.
 7138        WARNING:  The  palindrome-matching patterns above work only if the sub-
 7139        ject string does not start with a palindrome that is shorter  than  the
 7140        entire  string.  For example, although "abcba" is correctly matched, if
 7141        the subject is "ababa", PCRE finds the palindrome "aba" at  the  start,
 7142        then  fails at top level because the end of the string does not follow.
 7143        Once again, it cannot jump back into the recursion to try other  alter-
 7144        natives, so the entire match fails.
 7146        The  second  way  in which PCRE and Perl differ in their recursion pro-
 7147        cessing is in the handling of captured values. In Perl, when a  subpat-
 7148        tern  is  called recursively or as a subpattern (see the next section),
 7149        it has no access to any values that were captured  outside  the  recur-
 7150        sion,  whereas  in  PCRE  these values can be referenced. Consider this
 7151        pattern:
 7153          ^(.)(\1|a(?2))
 7155        In PCRE, this pattern matches "bab". The  first  capturing  parentheses
 7156        match  "b",  then in the second group, when the back reference \1 fails
 7157        to match "b", the second alternative matches "a" and then recurses.  In
 7158        the  recursion,  \1 does now match "b" and so the whole match succeeds.
 7159        In Perl, the pattern fails to match because inside the  recursive  call
 7160        \1 cannot access the externally set value.
 7165        If  the  syntax for a recursive subpattern call (either by number or by
 7166        name) is used outside the parentheses to which it refers,  it  operates
 7167        like  a subroutine in a programming language. The called subpattern may
 7168        be defined before or after the reference. A numbered reference  can  be
 7169        absolute or relative, as in these examples:
 7171          (...(absolute)...)...(?2)...
 7172          (...(relative)...)...(?-1)...
 7173          (...(?+1)...(relative)...
 7175        An earlier example pointed out that the pattern
 7177          (sens|respons)e and \1ibility
 7179        matches  "sense and sensibility" and "response and responsibility", but
 7180        not "sense and responsibility". If instead the pattern
 7182          (sens|respons)e and (?1)ibility
 7184        is used, it does match "sense and responsibility" as well as the  other
 7185        two  strings.  Another  example  is  given  in the discussion of DEFINE
 7186        above.
 7188        All subroutine calls, whether recursive or not, are always  treated  as
 7189        atomic  groups. That is, once a subroutine has matched some of the sub-
 7190        ject string, it is never re-entered, even if it contains untried alter-
 7191        natives  and  there  is  a  subsequent  matching failure. Any capturing
 7192        parentheses that are set during the subroutine  call  revert  to  their
 7193        previous values afterwards.
 7195        Processing  options  such as case-independence are fixed when a subpat-
 7196        tern is defined, so if it is used as a subroutine, such options  cannot
 7197        be changed for different calls. For example, consider this pattern:
 7199          (abc)(?i:(?-1))
 7201        It  matches  "abcabc". It does not match "abcABC" because the change of
 7202        processing option does not affect the called subpattern.
 7207        For compatibility with Oniguruma, the non-Perl syntax \g followed by  a
 7208        name or a number enclosed either in angle brackets or single quotes, is
 7209        an alternative syntax for referencing a  subpattern  as  a  subroutine,
 7210        possibly  recursively. Here are two of the examples used above, rewrit-
 7211        ten using this syntax:
 7213          (?<pn> \( ( (?>[^()]+) | \g<pn> )* \) )
 7214          (sens|respons)e and \g'1'ibility
 7216        PCRE supports an extension to Oniguruma: if a number is preceded  by  a
 7217        plus or a minus sign it is taken as a relative reference. For example:
 7219          (abc)(?i:\g<-1>)
 7221        Note  that \g{...} (Perl syntax) and \g<...> (Oniguruma syntax) are not
 7222        synonymous. The former is a back reference; the latter is a  subroutine
 7223        call.
 7228        Perl has a feature whereby using the sequence (?{...}) causes arbitrary
 7229        Perl code to be obeyed in the middle of matching a regular  expression.
 7230        This makes it possible, amongst other things, to extract different sub-
 7231        strings that match the same pair of parentheses when there is a repeti-
 7232        tion.
 7234        PCRE provides a similar feature, but of course it cannot obey arbitrary
 7235        Perl code. The feature is called "callout". The caller of PCRE provides
 7236        an  external function by putting its entry point in the global variable
 7237        pcre_callout (8-bit library) or pcre[16|32]_callout (16-bit  or  32-bit
 7238        library).   By default, this variable contains NULL, which disables all
 7239        calling out.
 7241        Within a regular expression, (?C) indicates the  points  at  which  the
 7242        external  function  is  to be called. If you want to identify different
 7243        callout points, you can put a number less than 256 after the letter  C.
 7244        The  default  value is zero.  For example, this pattern has two callout
 7245        points:
 7247          (?C1)abc(?C2)def
 7249        If the PCRE_AUTO_CALLOUT flag is passed to a compiling function,  call-
 7250        outs  are automatically installed before each item in the pattern. They
 7251        are all numbered 255. If there is a conditional group  in  the  pattern
 7252        whose condition is an assertion, an additional callout is inserted just
 7253        before the condition. An explicit callout may also be set at this posi-
 7254        tion, as in this example:
 7256          (?(?C9)(?=a)abc|def)
 7258        Note that this applies only to assertion conditions, not to other types
 7259        of condition.
 7261        During matching, when PCRE reaches a callout point, the external  func-
 7262        tion  is  called.  It  is  provided with the number of the callout, the
 7263        position in the pattern, and, optionally, one item of  data  originally
 7264        supplied  by  the caller of the matching function. The callout function
 7265        may cause matching to proceed, to backtrack, or to fail altogether.
 7267        By default, PCRE implements a number of optimizations at  compile  time
 7268        and  matching  time, and one side-effect is that sometimes callouts are
 7269        skipped. If you need all possible callouts to happen, you need  to  set
 7270        options  that  disable  the relevant optimizations. More details, and a
 7271        complete description of the interface  to  the  callout  function,  are
 7272        given in the pcrecallout documentation.
 7277        Perl  5.10 introduced a number of "Special Backtracking Control Verbs",
 7278        which are still described in the Perl  documentation  as  "experimental
 7279        and  subject to change or removal in a future version of Perl". It goes
 7280        on to say: "Their usage in production code should  be  noted  to  avoid
 7281        problems  during upgrades." The same remarks apply to the PCRE features
 7282        described in this section.
 7284        The new verbs make use of what was previously invalid syntax: an  open-
 7285        ing parenthesis followed by an asterisk. They are generally of the form
 7286        (*VERB) or (*VERB:NAME). Some may take either form,  possibly  behaving
 7287        differently  depending  on  whether or not a name is present. A name is
 7288        any sequence of characters that does not include a closing parenthesis.
 7289        The maximum length of name is 255 in the 8-bit library and 65535 in the
 7290        16-bit and 32-bit libraries. If the name is  empty,  that  is,  if  the
 7291        closing  parenthesis immediately follows the colon, the effect is as if
 7292        the colon were not there.  Any number of these verbs  may  occur  in  a
 7293        pattern.
 7295        Since  these  verbs  are  specifically related to backtracking, most of
 7296        them can be used only when the pattern is to be matched  using  one  of
 7297        the  traditional  matching  functions, because these use a backtracking
 7298        algorithm. With the exception of (*FAIL), which behaves like a  failing
 7299        negative  assertion,  the  backtracking control verbs cause an error if
 7300        encountered by a DFA matching function.
 7302        The behaviour of these verbs in repeated  groups,  assertions,  and  in
 7303        subpatterns called as subroutines (whether or not recursively) is docu-
 7304        mented below.
 7306    Optimizations that affect backtracking verbs
 7308        PCRE contains some optimizations that are used to speed up matching  by
 7309        running some checks at the start of each match attempt. For example, it
 7310        may know the minimum length of matching subject, or that  a  particular
 7311        character must be present. When one of these optimizations bypasses the
 7312        running of a match,  any  included  backtracking  verbs  will  not,  of
 7313        course, be processed. You can suppress the start-of-match optimizations
 7314        by setting the PCRE_NO_START_OPTIMIZE  option  when  calling  pcre_com-
 7315        pile() or pcre_exec(), or by starting the pattern with (*NO_START_OPT).
 7316        There is more discussion of this option in the section entitled "Option
 7317        bits for pcre_exec()" in the pcreapi documentation.
 7319        Experiments  with  Perl  suggest that it too has similar optimizations,
 7320        sometimes leading to anomalous results.
 7322    Verbs that act immediately
 7324        The following verbs act as soon as they are encountered. They  may  not
 7325        be followed by a name.
 7327           (*ACCEPT)
 7329        This  verb causes the match to end successfully, skipping the remainder
 7330        of the pattern. However, when it is inside a subpattern that is  called
 7331        as  a  subroutine, only that subpattern is ended successfully. Matching
 7332        then continues at the outer level. If (*ACCEPT) in triggered in a posi-
 7333        tive  assertion,  the  assertion succeeds; in a negative assertion, the
 7334        assertion fails.
 7336        If (*ACCEPT) is inside capturing parentheses, the data so far  is  cap-
 7337        tured. For example:
 7339          A((?:A|B(*ACCEPT)|C)D)
 7341        This  matches  "AB", "AAD", or "ACD"; when it matches "AB", "B" is cap-
 7342        tured by the outer parentheses.
 7344          (*FAIL) or (*F)
 7346        This verb causes a matching failure, forcing backtracking to occur.  It
 7347        is  equivalent to (?!) but easier to read. The Perl documentation notes
 7348        that it is probably useful only when combined  with  (?{})  or  (??{}).
 7349        Those  are,  of course, Perl features that are not present in PCRE. The
 7350        nearest equivalent is the callout feature, as for example in this  pat-
 7351        tern:
 7353          a+(?C)(*FAIL)
 7355        A  match  with the string "aaaa" always fails, but the callout is taken
 7356        before each backtrack happens (in this example, 10 times).
 7358    Recording which path was taken
 7360        There is one verb whose main purpose  is  to  track  how  a  match  was
 7361        arrived  at,  though  it  also  has a secondary use in conjunction with
 7362        advancing the match starting point (see (*SKIP) below).
 7364          (*MARK:NAME) or (*:NAME)
 7366        A name is always  required  with  this  verb.  There  may  be  as  many
 7367        instances  of  (*MARK) as you like in a pattern, and their names do not
 7368        have to be unique.
 7370        When a match succeeds, the name of the  last-encountered  (*MARK:NAME),
 7371        (*PRUNE:NAME),  or  (*THEN:NAME) on the matching path is passed back to
 7372        the caller as  described  in  the  section  entitled  "Extra  data  for
 7373        pcre_exec()"  in  the  pcreapi  documentation.  Here  is  an example of
 7374        pcretest output, where the /K modifier requests the retrieval and  out-
 7375        putting of (*MARK) data:
 7377            re> /X(*MARK:A)Y|X(*MARK:B)Z/K
 7378          data> XY
 7379           0: XY
 7380          MK: A
 7381          XZ
 7382           0: XZ
 7383          MK: B
 7385        The (*MARK) name is tagged with "MK:" in this output, and in this exam-
 7386        ple it indicates which of the two alternatives matched. This is a  more
 7387        efficient  way of obtaining this information than putting each alterna-
 7388        tive in its own capturing parentheses.
 7390        If a verb with a name is encountered in a positive  assertion  that  is
 7391        true,  the  name  is recorded and passed back if it is the last-encoun-
 7392        tered. This does not happen for negative assertions or failing positive
 7393        assertions.
 7395        After  a  partial match or a failed match, the last encountered name in
 7396        the entire match process is returned. For example:
 7398            re> /X(*MARK:A)Y|X(*MARK:B)Z/K
 7399          data> XP
 7400          No match, mark = B
 7402        Note that in this unanchored example the  mark  is  retained  from  the
 7403        match attempt that started at the letter "X" in the subject. Subsequent
 7404        match attempts starting at "P" and then with an empty string do not get
 7405        as far as the (*MARK) item, but nevertheless do not reset it.
 7407        If  you  are  interested  in  (*MARK)  values after failed matches, you
 7408        should probably set the PCRE_NO_START_OPTIMIZE option  (see  above)  to
 7409        ensure that the match is always attempted.
 7411    Verbs that act after backtracking
 7413        The following verbs do nothing when they are encountered. Matching con-
 7414        tinues with what follows, but if there is no subsequent match,  causing
 7415        a  backtrack  to  the  verb, a failure is forced. That is, backtracking
 7416        cannot pass to the left of the verb. However, when one of  these  verbs
 7417        appears inside an atomic group or an assertion that is true, its effect
 7418        is confined to that group, because once the  group  has  been  matched,
 7419        there  is never any backtracking into it. In this situation, backtrack-
 7420        ing can "jump back" to the left of the entire atomic  group  or  asser-
 7421        tion.  (Remember  also,  as  stated  above, that this localization also
 7422        applies in subroutine calls.)
 7424        These verbs differ in exactly what kind of failure  occurs  when  back-
 7425        tracking  reaches  them.  The behaviour described below is what happens
 7426        when the verb is not in a subroutine or an assertion.  Subsequent  sec-
 7427        tions cover these special cases.
 7429          (*COMMIT)
 7431        This  verb, which may not be followed by a name, causes the whole match
 7432        to fail outright if there is a later matching failure that causes back-
 7433        tracking  to  reach  it.  Even if the pattern is unanchored, no further
 7434        attempts to find a match by advancing the starting point take place. If
 7435        (*COMMIT)  is  the  only backtracking verb that is encountered, once it
 7436        has been passed pcre_exec() is committed to finding a match at the cur-
 7437        rent starting point, or not at all. For example:
 7439          a+(*COMMIT)b
 7441        This  matches  "xxaab" but not "aacaab". It can be thought of as a kind
 7442        of dynamic anchor, or "I've started, so I must finish." The name of the
 7443        most  recently passed (*MARK) in the path is passed back when (*COMMIT)
 7444        forces a match failure.
 7446        If there is more than one backtracking verb in a pattern,  a  different
 7447        one  that  follows  (*COMMIT) may be triggered first, so merely passing
 7448        (*COMMIT) during a match does not always guarantee that a match must be
 7449        at this starting point.
 7451        Note  that  (*COMMIT)  at  the start of a pattern is not the same as an
 7452        anchor, unless PCRE's start-of-match optimizations are turned  off,  as
 7453        shown in this output from pcretest:
 7455            re> /(*COMMIT)abc/
 7456          data> xyzabc
 7457           0: abc
 7458          data> xyzabc\Y
 7459          No match
 7461        For this pattern, PCRE knows that any match must start with "a", so the
 7462        optimization skips along the subject to "a" before applying the pattern
 7463        to  the first set of data. The match attempt then succeeds. In the sec-
 7464        ond set of data, the escape sequence \Y is interpreted by the  pcretest
 7465        program.  It  causes  the  PCRE_NO_START_OPTIMIZE option to be set when
 7466        pcre_exec() is called.  This disables the optimization that skips along
 7467        to the first character. The pattern is now applied starting at "x", and
 7468        so the (*COMMIT) causes the match to  fail  without  trying  any  other
 7469        starting points.
 7471          (*PRUNE) or (*PRUNE:NAME)
 7473        This  verb causes the match to fail at the current starting position in
 7474        the subject if there is a later matching failure that causes backtrack-
 7475        ing  to  reach it. If the pattern is unanchored, the normal "bumpalong"
 7476        advance to the next starting character then happens.  Backtracking  can
 7477        occur  as  usual to the left of (*PRUNE), before it is reached, or when
 7478        matching to the right of (*PRUNE), but if there  is  no  match  to  the
 7479        right,  backtracking cannot cross (*PRUNE). In simple cases, the use of
 7480        (*PRUNE) is just an alternative to an atomic group or possessive  quan-
 7481        tifier, but there are some uses of (*PRUNE) that cannot be expressed in
 7482        any other way. In an anchored pattern (*PRUNE) has the same  effect  as
 7483        (*COMMIT).
 7485        The   behaviour   of   (*PRUNE:NAME)   is   the   not   the   same   as
 7486        (*MARK:NAME)(*PRUNE).  It is like (*MARK:NAME)  in  that  the  name  is
 7487        remembered  for  passing  back  to  the  caller.  However, (*SKIP:NAME)
 7488        searches only for names set with (*MARK).
 7490          (*SKIP)
 7492        This verb, when given without a name, is like (*PRUNE), except that  if
 7493        the  pattern  is unanchored, the "bumpalong" advance is not to the next
 7494        character, but to the position in the subject where (*SKIP) was encoun-
 7495        tered.  (*SKIP)  signifies that whatever text was matched leading up to
 7496        it cannot be part of a successful match. Consider:
 7498          a+(*SKIP)b
 7500        If the subject is "aaaac...",  after  the  first  match  attempt  fails
 7501        (starting  at  the  first  character in the string), the starting point
 7502        skips on to start the next attempt at "c". Note that a possessive quan-
 7503        tifer  does not have the same effect as this example; although it would
 7504        suppress backtracking  during  the  first  match  attempt,  the  second
 7505        attempt  would  start at the second character instead of skipping on to
 7506        "c".
 7508          (*SKIP:NAME)
 7510        When (*SKIP) has an associated name, its behaviour is modified. When it
 7511        is triggered, the previous path through the pattern is searched for the
 7512        most recent (*MARK) that has the  same  name.  If  one  is  found,  the
 7513        "bumpalong" advance is to the subject position that corresponds to that
 7514        (*MARK) instead of to where (*SKIP) was encountered. If no (*MARK) with
 7515        a matching name is found, the (*SKIP) is ignored.
 7517        Note  that (*SKIP:NAME) searches only for names set by (*MARK:NAME). It
 7518        ignores names that are set by (*PRUNE:NAME) or (*THEN:NAME).
 7520          (*THEN) or (*THEN:NAME)
 7522        This verb causes a skip to the next innermost  alternative  when  back-
 7523        tracking  reaches  it.  That  is,  it  cancels any further backtracking
 7524        within the current alternative. Its name  comes  from  the  observation
 7525        that it can be used for a pattern-based if-then-else block:
 7527          ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
 7529        If  the COND1 pattern matches, FOO is tried (and possibly further items
 7530        after the end of the group if FOO succeeds); on  failure,  the  matcher
 7531        skips  to  the second alternative and tries COND2, without backtracking
 7532        into COND1. If that succeeds and BAR fails, COND3 is tried.  If  subse-
 7533        quently  BAZ fails, there are no more alternatives, so there is a back-
 7534        track to whatever came before the  entire  group.  If  (*THEN)  is  not
 7535        inside an alternation, it acts like (*PRUNE).
 7537        The    behaviour   of   (*THEN:NAME)   is   the   not   the   same   as
 7538        (*MARK:NAME)(*THEN).  It is like  (*MARK:NAME)  in  that  the  name  is
 7539        remembered  for  passing  back  to  the  caller.  However, (*SKIP:NAME)
 7540        searches only for names set with (*MARK).
 7542        A subpattern that does not contain a | character is just a part of  the
 7543        enclosing  alternative;  it  is  not a nested alternation with only one
 7544        alternative. The effect of (*THEN) extends beyond such a subpattern  to
 7545        the  enclosing alternative. Consider this pattern, where A, B, etc. are
 7546        complex pattern fragments that do not contain any | characters at  this
 7547        level:
 7549          A (B(*THEN)C) | D
 7551        If  A and B are matched, but there is a failure in C, matching does not
 7552        backtrack into A; instead it moves to the next alternative, that is, D.
 7553        However,  if the subpattern containing (*THEN) is given an alternative,
 7554        it behaves differently:
 7556          A (B(*THEN)C | (*FAIL)) | D
 7558        The effect of (*THEN) is now confined to the inner subpattern. After  a
 7559        failure in C, matching moves to (*FAIL), which causes the whole subpat-
 7560        tern to fail because there are no more alternatives  to  try.  In  this
 7561        case, matching does now backtrack into A.
 7563        Note  that  a  conditional  subpattern  is not considered as having two
 7564        alternatives, because only one is ever used.  In  other  words,  the  |
 7565        character in a conditional subpattern has a different meaning. Ignoring
 7566        white space, consider:
 7568          ^.*? (?(?=a) a | b(*THEN)c )
 7570        If the subject is "ba", this pattern does not  match.  Because  .*?  is
 7571        ungreedy,  it  initially  matches  zero characters. The condition (?=a)
 7572        then fails, the character "b" is matched,  but  "c"  is  not.  At  this
 7573        point,  matching does not backtrack to .*? as might perhaps be expected
 7574        from the presence of the | character.  The  conditional  subpattern  is
 7575        part of the single alternative that comprises the whole pattern, and so
 7576        the match fails. (If there was a backtrack into  .*?,  allowing  it  to
 7577        match "b", the match would succeed.)
 7579        The  verbs just described provide four different "strengths" of control
 7580        when subsequent matching fails. (*THEN) is the weakest, carrying on the
 7581        match  at  the next alternative. (*PRUNE) comes next, failing the match
 7582        at the current starting position, but allowing an advance to  the  next
 7583        character  (for an unanchored pattern). (*SKIP) is similar, except that
 7584        the advance may be more than one character. (*COMMIT) is the strongest,
 7585        causing the entire match to fail.
 7587    More than one backtracking verb
 7589        If  more  than  one  backtracking verb is present in a pattern, the one
 7590        that is backtracked onto first acts. For example,  consider  this  pat-
 7591        tern, where A, B, etc. are complex pattern fragments:
 7593          (A(*COMMIT)B(*THEN)C|ABD)
 7595        If  A matches but B fails, the backtrack to (*COMMIT) causes the entire
 7596        match to fail. However, if A and B match, but C fails, the backtrack to
 7597        (*THEN)  causes  the next alternative (ABD) to be tried. This behaviour
 7598        is consistent, but is not always the same as Perl's. It means  that  if
 7599        two  or  more backtracking verbs appear in succession, all the the last
 7600        of them has no effect. Consider this example:
 7602          ...(*COMMIT)(*PRUNE)...
 7604        If there is a matching failure to the right, backtracking onto (*PRUNE)
 7605        causes  it to be triggered, and its action is taken. There can never be
 7606        a backtrack onto (*COMMIT).
 7608    Backtracking verbs in repeated groups
 7610        PCRE differs from  Perl  in  its  handling  of  backtracking  verbs  in
 7611        repeated groups. For example, consider:
 7613          /(a(*COMMIT)b)+ac/
 7615        If  the  subject  is  "abac",  Perl matches, but PCRE fails because the
 7616        (*COMMIT) in the second repeat of the group acts.
 7618    Backtracking verbs in assertions
 7620        (*FAIL) in an assertion has its normal effect: it forces  an  immediate
 7621        backtrack.
 7623        (*ACCEPT) in a positive assertion causes the assertion to succeed with-
 7624        out any further processing. In a negative assertion,  (*ACCEPT)  causes
 7625        the assertion to fail without any further processing.
 7627        The  other  backtracking verbs are not treated specially if they appear
 7628        in a positive assertion. In  particular,  (*THEN)  skips  to  the  next
 7629        alternative  in  the  innermost  enclosing group that has alternations,
 7630        whether or not this is within the assertion.
 7632        Negative assertions are, however, different, in order  to  ensure  that
 7633        changing  a  positive  assertion  into a negative assertion changes its
 7634        result. Backtracking into (*COMMIT), (*SKIP), or (*PRUNE) causes a neg-
 7635        ative assertion to be true, without considering any further alternative
 7636        branches in the assertion.  Backtracking into (*THEN) causes it to skip
 7637        to  the next enclosing alternative within the assertion (the normal be-
 7638        haviour), but if the assertion  does  not  have  such  an  alternative,
 7639        (*THEN) behaves like (*PRUNE).
 7641    Backtracking verbs in subroutines
 7643        These  behaviours  occur whether or not the subpattern is called recur-
 7644        sively.  Perl's treatment of subroutines is different in some cases.
 7646        (*FAIL) in a subpattern called as a subroutine has its  normal  effect:
 7647        it forces an immediate backtrack.
 7649        (*ACCEPT)  in a subpattern called as a subroutine causes the subroutine
 7650        match to succeed without any further processing. Matching then  contin-
 7651        ues after the subroutine call.
 7653        (*COMMIT), (*SKIP), and (*PRUNE) in a subpattern called as a subroutine
 7654        cause the subroutine match to fail.
 7656        (*THEN) skips to the next alternative in the innermost enclosing  group
 7657        within  the subpattern that has alternatives. If there is no such group
 7658        within the subpattern, (*THEN) causes the subroutine match to fail.
 7661 SEE ALSO
 7663        pcreapi(3), pcrecallout(3),  pcrematching(3),  pcresyntax(3),  pcre(3),
 7664        pcre16(3), pcre32(3).
 7667 AUTHOR
 7669        Philip Hazel
 7670        University Computing Service
 7671        Cambridge CB2 3QH, England.
 7676        Last updated: 23 October 2016
 7677        Copyright (c) 1997-2016 University of Cambridge.
 7678 ------------------------------------------------------------------------------
 7681 PCRESYNTAX(3)              Library Functions Manual              PCRESYNTAX(3)
 7685 NAME
 7686        PCRE - Perl-compatible regular expressions
 7690        The  full syntax and semantics of the regular expressions that are sup-
 7691        ported by PCRE are described in  the  pcrepattern  documentation.  This
 7692        document contains a quick-reference summary of the syntax.
 7697          \x         where x is non-alphanumeric is a literal x
 7698          \Q...\E    treat enclosed characters as literal
 7703          \a         alarm, that is, the BEL character (hex 07)
 7704          \cx        "control-x", where x is any ASCII character
 7705          \e         escape (hex 1B)
 7706          \f         form feed (hex 0C)
 7707          \n         newline (hex 0A)
 7708          \r         carriage return (hex 0D)
 7709          \t         tab (hex 09)
 7710          \0dd       character with octal code 0dd
 7711          \ddd       character with octal code ddd, or backreference
 7712          \o{ddd..}  character with octal code ddd..
 7713          \xhh       character with hex code hh
 7714          \x{hhh..}  character with hex code hhh..
 7716        Note that \0dd is always an octal code, and that \8 and \9 are the lit-
 7717        eral characters "8" and "9".
 7722          .          any character except newline;
 7723                       in dotall mode, any character whatsoever
 7724          \C         one data unit, even in UTF mode (best avoided)
 7725          \d         a decimal digit
 7726          \D         a character that is not a decimal digit
 7727          \h         a horizontal white space character
 7728          \H         a character that is not a horizontal white space character
 7729          \N         a character that is not a newline
 7730          \p{xx}     a character with the xx property
 7731          \P{xx}     a character without the xx property
 7732          \R         a newline sequence
 7733          \s         a white space character
 7734          \S         a character that is not a white space character
 7735          \v         a vertical white space character
 7736          \V         a character that is not a vertical white space character
 7737          \w         a "word" character
 7738          \W         a "non-word" character
 7739          \X         a Unicode extended grapheme cluster
 7741        By default, \d, \s, and \w match only ASCII characters, even  in  UTF-8
 7742        mode  or  in  the 16- bit and 32-bit libraries. However, if locale-spe-
 7743        cific matching is happening, \s and \w may also match  characters  with
 7744        code  points  in  the range 128-255. If the PCRE_UCP option is set, the
 7745        behaviour of these escape sequences is changed to use  Unicode  proper-
 7746        ties and they match many more characters.
 7751          C          Other
 7752          Cc         Control
 7753          Cf         Format
 7754          Cn         Unassigned
 7755          Co         Private use
 7756          Cs         Surrogate
 7758          L          Letter
 7759          Ll         Lower case letter
 7760          Lm         Modifier letter
 7761          Lo         Other letter
 7762          Lt         Title case letter
 7763          Lu         Upper case letter
 7764          L&         Ll, Lu, or Lt
 7766          M          Mark
 7767          Mc         Spacing mark
 7768          Me         Enclosing mark
 7769          Mn         Non-spacing mark
 7771          N          Number
 7772          Nd         Decimal number
 7773          Nl         Letter number
 7774          No         Other number
 7776          P          Punctuation
 7777          Pc         Connector punctuation
 7778          Pd         Dash punctuation
 7779          Pe         Close punctuation
 7780          Pf         Final punctuation
 7781          Pi         Initial punctuation
 7782          Po         Other punctuation
 7783          Ps         Open punctuation
 7785          S          Symbol
 7786          Sc         Currency symbol
 7787          Sk         Modifier symbol
 7788          Sm         Mathematical symbol
 7789          So         Other symbol
 7791          Z          Separator
 7792          Zl         Line separator
 7793          Zp         Paragraph separator
 7794          Zs         Space separator
 7799          Xan        Alphanumeric: union of properties L and N
 7800          Xps        POSIX space: property Z or tab, NL, VT, FF, CR
 7801          Xsp        Perl space: property Z or tab, NL, VT, FF, CR
 7802          Xuc        Univerally-named character: one that can be
 7803                       represented by a Universal Character Name
 7804          Xwd        Perl word: property Xan or underscore
 7806        Perl and POSIX space are now the same. Perl added VT to its space char-
 7807        acter set at release 5.18 and PCRE changed at release 8.34.
 7812        Arabic, Armenian, Avestan, Balinese, Bamum, Bassa_Vah, Batak,  Bengali,
 7813        Bopomofo,  Brahmi,  Braille, Buginese, Buhid, Canadian_Aboriginal, Car-
 7814        ian, Caucasian_Albanian, Chakma, Cham, Cherokee, Common, Coptic, Cunei-
 7815        form, Cypriot, Cyrillic, Deseret, Devanagari, Duployan, Egyptian_Hiero-
 7816        glyphs,  Elbasan,  Ethiopic,  Georgian,  Glagolitic,  Gothic,  Grantha,
 7817        Greek,  Gujarati,  Gurmukhi,  Han,  Hangul,  Hanunoo, Hebrew, Hiragana,
 7818        Imperial_Aramaic,    Inherited,     Inscriptional_Pahlavi,     Inscrip-
 7819        tional_Parthian,   Javanese,   Kaithi,   Kannada,  Katakana,  Kayah_Li,
 7820        Kharoshthi, Khmer, Khojki, Khudawadi, Lao, Latin, Lepcha,  Limbu,  Lin-
 7821        ear_A,  Linear_B,  Lisu,  Lycian, Lydian, Mahajani, Malayalam, Mandaic,
 7822        Manichaean,     Meetei_Mayek,     Mende_Kikakui,      Meroitic_Cursive,
 7823        Meroitic_Hieroglyphs,  Miao,  Modi, Mongolian, Mro, Myanmar, Nabataean,
 7824        New_Tai_Lue,  Nko,  Ogham,  Ol_Chiki,  Old_Italic,   Old_North_Arabian,
 7825        Old_Permic, Old_Persian, Old_South_Arabian, Old_Turkic, Oriya, Osmanya,
 7826        Pahawh_Hmong,    Palmyrene,    Pau_Cin_Hau,    Phags_Pa,    Phoenician,
 7827        Psalter_Pahlavi,  Rejang,  Runic,  Samaritan, Saurashtra, Sharada, Sha-
 7828        vian, Siddham, Sinhala, Sora_Sompeng, Sundanese, Syloti_Nagri,  Syriac,
 7829        Tagalog,  Tagbanwa,  Tai_Le,  Tai_Tham, Tai_Viet, Takri, Tamil, Telugu,
 7830        Thaana, Thai, Tibetan, Tifinagh, Tirhuta, Ugaritic,  Vai,  Warang_Citi,
 7831        Yi.
 7836          [...]       positive character class
 7837          [^...]      negative character class
 7838          [x-y]       range (can be used for hex characters)
 7839          [[:xxx:]]   positive POSIX named set
 7840          [[:^xxx:]]  negative POSIX named set
 7842          alnum       alphanumeric
 7843          alpha       alphabetic
 7844          ascii       0-127
 7845          blank       space or tab
 7846          cntrl       control character
 7847          digit       decimal digit
 7848          graph       printing, excluding space
 7849          lower       lower case letter
 7850          print       printing, including space
 7851          punct       printing, excluding alphanumeric
 7852          space       white space
 7853          upper       upper case letter
 7854          word        same as \w
 7855          xdigit      hexadecimal digit
 7857        In  PCRE,  POSIX character set names recognize only ASCII characters by
 7858        default, but some of them use Unicode properties if  PCRE_UCP  is  set.
 7859        You can use \Q...\E inside a character class.
 7864          ?           0 or 1, greedy
 7865          ?+          0 or 1, possessive
 7866          ??          0 or 1, lazy
 7867          *           0 or more, greedy
 7868          *+          0 or more, possessive
 7869          *?          0 or more, lazy
 7870          +           1 or more, greedy
 7871          ++          1 or more, possessive
 7872          +?          1 or more, lazy
 7873          {n}         exactly n
 7874          {n,m}       at least n, no more than m, greedy
 7875          {n,m}+      at least n, no more than m, possessive
 7876          {n,m}?      at least n, no more than m, lazy
 7877          {n,}        n or more, greedy
 7878          {n,}+       n or more, possessive
 7879          {n,}?       n or more, lazy
 7884          \b          word boundary
 7885          \B          not a word boundary
 7886          ^           start of subject
 7887                       also after internal newline in multiline mode
 7888          \A          start of subject
 7889          $           end of subject
 7890                       also before newline at end of subject
 7891                       also before internal newline in multiline mode
 7892          \Z          end of subject
 7893                       also before newline at end of subject
 7894          \z          end of subject
 7895          \G          first matching position in subject
 7900          \K          reset start of match
 7902        \K is honoured in positive assertions, but ignored in negative ones.
 7907          expr|expr|expr...
 7912          (...)           capturing group
 7913          (?<name>...)    named capturing group (Perl)
 7914          (?'name'...)    named capturing group (Perl)
 7915          (?P<name>...)   named capturing group (Python)
 7916          (?:...)         non-capturing group
 7917          (?|...)         non-capturing group; reset group numbers for
 7918                           capturing groups in each alternative
 7923          (?>...)         atomic, non-capturing group
 7928          (?#....)        comment (not nestable)
 7933          (?i)            caseless
 7934          (?J)            allow duplicate names
 7935          (?m)            multiline
 7936          (?s)            single line (dotall)
 7937          (?U)            default ungreedy (lazy)
 7938          (?x)            extended (ignore white space)
 7939          (?-...)         unset option(s)
 7941        The  following  are  recognized  only at the very start of a pattern or
 7942        after one of the newline or \R options with similar syntax.  More  than
 7943        one of them may appear.
 7945          (*LIMIT_MATCH=d) set the match limit to d (decimal number)
 7946          (*LIMIT_RECURSION=d) set the recursion limit to d (decimal number)
 7947          (*NO_AUTO_POSSESS) no auto-possessification (PCRE_NO_AUTO_POSSESS)
 7948          (*NO_START_OPT) no start-match optimization (PCRE_NO_START_OPTIMIZE)
 7949          (*UTF8)         set UTF-8 mode: 8-bit library (PCRE_UTF8)
 7950          (*UTF16)        set UTF-16 mode: 16-bit library (PCRE_UTF16)
 7951          (*UTF32)        set UTF-32 mode: 32-bit library (PCRE_UTF32)
 7952          (*UTF)          set appropriate UTF mode for the library in use
 7953          (*UCP)          set PCRE_UCP (use Unicode properties for \d etc)
 7955        Note  that LIMIT_MATCH and LIMIT_RECURSION can only reduce the value of
 7956        the limits set by the caller of pcre_exec(), not increase them.
 7961        These are recognized only at the very start of  the  pattern  or  after
 7962        option settings with a similar syntax.
 7964          (*CR)           carriage return only
 7965          (*LF)           linefeed only
 7966          (*CRLF)         carriage return followed by linefeed
 7967          (*ANYCRLF)      all three of the above
 7968          (*ANY)          any Unicode newline sequence
 7973        These  are  recognized  only  at the very start of the pattern or after
 7974        option setting with a similar syntax.
 7976          (*BSR_ANYCRLF)  CR, LF, or CRLF
 7977          (*BSR_UNICODE)  any Unicode newline sequence
 7982          (?=...)         positive look ahead
 7983          (?!...)         negative look ahead
 7984          (?<=...)        positive look behind
 7985          (?<!...)        negative look behind
 7987        Each top-level branch of a look behind must be of a fixed length.
 7992          \n              reference by number (can be ambiguous)
 7993          \gn             reference by number
 7994          \g{n}           reference by number
 7995          \g{-n}          relative reference by number
 7996          \k<name>        reference by name (Perl)
 7997          \k'name'        reference by name (Perl)
 7998          \g{name}        reference by name (Perl)
 7999          \k{name}        reference by name (.NET)
 8000          (?P=name)       reference by name (Python)
 8005          (?R)            recurse whole pattern
 8006          (?n)            call subpattern by absolute number
 8007          (?+n)           call subpattern by relative number
 8008          (?-n)           call subpattern by relative number
 8009          (?&name)        call subpattern by name (Perl)
 8010          (?P>name)       call subpattern by name (Python)
 8011          \g<name>        call subpattern by name (Oniguruma)
 8012          \g'name'        call subpattern by name (Oniguruma)
 8013          \g<n>           call subpattern by absolute number (Oniguruma)
 8014          \g'n'           call subpattern by absolute number (Oniguruma)
 8015          \g<+n>          call subpattern by relative number (PCRE extension)
 8016          \g'+n'          call subpattern by relative number (PCRE extension)
 8017          \g<-n>          call subpattern by relative number (PCRE extension)
 8018          \g'-n'          call subpattern by relative number (PCRE extension)
 8023          (?(condition)yes-pattern)
 8024          (?(condition)yes-pattern|no-pattern)
 8026          (?(n)...        absolute reference condition
 8027          (?(+n)...       relative reference condition
 8028          (?(-n)...       relative reference condition
 8029          (?(<name>)...   named reference condition (Perl)
 8030          (?('name')...   named reference condition (Perl)
 8031          (?(name)...     named reference condition (PCRE)
 8032          (?(R)...        overall recursion condition
 8033          (?(Rn)...       specific group recursion condition
 8034          (?(R&name)...   specific recursion condition
 8035          (?(DEFINE)...   define subpattern for reference
 8036          (?(assert)...   assertion condition
 8041        The following act immediately they are reached:
 8043          (*ACCEPT)       force successful match
 8044          (*FAIL)         force backtrack; synonym (*F)
 8045          (*MARK:NAME)    set name to be passed back; synonym (*:NAME)
 8047        The following act only when a subsequent match failure causes  a  back-
 8048        track to reach them. They all force a match failure, but they differ in
 8049        what happens afterwards. Those that advance the start-of-match point do
 8050        so only if the pattern is not anchored.
 8052          (*COMMIT)       overall failure, no advance of starting point
 8053          (*PRUNE)        advance to next starting character
 8054          (*PRUNE:NAME)   equivalent to (*MARK:NAME)(*PRUNE)
 8055          (*SKIP)         advance to current matching position
 8056          (*SKIP:NAME)    advance to position corresponding to an earlier
 8057                          (*MARK:NAME); if not found, the (*SKIP) is ignored
 8058          (*THEN)         local failure, backtrack to next alternation
 8059          (*THEN:NAME)    equivalent to (*MARK:NAME)(*THEN)
 8064          (?C)      callout
 8065          (?Cn)     callout with data n
 8068 SEE ALSO
 8070        pcrepattern(3), pcreapi(3), pcrecallout(3), pcrematching(3), pcre(3).
 8073 AUTHOR
 8075        Philip Hazel
 8076        University Computing Service
 8077        Cambridge CB2 3QH, England.
 8082        Last updated: 08 January 2014
 8083        Copyright (c) 1997-2014 University of Cambridge.
 8084 ------------------------------------------------------------------------------
 8087 PCREUNICODE(3)             Library Functions Manual             PCREUNICODE(3)
 8091 NAME
 8092        PCRE - Perl-compatible regular expressions
 8096        As well as UTF-8 support, PCRE also supports UTF-16 (from release 8.30)
 8097        and UTF-32 (from release 8.32), by means of two  additional  libraries.
 8098        They can be built as well as, or instead of, the 8-bit library.
 8103        In  order  process  UTF-8  strings, you must build PCRE's 8-bit library
 8104        with UTF support, and, in addition, you must call  pcre_compile()  with
 8105        the  PCRE_UTF8 option flag, or the pattern must start with the sequence
 8106        (*UTF8) or (*UTF). When either of these is the case, both  the  pattern
 8107        and  any  subject  strings  that  are matched against it are treated as
 8108        UTF-8 strings instead of strings of individual 1-byte characters.
 8113        In order process UTF-16 or UTF-32 strings, you must build PCRE's 16-bit
 8114        or  32-bit  library  with  UTF support, and, in addition, you must call
 8115        pcre16_compile() or pcre32_compile() with the PCRE_UTF16 or  PCRE_UTF32
 8116        option flag, as appropriate. Alternatively, the pattern must start with
 8117        the sequence (*UTF16), (*UTF32), as appropriate, or (*UTF),  which  can
 8118        be used with either library. When UTF mode is set, both the pattern and
 8119        any subject strings that are matched against it are treated  as  UTF-16
 8120        or  UTF-32  strings  instead  of strings of individual 16-bit or 32-bit
 8121        characters.
 8126        If you compile PCRE with UTF support, but do not use it  at  run  time,
 8127        the  library will be a bit bigger, but the additional run time overhead
 8128        is limited to  testing  the  PCRE_UTF[8|16|32]  flag  occasionally,  so
 8129        should not be very big.
 8134        If PCRE is built with Unicode character property support (which implies
 8135        UTF support), the escape sequences \p{..}, \P{..}, and \X can be  used.
 8136        The  available properties that can be tested are limited to the general
 8137        category properties such as Lu for an upper case letter  or  Nd  for  a
 8138        decimal number, the Unicode script names such as Arabic or Han, and the
 8139        derived properties Any and L&. Full lists is given in  the  pcrepattern
 8140        and  pcresyntax  documentation. Only the short names for properties are
 8141        supported. For example, \p{L}  matches  a  letter.  Its  Perl  synonym,
 8142        \p{Letter},  is  not  supported.  Furthermore, in Perl, many properties
 8143        may optionally be prefixed by "Is", for compatibility  with  Perl  5.6.
 8144        PCRE does not support this.
 8146    Validity of UTF-8 strings
 8148        When  you  set  the PCRE_UTF8 flag, the byte strings passed as patterns
 8149        and subjects are (by default) checked for validity on entry to the rel-
 8150        evant functions. The entire string is checked before any other process-
 8151        ing takes place. From release 7.3 of PCRE, the check is  according  the
 8152        rules of RFC 3629, which are themselves derived from the Unicode speci-
 8153        fication. Earlier releases of PCRE followed  the  rules  of  RFC  2279,
 8154        which  allows  the  full  range of 31-bit values (0 to 0x7FFFFFFF). The
 8155        current check allows only values in the range U+0 to U+10FFFF,  exclud-
 8156        ing  the  surrogate area. (From release 8.33 the so-called "non-charac-
 8157        ter" code points are no longer excluded because Unicode corrigendum  #9
 8158        makes it clear that they should not be.)
 8160        Characters  in  the "Surrogate Area" of Unicode are reserved for use by
 8161        UTF-16, where they are used in pairs to encode codepoints  with  values
 8162        greater  than  0xFFFF. The code points that are encoded by UTF-16 pairs
 8163        are available independently in the  UTF-8  and  UTF-32  encodings.  (In
 8164        other  words,  the  whole  surrogate  thing is a fudge for UTF-16 which
 8165        unfortunately messes up UTF-8 and UTF-32.)
 8167        If an invalid UTF-8 string is passed to PCRE, an error return is given.
 8168        At  compile  time, the only additional information is the offset to the
 8169        first byte of the failing character. The run-time functions pcre_exec()
 8170        and  pcre_dfa_exec() also pass back this information, as well as a more
 8171        detailed reason code if the caller has provided memory in which  to  do
 8172        this.
 8174        In  some  situations, you may already know that your strings are valid,
 8175        and therefore want to skip these checks in  order  to  improve  perfor-
 8176        mance,  for  example in the case of a long subject string that is being
 8177        scanned repeatedly.  If you set the PCRE_NO_UTF8_CHECK flag at  compile
 8178        time  or  at  run  time, PCRE assumes that the pattern or subject it is
 8179        given (respectively) contains only valid UTF-8 codes. In this case,  it
 8180        does not diagnose an invalid UTF-8 string.
 8182        Note  that  passing  PCRE_NO_UTF8_CHECK to pcre_compile() just disables
 8183        the check for the pattern; it does not also apply to  subject  strings.
 8184        If  you  want  to  disable the check for a subject string you must pass
 8185        this option to pcre_exec() or pcre_dfa_exec().
 8187        If you pass an invalid UTF-8 string when PCRE_NO_UTF8_CHECK is set, the
 8188        result is undefined and your program may crash.
 8190    Validity of UTF-16 strings
 8192        When you set the PCRE_UTF16 flag, the strings of 16-bit data units that
 8193        are passed as patterns and subjects are (by default) checked for valid-
 8194        ity  on entry to the relevant functions. Values other than those in the
 8195        surrogate range U+D800 to U+DFFF are independent code points. Values in
 8196        the surrogate range must be used in pairs in the correct manner.
 8198        If  an  invalid  UTF-16  string  is  passed to PCRE, an error return is
 8199        given. At compile time, the only additional information is  the  offset
 8200        to the first data unit of the failing character. The run-time functions
 8201        pcre16_exec() and pcre16_dfa_exec() also pass back this information, as
 8202        well  as  a more detailed reason code if the caller has provided memory
 8203        in which to do this.
 8205        In some situations, you may already know that your strings  are  valid,
 8206        and  therefore  want  to  skip these checks in order to improve perfor-
 8207        mance. If you set the PCRE_NO_UTF16_CHECK flag at compile  time  or  at
 8208        run time, PCRE assumes that the pattern or subject it is given (respec-
 8209        tively) contains only valid UTF-16 sequences. In this case, it does not
 8210        diagnose  an  invalid  UTF-16 string.  However, if an invalid string is
 8211        passed, the result is undefined.
 8213    Validity of UTF-32 strings
 8215        When you set the PCRE_UTF32 flag, the strings of 32-bit data units that
 8216        are passed as patterns and subjects are (by default) checked for valid-
 8217        ity on entry to the relevant functions.  This check allows only  values
 8218        in  the  range  U+0 to U+10FFFF, excluding the surrogate area U+D800 to
 8219        U+DFFF.
 8221        If an invalid UTF-32 string is passed  to  PCRE,  an  error  return  is
 8222        given.  At  compile time, the only additional information is the offset
 8223        to the first data unit of the failing character. The run-time functions
 8224        pcre32_exec() and pcre32_dfa_exec() also pass back this information, as
 8225        well as a more detailed reason code if the caller has  provided  memory
 8226        in which to do this.
 8228        In  some  situations, you may already know that your strings are valid,
 8229        and therefore want to skip these checks in  order  to  improve  perfor-
 8230        mance.  If  you  set the PCRE_NO_UTF32_CHECK flag at compile time or at
 8231        run time, PCRE assumes that the pattern or subject it is given (respec-
 8232        tively) contains only valid UTF-32 sequences. In this case, it does not
 8233        diagnose an invalid UTF-32 string.  However, if an  invalid  string  is
 8234        passed, the result is undefined.
 8236    General comments about UTF modes
 8238        1.  Codepoints  less  than  256  can be specified in patterns by either
 8239        braced or unbraced hexadecimal escape sequences (for example, \x{b3} or
 8240        \xb3). Larger values have to use braced sequences.
 8242        2.  Octal  numbers  up  to  \777 are recognized, and in UTF-8 mode they
 8243        match two-byte characters for values greater than \177.
 8245        3. Repeat quantifiers apply to complete UTF characters, not to individ-
 8246        ual data units, for example: \x{100}{3}.
 8248        4.  The dot metacharacter matches one UTF character instead of a single
 8249        data unit.
 8251        5. The escape sequence \C can be used to match a single byte  in  UTF-8
 8252        mode,  or  a single 16-bit data unit in UTF-16 mode, or a single 32-bit
 8253        data unit in UTF-32 mode, but its use can lead to some strange  effects
 8254        because  it  breaks up multi-unit characters (see the description of \C
 8255        in the pcrepattern documentation). The use of \C is  not  supported  in
 8256        the  alternative  matching  function  pcre[16|32]_dfa_exec(), nor is it
 8257        supported in UTF mode by the JIT optimization of pcre[16|32]_exec(). If
 8258        JIT  optimization  is  requested for a UTF pattern that contains \C, it
 8259        will not succeed, and so the matching will be carried out by the normal
 8260        interpretive function.
 8262        6.  The  character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
 8263        test characters of any code value, but, by default, the characters that
 8264        PCRE  recognizes  as digits, spaces, or word characters remain the same
 8265        set as in non-UTF mode, all with values less  than  256.  This  remains
 8266        true  even  when  PCRE  is  built  to include Unicode property support,
 8267        because to do otherwise would slow down PCRE in many common cases. Note
 8268        in  particular that this applies to \b and \B, because they are defined
 8269        in terms of \w and \W. If you really want to test for a wider sense of,
 8270        say,  "digit",  you  can  use  explicit  Unicode property tests such as
 8271        \p{Nd}. Alternatively, if you set the PCRE_UCP option, the way that the
 8272        character  escapes  work is changed so that Unicode properties are used
 8273        to determine which characters match. There are more details in the sec-
 8274        tion on generic character types in the pcrepattern documentation.
 8276        7.  Similarly,  characters that match the POSIX named character classes
 8277        are all low-valued characters, unless the PCRE_UCP option is set.
 8279        8. However, the horizontal and vertical white  space  matching  escapes
 8280        (\h,  \H,  \v, and \V) do match all the appropriate Unicode characters,
 8281        whether or not PCRE_UCP is set.
 8283        9. Case-insensitive matching applies only to  characters  whose  values
 8284        are  less than 128, unless PCRE is built with Unicode property support.
 8285        A few Unicode characters such as Greek sigma have more than  two  code-
 8286        points that are case-equivalent. Up to and including PCRE release 8.31,
 8287        only one-to-one case mappings were supported, but later releases  (with
 8288        Unicode  property  support) do treat as case-equivalent all versions of
 8289        characters such as Greek sigma.
 8292 AUTHOR
 8294        Philip Hazel
 8295        University Computing Service
 8296        Cambridge CB2 3QH, England.
 8301        Last updated: 27 February 2013
 8302        Copyright (c) 1997-2013 University of Cambridge.
 8303 ------------------------------------------------------------------------------
 8306 PCREJIT(3)                 Library Functions Manual                 PCREJIT(3)
 8310 NAME
 8311        PCRE - Perl-compatible regular expressions
 8315        Just-in-time  compiling  is a heavyweight optimization that can greatly
 8316        speed up pattern matching. However, it comes at the cost of extra  pro-
 8317        cessing before the match is performed. Therefore, it is of most benefit
 8318        when the same pattern is going to be matched many times. This does  not
 8319        necessarily  mean  many calls of a matching function; if the pattern is
 8320        not anchored, matching attempts may take place many  times  at  various
 8321        positions  in  the  subject, even for a single call.  Therefore, if the
 8322        subject string is very long, it may still pay to use  JIT  for  one-off
 8323        matches.
 8325        JIT  support  applies  only to the traditional Perl-compatible matching
 8326        function.  It does not apply when the DFA matching  function  is  being
 8327        used. The code for this support was written by Zoltan Herczeg.
 8330 8-BIT, 16-BIT AND 32-BIT SUPPORT
 8332        JIT  support  is available for all of the 8-bit, 16-bit and 32-bit PCRE
 8333        libraries. To keep this documentation simple, only the 8-bit  interface
 8334        is described in what follows. If you are using the 16-bit library, sub-
 8335        stitute the  16-bit  functions  and  16-bit  structures  (for  example,
 8336        pcre16_jit_stack  instead  of  pcre_jit_stack).  If  you  are using the
 8337        32-bit library, substitute the 32-bit functions and  32-bit  structures
 8338        (for example, pcre32_jit_stack instead of pcre_jit_stack).
 8343        JIT  support  is  an  optional  feature of PCRE. The "configure" option
 8344        --enable-jit (or equivalent CMake option) must  be  set  when  PCRE  is
 8345        built  if  you want to use JIT. The support is limited to the following
 8346        hardware platforms:
 8348          ARM v5, v7, and Thumb2
 8349          Intel x86 32-bit and 64-bit
 8350          MIPS 32-bit
 8351          Power PC 32-bit and 64-bit
 8352          SPARC 32-bit (experimental)
 8354        If --enable-jit is set on an unsupported platform, compilation fails.
 8356        A program that is linked with PCRE 8.20 or later can tell if  JIT  sup-
 8357        port  is  available  by  calling pcre_config() with the PCRE_CONFIG_JIT
 8358        option. The result is 1 when JIT is available, and  0  otherwise.  How-
 8359        ever, a simple program does not need to check this in order to use JIT.
 8360        The normal API is implemented in a way that falls back to the interpre-
 8361        tive code if JIT is not available. For programs that need the best pos-
 8362        sible performance, there is also a "fast path"  API  that  is  JIT-spe-
 8363        cific.
 8365        If  your program may sometimes be linked with versions of PCRE that are
 8366        older than 8.20, but you want to use JIT when it is available, you  can
 8367        test the values of PCRE_MAJOR and PCRE_MINOR, or the existence of a JIT
 8368        macro such as PCRE_CONFIG_JIT, for compile-time control of  your  code.
 8369        Also  beware that the pcre_jit_exec() function was not available at all
 8370        before 8.32, and may not be available at all  if  PCRE  isn't  compiled
 8371        with  --enable-jit.  See  the  "JIT  FAST  PATH  API" section below for
 8372        details.
 8377        You have to do two things to make use of the JIT support  in  the  sim-
 8378        plest way:
 8380          (1) Call pcre_study() with the PCRE_STUDY_JIT_COMPILE option for
 8381              each compiled pattern, and pass the resulting pcre_extra block to
 8382              pcre_exec().
 8384          (2) Use pcre_free_study() to free the pcre_extra block when it is
 8385              no  longer  needed,  instead  of  just  freeing it yourself. This
 8386        ensures that
 8387              any JIT data is also freed.
 8389        For a program that may be linked with pre-8.20 versions  of  PCRE,  you
 8390        can insert
 8392          #ifndef PCRE_STUDY_JIT_COMPILE
 8393          #define PCRE_STUDY_JIT_COMPILE 0
 8394          #endif
 8396        so  that  no  option  is passed to pcre_study(), and then use something
 8397        like this to free the study data:
 8399          #ifdef PCRE_CONFIG_JIT
 8400              pcre_free_study(study_ptr);
 8401          #else
 8402              pcre_free(study_ptr);
 8403          #endif
 8405        PCRE_STUDY_JIT_COMPILE requests the JIT compiler to generate  code  for
 8406        complete  matches.  If  you  want  to  run  partial  matches  using the
 8407        PCRE_PARTIAL_HARD or  PCRE_PARTIAL_SOFT  options  of  pcre_exec(),  you
 8408        should  set  one  or  both  of the following options in addition to, or
 8409        instead of, PCRE_STUDY_JIT_COMPILE when you call pcre_study():
 8414        If using pcre_jit_exec() and supporting a pre-8.32 version of PCRE, you
 8415        can insert:
 8417           #if PCRE_MAJOR >= 8 && PCRE_MINOR >= 32
 8418           pcre_jit_exec(...);
 8419           #else
 8420           pcre_exec(...)
 8421           #endif
 8423        but  as described in the "JIT FAST PATH API" section below this assumes
 8424        version 8.32 and later are compiled with --enable-jit, which may break.
 8426        The JIT compiler generates different optimized code  for  each  of  the
 8427        three  modes  (normal, soft partial, hard partial). When pcre_exec() is
 8428        called, the appropriate code is run if it is available. Otherwise,  the
 8429        pattern is matched using interpretive code.
 8431        In  some circumstances you may need to call additional functions. These
 8432        are described in the  section  entitled  "Controlling  the  JIT  stack"
 8433        below.
 8435        If  JIT  support  is  not  available,  PCRE_STUDY_JIT_COMPILE  etc. are
 8436        ignored, and no JIT data is created. Otherwise, the compiled pattern is
 8437        passed  to the JIT compiler, which turns it into machine code that exe-
 8438        cutes much faster than the normal interpretive code.  When  pcre_exec()
 8439        is  passed  a  pcre_extra block containing a pointer to JIT code of the
 8440        appropriate mode (normal or hard/soft  partial),  it  obeys  that  code
 8441        instead  of  running  the interpreter. The result is identical, but the
 8442        compiled JIT code runs much faster.
 8444        There are some pcre_exec() options that are not supported for JIT  exe-
 8445        cution.  There  are  also  some  pattern  items that JIT cannot handle.
 8446        Details are given below. In both cases, execution  automatically  falls
 8447        back  to  the  interpretive  code.  If you want to know whether JIT was
 8448        actually used for a particular match, you  should  arrange  for  a  JIT
 8449        callback  function  to  be  set up as described in the section entitled
 8450        "Controlling the JIT stack" below, even if you do not need to supply  a
 8451        non-default  JIT stack. Such a callback function is called whenever JIT
 8452        code is about to be obeyed. If the execution options are not right  for
 8453        JIT execution, the callback function is not obeyed.
 8455        If  the  JIT  compiler finds an unsupported item, no JIT data is gener-
 8456        ated. You can find out if JIT execution is available after  studying  a
 8457        pattern  by  calling  pcre_fullinfo()  with the PCRE_INFO_JIT option. A
 8458        result of 1 means that JIT compilation was successful. A  result  of  0
 8459        means that JIT support is not available, or the pattern was not studied
 8460        with PCRE_STUDY_JIT_COMPILE etc., or the JIT compiler was not  able  to
 8461        handle the pattern.
 8463        Once a pattern has been studied, with or without JIT, it can be used as
 8464        many times as you like for matching different subject strings.
 8469        The only pcre_exec() options that are supported for JIT  execution  are
 8472        TIAL_HARD, and PCRE_PARTIAL_SOFT.
 8474        The  only  unsupported  pattern items are \C (match a single data unit)
 8475        when running in a UTF mode, and a callout immediately before an  asser-
 8476        tion condition in a conditional group.
 8481        When  a  pattern  is matched using JIT execution, the return values are
 8482        the same as those given by the interpretive pcre_exec() code, with  the
 8483        addition  of  one new error code: PCRE_ERROR_JIT_STACKLIMIT. This means
 8484        that the memory used for the JIT stack was insufficient. See  "Control-
 8485        ling the JIT stack" below for a discussion of JIT stack usage. For com-
 8486        patibility with the interpretive pcre_exec() code, no  more  than  two-
 8487        thirds  of  the ovector argument is used for passing back captured sub-
 8488        strings.
 8490        The error code PCRE_ERROR_MATCHLIMIT is returned by  the  JIT  code  if
 8491        searching  a  very large pattern tree goes on for too long, as it is in
 8492        the same circumstance when JIT is not used, but the details of  exactly
 8493        what  is  counted are not the same. The PCRE_ERROR_RECURSIONLIMIT error
 8494        code is never returned by JIT execution.
 8499        The code that is generated by the  JIT  compiler  is  architecture-spe-
 8500        cific,  and  is also position dependent. For those reasons it cannot be
 8501        saved (in a file or database) and restored later like the bytecode  and
 8502        other  data  of  a compiled pattern. Saving and restoring compiled pat-
 8503        terns is not something many people do. More detail about this  facility
 8504        is  given in the pcreprecompile documentation. It should be possible to
 8505        run pcre_study() on a saved and restored pattern, and thereby  recreate
 8506        the  JIT  data, but because JIT compilation uses significant resources,
 8507        it is probably not worth doing this; you might as  well  recompile  the
 8508        original pattern.
 8513        When the compiled JIT code runs, it needs a block of memory to use as a
 8514        stack.  By default, it uses 32K on the  machine  stack.  However,  some
 8515        large   or   complicated  patterns  need  more  than  this.  The  error
 8516        PCRE_ERROR_JIT_STACKLIMIT is given when  there  is  not  enough  stack.
 8517        Three  functions  are provided for managing blocks of memory for use as
 8518        JIT stacks. There is further discussion about the use of JIT stacks  in
 8519        the section entitled "JIT stack FAQ" below.
 8521        The  pcre_jit_stack_alloc() function creates a JIT stack. Its arguments
 8522        are a starting size and a maximum size, and it returns a pointer to  an
 8523        opaque  structure of type pcre_jit_stack, or NULL if there is an error.
 8524        The pcre_jit_stack_free() function can be used to free a stack that  is
 8525        no  longer  needed.  (For  the technically minded: the address space is
 8526        allocated by mmap or VirtualAlloc.)
 8528        JIT uses far less memory for recursion than the interpretive code,  and
 8529        a  maximum  stack size of 512K to 1M should be more than enough for any
 8530        pattern.
 8532        The pcre_assign_jit_stack() function specifies  which  stack  JIT  code
 8533        should use. Its arguments are as follows:
 8535          pcre_extra         *extra
 8536          pcre_jit_callback  callback
 8537          void               *data
 8539        The  extra  argument  must  be  the  result  of studying a pattern with
 8540        PCRE_STUDY_JIT_COMPILE etc. There are three cases for the values of the
 8541        other two options:
 8543          (1) If callback is NULL and data is NULL, an internal 32K block
 8544              on the machine stack is used.
 8546          (2) If callback is NULL and data is not NULL, data must be
 8547              a valid JIT stack, the result of calling pcre_jit_stack_alloc().
 8549          (3) If callback is not NULL, it must point to a function that is
 8550              called with data as an argument at the start of matching, in
 8551              order to set up a JIT stack. If the return from the callback
 8552              function is NULL, the internal 32K stack is used; otherwise the
 8553              return value must be a valid JIT stack, the result of calling
 8554              pcre_jit_stack_alloc().
 8556        A  callback function is obeyed whenever JIT code is about to be run; it
 8557        is not obeyed when pcre_exec() is called with options that  are  incom-
 8558        patible for JIT execution. A callback function can therefore be used to
 8559        determine whether a match operation was  executed  by  JIT  or  by  the
 8560        interpreter.
 8562        You may safely use the same JIT stack for more than one pattern (either
 8563        by assigning directly or by callback), as long as the patterns are  all
 8564        matched  sequentially in the same thread. In a multithread application,
 8565        if you do not specify a JIT stack, or if you assign or pass  back  NULL
 8566        from  a  callback, that is thread-safe, because each thread has its own
 8567        machine stack. However, if you assign  or  pass  back  a  non-NULL  JIT
 8568        stack,  this  must  be  a  different  stack for each thread so that the
 8569        application is thread-safe.
 8571        Strictly speaking, even more is allowed. You can assign the  same  non-
 8572        NULL  stack  to any number of patterns as long as they are not used for
 8573        matching by multiple threads at the same time.  For  example,  you  can
 8574        assign  the same stack to all compiled patterns, and use a global mutex
 8575        in the callback to wait until the stack is available for use.  However,
 8576        this is an inefficient solution, and not recommended.
 8578        This  is a suggestion for how a multithreaded program that needs to set
 8579        up non-default JIT stacks might operate:
 8581          During thread initalization
 8582            thread_local_var = pcre_jit_stack_alloc(...)
 8584          During thread exit
 8585            pcre_jit_stack_free(thread_local_var)
 8587          Use a one-line callback function
 8588            return thread_local_var
 8590        All the functions described in this section do nothing if  JIT  is  not
 8591        available,  and  pcre_assign_jit_stack()  does nothing unless the extra
 8592        argument is non-NULL and points to  a  pcre_extra  block  that  is  the
 8593        result of a successful study with PCRE_STUDY_JIT_COMPILE etc.
 8598        (1) Why do we need JIT stacks?
 8600        PCRE  (and JIT) is a recursive, depth-first engine, so it needs a stack
 8601        where the local data of the current node is pushed before checking  its
 8602        child nodes.  Allocating real machine stack on some platforms is diffi-
 8603        cult. For example, the stack chain needs to be updated every time if we
 8604        extend  the  stack  on  PowerPC.  Although it is possible, its updating
 8605        time overhead decreases performance. So we do the recursion in memory.
 8607        (2) Why don't we simply allocate blocks of memory with malloc()?
 8609        Modern operating systems have a  nice  feature:  they  can  reserve  an
 8610        address space instead of allocating memory. We can safely allocate mem-
 8611        ory pages inside this address space, so the stack  could  grow  without
 8612        moving memory data (this is important because of pointers). Thus we can
 8613        allocate 1M address space, and use only a single memory  page  (usually
 8614        4K)  if  that is enough. However, we can still grow up to 1M anytime if
 8615        needed.
 8617        (3) Who "owns" a JIT stack?
 8619        The owner of the stack is the user program, not the JIT studied pattern
 8620        or  anything else. The user program must ensure that if a stack is used
 8621        by pcre_exec(), (that is, it is assigned to the pattern currently  run-
 8622        ning), that stack must not be used by any other threads (to avoid over-
 8623        writing the same memory area). The best practice for multithreaded pro-
 8624        grams  is  to  allocate  a stack for each thread, and return this stack
 8625        through the JIT callback function.
 8627        (4) When should a JIT stack be freed?
 8629        You can free a JIT stack at any time, as long as it will not be used by
 8630        pcre_exec()  again.  When  you  assign  the  stack to a pattern, only a
 8631        pointer is set. There is no reference counting or any other magic.  You
 8632        can  free  the  patterns  and stacks in any order, anytime. Just do not
 8633        call pcre_exec() with a pattern pointing to an already freed stack,  as
 8634        that  will cause SEGFAULT. (Also, do not free a stack currently used by
 8635        pcre_exec() in another thread). You can also replace the  stack  for  a
 8636        pattern  at  any  time.  You  can  even  free the previous stack before
 8637        assigning a replacement.
 8639        (5) Should I allocate/free a  stack  every  time  before/after  calling
 8640        pcre_exec()?
 8642        No,  because  this  is  too  costly in terms of resources. However, you
 8643        could implement some clever idea which release the stack if it  is  not
 8644        used  in  let's  say  two minutes. The JIT callback can help to achieve
 8645        this without keeping a list of the currently JIT studied patterns.
 8647        (6) OK, the stack is for long term memory allocation. But what  happens
 8648        if  a pattern causes stack overflow with a stack of 1M? Is that 1M kept
 8649        until the stack is freed?
 8651        Especially on embedded sytems, it might be a good idea to release  mem-
 8652        ory  sometimes  without  freeing the stack. There is no API for this at
 8653        the moment.  Probably a function call which returns with the  currently
 8654        allocated  memory for any stack and another which allows releasing mem-
 8655        ory (shrinking the stack) would be a good idea if someone needs this.
 8657        (7) This is too much of a headache. Isn't there any better solution for
 8658        JIT stack handling?
 8660        No,  thanks to Windows. If POSIX threads were used everywhere, we could
 8661        throw out this complicated API.
 8666        This is a single-threaded example that specifies a  JIT  stack  without
 8667        using a callback.
 8669          int rc;
 8670          int ovector[30];
 8671          pcre *re;
 8672          pcre_extra *extra;
 8673          pcre_jit_stack *jit_stack;
 8675          re = pcre_compile(pattern, 0, &error, &erroffset, NULL);
 8676          /* Check for errors */
 8677          extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
 8678          jit_stack = pcre_jit_stack_alloc(32*1024, 512*1024);
 8679          /* Check for error (NULL) */
 8680          pcre_assign_jit_stack(extra, NULL, jit_stack);
 8681          rc = pcre_exec(re, extra, subject, length, 0, 0, ovector, 30);
 8682          /* Check results */
 8683          pcre_free(re);
 8684          pcre_free_study(extra);
 8685          pcre_jit_stack_free(jit_stack);
 8690        Because  the  API  described  above falls back to interpreted execution
 8691        when JIT is not available, it is convenient for programs that are writ-
 8692        ten  for  general  use  in  many environments. However, calling JIT via
 8693        pcre_exec() does have a performance impact. Programs that  are  written
 8694        for  use  where  JIT  is known to be available, and which need the best
 8695        possible performance, can instead use a "fast path"  API  to  call  JIT
 8696        execution  directly  instead of calling pcre_exec() (obviously only for
 8697        patterns that have been successfully studied by JIT).
 8699        The fast path function is called pcre_jit_exec(), and it takes  exactly
 8700        the  same  arguments  as pcre_exec(), plus one additional argument that
 8701        must point to a JIT stack. The JIT stack arrangements  described  above
 8702        do not apply. The return values are the same as for pcre_exec().
 8704        When  you  call  pcre_exec(), as well as testing for invalid options, a
 8705        number of other sanity checks are performed on the arguments. For exam-
 8706        ple,  if  the  subject  pointer  is NULL, or its length is negative, an
 8707        immediate error is given. Also, unless PCRE_NO_UTF[8|16|32] is  set,  a
 8708        UTF  subject  string is tested for validity. In the interests of speed,
 8709        these checks do not happen on the JIT fast path, and if invalid data is
 8710        passed, the result is undefined.
 8712        Bypassing  the  sanity  checks  and  the  pcre_exec() wrapping can give
 8713        speedups of more than 10%.
 8715        Note that the pcre_jit_exec() function is not available in versions  of
 8716        PCRE  before  8.32  (released in November 2012). If you need to support
 8717        versions that old you must either use the slower pcre_exec(), or switch
 8718        between  the  two  codepaths  by  checking the values of PCRE_MAJOR and
 8719        PCRE_MINOR.
 8721        Due to an unfortunate implementation oversight, even in  versions  8.32
 8722        and  later  there will be no pcre_jit_exec() stub function defined when
 8723        PCRE is compiled with --disable-jit, which is the default, and  there's
 8724        no  way  to  detect  whether  PCRE was compiled with --enable-jit via a
 8725        macro.
 8727        If you need to support versions older than 8.32, or versions  that  may
 8728        not   build   with   --enable-jit,  you  must  either  use  the  slower
 8729        pcre_exec(), or switch between the two codepaths by checking the values
 8730        of PCRE_MAJOR and PCRE_MINOR.
 8732        Switching  between the two by checking the version assumes that all the
 8733        versions being targeted are built with --enable-jit.  To  also  support
 8734        builds that may use --disable-jit either pcre_exec() must be used, or a
 8735        compile-time check for JIT via pcre_config() (which assumes the runtime
 8736        environment  will  be  the  same), or as the Git project decided to do,
 8737        simply assume that pcre_jit_exec() is present in 8.32 or later unless a
 8738        compile-time  flag  is  provided, see the "grep: un-break building with
 8739        PCRE >= 8.32 without --enable-jit" commit in git.git for an example  of
 8740        that.
 8743 SEE ALSO
 8745        pcreapi(3)
 8748 AUTHOR
 8750        Philip Hazel (FAQ by Zoltan Herczeg)
 8751        University Computing Service
 8752        Cambridge CB2 3QH, England.
 8757        Last updated: 05 July 2017
 8758        Copyright (c) 1997-2017 University of Cambridge.
 8759 ------------------------------------------------------------------------------
 8762 PCREPARTIAL(3)             Library Functions Manual             PCREPARTIAL(3)
 8766 NAME
 8767        PCRE - Perl-compatible regular expressions
 8771        In normal use of PCRE, if the subject string that is passed to a match-
 8772        ing function matches as far as it goes, but is too short to  match  the
 8773        entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances
 8774        where it might be helpful to distinguish this case from other cases  in
 8775        which there is no match.
 8777        Consider, for example, an application where a human is required to type
 8778        in data for a field with specific formatting requirements.  An  example
 8779        might be a date in the form ddmmmyy, defined by this pattern:
 8781          ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
 8783        If the application sees the user's keystrokes one by one, and can check
 8784        that what has been typed so far is potentially valid,  it  is  able  to
 8785        raise  an  error  as  soon  as  a  mistake  is made, by beeping and not
 8786        reflecting the character that has been typed, for example. This immedi-
 8787        ate  feedback is likely to be a better user interface than a check that
 8788        is delayed until the entire string has been entered.  Partial  matching
 8789        can  also be useful when the subject string is very long and is not all
 8790        available at once.
 8792        PCRE supports partial matching by means of  the  PCRE_PARTIAL_SOFT  and
 8793        PCRE_PARTIAL_HARD  options,  which  can  be set when calling any of the
 8794        matching functions. For backwards compatibility, PCRE_PARTIAL is a syn-
 8795        onym  for  PCRE_PARTIAL_SOFT.  The essential difference between the two
 8796        options is whether or not a partial match is preferred to  an  alterna-
 8797        tive complete match, though the details differ between the two types of
 8798        matching function. If both options  are  set,  PCRE_PARTIAL_HARD  takes
 8799        precedence.
 8801        If  you  want to use partial matching with just-in-time optimized code,
 8802        you must call pcre_study(), pcre16_study() or  pcre32_study() with  one
 8803        or both of these options:
 8808        PCRE_STUDY_JIT_COMPILE  should also be set if you are going to run non-
 8809        partial matches on the same pattern. If the appropriate JIT study  mode
 8810        has not been set for a match, the interpretive matching code is used.
 8812        Setting a partial matching option disables two of PCRE's standard opti-
 8813        mizations. PCRE remembers the last literal data unit in a pattern,  and
 8814        abandons  matching  immediately  if  it  is  not present in the subject
 8815        string. This optimization cannot be used  for  a  subject  string  that
 8816        might  match only partially. If the pattern was studied, PCRE knows the
 8817        minimum length of a matching string, and does not  bother  to  run  the
 8818        matching  function  on  shorter strings. This optimization is also dis-
 8819        abled for partial matching.
 8822 PARTIAL MATCHING USING pcre_exec() OR pcre[16|32]_exec()
 8824        A  partial   match   occurs   during   a   call   to   pcre_exec()   or
 8825        pcre[16|32]_exec()  when  the end of the subject string is reached suc-
 8826        cessfully, but matching cannot continue  because  more  characters  are
 8827        needed.   However, at least one character in the subject must have been
 8828        inspected. This character need not  form  part  of  the  final  matched
 8829        string;  lookbehind  assertions and the \K escape sequence provide ways
 8830        of inspecting characters before the start of a matched  substring.  The
 8831        requirement  for  inspecting  at  least one character exists because an
 8832        empty string can always be matched; without such  a  restriction  there
 8833        would  always  be  a partial match of an empty string at the end of the
 8834        subject.
 8836        If there are at least two slots in the offsets vector  when  a  partial
 8837        match  is returned, the first slot is set to the offset of the earliest
 8838        character that was inspected. For convenience, the second offset points
 8839        to the end of the subject so that a substring can easily be identified.
 8840        If there are at least three slots in the offsets vector, the third slot
 8841        is set to the offset of the character where matching started.
 8843        For the majority of patterns, the contents of the first and third slots
 8844        will be the same. However, for patterns that contain lookbehind  asser-
 8845        tions, or begin with \b or \B, characters before the one where matching
 8846        started may have been inspected while carrying out the match. For exam-
 8847        ple, consider this pattern:
 8849          /(?<=abc)123/
 8851        This pattern matches "123", but only if it is preceded by "abc". If the
 8852        subject string is "xyzabc12", the first two  offsets  after  a  partial
 8853        match  are for the substring "abc12", because all these characters were
 8854        inspected. However, the third offset is set to 6, because that  is  the
 8855        offset where matching began.
 8857        What happens when a partial match is identified depends on which of the
 8858        two partial matching options are set.
 8860    PCRE_PARTIAL_SOFT WITH pcre_exec() OR pcre[16|32]_exec()
 8862        If PCRE_PARTIAL_SOFT is  set  when  pcre_exec()  or  pcre[16|32]_exec()
 8863        identifies a partial match, the partial match is remembered, but match-
 8864        ing continues as normal, and other  alternatives  in  the  pattern  are
 8865        tried.  If  no  complete  match  can  be  found,  PCRE_ERROR_PARTIAL is
 8866        returned instead of PCRE_ERROR_NOMATCH.
 8868        This option is "soft" because it prefers a complete match over  a  par-
 8869        tial  match.   All the various matching items in a pattern behave as if
 8870        the subject string is potentially complete. For example, \z, \Z, and  $
 8871        match  at  the end of the subject, as normal, and for \b and \B the end
 8872        of the subject is treated as a non-alphanumeric.
 8874        If there is more than one partial match, the first one that  was  found
 8875        provides the data that is returned. Consider this pattern:
 8877          /123\w+X|dogY/
 8879        If  this is matched against the subject string "abc123dog", both alter-
 8880        natives fail to match, but the end of the  subject  is  reached  during
 8881        matching,  so  PCRE_ERROR_PARTIAL is returned. The offsets are set to 3
 8882        and 9, identifying "123dog" as the first partial match that was  found.
 8883        (In  this  example, there are two partial matches, because "dog" on its
 8884        own partially matches the second alternative.)
 8886    PCRE_PARTIAL_HARD WITH pcre_exec() OR pcre[16|32]_exec()
 8888        If PCRE_PARTIAL_HARD is  set  for  pcre_exec()  or  pcre[16|32]_exec(),
 8889        PCRE_ERROR_PARTIAL  is  returned  as  soon as a partial match is found,
 8890        without continuing to search for possible complete matches. This option
 8891        is "hard" because it prefers an earlier partial match over a later com-
 8892        plete match. For this reason, the assumption is made that  the  end  of
 8893        the  supplied  subject  string may not be the true end of the available
 8894        data, and so, if \z, \Z, \b, \B, or $ are encountered at the end of the
 8895        subject,  the  result is PCRE_ERROR_PARTIAL, provided that at least one
 8896        character in the subject has been inspected.
 8898        Setting PCRE_PARTIAL_HARD also affects the way UTF-8 and UTF-16 subject
 8899        strings  are checked for validity. Normally, an invalid sequence causes
 8900        the error PCRE_ERROR_BADUTF8 or PCRE_ERROR_BADUTF16.  However,  in  the
 8901        special  case  of  a  truncated  character  at  the end of the subject,
 8902        PCRE_ERROR_SHORTUTF8  or   PCRE_ERROR_SHORTUTF16   is   returned   when
 8903        PCRE_PARTIAL_HARD is set.
 8905    Comparing hard and soft partial matching
 8907        The  difference  between the two partial matching options can be illus-
 8908        trated by a pattern such as:
 8910          /dog(sbody)?/
 8912        This matches either "dog" or "dogsbody", greedily (that is, it  prefers
 8913        the  longer  string  if  possible). If it is matched against the string
 8914        "dog" with PCRE_PARTIAL_SOFT, it yields a  complete  match  for  "dog".
 8915        However, if PCRE_PARTIAL_HARD is set, the result is PCRE_ERROR_PARTIAL.
 8916        On the other hand, if the pattern is made ungreedy the result  is  dif-
 8917        ferent:
 8919          /dog(sbody)??/
 8921        In  this  case  the  result  is always a complete match because that is
 8922        found first, and matching never  continues  after  finding  a  complete
 8923        match. It might be easier to follow this explanation by thinking of the
 8924        two patterns like this:
 8926          /dog(sbody)?/    is the same as  /dogsbody|dog/
 8927          /dog(sbody)??/   is the same as  /dog|dogsbody/
 8929        The second pattern will never match "dogsbody", because it will  always
 8930        find the shorter match first.
 8933 PARTIAL MATCHING USING pcre_dfa_exec() OR pcre[16|32]_dfa_exec()
 8935        The DFA functions move along the subject string character by character,
 8936        without backtracking, searching for  all  possible  matches  simultane-
 8937        ously.  If the end of the subject is reached before the end of the pat-
 8938        tern, there is the possibility of a partial match, again provided  that
 8939        at least one character has been inspected.
 8941        When  PCRE_PARTIAL_SOFT  is set, PCRE_ERROR_PARTIAL is returned only if
 8942        there have been no complete matches. Otherwise,  the  complete  matches
 8943        are  returned.   However,  if PCRE_PARTIAL_HARD is set, a partial match
 8944        takes precedence over any complete matches. The portion of  the  string
 8945        that  was  inspected when the longest partial match was found is set as
 8946        the first matching string, provided there are at least two slots in the
 8947        offsets vector.
 8949        Because  the  DFA functions always search for all possible matches, and
 8950        there is no difference between greedy and  ungreedy  repetition,  their
 8951        behaviour  is  different  from  the  standard  functions when PCRE_PAR-
 8952        TIAL_HARD is  set.  Consider  the  string  "dog"  matched  against  the
 8953        ungreedy pattern shown above:
 8955          /dog(sbody)??/
 8957        Whereas  the  standard functions stop as soon as they find the complete
 8958        match for "dog", the DFA functions also  find  the  partial  match  for
 8959        "dogsbody", and so return that when PCRE_PARTIAL_HARD is set.
 8964        If  a  pattern ends with one of sequences \b or \B, which test for word
 8965        boundaries, partial matching with PCRE_PARTIAL_SOFT can  give  counter-
 8966        intuitive results. Consider this pattern:
 8968          /\bcat\b/
 8970        This matches "cat", provided there is a word boundary at either end. If
 8971        the subject string is "the cat", the comparison of the final "t" with a
 8972        following  character  cannot  take  place, so a partial match is found.
 8973        However, normal matching carries on, and \b matches at the end  of  the
 8974        subject  when  the  last  character is a letter, so a complete match is
 8975        found.  The  result,  therefore,  is  not   PCRE_ERROR_PARTIAL.   Using
 8976        PCRE_PARTIAL_HARD  in  this case does yield PCRE_ERROR_PARTIAL, because
 8977        then the partial match takes precedence.
 8982        For releases of PCRE prior to 8.00, because of the way certain internal
 8983        optimizations   were  implemented  in  the  pcre_exec()  function,  the
 8984        PCRE_PARTIAL option (predecessor of  PCRE_PARTIAL_SOFT)  could  not  be
 8985        used  with all patterns. From release 8.00 onwards, the restrictions no
 8986        longer apply, and partial matching with can be requested for  any  pat-
 8987        tern.
 8989        Items that were formerly restricted were repeated single characters and
 8990        repeated metasequences. If PCRE_PARTIAL was set for a pattern that  did
 8991        not  conform  to  the restrictions, pcre_exec() returned the error code
 8992        PCRE_ERROR_BADPARTIAL (-13). This error code is no longer in  use.  The
 8993        PCRE_INFO_OKPARTIAL  call  to pcre_fullinfo() to find out if a compiled
 8994        pattern can be used for partial matching now always returns 1.
 8999        If the escape sequence \P is present  in  a  pcretest  data  line,  the
 9000        PCRE_PARTIAL_SOFT  option  is  used  for  the  match.  Here is a run of
 9001        pcretest that uses the date example quoted above:
 9003            re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
 9004          data> 25jun04\P
 9005           0: 25jun04
 9006           1: jun
 9007          data> 25dec3\P
 9008          Partial match: 23dec3
 9009          data> 3ju\P
 9010          Partial match: 3ju
 9011          data> 3juj\P
 9012          No match
 9013          data> j\P
 9014          No match
 9016        The first data string is matched  completely,  so  pcretest  shows  the
 9017        matched  substrings.  The  remaining four strings do not match the com-
 9018        plete pattern, but the first two are partial matches. Similar output is
 9019        obtained if DFA matching is used.
 9021        If  the escape sequence \P is present more than once in a pcretest data
 9022        line, the PCRE_PARTIAL_HARD option is set for the match.
 9025 MULTI-SEGMENT MATCHING WITH pcre_dfa_exec() OR pcre[16|32]_dfa_exec()
 9027        When a partial match has been found using a DFA matching  function,  it
 9028        is  possible to continue the match by providing additional subject data
 9029        and calling the function again with the same compiled  regular  expres-
 9030        sion,  this time setting the PCRE_DFA_RESTART option. You must pass the
 9031        same working space as before, because this is where details of the pre-
 9032        vious  partial  match  are  stored.  Here is an example using pcretest,
 9033        using the \R escape sequence to set  the  PCRE_DFA_RESTART  option  (\D
 9034        specifies the use of the DFA matching function):
 9036            re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
 9037          data> 23ja\P\D
 9038          Partial match: 23ja
 9039          data> n05\R\D
 9040           0: n05
 9042        The  first  call has "23ja" as the subject, and requests partial match-
 9043        ing; the second call  has  "n05"  as  the  subject  for  the  continued
 9044        (restarted)  match.   Notice  that when the match is complete, only the
 9045        last part is shown; PCRE does  not  retain  the  previously  partially-
 9046        matched  string. It is up to the calling program to do that if it needs
 9047        to.
 9049        That means that, for an unanchored pattern, if a continued match fails,
 9050        it  is  not  possible  to  try  again at a new starting point. All this
 9051        facility is capable of doing is  continuing  with  the  previous  match
 9052        attempt.  In  the previous example, if the second set of data is "ug23"
 9053        the result is no match, even though there would be a match for  "aug23"
 9054        if  the entire string were given at once. Depending on the application,
 9055        this may or may not be what you want.  The only way to allow for start-
 9056        ing  again  at  the next character is to retain the matched part of the
 9057        subject and try a new complete match.
 9059        You can set the PCRE_PARTIAL_SOFT  or  PCRE_PARTIAL_HARD  options  with
 9060        PCRE_DFA_RESTART  to  continue partial matching over multiple segments.
 9061        This facility can be used to pass very long subject strings to the  DFA
 9062        matching functions.
 9065 MULTI-SEGMENT MATCHING WITH pcre_exec() OR pcre[16|32]_exec()
 9067        From  release 8.00, the standard matching functions can also be used to
 9068        do multi-segment matching. Unlike the DFA functions, it is not possible
 9069        to  restart the previous match with a new segment of data. Instead, new
 9070        data must be added to the previous subject string, and the entire match
 9071        re-run,  starting from the point where the partial match occurred. Ear-
 9072        lier data can be discarded.
 9074        It is best to use PCRE_PARTIAL_HARD in this situation, because it  does
 9075        not  treat the end of a segment as the end of the subject when matching
 9076        \z, \Z, \b, \B, and $. Consider  an  unanchored  pattern  that  matches
 9077        dates:
 9079            re> /\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d/
 9080          data> The date is 23ja\P\P
 9081          Partial match: 23ja
 9083        At  this stage, an application could discard the text preceding "23ja",
 9084        add on text from the next  segment,  and  call  the  matching  function
 9085        again.  Unlike  the  DFA matching functions, the entire matching string
 9086        must always be available, and the complete matching process occurs  for
 9087        each call, so more memory and more processing time is needed.
 9089        Note:  If  the pattern contains lookbehind assertions, or \K, or starts
 9090        with \b or \B, the string that is returned for a partial match includes
 9091        characters  that precede the start of what would be returned for a com-
 9092        plete match, because it contains all the characters that were inspected
 9093        during the partial match.
 9098        Certain types of pattern may give problems with multi-segment matching,
 9099        whichever matching function is used.
 9101        1. If the pattern contains a test for the beginning of a line, you need
 9102        to  pass  the  PCRE_NOTBOL  option when the subject string for any call
 9103        does start at the beginning of a line.  There  is  also  a  PCRE_NOTEOL
 9104        option, but in practice when doing multi-segment matching you should be
 9105        using PCRE_PARTIAL_HARD, which includes the effect of PCRE_NOTEOL.
 9107        2. Lookbehind assertions that have already been obeyed are catered  for
 9108        in the offsets that are returned for a partial match. However a lookbe-
 9109        hind assertion later in the pattern could require even earlier  charac-
 9110        ters   to  be  inspected.  You  can  handle  this  case  by  using  the
 9111        PCRE_INFO_MAXLOOKBEHIND    option    of    the    pcre_fullinfo()    or
 9112        pcre[16|32]_fullinfo()  functions  to  obtain the length of the longest
 9113        lookbehind in the pattern. This length  is  given  in  characters,  not
 9114        bytes.  If  you  always retain at least that many characters before the
 9115        partially matched string, all should be  well.  (Of  course,  near  the
 9116        start of the subject, fewer characters may be present; in that case all
 9117        characters should be retained.)
 9119        From release 8.33, there is a more accurate way of deciding which char-
 9120        acters  to  retain.  Instead  of  subtracting the length of the longest
 9121        lookbehind from the  earliest  inspected  character  (offsets[0]),  the
 9122        match  start  position  (offsets[2]) should be used, and the next match
 9123        attempt started at the offsets[2] character by setting the  startoffset
 9124        argument of pcre_exec() or pcre_dfa_exec().
 9126        For  example, if the pattern "(?<=123)abc" is partially matched against
 9127        the string "xx123a", the three offset values returned are 2, 6, and  5.
 9128        This  indicates  that  the  matching  process that gave a partial match
 9129        started at offset 5, but the characters "123a" were all inspected.  The
 9130        maximum  lookbehind  for  that pattern is 3, so taking that away from 5
 9131        shows that we need only keep "123a", and the next match attempt can  be
 9132        started at offset 3 (that is, at "a") when further characters have been
 9133        added. When the match start is not the  earliest  inspected  character,
 9134        pcretest shows it explicitly:
 9136            re> "(?<=123)abc"
 9137          data> xx123a\P\P
 9138          Partial match at offset 5: 123a
 9140        3.  Because a partial match must always contain at least one character,
 9141        what might be considered a partial match of an  empty  string  actually
 9142        gives a "no match" result. For example:
 9144            re> /c(?<=abc)x/
 9145          data> ab\P
 9146          No match
 9148        If the next segment begins "cx", a match should be found, but this will
 9149        only happen if characters from the previous segment are  retained.  For
 9150        this  reason,  a  "no  match"  result should be interpreted as "partial
 9151        match of an empty string" when the pattern contains lookbehinds.
 9153        4. Matching a subject string that is split into multiple  segments  may
 9154        not  always produce exactly the same result as matching over one single
 9155        long string, especially when PCRE_PARTIAL_SOFT  is  used.  The  section
 9156        "Partial  Matching  and  Word Boundaries" above describes an issue that
 9157        arises if the pattern ends with \b or \B. Another  kind  of  difference
 9158        may  occur when there are multiple matching possibilities, because (for
 9159        PCRE_PARTIAL_SOFT) a partial match result is given only when there  are
 9160        no completed matches. This means that as soon as the shortest match has
 9161        been found, continuation to a new subject segment is no  longer  possi-
 9162        ble. Consider again this pcretest example:
 9164            re> /dog(sbody)?/
 9165          data> dogsb\P
 9166           0: dog
 9167          data> do\P\D
 9168          Partial match: do
 9169          data> gsb\R\P\D
 9170           0: g
 9171          data> dogsbody\D
 9172           0: dogsbody
 9173           1: dog
 9175        The  first  data  line passes the string "dogsb" to a standard matching
 9176        function, setting the PCRE_PARTIAL_SOFT option. Although the string  is
 9177        a  partial  match for "dogsbody", the result is not PCRE_ERROR_PARTIAL,
 9178        because the shorter string "dog" is a complete match.  Similarly,  when
 9179        the  subject  is  presented to a DFA matching function in several parts
 9180        ("do" and "gsb" being the first two) the match  stops  when  "dog"  has
 9181        been  found, and it is not possible to continue.  On the other hand, if
 9182        "dogsbody" is presented as a single string,  a  DFA  matching  function
 9183        finds both matches.
 9185        Because  of  these  problems,  it is best to use PCRE_PARTIAL_HARD when
 9186        matching multi-segment data. The example  above  then  behaves  differ-
 9187        ently:
 9189            re> /dog(sbody)?/
 9190          data> dogsb\P\P
 9191          Partial match: dogsb
 9192          data> do\P\D
 9193          Partial match: do
 9194          data> gsb\R\P\P\D
 9195          Partial match: gsb
 9197        5. Patterns that contain alternatives at the top level which do not all
 9198        start with the  same  pattern  item  may  not  work  as  expected  when
 9199        PCRE_DFA_RESTART is used. For example, consider this pattern:
 9201          1234|3789
 9203        If  the  first  part of the subject is "ABC123", a partial match of the
 9204        first alternative is found at offset 3. There is no partial  match  for
 9205        the second alternative, because such a match does not start at the same
 9206        point in the subject string. Attempting to  continue  with  the  string
 9207        "7890"  does  not  yield  a  match because only those alternatives that
 9208        match at one point in the subject are remembered.  The  problem  arises
 9209        because  the  start  of the second alternative matches within the first
 9210        alternative. There is no problem with  anchored  patterns  or  patterns
 9211        such as:
 9213          1234|ABCD
 9215        where  no  string can be a partial match for both alternatives. This is
 9216        not a problem if a standard matching  function  is  used,  because  the
 9217        entire match has to be rerun each time:
 9219            re> /1234|3789/
 9220          data> ABC123\P\P
 9221          Partial match: 123
 9222          data> 1237890
 9223           0: 3789
 9225        Of course, instead of using PCRE_DFA_RESTART, the same technique of re-
 9226        running the entire match can also be used with the DFA  matching  func-
 9227        tions.  Another  possibility  is to work with two buffers. If a partial
 9228        match at offset n in the first buffer is followed by  "no  match"  when
 9229        PCRE_DFA_RESTART  is  used on the second buffer, you can then try a new
 9230        match starting at offset n+1 in the first buffer.
 9233 AUTHOR
 9235        Philip Hazel
 9236        University Computing Service
 9237        Cambridge CB2 3QH, England.
 9242        Last updated: 02 July 2013
 9243        Copyright (c) 1997-2013 University of Cambridge.
 9244 ------------------------------------------------------------------------------
 9247 PCREPRECOMPILE(3)          Library Functions Manual          PCREPRECOMPILE(3)
 9251 NAME
 9252        PCRE - Perl-compatible regular expressions
 9256        If  you  are running an application that uses a large number of regular
 9257        expression patterns, it may be useful to store them  in  a  precompiled
 9258        form  instead  of  having to compile them every time the application is
 9259        run.  If you are not  using  any  private  character  tables  (see  the
 9260        pcre_maketables()  documentation),  this is relatively straightforward.
 9261        If you are using private tables, it is a little bit  more  complicated.
 9262        However,  if you are using the just-in-time optimization feature, it is
 9263        not possible to save and reload the JIT data.
 9265        If you save compiled patterns to a file, you can copy them to a differ-
 9266        ent host and run them there. If the two hosts have different endianness
 9267        (byte    order),    you     should     run     the     pcre[16|32]_pat-
 9268        tern_to_host_byte_order()  function  on  the  new host before trying to
 9269        match the pattern. The matching functions return  PCRE_ERROR_BADENDIAN-
 9270        NESS if they detect a pattern with the wrong endianness.
 9272        Compiling  regular  expressions with one version of PCRE for use with a
 9273        different version is not guaranteed to work and may cause crashes,  and
 9274        saving  and  restoring  a  compiled  pattern loses any JIT optimization
 9275        data.
 9280        The value returned by pcre[16|32]_compile() points to a single block of
 9281        memory  that  holds  the  compiled pattern and associated data. You can
 9282        find   the   length   of   this   block    in    bytes    by    calling
 9283        pcre[16|32]_fullinfo() with an argument of PCRE_INFO_SIZE. You can then
 9284        save the data in any appropriate manner. Here is sample  code  for  the
 9285        8-bit  library  that  compiles  a  pattern  and writes it to a file. It
 9286        assumes that the variable fd refers to a file that is open for output:
 9288          int erroroffset, rc, size;
 9289          char *error;
 9290          pcre *re;
 9292          re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
 9293          if (re == NULL) { ... handle errors ... }
 9294          rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
 9295          if (rc < 0) { ... handle errors ... }
 9296          rc = fwrite(re, 1, size, fd);
 9297          if (rc != size) { ... handle errors ... }
 9299        In this example, the bytes  that  comprise  the  compiled  pattern  are
 9300        copied  exactly.  Note that this is binary data that may contain any of
 9301        the 256 possible byte  values.  On  systems  that  make  a  distinction
 9302        between binary and non-binary data, be sure that the file is opened for
 9303        binary output.
 9305        If you want to write more than one pattern to a file, you will have  to
 9306        devise  a  way of separating them. For binary data, preceding each pat-
 9307        tern with its length is probably  the  most  straightforward  approach.
 9308        Another  possibility is to write out the data in hexadecimal instead of
 9309        binary, one pattern to a line.
 9311        Saving compiled patterns in a file is only one possible way of  storing
 9312        them  for later use. They could equally well be saved in a database, or
 9313        in the memory of some daemon process that passes them  via  sockets  to
 9314        the processes that want them.
 9316        If the pattern has been studied, it is also possible to save the normal
 9317        study data in a similar way to the compiled pattern itself. However, if
 9318        the PCRE_STUDY_JIT_COMPILE was used, the just-in-time data that is cre-
 9319        ated cannot be saved because it is too dependent on the  current  envi-
 9320        ronment.    When    studying    generates    additional    information,
 9321        pcre[16|32]_study() returns  a  pointer  to  a  pcre[16|32]_extra  data
 9322        block.  Its  format  is defined in the section on matching a pattern in
 9323        the pcreapi documentation. The study_data field points  to  the  binary
 9324        study  data,  and this is what you must save (not the pcre[16|32]_extra
 9325        block itself). The length of the study data can be obtained by  calling
 9326        pcre[16|32]_fullinfo()  with an argument of PCRE_INFO_STUDYSIZE. Remem-
 9327        ber to check that  pcre[16|32]_study()  did  return  a  non-NULL  value
 9328        before trying to save the study data.
 9333        Re-using  a  precompiled pattern is straightforward. Having reloaded it
 9334        into main memory,  called  pcre[16|32]_pattern_to_host_byte_order()  if
 9335        necessary,    you   pass   its   pointer   to   pcre[16|32]_exec()   or
 9336        pcre[16|32]_dfa_exec() in the usual way.
 9338        However, if you passed a pointer to custom character  tables  when  the
 9339        pattern  was compiled (the tableptr argument of pcre[16|32]_compile()),
 9340        you  must  now  pass  a  similar  pointer  to   pcre[16|32]_exec()   or
 9341        pcre[16|32]_dfa_exec(),  because the value saved with the compiled pat-
 9342        tern will obviously be nonsense. A field in a pcre[16|32]_extra() block
 9343        is  used  to  pass this data, as described in the section on matching a
 9344        pattern in the pcreapi documentation.
 9346        Warning: The tables that pcre_exec() and pcre_dfa_exec()  use  must  be
 9347        the same as those that were used when the pattern was compiled. If this
 9348        is not the case, the behaviour is undefined.
 9350        If you did not provide custom character tables  when  the  pattern  was
 9351        compiled, the pointer in the compiled pattern is NULL, which causes the
 9352        matching functions to use PCRE's internal tables. Thus, you do not need
 9353        to take any special action at run time in this case.
 9355        If  you  saved study data with the compiled pattern, you need to create
 9356        your own pcre[16|32]_extra data block and set the study_data  field  to
 9357        point   to   the   reloaded   study   data.   You  must  also  set  the
 9358        PCRE_EXTRA_STUDY_DATA bit in the flags field  to  indicate  that  study
 9359        data  is present. Then pass the pcre[16|32]_extra block to the matching
 9360        function in the usual way. If the pattern was studied for  just-in-time
 9361        optimization,  that  data  cannot  be  saved,  and  so  is  lost  by  a
 9362        save/restore cycle.
 9367        In general, it is safest to  recompile  all  saved  patterns  when  you
 9368        update  to  a new PCRE release, though not all updates actually require
 9369        this.
 9372 AUTHOR
 9374        Philip Hazel
 9375        University Computing Service
 9376        Cambridge CB2 3QH, England.
 9381        Last updated: 12 November 2013
 9382        Copyright (c) 1997-2013 University of Cambridge.
 9383 ------------------------------------------------------------------------------
 9386 PCREPERFORM(3)             Library Functions Manual             PCREPERFORM(3)
 9390 NAME
 9391        PCRE - Perl-compatible regular expressions
 9395        Two  aspects  of performance are discussed below: memory usage and pro-
 9396        cessing time. The way you express your pattern as a regular  expression
 9397        can affect both of them.
 9402        Patterns  are compiled by PCRE into a reasonably efficient interpretive
 9403        code, so that most simple patterns do not  use  much  memory.  However,
 9404        there  is  one case where the memory usage of a compiled pattern can be
 9405        unexpectedly large. If a parenthesized subpattern has a quantifier with
 9406        a minimum greater than 1 and/or a limited maximum, the whole subpattern
 9407        is repeated in the compiled code. For example, the pattern
 9409          (abc|def){2,4}
 9411        is compiled as if it were
 9413          (abc|def)(abc|def)((abc|def)(abc|def)?)?
 9415        (Technical aside: It is done this way so that backtrack  points  within
 9416        each of the repetitions can be independently maintained.)
 9418        For  regular expressions whose quantifiers use only small numbers, this
 9419        is not usually a problem. However, if the numbers are large,  and  par-
 9420        ticularly  if  such repetitions are nested, the memory usage can become
 9421        an embarrassment. For example, the very simple pattern
 9423          ((ab){1,1000}c){1,3}
 9425        uses 51K bytes when compiled using the 8-bit library. When PCRE is com-
 9426        piled  with  its  default  internal pointer size of two bytes, the size
 9427        limit on a compiled pattern is 64K data units, and this is reached with
 9428        the  above  pattern  if  the outer repetition is increased from 3 to 4.
 9429        PCRE can be compiled to use larger internal pointers  and  thus  handle
 9430        larger  compiled patterns, but it is better to try to rewrite your pat-
 9431        tern to use less memory if you can.
 9433        One way of reducing the memory usage for such patterns is to  make  use
 9434        of PCRE's "subroutine" facility. Re-writing the above pattern as
 9436          ((ab)(?2){0,999}c)(?1){0,2}
 9438        reduces the memory requirements to 18K, and indeed it remains under 20K
 9439        even with the outer repetition increased to 100. However, this  pattern
 9440        is  not  exactly equivalent, because the "subroutine" calls are treated
 9441        as atomic groups into which there can be no backtracking if there is  a
 9442        subsequent  matching  failure.  Therefore,  PCRE cannot do this kind of
 9443        rewriting automatically.  Furthermore, there is a  noticeable  loss  of
 9444        speed  when executing the modified pattern. Nevertheless, if the atomic
 9445        grouping is not a problem and the loss of  speed  is  acceptable,  this
 9446        kind  of  rewriting will allow you to process patterns that PCRE cannot
 9447        otherwise handle.
 9452        When pcre_exec() or pcre[16|32]_exec() is used  for  matching,  certain
 9453        kinds  of  pattern  can  cause  it  to use large amounts of the process
 9454        stack. In some environments the default process stack is  quite  small,
 9455        and  if it runs out the result is often SIGSEGV. This issue is probably
 9456        the most frequently raised problem with PCRE.  Rewriting  your  pattern
 9457        can  often  help.  The  pcrestack documentation discusses this issue in
 9458        detail.
 9463        Certain items in regular expression patterns are processed  more  effi-
 9464        ciently than others. It is more efficient to use a character class like
 9465        [aeiou]  than  a  set  of   single-character   alternatives   such   as
 9466        (a|e|i|o|u).  In  general,  the simplest construction that provides the
 9467        required behaviour is usually the most efficient. Jeffrey Friedl's book
 9468        contains  a  lot  of useful general discussion about optimizing regular
 9469        expressions for efficient performance. This  document  contains  a  few
 9470        observations about PCRE.
 9472        Using  Unicode  character  properties  (the  \p, \P, and \X escapes) is
 9473        slow, because PCRE has to use a multi-stage table  lookup  whenever  it
 9474        needs  a  character's  property. If you can find an alternative pattern
 9475        that does not use character properties, it will probably be faster.
 9477        By default, the escape sequences \b, \d, \s,  and  \w,  and  the  POSIX
 9478        character  classes  such  as  [:alpha:]  do not use Unicode properties,
 9479        partly for backwards compatibility, and partly for performance reasons.
 9480        However,  you can set PCRE_UCP if you want Unicode character properties
 9481        to be used. This can double the matching time for  items  such  as  \d,
 9482        when matched with a traditional matching function; the performance loss
 9483        is less with a DFA matching function, and in both cases  there  is  not
 9484        much difference for \b.
 9486        When  a  pattern  begins  with .* not in parentheses, or in parentheses
 9487        that are not the subject of a backreference, and the PCRE_DOTALL option
 9488        is  set, the pattern is implicitly anchored by PCRE, since it can match
 9489        only at the start of a subject string. However, if PCRE_DOTALL  is  not
 9490        set,  PCRE  cannot  make this optimization, because the . metacharacter
 9491        does not then match a newline, and if the subject string contains  new-
 9492        lines,  the  pattern may match from the character immediately following
 9493        one of them instead of from the very start. For example, the pattern
 9495          .*second
 9497        matches the subject "first\nand second" (where \n stands for a  newline
 9498        character),  with the match starting at the seventh character. In order
 9499        to do this, PCRE has to retry the match starting after every newline in
 9500        the subject.
 9502        If  you  are using such a pattern with subject strings that do not con-
 9503        tain newlines, the best performance is obtained by setting PCRE_DOTALL,
 9504        or  starting  the pattern with ^.* or ^.*? to indicate explicit anchor-
 9505        ing. That saves PCRE from having to scan along the subject looking  for
 9506        a newline to restart at.
 9508        Beware  of  patterns  that contain nested indefinite repeats. These can
 9509        take a long time to run when applied to a string that does  not  match.
 9510        Consider the pattern fragment
 9512          ^(a+)*
 9514        This  can  match "aaaa" in 16 different ways, and this number increases
 9515        very rapidly as the string gets longer. (The * repeat can match  0,  1,
 9516        2,  3, or 4 times, and for each of those cases other than 0 or 4, the +
 9517        repeats can match different numbers of times.) When  the  remainder  of
 9518        the pattern is such that the entire match is going to fail, PCRE has in
 9519        principle to try  every  possible  variation,  and  this  can  take  an
 9520        extremely long time, even for relatively short strings.
 9522        An optimization catches some of the more simple cases such as
 9524          (a+)*b
 9526        where  a  literal  character  follows. Before embarking on the standard
 9527        matching procedure, PCRE checks that there is a "b" later in  the  sub-
 9528        ject  string, and if there is not, it fails the match immediately. How-
 9529        ever, when there is no following literal this  optimization  cannot  be
 9530        used. You can see the difference by comparing the behaviour of
 9532          (a+)*\d
 9534        with  the  pattern  above.  The former gives a failure almost instantly
 9535        when applied to a whole line of  "a"  characters,  whereas  the  latter
 9536        takes an appreciable time with strings longer than about 20 characters.
 9538        In many cases, the solution to this kind of performance issue is to use
 9539        an atomic group or a possessive quantifier.
 9542 AUTHOR
 9544        Philip Hazel
 9545        University Computing Service
 9546        Cambridge CB2 3QH, England.
 9551        Last updated: 25 August 2012
 9552        Copyright (c) 1997-2012 University of Cambridge.
 9553 ------------------------------------------------------------------------------
 9556 PCREPOSIX(3)               Library Functions Manual               PCREPOSIX(3)
 9560 NAME
 9561        PCRE - Perl-compatible regular expressions.
 9565        #include <pcreposix.h>
 9567        int regcomp(regex_t *preg, const char *pattern,
 9568             int cflags);
 9570        int regexec(regex_t *preg, const char *string,
 9571             size_t nmatch, regmatch_t pmatch[], int eflags);
 9572             size_t regerror(int errcode, const regex_t *preg,
 9573             char *errbuf, size_t errbuf_size);
 9575        void regfree(regex_t *preg);
 9580        This  set  of functions provides a POSIX-style API for the PCRE regular
 9581        expression 8-bit library. See the pcreapi documentation for a  descrip-
 9582        tion  of  PCRE's native API, which contains much additional functional-
 9583        ity. There is no POSIX-style  wrapper  for  PCRE's  16-bit  and  32-bit
 9584        library.
 9586        The functions described here are just wrapper functions that ultimately
 9587        call  the  PCRE  native  API.  Their  prototypes  are  defined  in  the
 9588        pcreposix.h  header  file,  and  on  Unix systems the library itself is
 9589        called pcreposix.a, so can be accessed by  adding  -lpcreposix  to  the
 9590        command  for  linking  an application that uses them. Because the POSIX
 9591        functions call the native ones, it is also necessary to add -lpcre.
 9593        I have implemented only those POSIX option bits that can be  reasonably
 9594        mapped  to PCRE native options. In addition, the option REG_EXTENDED is
 9595        defined with the value zero. This has no  effect,  but  since  programs
 9596        that  are  written  to  the POSIX interface often use it, this makes it
 9597        easier to slot in PCRE as a replacement library.  Other  POSIX  options
 9598        are not even defined.
 9600        There  are also some other options that are not defined by POSIX. These
 9601        have been added at the request of users who want to make use of certain
 9602        PCRE-specific features via the POSIX calling interface.
 9604        When  PCRE  is  called  via these functions, it is only the API that is
 9605        POSIX-like in style. The syntax and semantics of  the  regular  expres-
 9606        sions  themselves  are  still  those of Perl, subject to the setting of
 9607        various PCRE options, as described below. "POSIX-like in  style"  means
 9608        that  the  API  approximates  to  the POSIX definition; it is not fully
 9609        POSIX-compatible, and in multi-byte encoding  domains  it  is  probably
 9610        even less compatible.
 9612        The  header for these functions is supplied as pcreposix.h to avoid any
 9613        potential clash with other POSIX  libraries.  It  can,  of  course,  be
 9614        renamed or aliased as regex.h, which is the "correct" name. It provides
 9615        two structure types, regex_t for  compiled  internal  forms,  and  reg-
 9616        match_t  for  returning  captured substrings. It also defines some con-
 9617        stants whose names start  with  "REG_";  these  are  used  for  setting
 9618        options and identifying error codes.
 9623        The  function regcomp() is called to compile a pattern into an internal
 9624        form. The pattern is a C string terminated by a  binary  zero,  and  is
 9625        passed  in  the  argument  pattern. The preg argument is a pointer to a
 9626        regex_t structure that is used as a base for storing information  about
 9627        the compiled regular expression.
 9629        The argument cflags is either zero, or contains one or more of the bits
 9630        defined by the following macros:
 9632          REG_DOTALL
 9634        The PCRE_DOTALL option is set when the regular expression is passed for
 9635        compilation to the native function. Note that REG_DOTALL is not part of
 9636        the POSIX standard.
 9638          REG_ICASE
 9640        The PCRE_CASELESS option is set when the regular expression  is  passed
 9641        for compilation to the native function.
 9643          REG_NEWLINE
 9645        The  PCRE_MULTILINE option is set when the regular expression is passed
 9646        for compilation to the native function. Note that this does  not  mimic
 9647        the  defined  POSIX  behaviour  for REG_NEWLINE (see the following sec-
 9648        tion).
 9650          REG_NOSUB
 9652        The PCRE_NO_AUTO_CAPTURE option is set when the regular  expression  is
 9653        passed for compilation to the native function. In addition, when a pat-
 9654        tern that is compiled with this flag is passed to regexec() for  match-
 9655        ing,  the  nmatch  and  pmatch  arguments  are ignored, and no captured
 9656        strings are returned.
 9658          REG_UCP
 9660        The PCRE_UCP option is set when the regular expression  is  passed  for
 9661        compilation  to  the  native  function. This causes PCRE to use Unicode
 9662        properties when matchine \d, \w,  etc.,  instead  of  just  recognizing
 9663        ASCII values. Note that REG_UTF8 is not part of the POSIX standard.
 9665          REG_UNGREEDY
 9667        The  PCRE_UNGREEDY  option is set when the regular expression is passed
 9668        for compilation to the native function. Note that REG_UNGREEDY  is  not
 9669        part of the POSIX standard.
 9671          REG_UTF8
 9673        The  PCRE_UTF8  option is set when the regular expression is passed for
 9674        compilation to the native function. This causes the pattern itself  and
 9675        all  data  strings used for matching it to be treated as UTF-8 strings.
 9676        Note that REG_UTF8 is not part of the POSIX standard.
 9678        In the absence of these flags, no options  are  passed  to  the  native
 9679        function.   This  means  the  the  regex  is compiled with PCRE default
 9680        semantics. In particular, the way it handles newline characters in  the
 9681        subject  string  is  the Perl way, not the POSIX way. Note that setting
 9682        PCRE_MULTILINE has only some of the effects specified for  REG_NEWLINE.
 9683        It  does not affect the way newlines are matched by . (they are not) or
 9684        by a negative class such as [^a] (they are).
 9686        The yield of regcomp() is zero on success, and non-zero otherwise.  The
 9687        preg structure is filled in on success, and one member of the structure
 9688        is public: re_nsub contains the number of capturing subpatterns in  the
 9689        regular expression. Various error codes are defined in the header file.
 9691        NOTE:  If  the  yield of regcomp() is non-zero, you must not attempt to
 9692        use the contents of the preg structure. If, for example, you pass it to
 9693        regexec(), the result is undefined and your program is likely to crash.
 9698        This area is not simple, because POSIX and Perl take different views of
 9699        things.  It is not possible to get PCRE to obey  POSIX  semantics,  but
 9700        then  PCRE was never intended to be a POSIX engine. The following table
 9701        lists the different possibilities for matching  newline  characters  in
 9702        PCRE:
 9704                                  Default   Change with
 9706          . matches newline          no     PCRE_DOTALL
 9707          newline matches [^a]       yes    not changeable
 9708          $ matches \n at end        yes    PCRE_DOLLARENDONLY
 9709          $ matches \n in middle     no     PCRE_MULTILINE
 9710          ^ matches \n in middle     no     PCRE_MULTILINE
 9712        This is the equivalent table for POSIX:
 9714                                  Default   Change with
 9716          . matches newline          yes    REG_NEWLINE
 9717          newline matches [^a]       yes    REG_NEWLINE
 9718          $ matches \n at end        no     REG_NEWLINE
 9719          $ matches \n in middle     no     REG_NEWLINE
 9720          ^ matches \n in middle     no     REG_NEWLINE
 9722        PCRE's behaviour is the same as Perl's, except that there is no equiva-
 9723        lent for PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl,  there  is
 9724        no way to stop newline from matching [^a].
 9726        The   default  POSIX  newline  handling  can  be  obtained  by  setting
 9727        PCRE_DOTALL and PCRE_DOLLAR_ENDONLY, but there is no way to  make  PCRE
 9728        behave exactly as for the REG_NEWLINE action.
 9733        The  function  regexec()  is  called  to  match a compiled pattern preg
 9734        against a given string, which is by default terminated by a  zero  byte
 9735        (but  see  REG_STARTEND below), subject to the options in eflags. These
 9736        can be:
 9738          REG_NOTBOL
 9740        The PCRE_NOTBOL option is set when calling the underlying PCRE matching
 9741        function.
 9743          REG_NOTEMPTY
 9745        The PCRE_NOTEMPTY option is set when calling the underlying PCRE match-
 9746        ing function. Note that REG_NOTEMPTY is not part of the POSIX standard.
 9747        However, setting this option can give more POSIX-like behaviour in some
 9748        situations.
 9750          REG_NOTEOL
 9752        The PCRE_NOTEOL option is set when calling the underlying PCRE matching
 9753        function.
 9755          REG_STARTEND
 9757        The  string  is  considered to start at string + pmatch[0].rm_so and to
 9758        have a terminating NUL located at string + pmatch[0].rm_eo (there  need
 9759        not  actually  be  a  NUL at that location), regardless of the value of
 9760        nmatch. This is a BSD extension, compatible with but not  specified  by
 9761        IEEE  Standard  1003.2  (POSIX.2),  and  should be used with caution in
 9762        software intended to be portable to other systems. Note that a non-zero
 9763        rm_so does not imply REG_NOTBOL; REG_STARTEND affects only the location
 9764        of the string, not how it is matched.
 9766        If the pattern was compiled with the REG_NOSUB flag, no data about  any
 9767        matched  strings  is  returned.  The  nmatch  and  pmatch  arguments of
 9768        regexec() are ignored.
 9770        If the value of nmatch is zero, or if the value pmatch is NULL, no data
 9771        about any matched strings is returned.
 9773        Otherwise,the portion of the string that was matched, and also any cap-
 9774        tured substrings, are returned via the pmatch argument, which points to
 9775        an  array  of nmatch structures of type regmatch_t, containing the mem-
 9776        bers rm_so and rm_eo. These contain the offset to the  first  character
 9777        of  each  substring and the offset to the first character after the end
 9778        of each substring, respectively. The 0th element of the vector  relates
 9779        to  the  entire portion of string that was matched; subsequent elements
 9780        relate to the capturing subpatterns of the regular  expression.  Unused
 9781        entries in the array have both structure members set to -1.
 9783        A  successful  match  yields  a  zero  return;  various error codes are
 9784        defined in the header file, of  which  REG_NOMATCH  is  the  "expected"
 9785        failure code.
 9790        The regerror() function maps a non-zero errorcode from either regcomp()
 9791        or regexec() to a printable message. If preg is  not  NULL,  the  error
 9792        should have arisen from the use of that structure. A message terminated
 9793        by a binary zero is placed  in  errbuf.  The  length  of  the  message,
 9794        including  the  zero, is limited to errbuf_size. The yield of the func-
 9795        tion is the size of buffer needed to hold the whole message.
 9800        Compiling a regular expression causes memory to be allocated and  asso-
 9801        ciated  with  the preg structure. The function regfree() frees all such
 9802        memory, after which preg may no longer be used as  a  compiled  expres-
 9803        sion.
 9806 AUTHOR
 9808        Philip Hazel
 9809        University Computing Service
 9810        Cambridge CB2 3QH, England.
 9815        Last updated: 09 January 2012
 9816        Copyright (c) 1997-2012 University of Cambridge.
 9817 ------------------------------------------------------------------------------
 9820 PCRECPP(3)                 Library Functions Manual                 PCRECPP(3)
 9824 NAME
 9825        PCRE - Perl-compatible regular expressions.
 9829        #include <pcrecpp.h>
 9834        The  C++  wrapper  for PCRE was provided by Google Inc. Some additional
 9835        functionality was added by Giuseppe Maxia. This brief man page was con-
 9836        structed  from  the  notes  in the pcrecpp.h file, which should be con-
 9837        sulted for further details. Note that the C++ wrapper supports only the
 9838        original  8-bit  PCRE  library. There is no 16-bit or 32-bit support at
 9839        present.
 9844        The "FullMatch" operation checks that supplied text matches a  supplied
 9845        pattern  exactly.  If pointer arguments are supplied, it copies matched
 9846        sub-strings that match sub-patterns into them.
 9848          Example: successful match
 9849             pcrecpp::RE re("h.*o");
 9850             re.FullMatch("hello");
 9852          Example: unsuccessful match (requires full match):
 9853             pcrecpp::RE re("e");
 9854             !re.FullMatch("hello");
 9856          Example: creating a temporary RE object:
 9857             pcrecpp::RE("h.*o").FullMatch("hello");
 9859        You can pass in a "const char*" or a "string" for "text". The  examples
 9860        below  tend to use a const char*. You can, as in the different examples
 9861        above, store the RE object explicitly in a variable or use a  temporary
 9862        RE  object.  The  examples below use one mode or the other arbitrarily.
 9863        Either could correctly be used for any of these examples.
 9865        You must supply extra pointer arguments to extract matched subpieces.
 9867          Example: extracts "ruby" into "s" and 1234 into "i"
 9868             int i;
 9869             string s;
 9870             pcrecpp::RE re("(\\w+):(\\d+)");
 9871             re.FullMatch("ruby:1234", &s, &i);
 9873          Example: does not try to extract any extra sub-patterns
 9874             re.FullMatch("ruby:1234", &s);
 9876          Example: does not try to extract into NULL
 9877             re.FullMatch("ruby:1234", NULL, &i);
 9879          Example: integer overflow causes failure
 9880             !re.FullMatch("ruby:1234567891234", NULL, &i);
 9882          Example: fails because there aren't enough sub-patterns:
 9883             !pcrecpp::RE("\\w+:\\d+").FullMatch("ruby:1234", &s);
 9885          Example: fails because string cannot be stored in integer
 9886             !pcrecpp::RE("(.*)").FullMatch("ruby", &i);
 9888        The provided pointer arguments can be pointers to  any  scalar  numeric
 9889        type, or one of:
 9891           string        (matched piece is copied to string)
 9892           StringPiece   (StringPiece is mutated to point to matched piece)
 9893           T             (where "bool T::ParseFrom(const char*, int)" exists)
 9894           NULL          (the corresponding matched sub-pattern is not copied)
 9896        The  function returns true iff all of the following conditions are sat-
 9897        isfied:
 9899          a. "text" matches "pattern" exactly;
 9901          b. The number of matched sub-patterns is >= number of supplied
 9902             pointers;
 9904          c. The "i"th argument has a suitable type for holding the
 9905             string captured as the "i"th sub-pattern. If you pass in
 9906             void * NULL for the "i"th argument, or a non-void * NULL
 9907             of the correct type, or pass fewer arguments than the
 9908             number of sub-patterns, "i"th captured sub-pattern is
 9909             ignored.
 9911        CAVEAT: An optional sub-pattern that does  not  exist  in  the  matched
 9912        string  is  assigned  the  empty  string. Therefore, the following will
 9913        return false (because the empty string is not a valid number):
 9915           int number;
 9916           pcrecpp::RE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
 9918        The matching interface supports at most 16 arguments per call.  If  you
 9919        need    more,    consider    using    the    more   general   interface
 9920        pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.
 9922        NOTE: Do not use no_arg, which is used internally to mark the end of  a
 9923        list  of optional arguments, as a placeholder for missing arguments, as
 9924        this can lead to segfaults.
 9929        You can use the "QuoteMeta" operation to insert backslashes before  all
 9930        potentially  meaningful  characters  in  a string. The returned string,
 9931        used as a regular expression, will exactly match the original string.
 9933          Example:
 9934             string quoted = RE::QuoteMeta(unquoted);
 9936        Note that it's legal to escape a character even if it  has  no  special
 9937        meaning  in  a  regular expression -- so this function does that. (This
 9938        also makes it identical to the perl function  of  the  same  name;  see
 9939        "perldoc    -f    quotemeta".)    For   example,   "1.5-2.0?"   becomes
 9940        "1\.5\-2\.0\?".
 9945        You can use the "PartialMatch" operation when you want the  pattern  to
 9946        match any substring of the text.
 9948          Example: simple search for a string:
 9949             pcrecpp::RE("ell").PartialMatch("hello");
 9951          Example: find first number in a string:
 9952             int number;
 9953             pcrecpp::RE re("(\\d+)");
 9954             re.PartialMatch("x*100 + 20", &number);
 9955             assert(number == 100);
 9960        By  default,  pattern  and text are plain text, one byte per character.
 9961        The UTF8 flag, passed to  the  constructor,  causes  both  pattern  and
 9962        string to be treated as UTF-8 text, still a byte stream but potentially
 9963        multiple bytes per character. In practice, the text is likelier  to  be
 9964        UTF-8  than  the pattern, but the match returned may depend on the UTF8
 9965        flag, so always use it when matching UTF8 text. For example,  "."  will
 9966        match  one  byte normally but with UTF8 set may match up to three bytes
 9967        of a multi-byte character.
 9969          Example:
 9970             pcrecpp::RE_Options options;
 9971             options.set_utf8();
 9972             pcrecpp::RE re(utf8_pattern, options);
 9973             re.FullMatch(utf8_string);
 9975          Example: using the convenience function UTF8():
 9976             pcrecpp::RE re(utf8_pattern, pcrecpp::UTF8());
 9977             re.FullMatch(utf8_string);
 9979        NOTE: The UTF8 flag is ignored if pcre was not configured with the
 9980              --enable-utf8 flag.
 9985        PCRE defines some modifiers to  change  the  behavior  of  the  regular
 9986        expression   engine.  The  C++  wrapper  defines  an  auxiliary  class,
 9987        RE_Options, as a vehicle to pass such modifiers to  a  RE  class.  Cur-
 9988        rently, the following modifiers are supported:
 9990           modifier              description               Perl corresponding
 9992           PCRE_CASELESS         case insensitive match      /i
 9993           PCRE_MULTILINE        multiple lines match        /m
 9994           PCRE_DOTALL           dot matches newlines        /s
 9995           PCRE_DOLLAR_ENDONLY   $ matches only at end       N/A
 9996           PCRE_EXTRA            strict escape parsing       N/A
 9997           PCRE_EXTENDED         ignore white spaces         /x
 9998           PCRE_UTF8             handles UTF8 chars          built-in
 9999           PCRE_UNGREEDY         reverses * and *?           N/A
10000           PCRE_NO_AUTO_CAPTURE  disables capturing parens   N/A (*)
10002        (*)  Both Perl and PCRE allow non capturing parentheses by means of the
10003        "?:" modifier within the pattern itself. e.g. (?:ab|cd) does  not  cap-
10004        ture, while (ab|cd) does.
10006        For  a  full  account on how each modifier works, please check the PCRE
10007        API reference page.
10009        For each modifier, there are two member functions whose  name  is  made
10010        out  of  the  modifier  in  lowercase,  without the "PCRE_" prefix. For
10011        instance, PCRE_CASELESS is handled by
10013          bool caseless()
10015        which returns true if the modifier is set, and
10017          RE_Options & set_caseless(bool)
10019        which sets or unsets the modifier. Moreover, PCRE_EXTRA_MATCH_LIMIT can
10020        be  accessed  through  the  set_match_limit()  and match_limit() member
10021        functions. Setting match_limit to a non-zero value will limit the  exe-
10022        cution  of pcre to keep it from doing bad things like blowing the stack
10023        or taking an eternity to return a result.  A  value  of  5000  is  good
10024        enough  to stop stack blowup in a 2MB thread stack. Setting match_limit
10025        to  zero  disables  match  limiting.  Alternatively,   you   can   call
10026        match_limit_recursion()  which uses PCRE_EXTRA_MATCH_LIMIT_RECURSION to
10027        limit how much  PCRE  recurses.  match_limit()  limits  the  number  of
10028        matches PCRE does; match_limit_recursion() limits the depth of internal
10029        recursion, and therefore the amount of stack that is used.
10031        Normally, to pass one or more modifiers to a RE class,  you  declare  a
10032        RE_Options object, set the appropriate options, and pass this object to
10033        a RE constructor. Example:
10035           RE_Options opt;
10036           opt.set_caseless(true);
10037           if (RE("HELLO", opt).PartialMatch("hello world")) ...
10039        RE_options has two constructors. The default constructor takes no argu-
10040        ments  and creates a set of flags that are off by default. The optional
10041        parameter option_flags is to facilitate transfer of legacy code from  C
10042        programs.  This lets you do
10044           RE(pattern,
10045             RE_Options(PCRE_CASELESS|PCRE_MULTILINE)).PartialMatch(str);
10047        However, new code is better off doing
10049           RE(pattern,
10050             RE_Options().set_caseless(true).set_multiline(true))
10051               .PartialMatch(str);
10053        If you are going to pass one of the most used modifiers, there are some
10054        convenience functions that return a RE_Options class with the appropri-
10055        ate  modifier  already  set: CASELESS(), UTF8(), MULTILINE(), DOTALL(),
10056        and EXTENDED().
10058        If you need to set several options at once, and you don't  want  to  go
10059        through  the pains of declaring a RE_Options object and setting several
10060        options, there is a parallel method that give you such ability  on  the
10061        fly.  You  can  concatenate several set_xxxxx() member functions, since
10062        each of them returns a reference to its class object. For  example,  to
10063        pass  PCRE_CASELESS, PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one
10064        statement, you may write:
10066           RE(" ^ xyz \\s+ .* blah$",
10067             RE_Options()
10068               .set_caseless(true)
10069               .set_extended(true)
10070               .set_multiline(true)).PartialMatch(sometext);
10075        The "Consume" operation may be useful if you want to  repeatedly  match
10076        regular expressions at the front of a string and skip over them as they
10077        match. This requires use of the "StringPiece" type, which represents  a
10078        sub-range  of  a  real  string.  Like RE, StringPiece is defined in the
10079        pcrecpp namespace.
10081          Example: read lines of the form "var = value" from a string.
10082             string contents = ...;                 // Fill string somehow
10083             pcrecpp::StringPiece input(contents);  // Wrap in a StringPiece
10085             string var;
10086             int value;
10087             pcrecpp::RE re("(\\w+) = (\\d+)\n");
10088             while (re.Consume(&input, &var, &value)) {
10089               ...;
10090             }
10092        Each successful call  to  "Consume"  will  set  "var/value",  and  also
10093        advance "input" so it points past the matched text.
10095        The  "FindAndConsume"  operation  is  similar to "Consume" but does not
10096        anchor your match at the beginning of  the  string.  For  example,  you
10097        could extract all words from a string by repeatedly calling
10099          pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)
10104        By default, if you pass a pointer to a numeric value, the corresponding
10105        text is interpreted as a base-10  number.  You  can  instead  wrap  the
10106        pointer with a call to one of the operators Hex(), Octal(), or CRadix()
10107        to interpret the text in another base. The CRadix  operator  interprets
10108        C-style  "0"  (base-8)  and  "0x"  (base-16)  prefixes, but defaults to
10109        base-10.
10111          Example:
10112            int a, b, c, d;
10113            pcrecpp::RE re("(.*) (.*) (.*) (.*)");
10114            re.FullMatch("100 40 0100 0x40",
10115                         pcrecpp::Octal(&a), pcrecpp::Hex(&b),
10116                         pcrecpp::CRadix(&c), pcrecpp::CRadix(&d));
10118        will leave 64 in a, b, c, and d.
10123        You can replace the first match of "pattern" in "str"  with  "rewrite".
10124        Within  "rewrite",  backslash-escaped  digits (\1 to \9) can be used to
10125        insert text matching corresponding parenthesized group  from  the  pat-
10126        tern. \0 in "rewrite" refers to the entire matching text. For example:
10128          string s = "yabba dabba doo";
10129          pcrecpp::RE("b+").Replace("d", &s);
10131        will  leave  "s" containing "yada dabba doo". The result is true if the
10132        pattern matches and a replacement occurs, false otherwise.
10134        GlobalReplace is like Replace except that it replaces  all  occurrences
10135        of  the  pattern  in  the string with the rewrite. Replacements are not
10136        subject to re-matching. For example:
10138          string s = "yabba dabba doo";
10139          pcrecpp::RE("b+").GlobalReplace("d", &s);
10141        will leave "s" containing "yada dada doo". It  returns  the  number  of
10142        replacements made.
10144        Extract  is like Replace, except that if the pattern matches, "rewrite"
10145        is copied into "out" (an additional argument) with substitutions.   The
10146        non-matching  portions  of "text" are ignored. Returns true iff a match
10147        occurred and the extraction happened successfully;  if no match occurs,
10148        the string is left unaffected.
10151 AUTHOR
10153        The C++ wrapper was contributed by Google Inc.
10154        Copyright (c) 2007 Google Inc.
10159        Last updated: 08 January 2012
10160 ------------------------------------------------------------------------------
10163 PCRESAMPLE(3)              Library Functions Manual              PCRESAMPLE(3)
10167 NAME
10168        PCRE - Perl-compatible regular expressions
10172        A simple, complete demonstration program, to get you started with using
10173        PCRE, is supplied in the file pcredemo.c in the  PCRE  distribution.  A
10174        listing  of this program is given in the pcredemo documentation. If you
10175        do not have a copy of the PCRE distribution, you can save this  listing
10176        to re-create pcredemo.c.
10178        The  demonstration program, which uses the original PCRE 8-bit library,
10179        compiles the regular expression that is its first argument, and matches
10180        it  against  the subject string in its second argument. No PCRE options
10181        are set, and default character tables are used. If  matching  succeeds,
10182        the  program  outputs the portion of the subject that matched, together
10183        with the contents of any captured substrings.
10185        If the -g option is given on the command line, the program then goes on
10186        to check for further matches of the same regular expression in the same
10187        subject string. The logic is a little bit tricky because of the  possi-
10188        bility  of  matching an empty string. Comments in the code explain what
10189        is going on.
10191        If PCRE is installed in the standard include  and  library  directories
10192        for your operating system, you should be able to compile the demonstra-
10193        tion program using this command:
10195          gcc -o pcredemo pcredemo.c -lpcre
10197        If PCRE is installed elsewhere, you may need to add additional  options
10198        to  the  command line. For example, on a Unix-like system that has PCRE
10199        installed in /usr/local, you  can  compile  the  demonstration  program
10200        using a command like this:
10202          gcc -o pcredemo -I/usr/local/include pcredemo.c \
10203              -L/usr/local/lib -lpcre
10205        In  a  Windows  environment, if you want to statically link the program
10206        against a non-dll pcre.a file, you must uncomment the line that defines
10207        PCRE_STATIC  before  including  pcre.h, because otherwise the pcre_mal-
10208        loc()   and   pcre_free()   exported   functions   will   be   declared
10209        __declspec(dllimport), with unwanted results.
10211        Once  you  have  compiled and linked the demonstration program, you can
10212        run simple tests like this:
10214          ./pcredemo 'cat|dog' 'the cat sat on the mat'
10215          ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
10217        Note that there is a  much  more  comprehensive  test  program,  called
10218        pcretest,  which  supports  many  more  facilities  for testing regular
10219        expressions and both PCRE libraries. The pcredemo program  is  provided
10220        as a simple coding example.
10222        If  you  try to run pcredemo when PCRE is not installed in the standard
10223        library directory, you may get an error like  this  on  some  operating
10224        systems (e.g. Solaris):
10226          ld.so.1:  a.out:  fatal:  libpcre.so.0:  open failed: No such file or
10227        directory
10229        This is caused by the way shared library support works  on  those  sys-
10230        tems. You need to add
10232          -R/usr/local/lib
10234        (for example) to the compile command to get round this problem.
10237 AUTHOR
10239        Philip Hazel
10240        University Computing Service
10241        Cambridge CB2 3QH, England.
10246        Last updated: 10 January 2012
10247        Copyright (c) 1997-2012 University of Cambridge.
10248 ------------------------------------------------------------------------------
10249 PCRELIMITS(3)              Library Functions Manual              PCRELIMITS(3)
10253 NAME
10254        PCRE - Perl-compatible regular expressions
10258        There  are some size limitations in PCRE but it is hoped that they will
10259        never in practice be relevant.
10261        The maximum length of a compiled  pattern  is  approximately  64K  data
10262        units  (bytes  for  the  8-bit  library,  16-bit  units  for the 16-bit
10263        library, and 32-bit units for the 32-bit library) if PCRE  is  compiled
10264        with  the default internal linkage size, which is 2 bytes for the 8-bit
10265        and 16-bit libraries, and 4 bytes for the 32-bit library. If  you  want
10266        to process regular expressions that are truly enormous, you can compile
10267        PCRE with an internal linkage size of 3 or 4 (when building the  16-bit
10268        or  32-bit  library,  3 is rounded up to 4). See the README file in the
10269        source distribution and the pcrebuild  documentation  for  details.  In
10270        these  cases  the limit is substantially larger.  However, the speed of
10271        execution is slower.
10273        All values in repeating quantifiers must be less than 65536.
10275        There is no limit to the number of parenthesized subpatterns, but there
10276        can  be  no more than 65535 capturing subpatterns. There is, however, a
10277        limit to the depth of  nesting  of  parenthesized  subpatterns  of  all
10278        kinds.  This  is  imposed  in order to limit the amount of system stack
10279        used at compile time. The limit can be specified when  PCRE  is  built;
10280        the default is 250.
10282        There is a limit to the number of forward references to subsequent sub-
10283        patterns of around 200,000.  Repeated  forward  references  with  fixed
10284        upper  limits,  for example, (?2){0,100} when subpattern number 2 is to
10285        the right, are included in the count. There is no limit to  the  number
10286        of backward references.
10288        The maximum length of name for a named subpattern is 32 characters, and
10289        the maximum number of named subpatterns is 10000.
10291        The maximum length of a  name  in  a  (*MARK),  (*PRUNE),  (*SKIP),  or
10292        (*THEN)  verb is 255 for the 8-bit library and 65535 for the 16-bit and
10293        32-bit libraries.
10295        The maximum length of a subject string is the largest  positive  number
10296        that  an integer variable can hold. However, when using the traditional
10297        matching function, PCRE uses recursion to handle subpatterns and indef-
10298        inite  repetition.  This means that the available stack space may limit
10299        the size of a subject string that can be processed by certain patterns.
10300        For a discussion of stack issues, see the pcrestack documentation.
10303 AUTHOR
10305        Philip Hazel
10306        University Computing Service
10307        Cambridge CB2 3QH, England.
10312        Last updated: 05 November 2013
10313        Copyright (c) 1997-2013 University of Cambridge.
10314 ------------------------------------------------------------------------------
10317 PCRESTACK(3)               Library Functions Manual               PCRESTACK(3)
10321 NAME
10322        PCRE - Perl-compatible regular expressions
10326        When  you call pcre[16|32]_exec(), it makes use of an internal function
10327        called match(). This calls itself recursively at branch points  in  the
10328        pattern,  in  order  to  remember the state of the match so that it can
10329        back up and try a different alternative if  the  first  one  fails.  As
10330        matching proceeds deeper and deeper into the tree of possibilities, the
10331        recursion depth increases. The match() function is also called in other
10332        circumstances,  for  example,  whenever  a parenthesized sub-pattern is
10333        entered, and in certain cases of repetition.
10335        Not all calls of match() increase the recursion depth; for an item such
10336        as  a* it may be called several times at the same level, after matching
10337        different numbers of a's. Furthermore, in a number of cases  where  the
10338        result  of  the  recursive call would immediately be passed back as the
10339        result of the current call (a "tail recursion"), the function  is  just
10340        restarted instead.
10342        The  above  comments apply when pcre[16|32]_exec() is run in its normal
10343        interpretive  manner.   If   the   pattern   was   studied   with   the
10344        PCRE_STUDY_JIT_COMPILE  option, and just-in-time compiling was success-
10345        ful, and the options passed to pcre[16|32]_exec() were  not  incompati-
10346        ble,  the  matching  process  uses the JIT-compiled code instead of the
10347        match() function. In this case, the  memory  requirements  are  handled
10348        entirely differently. See the pcrejit documentation for details.
10350        The  pcre[16|32]_dfa_exec()  function operates in an entirely different
10351        way, and uses recursion only when there is a regular expression  recur-
10352        sion or subroutine call in the pattern. This includes the processing of
10353        assertion and "once-only" subpatterns, which are handled  like  subrou-
10354        tine  calls.  Normally, these are never very deep, and the limit on the
10355        complexity of pcre[16|32]_dfa_exec() is controlled  by  the  amount  of
10356        workspace  it is given.  However, it is possible to write patterns with
10357        runaway    infinite    recursions;    such    patterns    will    cause
10358        pcre[16|32]_dfa_exec()  to  run  out  of stack. At present, there is no
10359        protection against this.
10361        The comments that follow do NOT apply to  pcre[16|32]_dfa_exec();  they
10362        are relevant only for pcre[16|32]_exec() without the JIT optimization.
10364    Reducing pcre[16|32]_exec()'s stack usage
10366        Each  time  that match() is actually called recursively, it uses memory
10367        from the process stack. For certain kinds of  pattern  and  data,  very
10368        large  amounts of stack may be needed, despite the recognition of "tail
10369        recursion".  You can often reduce the amount of recursion,  and  there-
10370        fore  the  amount of stack used, by modifying the pattern that is being
10371        matched. Consider, for example, this pattern:
10373          ([^<]|<(?!inet))+
10375        It matches from wherever it starts until it encounters "<inet"  or  the
10376        end  of  the  data,  and is the kind of pattern that might be used when
10377        processing an XML file. Each iteration of the outer parentheses matches
10378        either  one  character that is not "<" or a "<" that is not followed by
10379        "inet". However, each time a  parenthesis  is  processed,  a  recursion
10380        occurs, so this formulation uses a stack frame for each matched charac-
10381        ter. For a long string, a lot of stack is required. Consider  now  this
10382        rewritten pattern, which matches exactly the same strings:
10384          ([^<]++|<(?!inet))+
10386        This  uses very much less stack, because runs of characters that do not
10387        contain "<" are "swallowed" in one item inside the parentheses.  Recur-
10388        sion  happens  only when a "<" character that is not followed by "inet"
10389        is encountered (and we assume this is relatively  rare).  A  possessive
10390        quantifier  is  used  to stop any backtracking into the runs of non-"<"
10391        characters, but that is not related to stack usage.
10393        This example shows that one way of avoiding stack problems when  match-
10394        ing long subject strings is to write repeated parenthesized subpatterns
10395        to match more than one character whenever possible.
10397    Compiling PCRE to use heap instead of stack for pcre[16|32]_exec()
10399        In environments where stack memory is constrained, you  might  want  to
10400        compile  PCRE to use heap memory instead of stack for remembering back-
10401        up points when pcre[16|32]_exec() is running. This makes it run  a  lot
10402        more slowly, however.  Details of how to do this are given in the pcre-
10403        build documentation. When built in  this  way,  instead  of  using  the
10404        stack,  PCRE obtains and frees memory by calling the functions that are
10405        pointed to by the pcre[16|32]_stack_malloc  and  pcre[16|32]_stack_free
10406        variables.  By default, these point to malloc() and free(), but you can
10407        replace the pointers to cause PCRE to use your own functions. Since the
10408        block sizes are always the same, and are always freed in reverse order,
10409        it may be possible to implement customized  memory  handlers  that  are
10410        more efficient than the standard functions.
10412    Limiting pcre[16|32]_exec()'s stack usage
10414        You  can set limits on the number of times that match() is called, both
10415        in total and recursively. If a limit  is  exceeded,  pcre[16|32]_exec()
10416        returns  an  error code. Setting suitable limits should prevent it from
10417        running out of stack. The default values of the limits are very  large,
10418        and  unlikely  ever to operate. They can be changed when PCRE is built,
10419        and they can also be set when pcre[16|32]_exec() is called. For details
10420        of these interfaces, see the pcrebuild documentation and the section on
10421        extra data for pcre[16|32]_exec() in the pcreapi documentation.
10423        As a very rough rule of thumb, you should reckon on about 500 bytes per
10424        recursion.  Thus,  if  you  want  to limit your stack usage to 8Mb, you
10425        should set the limit at 16000 recursions. A 64Mb stack,  on  the  other
10426        hand, can support around 128000 recursions.
10428        In Unix-like environments, the pcretest test program has a command line
10429        option (-S) that can be used to increase the size of its stack. As long
10430        as  the  stack is large enough, another option (-M) can be used to find
10431        the smallest limits that allow a particular pattern to  match  a  given
10432        subject  string.  This is done by calling pcre[16|32]_exec() repeatedly
10433        with different limits.
10435    Obtaining an estimate of stack usage
10437        The actual amount of stack used per recursion can  vary  quite  a  lot,
10438        depending on the compiler that was used to build PCRE and the optimiza-
10439        tion or debugging options that were set for it. The rule of thumb value
10440        of  500  bytes  mentioned  above  may be larger or smaller than what is
10441        actually needed. A better approximation can be obtained by running this
10442        command:
10444          pcretest -m -C
10446        The  -C  option causes pcretest to output information about the options
10447        with which PCRE was compiled. When -m is also given (before -C), infor-
10448        mation about stack use is given in a line like this:
10450          Match recursion uses stack: approximate frame size = 640 bytes
10452        The value is approximate because some recursions need a bit more (up to
10453        perhaps 16 more bytes).
10455        If the above command is given when PCRE is compiled  to  use  the  heap
10456        instead  of  the  stack  for recursion, the value that is output is the
10457        size of each block that is obtained from the heap.
10459    Changing stack size in Unix-like systems
10461        In Unix-like environments, there is not often a problem with the  stack
10462        unless  very  long  strings  are  involved, though the default limit on
10463        stack size varies from system to system. Values from 8Mb  to  64Mb  are
10464        common. You can find your default limit by running the command:
10466          ulimit -s
10468        Unfortunately,  the  effect  of  running out of stack is often SIGSEGV,
10469        though sometimes a more explicit error message is given. You  can  nor-
10470        mally increase the limit on stack size by code such as this:
10472          struct rlimit rlim;
10473          getrlimit(RLIMIT_STACK, &rlim);
10474          rlim.rlim_cur = 100*1024*1024;
10475          setrlimit(RLIMIT_STACK, &rlim);
10477        This  reads  the current limits (soft and hard) using getrlimit(), then
10478        attempts to increase the soft limit to  100Mb  using  setrlimit().  You
10479        must do this before calling pcre[16|32]_exec().
10481    Changing stack size in Mac OS X
10483        Using setrlimit(), as described above, should also work on Mac OS X. It
10484        is also possible to set a stack size when linking a program. There is a
10485        discussion   about   stack  sizes  in  Mac  OS  X  at  this  web  site:
10486        http://developer.apple.com/qa/qa2005/qa1419.html.
10489 AUTHOR
10491        Philip Hazel
10492        University Computing Service
10493        Cambridge CB2 3QH, England.
10498        Last updated: 24 June 2012
10499        Copyright (c) 1997-2012 University of Cambridge.
10500 ------------------------------------------------------------------------------