From 7fd9fe181150f166a098eaf4e006f878c28cb770 Mon Sep 17 00:00:00 2001 From: Gluzskiy Alexandr Date: Mon, 15 Feb 2010 05:51:01 +0300 Subject: sort --- Utilities/PCRE/bin/pcre.dll | Bin 0 -> 183313 bytes Utilities/PCRE/bin/pcreposix.dll | Bin 0 -> 175142 bytes Utilities/PCRE/include/pcre.h | 239 ++++ Utilities/PCRE/include/pcreposix.h | 117 ++ Utilities/PCRE/lib/libpcre-bcc.lib | Bin 0 -> 2560 bytes Utilities/PCRE/lib/libpcre.def | 26 + Utilities/PCRE/lib/libpcre.dll.a | Bin 0 -> 15942 bytes Utilities/PCRE/lib/libpcre.lib | Bin 0 -> 6514 bytes Utilities/PCRE/lib/libpcreposix-bcc.lib | Bin 0 -> 2048 bytes Utilities/PCRE/lib/libpcreposix.def | 16 + Utilities/PCRE/lib/libpcreposix.dll.a | Bin 0 -> 9690 bytes Utilities/PCRE/lib/libpcreposix.lib | Bin 0 -> 4386 bytes Utilities/PCRE/man/html/pcre.3.html | 174 +++ Utilities/PCRE/man/html/pcre_compile.3.html | 67 ++ Utilities/PCRE/man/html/pcre_config.3.html | 56 + .../PCRE/man/html/pcre_copy_named_substring.3.html | 48 + Utilities/PCRE/man/html/pcre_copy_substring.3.html | 47 + Utilities/PCRE/man/html/pcre_exec.3.html | 71 ++ Utilities/PCRE/man/html/pcre_free_substring.3.html | 37 + .../PCRE/man/html/pcre_free_substring_list.3.html | 37 + Utilities/PCRE/man/html/pcre_fullinfo.3.html | 67 ++ .../PCRE/man/html/pcre_get_named_substring.3.html | 48 + .../PCRE/man/html/pcre_get_stringnumber.3.html | 42 + Utilities/PCRE/man/html/pcre_get_substring.3.html | 47 + .../PCRE/man/html/pcre_get_substring_list.3.html | 47 + Utilities/PCRE/man/html/pcre_info.3.html | 35 + Utilities/PCRE/man/html/pcre_maketables.3.html | 39 + Utilities/PCRE/man/html/pcre_study.3.html | 49 + Utilities/PCRE/man/html/pcre_version.3.html | 36 + Utilities/PCRE/man/html/pcreapi.3.html | 1069 +++++++++++++++++ Utilities/PCRE/man/html/pcrebuild.3.html | 167 +++ Utilities/PCRE/man/html/pcrecallout.3.html | 148 +++ Utilities/PCRE/man/html/pcrecompat.3.html | 115 ++ Utilities/PCRE/man/html/pcregrep.1.html | 147 +++ Utilities/PCRE/man/html/pcrepattern.3.html | 1268 ++++++++++++++++++++ Utilities/PCRE/man/html/pcreperform.3.html | 86 ++ Utilities/PCRE/man/html/pcreposix.3.html | 187 +++ Utilities/PCRE/man/html/pcresample.3.html | 72 ++ Utilities/PCRE/man/html/pcretest.1.html | 433 +++++++ Utilities/PCRE/manifest/pcre-5.0-doc.mft | 58 + Utilities/PCRE/manifest/pcre-5.0-doc.ver | 2 + Utilities/PCRE/manifest/pcre-5.0-lib.mft | 12 + Utilities/PCRE/manifest/pcre-5.0-lib.ver | 2 + Utilities/PCRE/pcre_subst/pcre_subst.3 | 73 ++ Utilities/PCRE/pcre_subst/pcre_subst.c | 191 +++ Utilities/PCRE/pcre_subst/pcre_subst.h | 35 + 46 files changed, 5410 insertions(+) create mode 100644 Utilities/PCRE/bin/pcre.dll create mode 100644 Utilities/PCRE/bin/pcreposix.dll create mode 100644 Utilities/PCRE/include/pcre.h create mode 100644 Utilities/PCRE/include/pcreposix.h create mode 100644 Utilities/PCRE/lib/libpcre-bcc.lib create mode 100644 Utilities/PCRE/lib/libpcre.def create mode 100644 Utilities/PCRE/lib/libpcre.dll.a create mode 100644 Utilities/PCRE/lib/libpcre.lib create mode 100644 Utilities/PCRE/lib/libpcreposix-bcc.lib create mode 100644 Utilities/PCRE/lib/libpcreposix.def create mode 100644 Utilities/PCRE/lib/libpcreposix.dll.a create mode 100644 Utilities/PCRE/lib/libpcreposix.lib create mode 100644 Utilities/PCRE/man/html/pcre.3.html create mode 100644 Utilities/PCRE/man/html/pcre_compile.3.html create mode 100644 Utilities/PCRE/man/html/pcre_config.3.html create mode 100644 Utilities/PCRE/man/html/pcre_copy_named_substring.3.html create mode 100644 Utilities/PCRE/man/html/pcre_copy_substring.3.html create mode 100644 Utilities/PCRE/man/html/pcre_exec.3.html create mode 100644 Utilities/PCRE/man/html/pcre_free_substring.3.html create mode 100644 Utilities/PCRE/man/html/pcre_free_substring_list.3.html create mode 100644 Utilities/PCRE/man/html/pcre_fullinfo.3.html create mode 100644 Utilities/PCRE/man/html/pcre_get_named_substring.3.html create mode 100644 Utilities/PCRE/man/html/pcre_get_stringnumber.3.html create mode 100644 Utilities/PCRE/man/html/pcre_get_substring.3.html create mode 100644 Utilities/PCRE/man/html/pcre_get_substring_list.3.html create mode 100644 Utilities/PCRE/man/html/pcre_info.3.html create mode 100644 Utilities/PCRE/man/html/pcre_maketables.3.html create mode 100644 Utilities/PCRE/man/html/pcre_study.3.html create mode 100644 Utilities/PCRE/man/html/pcre_version.3.html create mode 100644 Utilities/PCRE/man/html/pcreapi.3.html create mode 100644 Utilities/PCRE/man/html/pcrebuild.3.html create mode 100644 Utilities/PCRE/man/html/pcrecallout.3.html create mode 100644 Utilities/PCRE/man/html/pcrecompat.3.html create mode 100644 Utilities/PCRE/man/html/pcregrep.1.html create mode 100644 Utilities/PCRE/man/html/pcrepattern.3.html create mode 100644 Utilities/PCRE/man/html/pcreperform.3.html create mode 100644 Utilities/PCRE/man/html/pcreposix.3.html create mode 100644 Utilities/PCRE/man/html/pcresample.3.html create mode 100644 Utilities/PCRE/man/html/pcretest.1.html create mode 100644 Utilities/PCRE/manifest/pcre-5.0-doc.mft create mode 100644 Utilities/PCRE/manifest/pcre-5.0-doc.ver create mode 100644 Utilities/PCRE/manifest/pcre-5.0-lib.mft create mode 100644 Utilities/PCRE/manifest/pcre-5.0-lib.ver create mode 100644 Utilities/PCRE/pcre_subst/pcre_subst.3 create mode 100644 Utilities/PCRE/pcre_subst/pcre_subst.c create mode 100644 Utilities/PCRE/pcre_subst/pcre_subst.h (limited to 'Utilities/PCRE') diff --git a/Utilities/PCRE/bin/pcre.dll b/Utilities/PCRE/bin/pcre.dll new file mode 100644 index 0000000..54f5ae7 Binary files /dev/null and b/Utilities/PCRE/bin/pcre.dll differ diff --git a/Utilities/PCRE/bin/pcreposix.dll b/Utilities/PCRE/bin/pcreposix.dll new file mode 100644 index 0000000..06881cf Binary files /dev/null and b/Utilities/PCRE/bin/pcreposix.dll differ diff --git a/Utilities/PCRE/include/pcre.h b/Utilities/PCRE/include/pcre.h new file mode 100644 index 0000000..aa37389 --- /dev/null +++ b/Utilities/PCRE/include/pcre.h @@ -0,0 +1,239 @@ +/************************************************* +* Perl-Compatible Regular Expressions * +*************************************************/ + +/* In its original form, this is the .in file that is transformed by +"configure" into pcre.h. + + Copyright (c) 1997-2004 University of Cambridge + +----------------------------------------------------------------------------- +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the University of Cambridge nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. +----------------------------------------------------------------------------- +*/ + +#ifndef _PCRE_H +#define _PCRE_H + +/* The file pcre.h is build by "configure". Do not edit it; instead +make changes to pcre.in. */ + +#define PCRE_MAJOR 5 +#define PCRE_MINOR 0 +#define PCRE_DATE 13-Sep-2004 + +/* Win32 uses DLL by default */ + +#ifdef _WIN32 +# ifdef PCRE_DEFINITION +# ifdef DLL_EXPORT +# define PCRE_DATA_SCOPE __declspec(dllexport) +# endif +# else +# ifndef PCRE_STATIC +# define PCRE_DATA_SCOPE extern __declspec(dllimport) +# endif +# endif +#endif +#ifndef PCRE_DATA_SCOPE +# define PCRE_DATA_SCOPE extern +#endif + +/* Have to include stdlib.h in order to ensure that size_t is defined; +it is needed here for malloc. */ + +#include + +/* Allow for C++ users */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Options */ + +#define PCRE_CASELESS 0x0001 +#define PCRE_MULTILINE 0x0002 +#define PCRE_DOTALL 0x0004 +#define PCRE_EXTENDED 0x0008 +#define PCRE_ANCHORED 0x0010 +#define PCRE_DOLLAR_ENDONLY 0x0020 +#define PCRE_EXTRA 0x0040 +#define PCRE_NOTBOL 0x0080 +#define PCRE_NOTEOL 0x0100 +#define PCRE_UNGREEDY 0x0200 +#define PCRE_NOTEMPTY 0x0400 +#define PCRE_UTF8 0x0800 +#define PCRE_NO_AUTO_CAPTURE 0x1000 +#define PCRE_NO_UTF8_CHECK 0x2000 +#define PCRE_AUTO_CALLOUT 0x4000 +#define PCRE_PARTIAL 0x8000 + +/* Exec-time and get/set-time error codes */ + +#define PCRE_ERROR_NOMATCH (-1) +#define PCRE_ERROR_NULL (-2) +#define PCRE_ERROR_BADOPTION (-3) +#define PCRE_ERROR_BADMAGIC (-4) +#define PCRE_ERROR_UNKNOWN_NODE (-5) +#define PCRE_ERROR_NOMEMORY (-6) +#define PCRE_ERROR_NOSUBSTRING (-7) +#define PCRE_ERROR_MATCHLIMIT (-8) +#define PCRE_ERROR_CALLOUT (-9) /* Never used by PCRE itself */ +#define PCRE_ERROR_BADUTF8 (-10) +#define PCRE_ERROR_BADUTF8_OFFSET (-11) +#define PCRE_ERROR_PARTIAL (-12) +#define PCRE_ERROR_BADPARTIAL (-13) +#define PCRE_ERROR_INTERNAL (-14) +#define PCRE_ERROR_BADCOUNT (-15) + +/* Request types for pcre_fullinfo() */ + +#define PCRE_INFO_OPTIONS 0 +#define PCRE_INFO_SIZE 1 +#define PCRE_INFO_CAPTURECOUNT 2 +#define PCRE_INFO_BACKREFMAX 3 +#define PCRE_INFO_FIRSTBYTE 4 +#define PCRE_INFO_FIRSTCHAR 4 /* For backwards compatibility */ +#define PCRE_INFO_FIRSTTABLE 5 +#define PCRE_INFO_LASTLITERAL 6 +#define PCRE_INFO_NAMEENTRYSIZE 7 +#define PCRE_INFO_NAMECOUNT 8 +#define PCRE_INFO_NAMETABLE 9 +#define PCRE_INFO_STUDYSIZE 10 +#define PCRE_INFO_DEFAULT_TABLES 11 + +/* Request types for pcre_config() */ + +#define PCRE_CONFIG_UTF8 0 +#define PCRE_CONFIG_NEWLINE 1 +#define PCRE_CONFIG_LINK_SIZE 2 +#define PCRE_CONFIG_POSIX_MALLOC_THRESHOLD 3 +#define PCRE_CONFIG_MATCH_LIMIT 4 +#define PCRE_CONFIG_STACKRECURSE 5 +#define PCRE_CONFIG_UNICODE_PROPERTIES 6 + +/* Bit flags for the pcre_extra structure */ + +#define PCRE_EXTRA_STUDY_DATA 0x0001 +#define PCRE_EXTRA_MATCH_LIMIT 0x0002 +#define PCRE_EXTRA_CALLOUT_DATA 0x0004 +#define PCRE_EXTRA_TABLES 0x0008 + +/* Types */ + +struct real_pcre; /* declaration; the definition is private */ +typedef struct real_pcre pcre; + +/* The structure for passing additional data to pcre_exec(). This is defined in +such as way as to be extensible. Always add new fields at the end, in order to +remain compatible. */ + +typedef struct pcre_extra { + unsigned long int flags; /* Bits for which fields are set */ + void *study_data; /* Opaque data from pcre_study() */ + unsigned long int match_limit; /* Maximum number of calls to match() */ + void *callout_data; /* Data passed back in callouts */ + const unsigned char *tables; /* Pointer to character tables */ +} pcre_extra; + +/* The structure for passing out data via the pcre_callout_function. We use a +structure so that new fields can be added on the end in future versions, +without changing the API of the function, thereby allowing old clients to work +without modification. */ + +typedef struct pcre_callout_block { + int version; /* Identifies version of block */ + /* ------------------------ Version 0 ------------------------------- */ + int callout_number; /* Number compiled into pattern */ + int *offset_vector; /* The offset vector */ + const char *subject; /* The subject being matched */ + int subject_length; /* The length of the subject */ + int start_match; /* Offset to start of this match attempt */ + int current_position; /* Where we currently are in the subject */ + int capture_top; /* Max current capture */ + int capture_last; /* Most recently closed capture */ + void *callout_data; /* Data passed in with the call */ + /* ------------------- Added for Version 1 -------------------------- */ + int pattern_position; /* Offset to next item in the pattern */ + int next_item_length; /* Length of next item in the pattern */ + /* ------------------------------------------------------------------ */ +} pcre_callout_block; + +/* Indirection for store get and free functions. These can be set to +alternative malloc/free functions if required. Special ones are used in the +non-recursive case for "frames". There is also an optional callout function +that is triggered by the (?) regex item. Some magic is required for Win32 DLL; +it is null on other OS. For Virtual Pascal, these have to be different again. +*/ + +#ifndef VPCOMPAT +PCRE_DATA_SCOPE void *(*pcre_malloc)(size_t); +PCRE_DATA_SCOPE void (*pcre_free)(void *); +PCRE_DATA_SCOPE void *(*pcre_stack_malloc)(size_t); +PCRE_DATA_SCOPE void (*pcre_stack_free)(void *); +PCRE_DATA_SCOPE int (*pcre_callout)(pcre_callout_block *); +#else /* VPCOMPAT */ +extern void *pcre_malloc(size_t); +extern void pcre_free(void *); +extern void *pcre_stack_malloc(size_t); +extern void pcre_stack_free(void *); +extern int pcre_callout(pcre_callout_block *); +#endif /* VPCOMPAT */ + +/* Exported PCRE functions */ + +extern pcre *pcre_compile(const char *, int, const char **, + int *, const unsigned char *); +extern int pcre_config(int, void *); +extern int pcre_copy_named_substring(const pcre *, const char *, + int *, int, const char *, char *, int); +extern int pcre_copy_substring(const char *, int *, int, int, + char *, int); +extern int pcre_exec(const pcre *, const pcre_extra *, + const char *, int, int, int, int *, int); +extern void pcre_free_substring(const char *); +extern void pcre_free_substring_list(const char **); +extern int pcre_fullinfo(const pcre *, const pcre_extra *, int, + void *); +extern int pcre_get_named_substring(const pcre *, const char *, + int *, int, const char *, const char **); +extern int pcre_get_stringnumber(const pcre *, const char *); +extern int pcre_get_substring(const char *, int *, int, int, + const char **); +extern int pcre_get_substring_list(const char *, int *, int, + const char ***); +extern int pcre_info(const pcre *, int *, int *); +extern const unsigned char *pcre_maketables(void); +extern pcre_extra *pcre_study(const pcre *, int, const char **); +extern const char *pcre_version(void); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* End of pcre.h */ diff --git a/Utilities/PCRE/include/pcreposix.h b/Utilities/PCRE/include/pcreposix.h new file mode 100644 index 0000000..a8056bd --- /dev/null +++ b/Utilities/PCRE/include/pcreposix.h @@ -0,0 +1,117 @@ +/************************************************* +* Perl-Compatible Regular Expressions * +*************************************************/ + +#ifndef _PCREPOSIX_H +#define _PCREPOSIX_H + +/* This is the header for the POSIX wrapper interface to the PCRE Perl- +Compatible Regular Expression library. It defines the things POSIX says should +be there. I hope. + + Copyright (c) 1997-2004 University of Cambridge + +----------------------------------------------------------------------------- +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the University of Cambridge nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. +----------------------------------------------------------------------------- +*/ + +/* Have to include stdlib.h in order to ensure that size_t is defined. */ + +#include + +/* Allow for C++ users */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Options defined by POSIX. */ + +#define REG_ICASE 0x01 +#define REG_NEWLINE 0x02 +#define REG_NOTBOL 0x04 +#define REG_NOTEOL 0x08 + +/* These are not used by PCRE, but by defining them we make it easier +to slot PCRE into existing programs that make POSIX calls. */ + +#define REG_EXTENDED 0 +#define REG_NOSUB 0 + +/* Error values. Not all these are relevant or used by the wrapper. */ + +enum { + REG_ASSERT = 1, /* internal error ? */ + REG_BADBR, /* invalid repeat counts in {} */ + REG_BADPAT, /* pattern error */ + REG_BADRPT, /* ? * + invalid */ + REG_EBRACE, /* unbalanced {} */ + REG_EBRACK, /* unbalanced [] */ + REG_ECOLLATE, /* collation error - not relevant */ + REG_ECTYPE, /* bad class */ + REG_EESCAPE, /* bad escape sequence */ + REG_EMPTY, /* empty expression */ + REG_EPAREN, /* unbalanced () */ + REG_ERANGE, /* bad range inside [] */ + REG_ESIZE, /* expression too big */ + REG_ESPACE, /* failed to get memory */ + REG_ESUBREG, /* bad back reference */ + REG_INVARG, /* bad argument */ + REG_NOMATCH /* match failed */ +}; + + +/* The structure representing a compiled regular expression. */ + +typedef struct { + void *re_pcre; + size_t re_nsub; + size_t re_erroffset; +} regex_t; + +/* The structure in which a captured offset is returned. */ + +typedef int regoff_t; + +typedef struct { + regoff_t rm_so; + regoff_t rm_eo; +} regmatch_t; + +/* The functions */ + +extern int regcomp(regex_t *, const char *, int); +extern int regexec(const regex_t *, const char *, size_t, regmatch_t *, int); +extern size_t regerror(int, const regex_t *, char *, size_t); +extern void regfree(regex_t *); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* End of pcreposix.h */ diff --git a/Utilities/PCRE/lib/libpcre-bcc.lib b/Utilities/PCRE/lib/libpcre-bcc.lib new file mode 100644 index 0000000..706c7af Binary files /dev/null and b/Utilities/PCRE/lib/libpcre-bcc.lib differ diff --git a/Utilities/PCRE/lib/libpcre.def b/Utilities/PCRE/lib/libpcre.def new file mode 100644 index 0000000..a7bdcbf --- /dev/null +++ b/Utilities/PCRE/lib/libpcre.def @@ -0,0 +1,26 @@ +EXPORTS + pcre_callout @1 DATA + pcre_compile @2 + pcre_config @3 + pcre_copy_named_substring @4 + pcre_copy_substring @5 + pcre_exec @6 + pcre_free @7 DATA + pcre_free_substring @8 + pcre_free_substring_list @9 + pcre_fullinfo @10 + pcre_get_named_substring @11 + pcre_get_stringnumber @12 + pcre_get_substring @13 + pcre_get_substring_list @14 + pcre_info @15 + pcre_maketables @16 + pcre_malloc @17 DATA + pcre_stack_free @18 DATA + pcre_stack_malloc @19 DATA + pcre_study @20 + pcre_version @21 + regcomp @22 + regerror @23 + regexec @24 + regfree @25 diff --git a/Utilities/PCRE/lib/libpcre.dll.a b/Utilities/PCRE/lib/libpcre.dll.a new file mode 100644 index 0000000..2191488 Binary files /dev/null and b/Utilities/PCRE/lib/libpcre.dll.a differ diff --git a/Utilities/PCRE/lib/libpcre.lib b/Utilities/PCRE/lib/libpcre.lib new file mode 100644 index 0000000..71c1835 Binary files /dev/null and b/Utilities/PCRE/lib/libpcre.lib differ diff --git a/Utilities/PCRE/lib/libpcreposix-bcc.lib b/Utilities/PCRE/lib/libpcreposix-bcc.lib new file mode 100644 index 0000000..b532b5b Binary files /dev/null and b/Utilities/PCRE/lib/libpcreposix-bcc.lib differ diff --git a/Utilities/PCRE/lib/libpcreposix.def b/Utilities/PCRE/lib/libpcreposix.def new file mode 100644 index 0000000..8dca4c8 --- /dev/null +++ b/Utilities/PCRE/lib/libpcreposix.def @@ -0,0 +1,16 @@ +EXPORTS + pcre_callout @1 DATA + pcre_compile @2 + pcre_config @3 + pcre_exec @4 + pcre_free @5 DATA + pcre_fullinfo @6 + pcre_info @7 + pcre_malloc @8 DATA + pcre_stack_free @9 DATA + pcre_stack_malloc @10 DATA + pcre_version @11 + regcomp @12 + regerror @13 + regexec @14 + regfree @15 diff --git a/Utilities/PCRE/lib/libpcreposix.dll.a b/Utilities/PCRE/lib/libpcreposix.dll.a new file mode 100644 index 0000000..1208b41 Binary files /dev/null and b/Utilities/PCRE/lib/libpcreposix.dll.a differ diff --git a/Utilities/PCRE/lib/libpcreposix.lib b/Utilities/PCRE/lib/libpcreposix.lib new file mode 100644 index 0000000..a4bfe43 Binary files /dev/null and b/Utilities/PCRE/lib/libpcreposix.lib differ diff --git a/Utilities/PCRE/man/html/pcre.3.html b/Utilities/PCRE/man/html/pcre.3.html new file mode 100644 index 0000000..93f32fa --- /dev/null +++ b/Utilities/PCRE/man/html/pcre.3.html @@ -0,0 +1,174 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Introduction

+

+The PCRE library +is a set of functions that implement regular expression pattern matching +using the same syntax and semantics as Perl, with just a few differences. +The current implementation of PCRE (release 5.x) corresponds approximately +with Perl 5.8, including support for UTF-8 encoded strings and Unicode general +category properties. However, this support has to be explicitly enabled; +it is not the default.

+PCRE is written in C and released as a C library. +A number of people have written wrappers and interfaces of various kinds. +A C++ class is included in these contributions, which can be found in the +Contrib directory at the primary FTP site, which is:

+ ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre +

+Details of exactly which Perl regular expression features are and are not +supported by PCRE are given in separate documents. See the pcrepattern + and pcrecompat pages.

+Some features of PCRE can be included, excluded, +or changed when the library is built. The pcre_config() function makes +it possible for a client to discover which features are available. The features +themselves are described in the pcrebuild page. Documentation about building +PCRE for various operating systems can be found in the README file in the +source distribution. +

User Documentation

+

+The user documentation for PCRE +comprises a number of different sections. In the "man" format, each of these +is a separate "man page". In the HTML format, each is a separate page, linked +from the index page. In the plain text format, all the sections are concatenated, +for ease of searching. The sections are as follows:

+ pcre +this document
+ pcreapi details of PCRE’s native API
+ pcrebuild options for building PCRE
+ pcrecallout details of the callout feature
+ pcrecompat discussion of Perl compatibility
+ pcregrep description of the pcregrep command
+ pcrepartial details of the partial matching facility
+ pcrepattern syntax and semantics of supported
+ regular expressions
+ pcreperform discussion of performance issues
+ pcreposix the POSIX-compatible API
+ pcreprecompile details of saving and re-using precompiled patterns
+ pcresample discussion of the sample program
+ pcretest description of the pcretest testing command
+

+In addition, in the "man" and HTML formats, there is a short page for +each library function, listing its arguments and results. +

Limitations

+ +

+There are some size limitations in PCRE but it is hoped that they will +never in practice be relevant.

+The maximum length of a compiled pattern +is 65539 (sic) bytes if PCRE is compiled with the default internal linkage +size of 2. If you want to process regular expressions that are truly enormous, +you can compile PCRE with an internal linkage size of 3 or 4 (see the README +file in the source distribution and the pcrebuild documentation for details). +In these cases the limit is substantially larger. However, the speed of +execution will be slower.

+All values in repeating quantifiers must be less +than 65536. The maximum number of capturing subpatterns is 65535.

+There is +no limit to the number of non-capturing subpatterns, but the maximum depth +of nesting of all kinds of parenthesized subpattern, including capturing +subpatterns, assertions, and other types of subpattern, is 200.

+The maximum +length of a subject string is the largest positive number that an integer +variable can hold. However, PCRE uses recursion to handle subpatterns and +indefinite repetition. This means that the available stack space may limit +the size of a subject string that can be processed by certain patterns. +

+ +

Utf-8 and Unicode Property Support

+

+From release 3.3, PCRE has had some +support for character strings encoded in the UTF-8 format. For release 4.0 +this was greatly extended to cover most common requirements, and in release +5.0 additional support for Unicode general category properties was added. +

+In order process UTF-8 strings, you must build PCRE to include UTF-8 support +in the code, and, in addition, you must call pcre_compile() with the +PCRE_UTF8 option flag. When you do this, both the pattern and any subject +strings that are matched against it are treated as UTF-8 strings instead +of just strings of bytes.

+If you compile PCRE with UTF-8 support, but do +not use it at run time, the library will be a bit bigger, but the additional +run time overhead is limited to testing the PCRE_UTF8 flag in several places, +so should not be very large.

+If PCRE is built with Unicode character property +support (which implies UTF-8 support), the escape sequences \p{..}, \P{..}, and +\X are supported. The available properties that can be tested are limited +to the general category properties such as Lu for an upper case letter +or Nd for a decimal number. A full list is given in the pcrepattern documentation. +The PCRE library is increased in size by about 90K when Unicode property +support is included.

+The following comments apply when PCRE is running in +UTF-8 mode:

+1. When you set the PCRE_UTF8 flag, the strings passed as patterns +and subjects are checked for validity on entry to the relevant functions. +If an invalid UTF-8 string is passed, an error return is given. In some situations, +you may already know that your strings are valid, and therefore want to +skip these checks in order to improve performance. If you set the PCRE_NO_UTF8_CHECK +flag at compile time or at run time, PCRE assumes that the pattern or subject +it is given (respectively) contains only valid UTF-8 codes. In this case, +it does not diagnose an invalid UTF-8 string. If you pass an invalid UTF-8 +string to PCRE when PCRE_NO_UTF8_CHECK is set, the results are undefined. +Your program may crash.

+2. In a pattern, the escape sequence \x{...}, where the +contents of the braces is a string of hexadecimal digits, is interpreted +as a UTF-8 character whose code number is the given hexadecimal number, +for example: \x{1234}. If a non-hexadecimal digit appears between the braces, +the item is not recognized. This escape sequence can be used either as a +literal, or within a character class.

+3. The original hexadecimal escape +sequence, \xhh, matches a two-byte UTF-8 character if the value is greater +than 127.

+4. Repeat quantifiers apply to complete UTF-8 characters, not to +individual bytes, for example: \x{100}{3}.

+5. The dot metacharacter matches +one UTF-8 character instead of a single byte.

+6. The escape sequence \C can +be used to match a single byte in UTF-8 mode, but its use can lead to some +strange effects.

+7. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly +test characters of any code value, but the characters that PCRE recognizes +as digits, spaces, or word characters remain the same set as before, all +with values less than 256. This remains true even when PCRE includes Unicode +property support, because to do otherwise would slow down PCRE in many +common cases. If you really want to test for a wider sense of, say, "digit", +you must use Unicode property tests such as \p{Nd}.

+8. Similarly, characters +that match the POSIX named character classes are all low-valued characters. +

+9. Case-insensitive matching applies only to characters whose values are +less than 128, unless PCRE is built with Unicode property support. Even +when Unicode property support is available, PCRE still uses its own character +tables when checking the case of low-valued characters, so as not to degrade +performance. The Unicode property information is used only for characters +with higher values. +

Author

+

+Philip Hazel <ph10@cam.ac.uk>
+University Computing Service,
+Cambridge CB2 3QG, England.
+Phone: +44 1223 334714

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_compile.3.html b/Utilities/PCRE/man/html/pcre_compile.3.html new file mode 100644 index 0000000..bd9272c --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_compile.3.html @@ -0,0 +1,67 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+pcre *pcre_compile(const char *pattern, int options, const char **errptr, +int *erroffset, const unsigned char *tableptr); +

Description

+

+This function +compiles a regular expression into an internal form. Its arguments are: +

+ pattern A zero-terminated string containing the
+ regular expression to be compiled
+ options Zero or more option bits
+ errptr Where to put an error message
+ erroffset Offset in pattern where error was found
+ tableptr Pointer to character tables, or NULL to
+ use the built-in default
+

+The option bits are:

+ PCRE_ANCHORED Force pattern anchoring
+ PCRE_AUTO_CALLOUT Compile automatic callouts
+ PCRE_CASELESS Do caseless matching
+ PCRE_DOLLAR_ENDONLY $ not to match newline at end
+ PCRE_DOTALL . matches anything including NL
+ PCRE_EXTENDED Ignore whitespace and # comments
+ PCRE_EXTRA PCRE extra features
+ (not much use currently)
+ PCRE_MULTILINE ^ and $ match newlines within data
+ PCRE_NO_AUTO_CAPTURE Disable numbered capturing paren-
+ theses (named ones available)
+ PCRE_UNGREEDY Invert greediness of quantifiers
+ PCRE_UTF8 Run in UTF-8 mode
+ PCRE_NO_UTF8_CHECK Do not check the pattern for UTF-8
+ validity (only relevant if
+ PCRE_UTF8 is set)
+

+PCRE must be built with UTF-8 support in order to use PCRE_UTF8 and PCRE_NO_UTF8_CHECK. +

+The yield of the function is a pointer to a private data structure that +contains the compiled pattern, or NULL if an error was detected.

+There is +a complete description of the PCRE native API in the pcreapi page and +a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_config.3.html b/Utilities/PCRE/man/html/pcre_config.3.html new file mode 100644 index 0000000..edf2450 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_config.3.html @@ -0,0 +1,56 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_config(int what, void *where); +

Description

+

+This function makes +it possible for a client program to find out which optional features are +available in the version of the PCRE library it is using. Its arguments +are as follows:

+ what A code specifying what information is required
+ where Points to where to put the data
+

+The available codes are:

+ PCRE_CONFIG_LINK_SIZE Internal link size: +2, 3, or 4
+ PCRE_CONFIG_MATCH_LIMIT Internal resource limit
+ PCRE_CONFIG_NEWLINE Value of the newline character
+ PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
+ Threshold of return slots, above
+ which malloc() is used by
+ the POSIX API
+ PCRE_CONFIG_STACKRECURSE Recursion implementation (1=stack 0=heap)
+ PCRE_CONFIG_UTF8 Availability of UTF-8 support (1=yes 0=no)
+ PCRE_CONFIG_UNICODE_PROPERTIES
+ Availability of Unicode property support
+ (1=yes 0=no)
+

+The function yields 0 on success or PCRE_ERROR_BADOPTION otherwise.

+There +is a complete description of the PCRE native API in the pcreapi page +and a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_copy_named_substring.3.html b/Utilities/PCRE/man/html/pcre_copy_named_substring.3.html new file mode 100644 index 0000000..09c341f --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_copy_named_substring.3.html @@ -0,0 +1,48 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_copy_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, char *buffer, int +buffersize); +

Description

+

+This is a convenience function for extracting +a captured substring, identified by name, into a given buffer. The arguments +are:

+ code Pattern that was successfully matched
+ subject Subject that has been successfully matched
+ ovector Offset vector that pcre_exec() used
+ stringcount Value returned by pcre_exec()
+ stringname Name of the required substring
+ buffer Buffer to receive the string
+ buffersize Size of buffer
+

+The yield is the length of the substring, PCRE_ERROR_NOMEMORY if the buffer +was too small, or PCRE_ERROR_NOSUBSTRING if the string name is invalid. +

+There is a complete description of the PCRE native API in the pcreapi + page and a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_copy_substring.3.html b/Utilities/PCRE/man/html/pcre_copy_substring.3.html new file mode 100644 index 0000000..c706691 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_copy_substring.3.html @@ -0,0 +1,47 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_copy_substring(const char *subject, int *ovector, int stringcount, +int stringnumber, char *buffer, int buffersize); +

Description

+

+This is +a convenience function for extracting a captured substring into a given +buffer. The arguments are:

+ subject Subject that has been successfully +matched
+ ovector Offset vector that pcre_exec() used
+ stringcount Value returned by pcre_exec()
+ stringnumber Number of the required substring
+ buffer Buffer to receive the string
+ buffersize Size of buffer
+

+The yield is the legnth of the string, PCRE_ERROR_NOMEMORY if the buffer +was too small, or PCRE_ERROR_NOSUBSTRING if the string number is invalid. +

+There is a complete description of the PCRE native API in the pcreapi + page and a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_exec.3.html b/Utilities/PCRE/man/html/pcre_exec.3.html new file mode 100644 index 0000000..c985429 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_exec.3.html @@ -0,0 +1,71 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_exec(const pcre *code, "const pcre_extra *extra," const char +*subject, int length, int startoffset, int options, int *ovector, int +ovecsize); +

Description

+

+This function matches a compiled regular expression +against a given subject string, and returns offsets to capturing subexpressions. +Its arguments are:

+ code Points to the compiled pattern
+ extra Points to an associated pcre_extra structure,
+ or is NULL
+ subject Points to the subject string
+ length Length of the subject string, in bytes
+ startoffset Offset in bytes in the subject at which to
+ start matching
+ options Option bits
+ ovector Points to a vector of ints for result offsets
+ ovecsize Number of elements in the vector (a multiple of 3)
+

+The options are:

+ PCRE_ANCHORED Match only at the first position
+ PCRE_NOTBOL Subject is not the beginning of a line
+ PCRE_NOTEOL Subject is not the end of a line
+ PCRE_NOTEMPTY An empty string is not a valid match
+ PCRE_NO_UTF8_CHECK Do not check the subject for UTF-8
+ validity (only relevant if PCRE_UTF8
+ was set at compile time)
+ PCRE_PARTIAL Return PCRE_ERROR_PARTIAL for a partial match
+

+There are restrictions on what may appear in a pattern when partial matching +is requested.

+A pcre_extra structure contains the following fields:

+ flags + Bits indicating which fields are set
+ study_data Opaque data from pcre_study()
+ match_limit Limit on internal recursion
+ callout_data Opaque data passed back to callouts
+ tables Points to character tables or is NULL
+

+The flag bits are PCRE_EXTRA_STUDY_DATA, PCRE_EXTRA_MATCH_LIMIT, PCRE_EXTRA_CALLOUT_DATA, +and PCRE_EXTRA_TABLES.

+There is a complete description of the PCRE native +API in the pcreapi page and a description of the POSIX API in the pcreposix + page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_free_substring.3.html b/Utilities/PCRE/man/html/pcre_free_substring.3.html new file mode 100644 index 0000000..60a97b6 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_free_substring.3.html @@ -0,0 +1,37 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+void pcre_free_substring(const char *stringptr); +

Description

+

+This is a +convenience function for freeing the store obtained by a previous call +to pcre_get_substring() or pcre_get_named_substring(). Its only argument +is a pointer to the string.

+There is a complete description of the PCRE +native API in the pcreapi page and a description of the POSIX API in +the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_free_substring_list.3.html b/Utilities/PCRE/man/html/pcre_free_substring_list.3.html new file mode 100644 index 0000000..a66f3cc --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_free_substring_list.3.html @@ -0,0 +1,37 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+void pcre_free_substring_list(const char **stringptr); +

Description

+

+This +is a convenience function for freeing the store obtained by a previous +call to pcre_get_substring_list(). Its only argument is a pointer to the +list of string pointers.

+There is a complete description of the PCRE native +API in the pcreapi page and a description of the POSIX API in the pcreposix + page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_fullinfo.3.html b/Utilities/PCRE/man/html/pcre_fullinfo.3.html new file mode 100644 index 0000000..30392fc --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_fullinfo.3.html @@ -0,0 +1,67 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_fullinfo(const pcre *code, "const pcre_extra *extra," int what, +void *where); +

Description

+

+This function returns information about a compiled +pattern. Its arguments are:

+ code Compiled regular +expression
+ extra Result of pcre_study() or NULL
+ what What information is required
+ where Where to put the information
+

+The following information is available:

+ PCRE_INFO_BACKREFMAX Number +of highest back reference
+ PCRE_INFO_CAPTURECOUNT Number of capturing subpatterns
+ PCRE_INFO_DEFAULT_TABLES Pointer to default tables
+ PCRE_INFO_FIRSTBYTE Fixed first byte for a match, or
+ -1 for start of string
+ or after newline, or
+ -2 otherwise
+ PCRE_INFO_FIRSTTABLE Table of first bytes
+ (after studying)
+ PCRE_INFO_LASTLITERAL Literal last byte required
+ PCRE_INFO_NAMECOUNT Number of named subpatterns
+ PCRE_INFO_NAMEENTRYSIZE Size of name table entry
+ PCRE_INFO_NAMETABLE Pointer to name table
+ PCRE_INFO_OPTIONS Options used for compilation
+ PCRE_INFO_SIZE Size of compiled pattern
+ PCRE_INFO_STUDYSIZE Size of study data
+

+The yield of the function is zero on success or:

+ PCRE_ERROR_NULL + the argument code was NULL
+ the argument where was NULL
+ PCRE_ERROR_BADMAGIC the "magic number" was not found
+ PCRE_ERROR_BADOPTION the value of what was invalid
+

+There is a complete description of the PCRE native API in the pcreapi + page and a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_get_named_substring.3.html b/Utilities/PCRE/man/html/pcre_get_named_substring.3.html new file mode 100644 index 0000000..14f1c49 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_get_named_substring.3.html @@ -0,0 +1,48 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_get_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, const char **stringptr); + +

Description

+

+This is a convenience function for extracting a captured substring +by name. The arguments are:

+ code Compiled pattern
+ subject Subject that has been successfully matched
+ ovector Offset vector that pcre_exec() used
+ stringcount Value returned by pcre_exec()
+ stringname Name of the required substring
+ stringptr Where to put the string pointer
+

+The memory in which the substring is placed is obtained by calling pcre_malloc(). +The yield of the function is the length of the extracted substring, PCRE_ERROR_NOMEMORY +if sufficient memory could not be obtained, or PCRE_ERROR_NOSUBSTRING if +the string name is invalid.

+There is a complete description of the PCRE +native API in the pcreapi page and a description of the POSIX API in +the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_get_stringnumber.3.html b/Utilities/PCRE/man/html/pcre_get_stringnumber.3.html new file mode 100644 index 0000000..1ca280c --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_get_stringnumber.3.html @@ -0,0 +1,42 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_get_stringnumber(const pcre *code, const char *name); +

Description

+ +

+This convenience function finds the number of a named substring capturing +parenthesis in a compiled pattern. Its arguments are:

+ code Compiled +regular expression
+ name Name whose number is required
+

+The yield of the function is the number of the parenthesis if the name +is found, or PCRE_ERROR_NOSUBSTRING otherwise.

+There is a complete description +of the PCRE native API in the pcreapi page and a description of the POSIX +API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_get_substring.3.html b/Utilities/PCRE/man/html/pcre_get_substring.3.html new file mode 100644 index 0000000..566a393 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_get_substring.3.html @@ -0,0 +1,47 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_get_substring(const char *subject, int *ovector, int stringcount, +int stringnumber, const char **stringptr); +

Description

+

+This is a convenience +function for extracting a captured substring. The arguments are:

+ subject + Subject that has been successfully matched
+ ovector Offset vector that pcre_exec() used
+ stringcount Value returned by pcre_exec()
+ stringnumber Number of the required substring
+ stringptr Where to put the string pointer
+

+The memory in which the substring is placed is obtained by calling pcre_malloc(). +The yield of the function is the length of the substring, PCRE_ERROR_NOMEMORY +if sufficient memory could not be obtained, or PCRE_ERROR_NOSUBSTRING if +the string number is invalid.

+There is a complete description of the PCRE +native API in the pcreapi page and a description of the POSIX API in +the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_get_substring_list.3.html b/Utilities/PCRE/man/html/pcre_get_substring_list.3.html new file mode 100644 index 0000000..f4e5931 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_get_substring_list.3.html @@ -0,0 +1,47 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_get_substring_list(const char *subject, int *ovector, int stringcount, +"const char ***listptr);" +

Description

+

+This is a convenience function for +extracting a list of all the captured substrings. The arguments are:

+ subject + Subject that has been successfully matched
+ ovector Offset vector that pcre_exec used
+ stringcount Value returned by pcre_exec
+ listptr Where to put a pointer to the list
+

+The memory in which the substrings and the list are placed is obtained +by calling pcre_malloc(). A pointer to a list of pointers is put in the +variable whose address is in listptr. The list is terminated by a NULL pointer. +The yield of the function is zero on success or PCRE_ERROR_NOMEMORY if +sufficient memory could not be obtained.

+There is a complete description +of the PCRE native API in the pcreapi page and a description of the POSIX +API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_info.3.html b/Utilities/PCRE/man/html/pcre_info.3.html new file mode 100644 index 0000000..caf66db --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_info.3.html @@ -0,0 +1,35 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+int pcre_info(const pcre *code, int *optptr, int *firstcharptr); +

Description

+ +

+This function is obsolete. You should be using pcre_fullinfo() instead.

+There +is a complete description of the PCRE native API in the pcreapi page +and a description of the POSIX API in the pcreposix page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_maketables.3.html b/Utilities/PCRE/man/html/pcre_maketables.3.html new file mode 100644 index 0000000..7a73848 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_maketables.3.html @@ -0,0 +1,39 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+const unsigned char *pcre_maketables(void); +

Description

+

+This function +builds a set of character tables for character values less than 256. These +can be passed to pcre_compile() to override PCRE’s internal, built-in tables +(which were made by pcre_maketables() when PCRE was compiled). You might +want to do this if you are using a non-standard locale. The function yields +a pointer to the tables.

+There is a complete description of the PCRE native +API in the pcreapi page and a description of the POSIX API in the pcreposix + page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_study.3.html b/Utilities/PCRE/man/html/pcre_study.3.html new file mode 100644 index 0000000..20a7a67 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_study.3.html @@ -0,0 +1,49 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+pcre_extra *pcre_study(const pcre *code, int options, const char **errptr); + +

Description

+

+This function studies a compiled pattern, to see if additional +information can be extracted that might speed up matching. Its arguments +are:

+ code A compiled regular expression
+ options Options for pcre_study()
+ errptr Where to put an error message
+

+If the function succeeds, it returns a value that can be passed to pcre_exec() +via its extra argument.

+If the function returns NULL, either it could not +find any additional information, or there was an error. You can tell the +difference by looking at the error value. It is NULL in first case.

+There +are currently no options defined; the value of the second argument should +always be zero.

+There is a complete description of the PCRE native API in +the pcreapi page and a description of the POSIX API in the pcreposix + page.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcre_version.3.html b/Utilities/PCRE/man/html/pcre_version.3.html new file mode 100644 index 0000000..fe50a95 --- /dev/null +++ b/Utilities/PCRE/man/html/pcre_version.3.html @@ -0,0 +1,36 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Synopsis

+

+#include <pcre.h>

+ +
+char *pcre_version(void); +

Description

+

+This function returns a character +string that gives the version number of the PCRE library and the date of +its release.

+There is a complete description of the PCRE native API in the + pcreapi page and a description of the POSIX API in the pcreposix page. +

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcreapi.3.html b/Utilities/PCRE/man/html/pcreapi.3.html new file mode 100644 index 0000000..a083204 --- /dev/null +++ b/Utilities/PCRE/man/html/pcreapi.3.html @@ -0,0 +1,1069 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Native API

+

+#include <pcre.h> +

+ +
+pcre *pcre_compile(const char *pattern, int options, const char **errptr, +int *erroffset, const unsigned char *tableptr);

+
+pcre_extra *pcre_study(const pcre *code, int options, const char **errptr); +

+
+int pcre_exec(const pcre *code, "const pcre_extra *extra," const char +*subject, int length, int startoffset, int options, int *ovector, int +ovecsize);

+
+int pcre_copy_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, char *buffer, int +buffersize);

+
+int pcre_copy_substring(const char *subject, int *ovector, int stringcount, +int stringnumber, char *buffer, int buffersize);

+
+int pcre_get_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, const char **stringptr); +

+
+int pcre_get_stringnumber(const pcre *code, const char *name);

+
+int pcre_get_substring(const char *subject, int *ovector, int stringcount, +int stringnumber, const char **stringptr);

+
+int pcre_get_substring_list(const char *subject, int *ovector, int stringcount, +"const char ***listptr);"

+
+void pcre_free_substring(const char *stringptr);

+
+void pcre_free_substring_list(const char **stringptr);

+
+const unsigned char *pcre_maketables(void);

+
+int pcre_fullinfo(const pcre *code, "const pcre_extra *extra," int what, +void *where);

+
+int pcre_info(const pcre *code, int *optptr, int *firstcharptr);

+
+int pcre_config(int what, void *where);

+
+char *pcre_version(void);

+
+void *(*pcre_malloc)(size_t);

+
+void (*pcre_free)(void *);

+
+void *(*pcre_stack_malloc)(size_t);

+
+void (*pcre_stack_free)(void *);

+
+int (*pcre_callout)(pcre_callout_block *); +

Pcre API Overview

+

+PCRE has +its own native API, which is described in this document. There is also a +set of wrapper functions that correspond to the POSIX regular expression +API. These are described in the pcreposix documentation.

+The native API +function prototypes are defined in the header file pcre.h, and on Unix systems +the library itself is called libpcre. It can normally be accessed by adding +-lpcre to the command for linking an application that uses PCRE. The header +file defines the macros PCRE_MAJOR and PCRE_MINOR to contain the major +and minor release numbers for the library. Applications can use these to +include support for different releases of PCRE.

+The functions pcre_compile(), +pcre_study(), and pcre_exec() are used for compiling and matching regular +expressions. A sample program that demonstrates the simplest way of using +them is provided in the file called pcredemo.c in the source distribution. +The pcresample documentation describes how to run it.

+In addition to the +main compiling and matching functions, there are convenience functions +for extracting captured substrings from a matched subject string. They are: +

+ pcre_copy_substring()
+ pcre_copy_named_substring()
+ pcre_get_substring()
+ pcre_get_named_substring()
+ pcre_get_substring_list()
+ pcre_get_stringnumber()
+

+pcre_free_substring() and pcre_free_substring_list() are also provided, +to free the memory used for extracted strings.

+The function pcre_maketables() +is used to build a set of character tables in the current locale for passing +to pcre_compile() or pcre_exec(). This is an optional facility that is provided +for specialist use. Most commonly, no special tables are passed, in which +case internal tables that are generated when PCRE is built are used.

+The +function pcre_fullinfo() is used to find out information about a compiled +pattern; pcre_info() is an obsolete version that returns only some of the +available information, but is retained for backwards compatibility. The +function pcre_version() returns a pointer to a string containing the version +of PCRE and its date of release.

+The global variables pcre_malloc and pcre_free +initially contain the entry points of the standard malloc() and free() +functions, respectively. PCRE calls the memory management functions via +these variables, so a calling program can replace them if it wishes to +intercept the calls. This should be done before calling any PCRE functions. +

+The global variables pcre_stack_malloc and pcre_stack_free are also indirections +to memory management functions. These special functions are used only when +PCRE is compiled to use the heap for remembering data, instead of recursive +function calls. This is a non-standard way of building PCRE, for use in environments +that have limited stacks. Because of the greater use of memory management, +it runs more slowly. Separate functions are provided so that special-purpose +external code can be used for this case. When used, these functions are +always called in a stack-like manner (last obtained, first freed), and always +for memory blocks of the same size.

+The global variable pcre_callout initially +contains NULL. It can be set by the caller to a "callout" function, which +PCRE will then call at specified points during a matching operation. Details +are given in the pcrecallout documentation. +

Multithreading

+

+The PCRE +functions can be used in multi-threading applications, with the proviso +that the memory management functions pointed to by pcre_malloc, pcre_free, +pcre_stack_malloc, and pcre_stack_free, and the callout function pointed +to by pcre_callout, are shared by all threads.

+The compiled form of a regular +expression is not altered during matching, so the same compiled pattern +can safely be used by several threads at once. +

Saving Precompiled Patterns +for Later Use

+

+The compiled form of a regular expression can be saved and +re-used at a later time, possibly by a different program, and even on a +host other than the one on which it was compiled. Details are given in the + pcreprecompile documentation. +

Checking Build-time Options

+

+int pcre_config(int +what, void *where);

+The function pcre_config() makes it possible for a +PCRE client to discover which optional features have been compiled into +the PCRE library. The pcrebuild documentation has more details about these +optional features.

+The first argument for pcre_config() is an integer, specifying +which information is required; the second argument is a pointer to a variable +into which the information is placed. The following information is available: +

+ PCRE_CONFIG_UTF8
+

+The output is an integer that is set to one if UTF-8 support is available; +otherwise it is set to zero.

+ PCRE_CONFIG_UNICODE_PROPERTIES
+

+The output is an integer that is set to one if support for Unicode character +properties is available; otherwise it is set to zero.

+ PCRE_CONFIG_NEWLINE
+

+The output is an integer that is set to the value of the code that is +used for the newline character. It is either linefeed (10) or carriage return +(13), and should normally be the standard character for your operating +system.

+ PCRE_CONFIG_LINK_SIZE
+

+The output is an integer that contains the number of bytes used for internal +linkage in compiled regular expressions. The value is 2, 3, or 4. Larger +values allow larger regular expressions to be compiled, at the expense +of slower matching. The default value of 2 is sufficient for all but the +most massive patterns, since it allows the compiled pattern to be up to +64K in size.

+ PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
+

+The output is an integer that contains the threshold above which the POSIX +interface uses malloc() for output vectors. Further details are given in +the pcreposix documentation.

+ PCRE_CONFIG_MATCH_LIMIT
+

+The output is an integer that gives the default limit for the number of +internal matching function calls in a pcre_exec() execution. Further details +are given with pcre_exec() below.

+ PCRE_CONFIG_STACKRECURSE
+

+The output is an integer that is set to one if internal recursion is implemented +by recursive function calls that use the stack to remember their state. +This is the usual way that PCRE is compiled. The output is zero if PCRE +was compiled to use blocks of data on the heap instead of recursive function +calls. In this case, pcre_stack_malloc and pcre_stack_free are called to +manage memory blocks on the heap, thus avoiding the use of the stack. + +

Compiling a Pattern

+

+pcre *pcre_compile(const char *pattern, int options, + const char **errptr, int *erroffset, const unsigned char *tableptr); +

+The function pcre_compile() is called to compile a pattern into an internal +form. The pattern is a C string terminated by a binary zero, and is passed +in the pattern argument. A pointer to a single block of memory that is obtained +via pcre_malloc is returned. This contains the compiled code and related +data. The pcre type is defined for the returned block; this is a typedef +for a structure whose contents are not externally defined. It is up to the +caller to free the memory when it is no longer required.

+Although the compiled +code of a PCRE regex is relocatable, that is, it does not depend on memory +location, the complete pcre data block is not fully relocatable, because +it may contain a copy of the tableptr argument, which is an address (see +below).

+The options argument contains independent bits that affect the compilation. +It should be zero if no options are required. The available options are +described below. Some of them, in particular, those that are compatible +with Perl, can also be set and unset from within the pattern (see the detailed +description in the pcrepattern documentation). For these options, the +contents of the options argument specifies their initial settings at the +start of compilation and execution. The PCRE_ANCHORED option can be set +at the time of matching as well as at compile time.

+If errptr is NULL, pcre_compile() +returns NULL immediately. Otherwise, if compilation of a pattern fails, +pcre_compile() returns NULL, and sets the variable pointed to by errptr +to point to a textual error message. The offset from the start of the pattern +to the character where the error was discovered is placed in the variable +pointed to by erroffset, which must not be NULL. If it is, an immediate +error is given.

+If the final argument, tableptr, is NULL, PCRE uses a default +set of character tables that are built when PCRE is compiled, using the +default C locale. Otherwise, tableptr must be an address that is the result +of a call to pcre_maketables(). This value is stored with the compiled pattern, +and used again by pcre_exec(), unless another table pointer is passed to +it. For more discussion, see the section on locale support below.

+This code +fragment shows a typical straightforward call to pcre_compile():

+ pcre +*re;
+ const char *error;
+ int erroffset;
+ re = pcre_compile(
+ "^A.*Z", /* the pattern */
+ 0, /* default options */
+ &error, /* for error message */
+ &erroffset, /* for error offset */
+ NULL); /* use default character tables */
+

+The following names for option bits are defined in the pcre.h header file: +

+ PCRE_ANCHORED
+

+If this bit is set, the pattern is forced to be "anchored", that is, it +is constrained to match only at the first matching point in the string +that is being searched (the "subject string"). This effect can also be achieved +by appropriate constructs in the pattern itself, which is the only way +to do it in Perl.

+ PCRE_AUTO_CALLOUT
+

+If this bit is set, pcre_compile() automatically inserts callout items, +all with number 255, before each pattern item. For discussion of the callout +facility, see the pcrecallout documentation.

+ PCRE_CASELESS
+

+If this bit is set, letters in the pattern match both upper and lower +case letters. It is equivalent to Perl’s /i option, and it can be changed +within a pattern by a (?i) option setting. When running in UTF-8 mode, case +support for high-valued characters is available only when PCRE is built +with Unicode character property support.

+ PCRE_DOLLAR_ENDONLY
+

+If this bit is set, a dollar metacharacter in the pattern matches only +at the end of the subject string. Without this option, a dollar also matches +immediately before the final character if it is a newline (but not before +any other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE +is set. There is no equivalent to this option in Perl, and no way to set +it within a pattern.

+ PCRE_DOTALL
+

+If this bit is set, a dot metacharater in the pattern matches all characters, +including newlines. Without it, newlines are excluded. This option is equivalent +to Perl’s /s option, and it can be changed within a pattern by a (?s) option +setting. A negative class such as [^a] always matches a newline character, +independent of the setting of this option.

+ PCRE_EXTENDED
+

+If this bit is set, whitespace data characters in the pattern are totally +ignored except when escaped or inside a character class. Whitespace does +not include the VT character (code 11). In addition, characters between +an unescaped # outside a character class and the next newline character, +inclusive, are also ignored. This is equivalent to Perl’s /x option, and +it can be changed within a pattern by a (?x) option setting.

+This option +makes it possible to include comments inside complicated patterns. Note, +however, that this applies only to data characters. Whitespace characters +may never appear within special character sequences in a pattern, for example +within the sequence (?( which introduces a conditional subpattern.

+ PCRE_EXTRA
+

+This option was invented in order to turn on additional functionality +of PCRE that is incompatible with Perl, but it is currently of very little +use. When set, any backslash in a pattern that is followed by a letter that +has no special meaning causes an error, thus reserving these combinations +for future expansion. By default, as in Perl, a backslash followed by a +letter with no special meaning is treated as a literal. There are at present +no other features controlled by this option. It can also be set by a (?X) +option setting within a pattern.

+ PCRE_MULTILINE
+

+By default, PCRE treats the subject string as consisting of a single line +of characters (even if it actually contains newlines). The "start of line" +metacharacter (^) matches only at the start of the string, while the "end +of line" metacharacter ($) matches only at the end of the string, or before +a terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same +as Perl.

+When PCRE_MULTILINE it is set, the "start of line" and "end of +line" constructs match immediately following or immediately before any +newline in the subject string, respectively, as well as at the very start +and end. This is equivalent to Perl’s /m option, and it can be changed within +a pattern by a (?m) option setting. If there are no "\n" characters in a +subject string, or no occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE +has no effect.

+ PCRE_NO_AUTO_CAPTURE
+

+If this option is set, it disables the use of numbered capturing parentheses +in the pattern. Any opening parenthesis that is not followed by ? behaves +as if it were followed by ?: but named parentheses can still be used for +capturing (and they acquire numbers in the usual way). There is no equivalent +of this option in Perl.

+ PCRE_UNGREEDY
+

+This option inverts the "greediness" of the quantifiers so that they are +not greedy by default, but become greedy if followed by "?". It is not compatible +with Perl. It can also be set by a (?U) option setting within the pattern. +

+ PCRE_UTF8
+

+This option causes PCRE to regard both the pattern and the subject as +strings of UTF-8 characters instead of single-byte character strings. However, +it is available only when PCRE is built to include UTF-8 support. If not, +the use of this option provokes an error. Details of how this option changes +the behaviour of PCRE are given in the section on UTF-8 support in the +main pcre page.

+ PCRE_NO_UTF8_CHECK
+

+When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is +automatically checked. If an invalid UTF-8 sequence of bytes is found, pcre_compile() +returns an error. If you already know that your pattern is valid, and you +want to skip this check for performance reasons, you can set the PCRE_NO_UTF8_CHECK +option. When it is set, the effect of passing an invalid UTF-8 string as +a pattern is undefined. It may cause your program to crash. Note that this +option can also be passed to pcre_exec(), to suppress the UTF-8 validity +checking of subject strings. +

Studying a Pattern

+

+pcre_extra *pcre_study(const +pcre *code, int options, const char **errptr);

+If a compiled pattern is +going to be used several times, it is worth spending more time analyzing +it in order to speed up the time taken for matching. The function pcre_study() +takes a pointer to a compiled pattern as its first argument. If studying +the pattern produces additional information that will help speed up matching, +pcre_study() returns a pointer to a pcre_extra block, in which the study_data +field points to the results of the study.

+The returned value from pcre_study() +can be passed directly to pcre_exec(). However, a pcre_extra block also +contains other fields that can be set by the caller before the block is +passed; these are described below in the section on matching a pattern. +

+If studying the pattern does not produce any additional information, pcre_study() +returns NULL. In that circumstance, if the calling program wants to pass +any of the other fields to pcre_exec(), it must set up its own pcre_extra +block.

+The second argument of pcre_study() contains option bits. At present, +no options are defined, and this argument should always be zero.

+The third +argument for pcre_study() is a pointer for an error message. If studying +succeeds (even if no data is returned), the variable it points to is set +to NULL. Otherwise it points to a textual error message. You should therefore +test the error pointer for NULL after calling pcre_study(), to be sure +that it has run successfully.

+This is a typical call to pcre_study():

+ +pcre_extra *pe;
+ pe = pcre_study(
+ re, /* result of pcre_compile() */
+ 0, /* no options exist */
+ &error); /* set to NULL or points to a message */
+

+At present, studying a pattern is useful only for non-anchored patterns +that do not have a single fixed starting character. A bitmap of possible +starting bytes is created. +

Locale Support

+

+PCRE handles caseless matching, +and determines whether characters are letters, digits, or whatever, by +reference to a set of tables, indexed by character value. (When running +in UTF-8 mode, this applies only to characters with codes less than 128. +Higher-valued codes never match escapes such as \w or \d, but can be tested +with \p if PCRE is built with Unicode character property support.)

+An internal +set of tables is created in the default C locale when PCRE is built. This +is used when the final argument of pcre_compile() is NULL, and is sufficient +for many applications. An alternative set of tables can, however, be supplied. +These may be created in a different locale from the default. As more and +more applications change to using Unicode, the need for this locale support +is expected to die away.

+External tables are built by calling the pcre_maketables() +function, which has no arguments, in the relevant locale. The result can +then be passed to pcre_compile() or pcre_exec() as often as necessary. For +example, to build and use tables that are appropriate for the French locale +(where accented characters with values greater than 128 are treated as +letters), the following code could be used:

+ setlocale(LC_CTYPE, "fr_FR");
+ tables = pcre_maketables();
+ re = pcre_compile(..., tables);
+

+When pcre_maketables() runs, the tables are built in memory that is obtained +via pcre_malloc. It is the caller’s responsibility to ensure that the memory +containing the tables remains available for as long as it is needed.

+The +pointer that is passed to pcre_compile() is saved with the compiled pattern, +and the same tables are used via this pointer by pcre_study() and normally +also by pcre_exec(). Thus, by default, for any single pattern, compilation, +studying and matching all happen in the same locale, but different patterns +can be compiled in different locales.

+It is possible to pass a table pointer +or NULL (indicating the use of the internal tables) to pcre_exec(). Although +not intended for this purpose, this facility could be used to match a pattern +in a different locale from the one in which it was compiled. Passing table +pointers at run time is discussed below in the section on matching a pattern. + +

Information About a Pattern

+

+int pcre_fullinfo(const pcre *code, "const +pcre_extra *extra," int what, void *where);

+The pcre_fullinfo() function +returns information about a compiled pattern. It replaces the obsolete pcre_info() +function, which is nevertheless retained for backwards compability (and +is documented below).

+The first argument for pcre_fullinfo() is a pointer +to the compiled pattern. The second argument is the result of pcre_study(), +or NULL if the pattern was not studied. The third argument specifies which +piece of information is required, and the fourth argument is a pointer +to a variable to receive the data. The yield of the function is zero for +success, or one of the following negative numbers:

+ PCRE_ERROR_NULL + the argument code was NULL
+ the argument where was NULL
+ PCRE_ERROR_BADMAGIC the "magic number" was not found
+ PCRE_ERROR_BADOPTION the value of what was invalid
+

+The "magic number" is placed at the start of each compiled pattern as +an simple check against passing an arbitrary memory pointer. Here is a typical +call of pcre_fullinfo(), to obtain the length of the compiled pattern: +

+ int rc;
+ unsigned long int length;
+ rc = pcre_fullinfo(
+ re, /* result of pcre_compile() */
+ pe, /* result of pcre_study(), or NULL */
+ PCRE_INFO_SIZE, /* what is required */
+ &length); /* where to put the data */
+

+The possible values for the third argument are defined in pcre.h, and are +as follows:

+ PCRE_INFO_BACKREFMAX
+

+Return the number of the highest back reference in the pattern. The fourth +argument should point to an int variable. Zero is returned if there are +no back references.

+ PCRE_INFO_CAPTURECOUNT
+

+Return the number of capturing subpatterns in the pattern. The fourth argument +should point to an int variable.

+ PCRE_INFO_DEFAULTTABLES
+

+Return a pointer to the internal default character tables within PCRE. +The fourth argument should point to an unsigned char * variable. This information +call is provided for internal use by the pcre_study() function. External +callers can cause PCRE to use its internal tables by passing a NULL table +pointer.

+ PCRE_INFO_FIRSTBYTE
+

+Return information about the first byte of any matched string, for a non-anchored +pattern. (This option used to be called PCRE_INFO_FIRSTCHAR; the old name +is still recognized for backwards compatibility.)

+If there is a fixed first +byte, for example, from a pattern such as (cat|cow|coyote), it is returned +in the integer pointed to by where. Otherwise, if either

+(a) the pattern +was compiled with the PCRE_MULTILINE option, and every branch starts with +"^", or

+(b) every branch of the pattern starts with ".*" and PCRE_DOTALL +is not set (if it were set, the pattern would be anchored),

+-1 is returned, +indicating that the pattern matches only at the start of a subject string +or after any newline within the string. Otherwise -2 is returned. For anchored +patterns, -2 is returned.

+ PCRE_INFO_FIRSTTABLE
+

+If the pattern was studied, and this resulted in the construction of a +256-bit table indicating a fixed set of bytes for the first byte in any +matching string, a pointer to the table is returned. Otherwise NULL is returned. +The fourth argument should point to an unsigned char * variable.

+ PCRE_INFO_LASTLITERAL
+

+Return the value of the rightmost literal byte that must exist in any +matched string, other than at its start, if such a byte has been recorded. +The fourth argument should point to an int variable. If there is no such +byte, -1 is returned. For anchored patterns, a last literal byte is recorded +only if it follows something of variable length. For example, for the pattern +/^a\d+z\d+/ the returned value is "z", but for /^a\dz\d/ the returned value is +-1.

+ PCRE_INFO_NAMECOUNT
+ PCRE_INFO_NAMEENTRYSIZE
+ PCRE_INFO_NAMETABLE
+

+PCRE supports the use of named as well as numbered capturing parentheses. +The names are just an additional way of identifying the parentheses, which +still acquire numbers. A convenience function called pcre_get_named_substring() +is provided for extracting an individual captured substring by name. It +is also possible to extract the data directly, by first converting the +name to a number in order to access the correct pointers in the output +vector (described with pcre_exec() below). To do the conversion, you need +to use the name-to-number map, which is described by these three values.

+The +map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT gives +the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size of each +entry; both of these return an int value. The entry size depends on the +length of the longest name. PCRE_INFO_NAMETABLE returns a pointer to the +first entry of the table (a pointer to char). The first two bytes of each +entry are the number of the capturing parenthesis, most significant byte +first. The rest of the entry is the corresponding name, zero terminated. +The names are in alphabetical order. For example, consider the following +pattern (assume PCRE_EXTENDED is set, so white space - including newlines +- is ignored):

+ (?P<date> (?P<year>(\d\d)?\d\d) -
+ (?P<month>\d\d) - (?P<day>\d\d) )
+

+There are four named subpatterns, so the table has four entries, and each +entry in the table is eight bytes long. The table is as follows, with non-printing +bytes shows in hexadecimal, and undefined bytes shown as ??:

+ 00 01 d + a t e 00 ??
+ 00 05 d a y 00 ?? ??
+ 00 04 m o n t h 00
+ 00 02 y e a r 00 ??
+

+When writing code to extract data from named subpatterns using the name-to-number +map, remember that the length of each entry is likely to be different for +each compiled pattern.

+ PCRE_INFO_OPTIONS
+

+Return a copy of the options with which the pattern was compiled. The fourth +argument should point to an unsigned long int variable. These option bits +are those specified in the call to pcre_compile(), modified by any top-level +option settings within the pattern itself.

+A pattern is automatically anchored +by PCRE if all of its top-level alternatives begin with one of the following: +

+ ^ unless PCRE_MULTILINE is set
+ \A always
+ \G always
+ .* if PCRE_DOTALL is set and there are no back
+ references to the subpattern in which .* appears
+

+For such patterns, the PCRE_ANCHORED bit is set in the options returned +by pcre_fullinfo().

+ PCRE_INFO_SIZE
+

+Return the size of the compiled pattern, that is, the value that was passed +as the argument to pcre_malloc() when PCRE was getting memory in which +to place the compiled data. The fourth argument should point to a size_t +variable.

+ PCRE_INFO_STUDYSIZE
+

+Return the size of the data block pointed to by the study_data field in +a pcre_extra block. That is, it is the value that was passed to pcre_malloc() +when PCRE was getting memory into which to place the data created by pcre_study(). +The fourth argument should point to a size_t variable. +

Obsolete Info Function

+ +

+int pcre_info(const pcre *code, int *optptr, int *firstcharptr);

+The pcre_info() +function is now obsolete because its interface is too restrictive to return +all the available data about a compiled pattern. New programs should use +pcre_fullinfo() instead. The yield of pcre_info() is the number of capturing +subpatterns, or one of the following negative numbers:

+ PCRE_ERROR_NULL + the argument code was NULL
+ PCRE_ERROR_BADMAGIC the "magic number" was not found
+

+If the optptr argument is not NULL, a copy of the options with which the +pattern was compiled is placed in the integer it points to (see PCRE_INFO_OPTIONS +above).

+If the pattern is not anchored and the firstcharptr argument is +not NULL, it is used to pass back information about the first character +of any matched string (see PCRE_INFO_FIRSTBYTE above). +

Matching a Pattern

+ +

+int pcre_exec(const pcre *code, "const pcre_extra *extra," const char +*subject, int length, int startoffset, int options, int *ovector, int +ovecsize);

+The function pcre_exec() is called to match a subject string +against a compiled pattern, which is passed in the code argument. If the +pattern has been studied, the result of the study should be passed in the +extra argument.

+In most applications, the pattern will have been compiled +(and optionally studied) in the same process that calls pcre_exec(). However, +it is possible to save compiled patterns and study data, and then use them +later in different processes, possibly even on different hosts. For a discussion +about this, see the pcreprecompile documentation.

+Here is an example of +a simple call to pcre_exec():

+ int rc;
+ int ovector[30];
+ rc = pcre_exec(
+ re, /* result of pcre_compile() */
+ NULL, /* we didn’t study the pattern */
+ "some string", /* the subject string */
+ 11, /* the length of the subject string */
+ 0, /* start at offset 0 in the subject */
+ 0, /* default options */
+ ovector, /* vector of integers for substring information */
+ 30); /* number of elements in the vector (NOT size in bytes) +*/
+ +

Extra data for pcre_exec()

+

+If the extra argument is not NULL, it must +point to a pcre_extra data block. The pcre_study() function returns such +a block (when it doesn’t return NULL), but you can also create one for yourself, +and pass additional information in it. The fields in a pcre_extra block +are as follows:

+ unsigned long int flags;
+ void *study_data;
+ unsigned long int match_limit;
+ void *callout_data;
+ const unsigned char *tables;
+

+The flags field is a bitmap that specifies which of the other fields are +set. The flag bits are:

+ PCRE_EXTRA_STUDY_DATA
+ PCRE_EXTRA_MATCH_LIMIT
+ PCRE_EXTRA_CALLOUT_DATA
+ PCRE_EXTRA_TABLES
+

+Other flag bits should be set to zero. The study_data field is set in the +pcre_extra block that is returned by pcre_study(), together with the appropriate +flag bit. You should not set this yourself, but you may add to the block +by setting the other fields and their corresponding flag bits.

+The match_limit +field provides a means of preventing PCRE from using up a vast amount of +resources when running patterns that are not going to match, but which +have a very large number of possibilities in their search trees. The classic +example is the use of nested unlimited repeats.

+Internally, PCRE uses a +function called match() which it calls repeatedly (sometimes recursively). +The limit is imposed on the number of times this function is called during +a match, which has the effect of limiting the amount of recursion and backtracking +that can take place. For patterns that are not anchored, the count starts +from zero for each position in the subject string.

+The default limit for +the library can be set when PCRE is built; the default default is 10 million, +which handles all but the most extreme cases. You can reduce the default +by suppling pcre_exec() with a pcre_extra block in which match_limit is +set to a smaller value, and PCRE_EXTRA_MATCH_LIMIT is set in the flags +field. If the limit is exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT. +

+The pcre_callout field is used in conjunction with the "callout" feature, +which is described in the pcrecallout documentation.

+The tables field +is used to pass a character tables pointer to pcre_exec(); this overrides +the value that is stored with the compiled pattern. A non-NULL value is stored +with the compiled pattern only if custom tables were supplied to pcre_compile() +via its tableptr argument. If NULL is passed to pcre_exec() using this mechanism, +it forces PCRE’s internal tables to be used. This facility is helpful when +re-using patterns that have been saved after compiling with an external +set of tables, because the external tables might be at a different address +when pcre_exec() is called. See the pcreprecompile documentation for a +discussion of saving compiled patterns for later use. +

Option bits for pcre_exec()

+ +

+The unused bits of the options argument for pcre_exec() must be zero. The +only bits that may be set are PCRE_ANCHORED, PCRE_NOTBOL, PCRE_NOTEOL, +PCRE_NOTEMPTY, PCRE_NO_UTF8_CHECK and PCRE_PARTIAL.

+ PCRE_ANCHORED
+

+The PCRE_ANCHORED option limits pcre_exec() to matching at the first matching +position. If a pattern was compiled with PCRE_ANCHORED, or turned out to +be anchored by virtue of its contents, it cannot be made unachored at matching +time.

+ PCRE_NOTBOL
+

+This option specifies that first character of the subject string is not +the beginning of a line, so the circumflex metacharacter should not match +before it. Setting this without PCRE_MULTILINE (at compile time) causes +circumflex never to match. This option affects only the behaviour of the +circumflex metacharacter. It does not affect \A.

+ PCRE_NOTEOL
+

+This option specifies that the end of the subject string is not the end +of a line, so the dollar metacharacter should not match it nor (except +in multiline mode) a newline immediately before it. Setting this without +PCRE_MULTILINE (at compile time) causes dollar never to match. This option +affects only the behaviour of the dollar metacharacter. It does not affect +\Z or \z.

+ PCRE_NOTEMPTY
+

+An empty string is not considered to be a valid match if this option is +set. If there are alternatives in the pattern, they are tried. If all the +alternatives match the empty string, the entire match fails. For example, +if the pattern

+ a?b?
+

+is applied to a string not beginning with "a" or "b", it matches the empty +string at the start of the subject. With PCRE_NOTEMPTY set, this match is +not valid, so PCRE searches further into the string for occurrences of +"a" or "b".

+Perl has no direct equivalent of PCRE_NOTEMPTY, but it does +make a special case of a pattern match of the empty string within its split() +function, and when using the /g modifier. It is possible to emulate Perl’s +behaviour after matching a null string by first trying the match again +at the same offset with PCRE_NOTEMPTY and PCRE_ANCHORED, and then if that +fails by advancing the starting offset (see below) and trying an ordinary +match again. There is some code that demonstrates how to do this in the +pcredemo.c sample program.

+ PCRE_NO_UTF8_CHECK
+

+When PCRE_UTF8 is set at compile time, the validity of the subject as +a UTF-8 string is automatically checked when pcre_exec() is subsequently +called. The value of startoffset is also checked to ensure that it points +to the start of a UTF-8 character. If an invalid UTF-8 sequence of bytes is +found, pcre_exec() returns the error PCRE_ERROR_BADUTF8. If startoffset +contains an invalid value, PCRE_ERROR_BADUTF8_OFFSET is returned.

+If you +already know that your subject is valid, and you want to skip these checks +for performance reasons, you can set the PCRE_NO_UTF8_CHECK option when +calling pcre_exec(). You might want to do this for the second and subsequent +calls to pcre_exec() if you are making repeated calls to find all the matches +in a single subject string. However, you should be sure that the value of +startoffset points to the start of a UTF-8 character. When PCRE_NO_UTF8_CHECK +is set, the effect of passing an invalid UTF-8 string as a subject, or a +value of startoffset that does not point to the start of a UTF-8 character, +is undefined. Your program may crash.

+ PCRE_PARTIAL
+

+This option turns on the partial matching feature. If the subject string +fails to match the pattern, but at some point during the matching process +the end of the subject was reached (that is, the subject partially matches +the pattern and the failure to match occurred only because there were not +enough subject characters), pcre_exec() returns PCRE_ERROR_PARTIAL instead +of PCRE_ERROR_NOMATCH. When PCRE_PARTIAL is used, there are restrictions +on what may appear in the pattern. These are discussed in the pcrepartial + documentation. +

The string to be matched by pcre_exec()

+

+The subject string +is passed to pcre_exec() as a pointer in subject, a length in length, and +a starting byte offset in startoffset. In UTF-8 mode, the byte offset must +point to the start of a UTF-8 character. Unlike the pattern string, the subject +may contain binary zero bytes. When the starting offset is zero, the search +for a match starts at the beginning of the subject, and this is by far +the most common case.

+A non-zero starting offset is useful when searching +for another match in the same subject by calling pcre_exec() again after +a previous success. Setting startoffset differs from just passing over a +shortened string and setting PCRE_NOTBOL in the case of a pattern that +begins with any kind of lookbehind. For example, consider the pattern

+ +\Biss\B
+

+which finds occurrences of "iss" in the middle of words. (\B matches only +if the current position in the subject is not a word boundary.) When applied +to the string "Mississipi" the first call to pcre_exec() finds the first +occurrence. If pcre_exec() is called again with just the remainder of the +subject, namely "issipi", it does not match, because \B is always false +at the start of the subject, which is deemed to be a word boundary. However, +if pcre_exec() is passed the entire string again, but with startoffset +set to 4, it finds the second occurrence of "iss" because it is able to +look behind the starting point to discover that it is preceded by a letter. +

+If a non-zero starting offset is passed when the pattern is anchored, one +attempt to match at the given offset is made. This can only succeed if the +pattern does not require the match to be at the start of the subject. +

How +pcre_exec() returns captured substrings

+

+In general, a pattern matches a +certain portion of the subject, and in addition, further substrings from +the subject may be picked out by parts of the pattern. Following the usage +in Jeffrey Friedl’s book, this is called "capturing" in what follows, and +the phrase "capturing subpattern" is used for a fragment of a pattern that +picks out a substring. PCRE supports several other kinds of parenthesized +subpattern that do not cause substrings to be captured.

+Captured substrings +are returned to the caller via a vector of integer offsets whose address +is passed in ovector. The number of elements in the vector is passed in +ovecsize, which must be a non-negative number. Note: this argument is NOT +the size of ovector in bytes.

+The first two-thirds of the vector is used +to pass back captured substrings, each substring using a pair of integers. +The remaining third of the vector is used as workspace by pcre_exec() while +matching capturing subpatterns, and is not available for passing back information. +The length passed in ovecsize should always be a multiple of three. If it +is not, it is rounded down.

+When a match is successful, information about +captured substrings is returned in pairs of integers, starting at the beginning +of ovector, and continuing up to two-thirds of its length at the most. The +first element of a pair is set to the offset of the first character in +a substring, and the second is set to the offset of the first character +after the end of a substring. The first pair, ovector[0] and ovector[1], +identify the portion of the subject string matched by the entire pattern. +The next pair is used for the first capturing subpattern, and so on. The +value returned by pcre_exec() is the number of pairs that have been set. +If there are no capturing subpatterns, the return value from a successful +match is 1, indicating that just the first pair of offsets has been set. +

+Some convenience functions are provided for extracting the captured substrings +as separate strings. These are described in the following section.

+It is +possible for an capturing subpattern number n+1 to match some part of the +subject when subpattern n has not been used at all. For example, if the +string "abc" is matched against the pattern (a|(z))(bc) subpatterns 1 and +3 are matched, but 2 is not. When this happens, both offset values corresponding +to the unused subpattern are set to -1.

+If a capturing subpattern is matched +repeatedly, it is the last portion of the string that it matched that is +returned.

+If the vector is too small to hold all the captured substring +offsets, it is used as far as possible (up to two-thirds of its length), +and the function returns a value of zero. In particular, if the substring +offsets are not of interest, pcre_exec() may be called with ovector passed +as NULL and ovecsize as zero. However, if the pattern contains back references +and the ovector is not big enough to remember the related substrings, PCRE +has to get additional memory for use during matching. Thus it is usually +advisable to supply an ovector.

+Note that pcre_info() can be used to find +out how many capturing subpatterns there are in a compiled pattern. The +smallest size for ovector that will allow for n captured substrings, in +addition to the offsets of the substring matched by the whole pattern, +is (n+1)*3. +

Return values from pcre_exec()

+

+If pcre_exec() fails, it returns +a negative number. The following are defined in the header file:

+ PCRE_ERROR_NOMATCH + (-1)
+

+The subject string did not match the pattern.

+ PCRE_ERROR_NULL + (-2)
+

+Either code or subject was passed as NULL, or ovector was NULL and ovecsize +was not zero.

+ PCRE_ERROR_BADOPTION (-3)
+

+An unrecognized bit was set in the options argument.

+ PCRE_ERROR_BADMAGIC + (-4)
+

+PCRE stores a 4-byte "magic number" at the start of the compiled code, +to catch the case when it is passed a junk pointer and to detect when a +pattern that was compiled in an environment of one endianness is run in +an environment with the other endianness. This is the error that PCRE gives +when the magic number is not present.

+ PCRE_ERROR_UNKNOWN_NODE (-5)
+

+While running the pattern match, an unknown item was encountered in the +compiled pattern. This error could be caused by a bug in PCRE or by overwriting +of the compiled pattern.

+ PCRE_ERROR_NOMEMORY (-6)
+

+If a pattern contains back references, but the ovector that is passed +to pcre_exec() is not big enough to remember the referenced substrings, +PCRE gets a block of memory at the start of matching to use for this purpose. +If the call via pcre_malloc() fails, this error is given. The memory is +automatically freed at the end of matching.

+ PCRE_ERROR_NOSUBSTRING +(-7)
+

+This error is used by the pcre_copy_substring(), pcre_get_substring(), +and pcre_get_substring_list() functions (see below). It is never returned +by pcre_exec().

+ PCRE_ERROR_MATCHLIMIT (-8)
+

+The recursion and backtracking limit, as specified by the match_limit +field in a pcre_extra structure (or defaulted) was reached. See the description +above.

+ PCRE_ERROR_CALLOUT (-9)
+

+This error is never generated by pcre_exec() itself. It is provided for +use by callout functions that want to yield a distinctive error code. See +the pcrecallout documentation for details.

+ PCRE_ERROR_BADUTF8 + (-10)
+

+A string that contains an invalid UTF-8 byte sequence was passed as a subject. +

+ PCRE_ERROR_BADUTF8_OFFSET (-11)
+

+The UTF-8 byte sequence that was passed as a subject was valid, but the +value of startoffset did not point to the beginning of a UTF-8 character. +

+ PCRE_ERROR_PARTIAL (-12)
+

+The subject string did not match, but it did match partially. See the +pcrepartial documentation for details of partial matching.

+ PCRE_ERROR_BAD_PARTIAL +(-13)
+

+The PCRE_PARTIAL option was used with a compiled pattern containing items +that are not supported for partial matching. See the pcrepartial documentation +for details of partial matching.

+ PCRE_ERROR_INTERNAL (-14)
+

+An unexpected internal error has occurred. This error could be caused by +a bug in PCRE or by overwriting of the compiled pattern.

+ PCRE_ERROR_BADCOUNT +(-15)
+

+This error is given if the value of the ovecsize argument is negative. + +

Extracting Captured Substrings by Number

+

+int pcre_copy_substring(const +char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, + int buffersize);

+
+int pcre_get_substring(const char *subject, int *ovector, int stringcount, +int stringnumber, const char **stringptr);

+
+int pcre_get_substring_list(const char *subject, int *ovector, int stringcount, +"const char ***listptr);"

+Captured substrings can be accessed directly +by using the offsets returned by pcre_exec() in ovector. For convenience, +the functions pcre_copy_substring(), pcre_get_substring(), and pcre_get_substring_list() +are provided for extracting captured substrings as new, separate, zero-terminated +strings. These functions identify substrings by number. The next section +describes functions for extracting named substrings. A substring that contains +a binary zero is correctly extracted and has a further zero added on the +end, but the result is not, of course, a C string.

+The first three arguments +are the same for all three of these functions: subject is the subject string +that has just been successfully matched, ovector is a pointer to the vector +of integer offsets that was passed to pcre_exec(), and stringcount is the +number of substrings that were captured by the match, including the substring +that matched the entire regular expression. This is the value returned by +pcre_exec() if it is greater than zero. If pcre_exec() returned zero, indicating +that it ran out of space in ovector, the value passed as stringcount should +be the number of elements in the vector divided by three.

+The functions +pcre_copy_substring() and pcre_get_substring() extract a single substring, +whose number is given as stringnumber. A value of zero extracts the substring +that matched the entire pattern, whereas higher values extract the captured +substrings. For pcre_copy_substring(), the string is placed in buffer, whose +length is given by buffersize, while for pcre_get_substring() a new block +of memory is obtained via pcre_malloc, and its address is returned via +stringptr. The yield of the function is the length of the string, not including +the terminating zero, or one of

+ PCRE_ERROR_NOMEMORY (-6)
+

+The buffer was too small for pcre_copy_substring(), or the attempt to +get memory failed for pcre_get_substring().

+ PCRE_ERROR_NOSUBSTRING +(-7)
+

+There is no substring whose number is stringnumber.

+The pcre_get_substring_list() +function extracts all available substrings and builds a list of pointers +to them. All this is done in a single block of memory that is obtained via +pcre_malloc. The address of the memory block is returned via listptr, which +is also the start of the list of string pointers. The end of the list is +marked by a NULL pointer. The yield of the function is zero if all went +well, or

+ PCRE_ERROR_NOMEMORY (-6)
+

+if the attempt to get the memory block failed.

+When any of these functions +encounter a substring that is unset, which can happen when capturing subpattern +number n+1 matches some part of the subject, but subpattern n has not been +used at all, they return an empty string. This can be distinguished from +a genuine zero-length substring by inspecting the appropriate offset in +ovector, which is negative for unset substrings.

+The two convenience functions +pcre_free_substring() and pcre_free_substring_list() can be used to free +the memory returned by a previous call of pcre_get_substring() or pcre_get_substring_list(), +respectively. They do nothing more than call the function pointed to by +pcre_free, which of course could be called directly from a C program. However, +PCRE is used in some situations where it is linked via a special interface +to another programming language which cannot use pcre_free directly; it +is for these cases that the functions are provided. +

Extracting Captured +Substrings by Name

+

+int pcre_get_stringnumber(const pcre *code, const char +*name);

+
+int pcre_copy_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, char *buffer, int +buffersize);

+
+int pcre_get_named_substring(const pcre *code, const char *subject, int +*ovector, int stringcount, const char *stringname, const char **stringptr); +

+To extract a substring by name, you first have to find associated number. +For example, for this pattern

+ (a+)b(?<xxx>\d+)...
+

+the number of the subpattern called "xxx" is 2. You can find the number +from the name by calling pcre_get_stringnumber(). The first argument is +the compiled pattern, and the second is the name. The yield of the function +is the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if there is no +subpattern of that name.

+Given the number, you can extract the substring +directly, or use one of the functions described in the previous section. +For convenience, there are also two functions that do the whole job.

+Most +of the arguments of pcre_copy_named_substring() and pcre_get_named_substring() +are the same as those for the similarly named functions that extract by +number. As these are described in the previous section, they are not re-described +here. There are just two differences:

+First, instead of a substring number, +a substring name is given. Second, there is an extra argument, given at +the start, which is a pointer to the compiled pattern. This is needed in +order to gain access to the name-to-number translation table.

+These functions +call pcre_get_stringnumber(), and if it succeeds, they then call pcre_copy_substring() +or pcre_get_substring(), as appropriate.

+ Last updated: 09 September 2004 +
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcrebuild.3.html b/Utilities/PCRE/man/html/pcrebuild.3.html new file mode 100644 index 0000000..950a1f0 --- /dev/null +++ b/Utilities/PCRE/man/html/pcrebuild.3.html @@ -0,0 +1,167 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Build-time Options

+

+This +document describes the optional features of PCRE that can be selected when +the library is compiled. They are all selected, or deselected, by providing +options to the configure script that is run before the make command. The +complete list of options for configure (which includes the standard ones +such as the selection of the installation directory) can be obtained by +running

+ ./configure --help
+

+The following sections describe certain options whose names begin with +--enable or --disable. These settings specify changes to the defaults for the +configure command. Because of the way that configure works, --enable and --disable +always come in pairs, so the complementary option always exists as well, +but as it specifies the default, it is not described. +

Utf-8 Support

+

+To build +PCRE with support for UTF-8 character strings, add

+ --enable-utf8
+

+to the configure command. Of itself, this does not make PCRE treat strings +as UTF-8. As well as compiling PCRE with this option, you also have have +to set the PCRE_UTF8 option when you call the pcre_compile() function. + +

Unicode Character Property Support

+

+UTF-8 support allows PCRE to process +character values greater than 255 in the strings that it handles. On its +own, however, it does not provide any facilities for accessing the properties +of such characters. If you want to be able to use the pattern escapes \P, +\p, and \X, which refer to Unicode character properties, you must add

+ --enable-unicode-properties
+

+to the configure command. This implies UTF-8 support, even if you have not +explicitly requested it.

+Including Unicode property support adds around +90K of tables to the PCRE library, approximately doubling its size. Only +the general category properties such as Lu and Nd are supported. Details +are given in the pcrepattern documentation. +

Code Value of Newline

+

+By +default, PCRE treats character 10 (linefeed) as the newline character. This +is the normal newline character on Unix-like systems. You can compile PCRE +to use character 13 (carriage return) instead by adding

+ --enable-newline-is-cr
+

+to the configure command. For completeness there is also a --enable-newline-is-lf +option, which explicitly specifies linefeed as the newline character. +

Building +Shared and Static Libraries

+

+The PCRE building process uses libtool to build +both shared and static Unix libraries by default. You can suppress one of +these by adding one of

+ --disable-shared
+ --disable-static
+

+to the configure command, as required. +

Posix Malloc Usage

+

+When PCRE is +called through the POSIX interface (see the pcreposix documentation), +additional working storage is required for holding the pointers to capturing +substrings, because PCRE requires three integers per substring, whereas +the POSIX interface provides only two. If the number of expected substrings +is small, the wrapper function uses space on the stack, because this is +faster than using malloc() for each call. The default threshold above which +the stack is no longer used is 10; it can be changed by adding a setting +such as

+ --with-posix-malloc-threshold=20
+

+to the configure command. +

Limiting Pcre Resource Usage

+

+Internally, PCRE +has a function called match(), which it calls repeatedly (possibly recursively) +when matching a pattern. By controlling the maximum number of times this +function may be called during a single matching operation, a limit can +be placed on the resources used by a single call to pcre_exec(). The limit +can be changed at run time, as described in the pcreapi documentation. +The default is 10 million, but this can be changed by adding a setting +such as

+ --with-match-limit=500000
+

+to the configure command. +

Handling Very Large Patterns

+

+Within a compiled +pattern, offset values are used to point from one part to another (for +example, from an opening parenthesis to an alternation metacharacter). By +default, two-byte values are used for these offsets, leading to a maximum +size for a compiled pattern of around 64K. This is sufficient to handle +all but the most gigantic patterns. Nevertheless, some people do want to +process enormous patterns, so it is possible to compile PCRE to use three-byte +or four-byte offsets by adding a setting such as

+ --with-link-size=3
+

+to the configure command. The value given must be 2, 3, or 4. Using longer +offsets slows down the operation of PCRE because it has to load additional +bytes when handling them.

+If you build PCRE with an increased link size, +test 2 (and test 5 if you are using UTF-8) will fail. Part of the output +of these tests is a representation of the compiled pattern, and this changes +with the link size. +

Avoiding Excessive Stack Usage

+

+PCRE implements backtracking +while matching by making recursive calls to an internal function called +match(). In environments where the size of the stack is limited, this can +severely limit PCRE’s operation. (The Unix environment does not usually suffer +from this problem.) An alternative approach that uses memory from the heap +to remember data, instead of using recursive function calls, has been implemented +to work round this problem. If you want to build a version of PCRE that +works this way, add

+ --disable-stack-for-recursion
+

+to the configure command. With this configuration, PCRE will use the pcre_stack_malloc +and pcre_stack_free variables to call memory management functions. Separate +functions are provided because the usage is very predictable: the block +sizes requested are always the same, and the blocks are always freed in +reverse order. A calling program might be able to implement optimized functions +that perform better than the standard malloc() and free() functions. PCRE +runs noticeably more slowly when built in this way. +

Using Ebcdic Code

+

+PCRE +assumes by default that it will run in an environment where the character +code is ASCII (or Unicode, which is a superset of ASCII). PCRE can, however, +be compiled to run in an EBCDIC environment by adding

+ --enable-ebcdic
+

+to the configure command.

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcrecallout.3.html b/Utilities/PCRE/man/html/pcrecallout.3.html new file mode 100644 index 0000000..83e61b2 --- /dev/null +++ b/Utilities/PCRE/man/html/pcrecallout.3.html @@ -0,0 +1,148 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Callouts

+

+int (*pcre_callout)(pcre_callout_block +*);

+PCRE provides a feature called "callout", which is a means of temporarily +passing control to the caller of PCRE in the middle of pattern matching. +The caller of PCRE provides an external function by putting its entry point +in the global variable pcre_callout. By default, this variable contains +NULL, which disables all calling out.

+Within a regular expression, (?C) +indicates the points at which the external function is to be called. Different +callout points can be identified by putting a number less than 256 after +the letter C. The default value is zero. For example, this pattern has two +callout points:

+ (?C1)deabc(?C2)def
+

+If the PCRE_AUTO_CALLOUT option bit is set when pcre_compile() is called, +PCRE automatically inserts callouts, all with number 255, before each item +in the pattern. For example, if PCRE_AUTO_CALLOUT is used with the pattern +

+ A(\d{2}|--)
+

+it is processed as if it were

+(?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255) +

+Notice that there is a callout before and after each parenthesis and alternation +bar. Automatic callouts can be used for tracking the progress of pattern +matching. The pcretest command has an option that sets automatic callouts; +when it is used, the output indicates how the pattern is matched. This is +useful information when you are trying to optimize the performance of a +particular pattern. +

Missing Callouts

+

+You should be aware that, because +of optimizations in the way PCRE matches patterns, callouts sometimes do +not happen. For example, if the pattern is

+ ab(?C4)cd
+

+PCRE knows that any matching string must contain the letter "d". If the +subject string is "abyz", the lack of "d" means that matching doesn’t ever +start, and the callout is never reached. However, with "abyd", though the +result is still no match, the callout is obeyed. +

the Callout Interface

+ +

+During matching, when PCRE reaches a callout point, the external function +defined by pcre_callout is called (if it is set). The only argument is a +pointer to a pcre_callout block. This structure contains the following fields: +

+ int version;
+ int callout_number;
+ int *offset_vector;
+ const char *subject;
+ int subject_length;
+ int start_match;
+ int current_position;
+ int capture_top;
+ int capture_last;
+ void *callout_data;
+ int pattern_position;
+ int next_item_length;
+

+The version field is an integer containing the version number of the block +format. The initial version was 0; the current version is 1. The version +number will change again in future if additional fields are added, but +the intention is never to remove any of the existing fields.

+The callout_number +field contains the number of the callout, as compiled into the pattern +(that is, the number after ?C for manual callouts, and 255 for automatically +generated callouts).

+The offset_vector field is a pointer to the vector +of offsets that was passed by the caller to pcre_exec(). The contents can +be inspected in order to extract substrings that have been matched so far, +in the same way as for extracting substrings after a match has completed. +

+The subject and subject_length fields contain copies of the values that +were passed to pcre_exec().

+The start_match field contains the offset within +the subject at which the current match attempt started. If the pattern is +not anchored, the callout function may be called several times from the +same point in the pattern for different starting points in the subject. +

+The current_position field contains the offset within the subject of the +current match pointer.

+The capture_top field contains one more than the +number of the highest numbered captured substring so far. If no substrings +have been captured, the value of capture_top is one.

+The capture_last field +contains the number of the most recently captured substring. If no substrings +have been captured, its value is -1.

+The callout_data field contains a value +that is passed to pcre_exec() by the caller specifically so that it can +be passed back in callouts. It is passed in the pcre_callout field of the +pcre_extra data structure. If no such data was passed, the value of callout_data +in a pcre_callout block is NULL. There is a description of the pcre_extra +structure in the pcreapi documentation.

+The pattern_position field is +present from version 1 of the pcre_callout structure. It contains the offset +to the next item to be matched in the pattern string.

+The next_item_length +field is present from version 1 of the pcre_callout structure. It contains +the length of the next item to be matched in the pattern string. When the +callout immediately precedes an alternation bar, a closing parenthesis, +or the end of the pattern, the length is zero. When the callout precedes +an opening parenthesis, the length is that of the entire subpattern.

+The +pattern_position and next_item_length fields are intended to help in distinguishing +between different automatic callouts, which all have the same callout number. +However, they are set for all callouts. +

Return Values

+

+The external callout +function returns an integer to PCRE. If the value is zero, matching proceeds +as normal. If the value is greater than zero, matching fails at the current +point, but backtracking to test other matching possibilities goes ahead, +just as if a lookahead assertion had failed. If the value is less than zero, +the match is abandoned, and pcre_exec() returns the negative value.

+Negative +values should normally be chosen from the set of PCRE_ERROR_xxx values. +In particular, PCRE_ERROR_NOMATCH forces a standard "no match" failure. +The error number PCRE_ERROR_CALLOUT is reserved for use by callout functions; +it will never be used by PCRE itself.

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcrecompat.3.html b/Utilities/PCRE/man/html/pcrecompat.3.html new file mode 100644 index 0000000..af67000 --- /dev/null +++ b/Utilities/PCRE/man/html/pcrecompat.3.html @@ -0,0 +1,115 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Differences Between Pcre and +Perl

+

+This document describes the differences in the ways that PCRE and +Perl handle regular expressions. The differences described here are with +respect to Perl 5.8.

+1. PCRE does not have full UTF-8 support. Details of what +it does have are given in the section on UTF-8 support in the main pcre + page.

+2. PCRE does not allow repeat quantifiers on lookahead assertions. +Perl permits them, but they do not mean what you might think. For example, +(?!a){3} does not assert that the next three characters are not "a". It +just asserts that the next character is not "a" three times.

+3. Capturing +subpatterns that occur inside negative lookahead assertions are counted, +but their entries in the offsets vector are never set. Perl sets its numerical +variables from any such patterns that are matched before the assertion +fails to match something (thereby succeeding), but only if the negative +lookahead assertion contains just one branch.

+4. Though binary zero characters +are supported in the subject string, they are not allowed in a pattern +string because it is passed as a normal C string, terminated by zero. The +escape sequence \0 can be used in the pattern to represent a binary zero. +

+5. The following Perl escape sequences are not supported: \l, \u, \L, \U, and +\N. In fact these are implemented by Perl’s general string-handling and are +not part of its pattern matching engine. If any of these are encountered +by PCRE, an error is generated.

+6. The Perl escape sequences \p, \P, and \X +are supported only if PCRE is built with Unicode character property support. +The properties that can be tested with \p and \P are limited to the general +category properties such as Lu and Nd.

+7. PCRE does support the \Q...\E escape +for quoting substrings. Characters in between are treated as literals. This +is slightly different from Perl in that $ and @ are also handled as literals +inside the quotes. In Perl, they cause variable interpolation (but of course +PCRE does not have variables). Note the following examples:

+ Pattern + PCRE matches Perl matches
+

+ \Qabc$xyz\E abc$xyz abc followed by the
+ contents of $xyz
+ \Qabc\$xyz\E abc\$xyz abc\$xyz
+ \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
+

+The \Q...\E sequence is recognized both inside and outside character classes. +

+8. Fairly obviously, PCRE does not support the (?{code}) and (?p{code}) +constructions. However, there is support for recursive patterns using the +non-Perl items (?R), (?number), and (?P>name). Also, the PCRE "callout" feature +allows an external function to be called during pattern matching. See the + pcrecallout documentation for details.

+9. There are some differences that +are concerned with the settings of captured strings when part of a pattern +is repeated. For example, matching "aba" against the pattern /^(a(b)?)+$/ +in Perl leaves $2 unset, but in PCRE it is set to "b".

+10. PCRE provides +some extensions to the Perl regular expression facilities:

+(a) Although +lookbehind assertions must match fixed length strings, each alternative +branch of a lookbehind assertion can match a different length of string. +Perl requires them all to have the same length.

+(b) If PCRE_DOLLAR_ENDONLY +is set and PCRE_MULTILINE is not set, the $ meta-character matches only +at the very end of the string.

+(c) If PCRE_EXTRA is set, a backslash followed +by a letter with no special meaning is faulted.

+(d) If PCRE_UNGREEDY is +set, the greediness of the repetition quantifiers is inverted, that is, +by default they are not greedy, but if followed by a question mark they +are.

+(e) PCRE_ANCHORED can be used at matching time to force a pattern to +be tried only at the first matching position in the subject string.

+(f) +The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NO_AUTO_CAPTURE options +for pcre_exec() have no Perl equivalents.

+(g) The (?R), (?number), and (?P>name) +constructs allows for recursive pattern matching (Perl can do this using +the (?p{code}) construct, which PCRE cannot support.)

+(h) PCRE supports +named capturing substrings, using the Python syntax.

+(i) PCRE supports the +possessive quantifier "++" syntax, taken from Sun’s Java package.

+(j) The +(R) condition, for testing recursion, is a PCRE extension.

+(k) The callout +facility is PCRE-specific.

+(l) The partial matching facility is PCRE-specific. +

+(m) Patterns compiled by PCRE can be saved and re-used at a later time, +even on different hosts that have the other endianness.

+ Last updated: 09 +September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcregrep.1.html b/Utilities/PCRE/man/html/pcregrep.1.html new file mode 100644 index 0000000..726e8b7 --- /dev/null +++ b/Utilities/PCRE/man/html/pcregrep.1.html @@ -0,0 +1,147 @@ + + + + + +PCREGREP(1) manual page + + +Table of Contents

+ +

Name

+pcregrep - a grep with Perl-compatible regular expressions. +

Synopsis

+pcregrep +[-Vcfhilnrsuvx] [long options] [pattern] [file1 file2 ...] +

Description

+

+pcregrep +searches files for character patterns, in the same way as other grep commands +do, but it uses the PCRE regular expression library to support patterns +that are compatible with the regular expressions of Perl 5. See pcrepattern + for a full description of syntax and semantics of the regular expressions +that PCRE supports.

+A pattern must be specified on the command line unless +the -f option is used (see below).

+If no files are specified, pcregrep reads +the standard input. By default, each line that matches the pattern is copied +to the standard output, and if there is more than one file, the file name +is printed before each line of output. However, there are options that can +change how pcregrep behaves.

+Lines are limited to BUFSIZ characters. BUFSIZ +is defined in <stdio.h>. The newline character is removed from the end of each +line before it is matched against the pattern. +

Options

+

+ +

+ +
-V
+
Write the version +number of the PCRE library being used to the standard error stream.
+ +
-c
+
Do +not print individual lines; instead just print a count of the number of +lines that would otherwise have been printed. If several files are given, +a count is printed for each of them.
+ +
-ffilename
+
Read a number of patterns +from the file, one per line, and match all of them against each line of +input. A line is output if any of the patterns match it. When -f is used, +no pattern is taken from the command line; all arguments are treated as +file names. There is a maximum of 100 patterns. Trailing white space is removed, +and blank lines are ignored. An empty file contains no patterns and therefore +matches nothing.
+ +
-h
+
Suppress printing of filenames when searching multiple +files.
+ +
-i
+
Ignore upper/lower case distinctions during comparisons.
+ +
-l
+
Instead +of printing lines from the files, just print the names of the files containing +lines that would have been printed. Each file name is printed once, on a +separate line.
+ +
-n
+
Precede each line by its line number in the file.
+ +
-r
+
If any +file is a directory, recursively scan the files it contains. Without -r a +directory is scanned as a normal file.
+ +
-s
+
Work silently, that is, display +nothing except error messages. The exit status indicates whether any matches +were found.
+ +
-u
+
Operate in UTF-8 mode. This option is available only if PCRE +has been compiled with UTF-8 support. Both the pattern and each subject line +must be valid strings of UTF-8 characters.
+ +
-v
+
Invert the sense of the match, +so that lines which do not match the pattern are now the ones that are +found.
+ +
-x
+
Force the pattern to be anchored (it must start matching at the +beginning of the line) and in addition, require it to match the entire +line. This is equivalent to having ^ and $ characters at the start and end +of each alternative branch in the regular expression.
+
+ +

Long Options

+

+Long +forms of all the options are available, as in GNU grep. They are shown in +the following table:

+ -c --count
+ -h --no-filename
+ -i --ignore-case
+ -l --files-with-matches
+ -n --line-number
+ -r --recursive
+ -s --no-messages
+ -u --utf-8
+ -V --version
+ -v --invert-match
+ -x --line-regex
+ -x --line-regexp
+

+In addition, --file=filename is equivalent to -ffilename, and --help shows +the list of options and then exits. +

Diagnostics

+

+Exit status is 0 if any +matches were found, 1 if no matches were found, and 2 for syntax errors +or inacessible files (even if matches were found). +

Author

+

+Philip Hazel +<ph10@cam.ac.uk>
+University Computing Service
+Cambridge CB2 3QG, England.

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcrepattern.3.html b/Utilities/PCRE/man/html/pcrepattern.3.html new file mode 100644 index 0000000..11bb198 --- /dev/null +++ b/Utilities/PCRE/man/html/pcrepattern.3.html @@ -0,0 +1,1268 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Regular Expression Details

+ +

+The syntax and semantics of the regular expressions supported by PCRE are +described below. Regular expressions are also described in the Perl documentation +and in a number of books, some of which have copious examples. Jeffrey Friedl’s +"Mastering Regular Expressions", published by O’Reilly, covers regular expressions +in great detail. This description of PCRE’s regular expressions is intended +as reference material.

+The original operation of PCRE was on strings of +one-byte characters. However, there is now also support for UTF-8 character +strings. To use this, you must build PCRE to include UTF-8 support, and then +call pcre_compile() with the PCRE_UTF8 option. How this affects pattern +matching is mentioned in several places below. There is also a summary of +UTF-8 features in the section on UTF-8 support in the main pcre page. +

+A regular expression is a pattern that is matched against a subject string +from left to right. Most characters stand for themselves in a pattern, and +match the corresponding characters in the subject. As a trivial example, +the pattern

+ The quick brown fox
+

+matches a portion of a subject string that is identical to itself. The +power of regular expressions comes from the ability to include alternatives +and repetitions in the pattern. These are encoded in the pattern by the +use of metacharacters, which do not stand for themselves but instead are +interpreted in some special way.

+There are two different sets of metacharacters: +those that are recognized anywhere in the pattern except within square +brackets, and those that are recognized in square brackets. Outside square +brackets, the metacharacters are as follows:

+ \ general escape character +with several uses
+ ^ assert start of string (or line, in multiline mode)
+ $ assert end of string (or line, in multiline mode)
+ . match any character except newline (by default)
+ [ start character class definition
+ | start of alternative branch
+ ( start subpattern
+ ) end subpattern
+ ? extends the meaning of (
+ also 0 or 1 quantifier
+ also quantifier minimizer
+ * 0 or more quantifier
+ + 1 or more quantifier
+ also "possessive quantifier"
+ { start min/max quantifier
+

+Part of a pattern that is in square brackets is called a "character class". +In a character class the only metacharacters are:

+ \ general escape +character
+ ^ negate the class, but only if the first character
+ - indicates character range
+ [ POSIX character class (only if followed by POSIX
+ syntax)
+ ] terminates the character class
+

+The following sections describe the use of each of the metacharacters. + +

Backslash

+

+The backslash character has several uses. Firstly, if it is followed +by a non-alphanumeric character, it takes away any special meaning that +character may have. This use of backslash as an escape character applies +both inside and outside character classes.

+For example, if you want to match +a * character, you write \* in the pattern. This escaping action applies +whether or not the following character would otherwise be interpreted as +a metacharacter, so it is always safe to precede a non-alphanumeric with +backslash to specify that it stands for itself. In particular, if you want +to match a backslash, you write \\.

+If a pattern is compiled with the PCRE_EXTENDED +option, whitespace in the pattern (other than in a character class) and +characters between a # outside a character class and the next newline character +are ignored. An escaping backslash can be used to include a whitespace or +# character as part of the pattern.

+If you want to remove the special meaning +from a sequence of characters, you can do so by putting them between \Q +and \E. This is different from Perl in that $ and @ are handled as literals +in \Q...\E sequences in PCRE, whereas in Perl, $ and @ cause variable interpolation. +Note the following examples:

+ Pattern PCRE matches Perl matches
+

+ \Qabc$xyz\E abc$xyz abc followed by the
+ contents of $xyz
+ \Qabc\$xyz\E abc\$xyz abc\$xyz
+ \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
+

+The \Q...\E sequence is recognized both inside and outside character classes. + +

Non-printing characters

+

+A second use of backslash provides a way of encoding +non-printing characters in patterns in a visible manner. There is no restriction +on the appearance of non-printing characters, apart from the binary zero +that terminates a pattern, but when a pattern is being prepared by text +editing, it is usually easier to use one of the following escape sequences +than the binary character it represents:

+ \a alarm, that is, the +BEL character (hex 07)
+ \cx "control-x", where x is any character
+ \e escape (hex 1B)
+ \f formfeed (hex 0C)
+ \n newline (hex 0A)
+ \r carriage return (hex 0D)
+ \t tab (hex 09)
+ \ddd character with octal code ddd, or backreference
+ \xhh character with hex code hh
+ \x{hhh..} character with hex code hhh... (UTF-8 mode only)
+

+The precise effect of \cx is as follows: if x is a lower case letter, it +is converted to upper case. Then bit 6 of the character (hex 40) is inverted. +Thus \cz becomes hex 1A, but \c{ becomes hex 3B, while \c; becomes hex 7B. +

+After \x, from zero to two hexadecimal digits are read (letters can be in +upper or lower case). In UTF-8 mode, any number of hexadecimal digits may +appear between \x{ and }, but the value of the character code must be less +than 2**31 (that is, the maximum hexadecimal value is 7FFFFFFF). If characters +other than hexadecimal digits appear between \x{ and }, or if there is no +terminating }, this form of escape is not recognized. Instead, the initial +\x will be interpreted as a basic hexadecimal escape, with no following +digits, giving a character whose value is zero.

+Characters whose value is +less than 256 can be defined by either of the two syntaxes for \x when PCRE +is in UTF-8 mode. There is no difference in the way they are handled. For +example, \xdc is exactly the same as \x{dc}.

+After \0 up to two further octal +digits are read. In both cases, if there are fewer than two digits, just +those that are present are used. Thus the sequence \0\x\07 specifies two binary +zeros followed by a BEL character (code value 7). Make sure you supply two +digits after the initial zero if the pattern character that follows is +itself an octal digit.

+The handling of a backslash followed by a digit other +than 0 is complicated. Outside a character class, PCRE reads it and any +following digits as a decimal number. If the number is less than 10, or +if there have been at least that many previous capturing left parentheses +in the expression, the entire sequence is taken as a back reference. A description +of how this works is given later, following the discussion of parenthesized +subpatterns.

+Inside a character class, or if the decimal number is greater +than 9 and there have not been that many capturing subpatterns, PCRE re-reads +up to three octal digits following the backslash, and generates a single +byte from the least significant 8 bits of the value. Any subsequent digits +stand for themselves. For example:

+ \040 is another way of writing a space
+ \40 is the same, provided there are fewer than 40
+ previous capturing subpatterns
+ \7 is always a back reference
+ \11 might be a back reference, or another way of
+ writing a tab
+ \011 is always a tab
+ \0113 is a tab followed by the character "3"
+ \113 might be a back reference, otherwise the
+ character with octal code 113
+ \377 might be a back reference, otherwise
+ the byte consisting entirely of 1 bits
+ \81 is either a back reference, or a binary zero
+ followed by the two characters "8" and "1"
+

+Note that octal values of 100 or greater must not be introduced by a leading +zero, because no more than three octal digits are ever read.

+All the sequences +that define a single byte value or a single UTF-8 character (in UTF-8 mode) +can be used both inside and outside character classes. In addition, inside +a character class, the sequence \b is interpreted as the backspace character +(hex 08), and the sequence \X is interpreted as the character "X". Outside +a character class, these sequences have different meanings (see below). + +

Generic character types

+

+The third use of backslash is for specifying +generic character types. The following are always recognized:

+ \d any +decimal digit
+ \D any character that is not a decimal digit
+ \s any whitespace character
+ \S any character that is not a whitespace character
+ \w any "word" character
+ \W any "non-word" character
+

+Each pair of escape sequences partitions the complete set of characters +into two disjoint sets. Any given character matches one, and only one, of +each pair.

+These character type sequences can appear both inside and outside +character classes. They each match one character of the appropriate type. +If the current matching point is at the end of the subject string, all +of them fail, since there is no character to match.

+For compatibility with +Perl, \s does not match the VT character (code 11). This makes it different +from the the POSIX "space" class. The \s characters are HT (9) +, LF (10), +FF (12), CR (13), and space (32).

+A "word" character is an underscore or +any character less than 256 that is a letter or digit. The definition of +letters and digits is controlled by PCRE’s low-valued character tables, and +may vary if locale-specific matching is taking place (see "Locale support" + in the pcreapi page). For example, in the "fr_FR" (French) locale, some +character codes greater than 128 are used for accented letters, and these +are matched by \w.

+In UTF-8 mode, characters with values greater than 128 +never match \d, \s, or \w, and always match \D, \S, and \W. This is true even +when Unicode character property support is available. +

Unicode character +properties

+

+When PCRE is built with Unicode character property support, +three additional escape sequences to match generic character types are +available when UTF-8 mode is selected. They are:

+ \p{xx} a character with +the xx property
+ \P{xx} a character without the xx property
+ \X an extended Unicode sequence
+

+The property names represented by xx above are limited to the Unicode +general category properties. Each character has exactly one such property, +specified by a two-letter abbreviation. For compatibility with Perl, negation +can be specified by including a circumflex between the opening brace and +the property name. For example, \p{^Lu} is the same as \P{Lu}.

+If only one letter +is specified with \p or \P, it includes all the properties that start with +that letter. In this case, in the absence of negation, the curly brackets +in the escape sequence are optional; these two examples have the same effect: +

+ \p{L}
+ \pL
+

+The following property codes are supported:

+ C Other
+ Cc Control
+ Cf Format
+ Cn Unassigned
+ Co Private use
+ Cs Surrogate
+

+ L Letter
+ Ll Lower case letter
+ Lm Modifier letter
+ Lo Other letter
+ Lt Title case letter
+ Lu Upper case letter
+

+ M Mark
+ Mc Spacing mark
+ Me Enclosing mark
+ Mn Non-spacing mark
+

+ N Number
+ Nd Decimal number
+ Nl Letter number
+ No Other number
+

+ P Punctuation
+ Pc Connector punctuation
+ Pd Dash punctuation
+ Pe Close punctuation
+ Pf Final punctuation
+ Pi Initial punctuation
+ Po Other punctuation
+ Ps Open punctuation
+

+ S Symbol
+ Sc Currency symbol
+ Sk Modifier symbol
+ Sm Mathematical symbol
+ So Other symbol
+

+ Z Separator
+ Zl Line separator
+ Zp Paragraph separator
+ Zs Space separator
+

+Extended properties such as "Greek" or "InMusicalSymbols" are not supported +by PCRE.

+Specifying caseless matching does not affect these escape sequences. +For example, \p{Lu} always matches only upper case letters.

+The \X escape +matches any number of Unicode characters that form an extended Unicode +sequence. \X is equivalent to

+ (?>\PM\pM*)
+

+That is, it matches a character without the "mark" property, followed +by zero or more characters with the "mark" property, and treats the sequence +as an atomic group (see below). Characters with the "mark" property are +typically accents that affect the preceding character.

+Matching characters +by Unicode property is not fast, because PCRE has to search a structure +that contains data for over fifteen thousand characters. That is why the +traditional escape sequences such as \d and \w do not use Unicode properties +in PCRE. +

Simple assertions

+

+The fourth use of backslash is for certain +simple assertions. An assertion specifies a condition that has to be met +at a particular point in a match, without consuming any characters from +the subject string. The use of subpatterns for more complicated assertions +is described below. The backslashed assertions are:

+ \b matches at +a word boundary
+ \B matches when not at a word boundary
+ \A matches at start of subject
+ \Z matches at end of subject or before newline at end
+ \z matches at end of subject
+ \G matches at first matching position in subject
+

+These assertions may not appear in character classes (but note that \b +has a different meaning, namely the backspace character, inside a character +class).

+A word boundary is a position in the subject string where the current +character and the previous character do not both match \w or \W (i.e. one matches +\w and the other matches \W), or the start or end of the string if the first +or last character matches \w, respectively.

+The \A, \Z, and \z assertions differ +from the traditional circumflex and dollar (described in the next section) +in that they only ever match at the very start and end of the subject string, +whatever options are set. Thus, they are independent of multiline mode. These +three assertions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, +which affect only the behaviour of the circumflex and dollar metacharacters. +However, if the startoffset argument of pcre_exec() is non-zero, indicating +that matching is to start at a point other than the beginning of the subject, +\A can never match. The difference between \Z and \z is that \Z matches before +a newline that is the last character of the string as well as at the end +of the string, whereas \z matches only at the end.

+The \G assertion is true +only when the current matching position is at the start point of the match, +as specified by the startoffset argument of pcre_exec(). It differs from +\A when the value of startoffset is non-zero. By calling pcre_exec() multiple +times with appropriate arguments, you can mimic Perl’s /g option, and it +is in this kind of implementation where \G can be useful.

+Note, however, +that PCRE’s interpretation of \G, as the start of the current match, is subtly +different from Perl’s, which defines it as the end of the previous match. +In Perl, these can be different when the previously matched string was +empty. Because PCRE does just one match at a time, it cannot reproduce this +behaviour.

+If all the alternatives of a pattern begin with \G, the expression +is anchored to the starting match position, and the "anchored" flag is +set in the compiled regular expression. +

Circumflex and Dollar

+

+Outside +a character class, in the default matching mode, the circumflex character +is an assertion that is true only if the current matching point is at the +start of the subject string. If the startoffset argument of pcre_exec() +is non-zero, circumflex can never match if the PCRE_MULTILINE option is +unset. Inside a character class, circumflex has an entirely different meaning + (see below).

+Circumflex need not be the first character of the pattern +if a number of alternatives are involved, but it should be the first thing +in each alternative in which it appears if the pattern is ever to match +that branch. If all possible alternatives start with a circumflex, that +is, if the pattern is constrained to match only at the start of the subject, +it is said to be an "anchored" pattern. (There are also other constructs +that can cause a pattern to be anchored.)

+A dollar character is an assertion +that is true only if the current matching point is at the end of the subject +string, or immediately before a newline character that is the last character +in the string (by default). Dollar need not be the last character of the +pattern if a number of alternatives are involved, but it should be the +last item in any branch in which it appears. Dollar has no special meaning +in a character class.

+The meaning of dollar can be changed so that it matches +only at the very end of the string, by setting the PCRE_DOLLAR_ENDONLY +option at compile time. This does not affect the \Z assertion.

+The meanings +of the circumflex and dollar characters are changed if the PCRE_MULTILINE +option is set. When this is the case, they match immediately after and immediately +before an internal newline character, respectively, in addition to matching +at the start and end of the subject string. For example, the pattern /^abc$/ +matches the subject string "def\nabc" (where \n represents a newline character) +in multiline mode, but not otherwise. Consequently, patterns that are anchored +in single line mode because all branches start with ^ are not anchored in +multiline mode, and a match for circumflex is possible when the startoffset +argument of pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored +if PCRE_MULTILINE is set.

+Note that the sequences \A, \Z, and \z can be used +to match the start and end of the subject in both modes, and if all branches +of a pattern start with \A it is always anchored, whether PCRE_MULTILINE +is set or not. +

Full Stop (period, Dot)

+

+Outside a character class, a dot +in the pattern matches any one character in the subject, including a non-printing +character, but not (by default) newline. In UTF-8 mode, a dot matches any +UTF-8 character, which might be more than one byte long, except (by default) +newline. If the PCRE_DOTALL option is set, dots match newlines as well. The +handling of dot is entirely independent of the handling of circumflex and +dollar, the only relationship being that they both involve newline characters. +Dot has no special meaning in a character class. +

Matching a Single Byte

+ +

+Outside a character class, the escape sequence \C matches any one byte, +both in and out of UTF-8 mode. Unlike a dot, it can match a newline. The feature +is provided in Perl in order to match individual bytes in UTF-8 mode. Because +it breaks up UTF-8 characters into individual bytes, what remains in the +string may be a malformed UTF-8 string. For this reason, the \C escape sequence +is best avoided.

+PCRE does not allow \C to appear in lookbehind assertions + (described below), because in UTF-8 mode this would make it impossible +to calculate the length of the lookbehind. +

Square Brackets and Character +Classes

+

+An opening square bracket introduces a character class, terminated +by a closing square bracket. A closing square bracket on its own is not +special. If a closing square bracket is required as a member of the class, +it should be the first data character in the class (after an initial circumflex, +if present) or escaped with a backslash.

+A character class matches a single +character in the subject. In UTF-8 mode, the character may occupy more than +one byte. A matched character must be in the set of characters defined by +the class, unless the first character in the class definition is a circumflex, +in which case the subject character must not be in the set defined by the +class. If a circumflex is actually required as a member of the class, ensure +it is not the first character, or escape it with a backslash.

+For example, +the character class [aeiou] matches any lower case vowel, while [^aeiou] +matches any character that is not a lower case vowel. Note that a circumflex +is just a convenient notation for specifying the characters that are in +the class by enumerating those that are not. A class that starts with a +circumflex is not an assertion: it still consumes a character from the +subject string, and therefore it fails if the current pointer is at the +end of the string.

+In UTF-8 mode, characters with values greater than 255 +can be included in a class as a literal string of bytes, or by using the +\x{ escaping mechanism.

+When caseless matching is set, any letters in a class +represent both their upper case and lower case versions, so for example, +a caseless [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does +not match "A", whereas a caseful version would. When running in UTF-8 mode, +PCRE supports the concept of case for characters with values greater than +128 only when it is compiled with Unicode property support.

+The newline +character is never treated in any special way in character classes, whatever +the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class such +as [^a] will always match a newline.

+The minus (hyphen) character can be +used to specify a range of characters in a character class. For example, +[d-m] matches any letter between d and m, inclusive. If a minus character +is required in a class, it must be escaped with a backslash or appear in +a position where it cannot be interpreted as indicating a range, typically +as the first or last character in the class.

+It is not possible to have +the literal character "]" as the end character of a range. A pattern such +as [W-]46] is interpreted as a class of two characters ("W" and "-") followed +by a literal string "46]", so it would match "W46]" or "-46]". However, if +the "]" is escaped with a backslash it is interpreted as the end of range, +so [W-\]46] is interpreted as a class containing a range followed by two +other characters. The octal or hexadecimal representation of "]" can also +be used to end a range.

+Ranges operate in the collating sequence of character +values. They can also be used for characters specified numerically, for +example [\000-\037]. In UTF-8 mode, ranges can include characters whose values +are greater than 255, for example [\x{100}-\x{2ff}].

+If a range that includes +letters is used when caseless matching is set, it matches the letters in +either case. For example, [W-c] is equivalent to [][\\^_‘wxyzabc], matched caselessly, +and in non-UTF-8 mode, if character tables for the "fr_FR" locale are in +use, [\xc8-\xcb] matches accented E characters in both cases. In UTF-8 mode, +PCRE supports the concept of case for characters with values greater than +128 only when it is compiled with Unicode property support.

+The character +types \d, \D, \p, \P, \s, \S, \w, and \W may also appear in a character class, +and add the characters that they match to the class. For example, [\dABCDEF] +matches any hexadecimal digit. A circumflex can conveniently be used with +the upper case character types to specify a more restricted set of characters +than the matching lower case type. For example, the class [^\W_] matches any +letter or digit, but not underscore.

+The only metacharacters that are recognized +in character classes are backslash, hyphen (only where it can be interpreted +as specifying a range), circumflex (only at the start), opening square +bracket (only when it can be interpreted as introducing a POSIX class name +- see the next section), and the terminating closing square bracket. However, +escaping other non-alphanumeric characters does no harm. +

Posix Character +Classes

+

+Perl supports the POSIX notation for character classes. This uses +names enclosed by [: and :] within the enclosing square brackets. PCRE also +supports this notation. For example,

+ [01[:alpha:]%]
+

+matches "0", "1", any alphabetic character, or "%". The supported class +names are

+ alnum letters and digits
+ alpha letters
+ ascii character codes 0 - 127
+ blank space or tab only
+ cntrl control characters
+ digit decimal digits (same as \d)
+ graph printing characters, excluding space
+ lower lower case letters
+ print printing characters, including space
+ punct printing characters, excluding letters and digits
+ space white space (not quite the same as \s)
+ upper upper case letters
+ word "word" characters (same as \w)
+ xdigit hexadecimal digits
+

+The "space" characters are HT (9) +, LF (10), VT (11), FF (12), CR (13), +and space (32). Notice that this list includes the VT character (code 11). +This makes "space" different to \s, which does not include VT (for Perl +compatibility).

+The name "word" is a Perl extension, and "blank" is a GNU +extension from Perl 5.8. Another Perl extension is negation, which is indicated +by a ^ character after the colon. For example,

+ [12[:^digit:]]
+

+matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX +syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are +not supported, and an error is given if they are encountered.

+In UTF-8 mode, +characters with values greater than 128 do not match any of the POSIX character +classes. +

Vertical Bar

+

+Vertical bar characters are used to separate alternative +patterns. For example, the pattern

+ gilbert|sullivan
+

+matches either "gilbert" or "sullivan". Any number of alternatives may +appear, and an empty alternative is permitted (matching the empty string). +The matching process tries each alternative in turn, from left to right, +and the first one that succeeds is used. If the alternatives are within +a subpattern (defined below), "succeeds" means matching the rest of +the main pattern as well as the alternative in the subpattern. +

Internal +Option Setting

+

+The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, +and PCRE_EXTENDED options can be changed from within the pattern by a sequence +of Perl option letters enclosed between "(?" and ")". The option letters +are

+ i for PCRE_CASELESS
+ m for PCRE_MULTILINE
+ s for PCRE_DOTALL
+ x for PCRE_EXTENDED
+

+For example, (?im) sets caseless, multiline matching. It is also possible +to unset these options by preceding the letter with a hyphen, and a combined +setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and PCRE_MULTILINE +while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also permitted. If a letter +appears both before and after the hyphen, the option is unset.

+When an option +change occurs at top level (that is, not inside subpattern parentheses), +the change applies to the remainder of the pattern that follows. If the +change is placed right at the start of a pattern, PCRE extracts it into +the global options (and it will therefore show up in data extracted by +the pcre_fullinfo() function).

+An option change within a subpattern affects +only that part of the current pattern that follows it, so

+ (a(?i)b)c
+

+matches abc and aBc and no other strings (assuming PCRE_CASELESS is not +used). By this means, options can be made to have different settings in +different parts of the pattern. Any changes made in one alternative do carry +on into subsequent branches within the same subpattern. For example,

+ (a(?i)b|c)
+

+matches "ab", "aB", "c", and "C", even though when matching "C" the first +branch is abandoned before the option setting. This is because the effects +of option settings happen at compile time. There would be some very weird +behaviour otherwise.

+The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA +can be changed in the same way as the Perl-compatible options by using the +characters U and X respectively. The (?X) flag setting is special in that +it must always occur earlier in the pattern than any of the additional +features it turns on, even when it is at top level. It is best to put it +at the start. +

Subpatterns

+

+Subpatterns are delimited by parentheses (round +brackets), which can be nested. Turning part of a pattern into a subpattern +does two things:

+1. It localizes a set of alternatives. For example, the +pattern

+ cat(aract|erpillar|)
+

+matches one of the words "cat", "cataract", or "caterpillar". Without the +parentheses, it would match "cataract", "erpillar" or the empty string. +

+2. It sets up the subpattern as a capturing subpattern. This means that, +when the whole pattern matches, that portion of the subject string that +matched the subpattern is passed back to the caller via the ovector argument +of pcre_exec(). Opening parentheses are counted from left to right (starting +from 1) to obtain numbers for the capturing subpatterns.

+For example, if +the string "the red king" is matched against the pattern

+ the ((red|white) +(king|queen))
+

+the captured substrings are "red king", "red", and "king", and are numbered +1, 2, and 3, respectively.

+The fact that plain parentheses fulfil two functions +is not always helpful. There are often times when a grouping subpattern +is required without a capturing requirement. If an opening parenthesis is +followed by a question mark and a colon, the subpattern does not do any +capturing, and is not counted when computing the number of any subsequent +capturing subpatterns. For example, if the string "the white queen" is matched +against the pattern

+ the ((?:red|white) (king|queen))
+

+the captured substrings are "white queen" and "queen", and are numbered +1 and 2. The maximum number of capturing subpatterns is 65535, and the maximum +depth of nesting of all subpatterns, both capturing and non-capturing, is +200.

+As a convenient shorthand, if any option settings are required at the +start of a non-capturing subpattern, the option letters may appear between +the "?" and the ":". Thus the two patterns

+ (?i:saturday|sunday)
+ (?:(?i)saturday|sunday)
+

+match exactly the same set of strings. Because alternative branches are +tried from left to right, and options are not reset until the end of the +subpattern is reached, an option setting in one branch does affect subsequent +branches, so the above patterns match "SUNDAY" as well as "Saturday". + +

Named Subpatterns

+

+Identifying capturing parentheses by number is simple, +but it can be very hard to keep track of the numbers in complicated regular +expressions. Furthermore, if an expression is modified, the numbers may +change. To help with this difficulty, PCRE supports the naming of subpatterns, +something that Perl does not provide. The Python syntax (?P<name>...) is used. +Names consist of alphanumeric characters and underscores, and must be unique +within a pattern.

+Named capturing parentheses are still allocated numbers +as well as names. The PCRE API provides function calls for extracting the +name-to-number translation table from a compiled pattern. There is also a +convenience function for extracting a captured substring by name. For further +details see the pcreapi documentation. +

Repetition

+

+Repetition is specified +by quantifiers, which can follow any of the following items:

+ a literal +data character
+ the . metacharacter
+ the \C escape sequence
+ the \X escape sequence (in UTF-8 mode with Unicode properties)
+ an escape such as \d that matches a single character
+ a character class
+ a back reference (see next section)
+ a parenthesized subpattern (unless it is an assertion)
+

+The general repetition quantifier specifies a minimum and maximum number +of permitted matches, by giving the two numbers in curly brackets (braces), +separated by a comma. The numbers must be less than 65536, and the first +must be less than or equal to the second. For example:

+ z{2,4}
+

+matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special +character. If the second number is omitted, but the comma is present, there +is no upper limit; if the second number and the comma are both omitted, +the quantifier specifies an exact number of required matches. Thus

+ [aeiou]{3,}
+

+matches at least 3 successive vowels, but may match many more, while

+ + \d{8}
+

+matches exactly 8 digits. An opening curly bracket that appears in a position +where a quantifier is not allowed, or one that does not match the syntax +of a quantifier, is taken as a literal character. For example, {,6} is not +a quantifier, but a literal string of four characters.

+In UTF-8 mode, quantifiers +apply to UTF-8 characters rather than to individual bytes. Thus, for example, +\x{100}{2} matches two UTF-8 characters, each of which is represented by +a two-byte sequence. Similarly, when Unicode property support is available, +\X{3} matches three Unicode extended sequences, each of which may be several +bytes long (and they may be of different lengths).

+The quantifier {0} is +permitted, causing the expression to behave as if the previous item and +the quantifier were not present.

+For convenience (and historical compatibility) +the three most common quantifiers have single-character abbreviations:

+ + * is equivalent to {0,}
+ + is equivalent to {1,}
+ ? is equivalent to {0,1}
+

+It is possible to construct infinite loops by following a subpattern that +can match no characters with a quantifier that has no upper limit, for +example:

+ (a?)*
+

+Earlier versions of Perl and PCRE used to give an error at compile time +for such patterns. However, because there are cases where this can be useful, +such patterns are now accepted, but if any repetition of the subpattern +does in fact match no characters, the loop is forcibly broken.

+By default, +the quantifiers are "greedy", that is, they match as much as possible (up +to the maximum number of permitted times), without causing the rest of +the pattern to fail. The classic example of where this gives problems is +in trying to match comments in C programs. These appear between /* and */ +and within the comment, individual * and / characters may appear. An attempt +to match C comments by applying the pattern

+ /\*.*\*/
+

+to the string

+ /* first comment */ not comment /* second comment */
+

+fails, because it matches the entire string owing to the greediness of +the .* item.

+However, if a quantifier is followed by a question mark, it +ceases to be greedy, and instead matches the minimum number of times possible, +so the pattern

+ /\*.*?\*/
+

+does the right thing with the C comments. The meaning of the various quantifiers +is not otherwise changed, just the preferred number of matches. Do not confuse +this use of question mark with its use as a quantifier in its own right. +Because it has two uses, it can sometimes appear doubled, as in

+ \d??\d
+

+which matches one digit by preference, but can match two if that is the +only way the rest of the pattern matches.

+If the PCRE_UNGREEDY option is +set (an option which is not available in Perl), the quantifiers are not +greedy by default, but individual ones can be made greedy by following +them with a question mark. In other words, it inverts the default behaviour. +

+When a parenthesized subpattern is quantified with a minimum repeat count +that is greater than 1 or with a limited maximum, more memory is required +for the compiled pattern, in proportion to the size of the minimum or maximum. +

+If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent +to Perl’s /s) is set, thus allowing the . to match newlines, the pattern +is implicitly anchored, because whatever follows will be tried against +every character position in the subject string, so there is no point in +retrying the overall match at any position after the first. PCRE normally +treats such a pattern as though it were preceded by \A.

+In cases where it +is known that the subject string contains no newlines, it is worth setting +PCRE_DOTALL in order to obtain this optimization, or alternatively using +^ to indicate anchoring explicitly.

+However, there is one situation where +the optimization cannot be used. When .* is inside capturing parentheses +that are the subject of a backreference elsewhere in the pattern, a match +at the start may fail, and a later one succeed. Consider, for example:

+ + (.*)abc\1
+

+If the subject is "xyz123abc123" the match point is the fourth character. +For this reason, such a pattern is not implicitly anchored.

+When a capturing +subpattern is repeated, the value captured is the substring that matched +the final iteration. For example, after

+ (tweedle[dume]{3}\s*)+
+

+has matched "tweedledum tweedledee" the value of the captured substring +is "tweedledee". However, if there are nested capturing subpatterns, the +corresponding captured values may have been set in previous iterations. +For example, after

+ /(a|(b))+/
+

+matches "aba" the value of the second captured substring is "b". +

Atomic +Grouping and Possessive Quantifiers

+

+With both maximizing and minimizing +repetition, failure of what follows normally causes the repeated item to +be re-evaluated to see if a different number of repeats allows the rest +of the pattern to match. Sometimes it is useful to prevent this, either +to change the nature of the match, or to cause it fail earlier than it +otherwise might, when the author of the pattern knows there is no point +in carrying on.

+Consider, for example, the pattern \d+foo when applied to +the subject line

+ 123456bar
+

+After matching all 6 digits and then failing to match "foo", the normal +action of the matcher is to try again with only 5 digits matching the \d+ +item, and then with 4, and so on, before ultimately failing. "Atomic grouping" +(a term taken from Jeffrey Friedl’s book) provides the means for specifying +that once a subpattern has matched, it is not to be re-evaluated in this +way.

+If we use atomic grouping for the previous example, the matcher would +give up immediately on failing to match "foo" the first time. The notation +is a kind of special parenthesis, starting with (?> as in this example: +

+ (?>\d+)foo
+

+This kind of parenthesis "locks up" the part of the pattern it contains +once it has matched, and a failure further into the pattern is prevented +from backtracking into it. Backtracking past it to previous items, however, +works as normal.

+An alternative description is that a subpattern of this +type matches the string of characters that an identical standalone pattern +would match, if anchored at the current point in the subject string.

+Atomic +grouping subpatterns are not capturing subpatterns. Simple cases such as +the above example can be thought of as a maximizing repeat that must swallow +everything it can. So, while both \d+ and \d+? are prepared to adjust the +number of digits they match in order to make the rest of the pattern match, +(?>\d+) can only match an entire sequence of digits.

+Atomic groups in general +can of course contain arbitrarily complicated subpatterns, and can be nested. +However, when the subpattern for an atomic group is just a single repeated +item, as in the example above, a simpler notation, called a "possessive +quantifier" can be used. This consists of an additional + character following +a quantifier. Using this notation, the previous example can be rewritten +as

+ \d++foo
+

+Possessive quantifiers are always greedy; the setting of the PCRE_UNGREEDY +option is ignored. They are a convenient notation for the simpler forms +of atomic group. However, there is no difference in the meaning or processing +of a possessive quantifier and the equivalent atomic group.

+The possessive +quantifier syntax is an extension to the Perl syntax. It originates in Sun’s +Java package.

+When a pattern contains an unlimited repeat inside a subpattern +that can itself be repeated an unlimited number of times, the use of an +atomic group is the only way to avoid some failing matches taking a very +long time indeed. The pattern

+ (\D+|<\d+>)*[!?]
+

+matches an unlimited number of substrings that either consist of non-digits, +or digits enclosed in <>, followed by either ! or ?. When it matches, it runs +quickly. However, if it is applied to

+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+

+it takes a long time before reporting failure. This is because the string +can be divided between the internal \D+ repeat and the external * repeat +in a large number of ways, and all have to be tried. (The example uses [!?] +rather than a single character at the end, because both PCRE and Perl have +an optimization that allows for fast failure when a single character is +used. They remember the last single character that is required for a match, +and fail early if it is not present in the string.) If the pattern is changed +so that it uses an atomic group, like this:

+ ((?>\D+)|<\d+>)*[!?]
+

+sequences of non-digits cannot be broken, and failure happens quickly. + +

Back References

+

+Outside a character class, a backslash followed by a +digit greater than 0 (and possibly further digits) is a back reference +to a capturing subpattern earlier (that is, to its left) in the pattern, +provided there have been that many previous capturing left parentheses. +

+However, if the decimal number following the backslash is less than 10, +it is always taken as a back reference, and causes an error only if there +are not that many capturing left parentheses in the entire pattern. In other +words, the parentheses that are referenced need not be to the left of the +reference for numbers less than 10. See the subsection entitled "Non-printing +characters" above for further details of the handling of digits following +a backslash.

+A back reference matches whatever actually matched the capturing +subpattern in the current subject string, rather than anything matching +the subpattern itself (see "Subpatterns as subroutines" below for a +way of doing that). So the pattern

+ (sens|respons)e and \1ibility
+

+matches "sense and sensibility" and "response and responsibility", but +not "sense and responsibility". If caseful matching is in force at the time +of the back reference, the case of letters is relevant. For example,

+ ((?i)rah)\s+\1
+

+matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original +capturing subpattern is matched caselessly.

+Back references to named subpatterns +use the Python syntax (?P=name). We could rewrite the above example as follows: +

+ (?<p1>(?i)rah)\s+(?P=p1)
+

+There may be more than one back reference to the same subpattern. If a +subpattern has not actually been used in a particular match, any back references +to it always fail. For example, the pattern

+ (a|(bc))\2
+

+always fails if it starts to match "a" rather than "bc". Because there +may be many capturing parentheses in a pattern, all digits following the +backslash are taken as part of a potential back reference number. If the +pattern continues with a digit character, some delimiter must be used to +terminate the back reference. If the PCRE_EXTENDED option is set, this can +be whitespace. Otherwise an empty comment (see "Comments" below) can +be used.

+A back reference that occurs inside the parentheses to which it +refers fails when the subpattern is first used, so, for example, (a\1) never +matches. However, such references can be useful inside repeated subpatterns. +For example, the pattern

+ (a|b\1)+
+

+matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration +of the subpattern, the back reference matches the character string corresponding +to the previous iteration. In order for this to work, the pattern must be +such that the first iteration does not need to match the back reference. +This can be done using alternation, as in the example above, or by a quantifier +with a minimum of zero. +

Assertions

+

+An assertion is a test on the characters +following or preceding the current matching point that does not actually +consume any characters. The simple assertions coded as \b, \B, \A, \G, \Z, \z, +^ and $ are described above.

+More complicated assertions are coded as +subpatterns. There are two kinds: those that look ahead of the current position +in the subject string, and those that look behind it. An assertion subpattern +is matched in the normal way, except that it does not cause the current +matching position to be changed.

+Assertion subpatterns are not capturing +subpatterns, and may not be repeated, because it makes no sense to assert +the same thing several times. If any kind of assertion contains capturing +subpatterns within it, these are counted for the purposes of numbering +the capturing subpatterns in the whole pattern. However, substring capturing +is carried out only for positive assertions, because it does not make sense +for negative assertions. +

Lookahead assertions

+

+Lookahead assertions start +with (?= for positive assertions and (?! for negative assertions. For example, +

+ \w+(?=;)
+

+matches a word followed by a semicolon, but does not include the semicolon +in the match, and

+ foo(?!bar)
+

+matches any occurrence of "foo" that is not followed by "bar". Note that +the apparently similar pattern

+ (?!foo)bar
+

+does not find an occurrence of "bar" that is preceded by something other +than "foo"; it finds any occurrence of "bar" whatsoever, because the assertion +(?!foo) is always true when the next three characters are "bar". A lookbehind +assertion is needed to achieve the other effect.

+If you want to force a +matching failure at some point in a pattern, the most convenient way to +do it is with (?!) because an empty string always matches, so an assertion +that requires there not to be an empty string must always fail. +

Lookbehind +assertions

+

+Lookbehind assertions start with (?<= for positive assertions +and (?<! for negative assertions. For example,

+ (?<!foo)bar
+

+does find an occurrence of "bar" that is not preceded by "foo". The contents +of a lookbehind assertion are restricted such that all the strings it matches +must have a fixed length. However, if there are several alternatives, they +do not all have to have the same fixed length. Thus

+ (?<=bullock|donkey)
+

+is permitted, but

+ (?<!dogs?|cats?)
+

+causes an error at compile time. Branches that match different length strings +are permitted only at the top level of a lookbehind assertion. This is an +extension compared with Perl (at least for 5.8), which requires all branches +to match the same length of string. An assertion such as

+ (?<=ab(c|de))
+

+is not permitted, because its single top-level branch can match two different +lengths, but it is acceptable if rewritten to use two top-level branches: +

+ (?<=abc|abde)
+

+The implementation of lookbehind assertions is, for each alternative, +to temporarily move the current position back by the fixed width and then +try to match. If there are insufficient characters before the current position, +the match is deemed to fail.

+PCRE does not allow the \C escape (which matches +a single byte in UTF-8 mode) to appear in lookbehind assertions, because +it makes it impossible to calculate the length of the lookbehind. The \X +escape, which can match different numbers of bytes, is also not permitted. +

+Atomic groups can be used in conjunction with lookbehind assertions to +specify efficient matching at the end of the subject string. Consider a +simple pattern such as

+ abcd$
+

+when applied to a long string that does not match. Because matching proceeds +from left to right, PCRE will look for each "a" in the subject and then +see if what follows matches the rest of the pattern. If the pattern is specified +as

+ ^.*abcd$
+

+the initial .* matches the entire string at first, but when this fails +(because there is no following "a"), it backtracks to match all but the +last character, then all but the last two characters, and so on. Once again +the search for "a" covers the entire string, from right to left, so we +are no better off. However, if the pattern is written as

+ ^(?>.*)(?<=abcd)
+

+or, equivalently, using the possessive quantifier syntax,

+ ^.*+(?<=abcd)
+

+there can be no backtracking for the .* item; it can match only the entire +string. The subsequent lookbehind assertion does a single test on the last +four characters. If it fails, the match fails immediately. For long strings, +this approach makes a significant difference to the processing time. +

Using +multiple assertions

+

+Several assertions (of any sort) may occur in succession. +For example,

+ (?<=\d{3})(?<!999)foo
+

+matches "foo" preceded by three digits that are not "999". Notice that +each of the assertions is applied independently at the same point in the +subject string. First there is a check that the previous three characters +are all digits, and then there is a check that the same three characters +are not "999". This pattern does not match "foo" preceded by six characters, +the first of which are digits and the last three of which are not "999". +For example, it doesn’t match "123abcfoo". A pattern to do that is

+ (?<=\d{3}...)(?<!999)foo
+

+This time the first assertion looks at the preceding six characters, checking +that the first three are digits, and then the second assertion checks that +the preceding three characters are not "999".

+Assertions can be nested in +any combination. For example,

+ (?<=(?<!foo)bar)baz
+

+matches an occurrence of "baz" that is preceded by "bar" which in turn +is not preceded by "foo", while

+ (?<=\d{3}(?!999)...)foo
+

+is another pattern that matches "foo" preceded by three digits and any +three characters that are not "999". +

Conditional Subpatterns

+

+It is possible +to cause the matching process to obey a subpattern conditionally or to +choose between two alternative subpatterns, depending on the result of +an assertion, or whether a previous capturing subpattern matched or not. +The two possible forms of conditional subpattern are

+ (?(condition)yes-pattern)
+ (?(condition)yes-pattern|no-pattern)
+

+If the condition is satisfied, the yes-pattern is used; otherwise the no-pattern +(if present) is used. If there are more than two alternatives in the subpattern, +a compile-time error occurs.

+There are three kinds of condition. If the text +between the parentheses consists of a sequence of digits, the condition +is satisfied if the capturing subpattern of that number has previously +matched. The number must be greater than zero. Consider the following pattern, +which contains non-significant white space to make it more readable (assume +the PCRE_EXTENDED option) and to divide it into three parts for ease of +discussion:

+ ( \( )? [^()]+ (?(1) \) )
+

+The first part matches an optional opening parenthesis, and if that character +is present, sets it as the first captured substring. The second part matches +one or more characters that are not parentheses. The third part is a conditional +subpattern that tests whether the first set of parentheses matched or not. +If they did, that is, if subject started with an opening parenthesis, the +condition is true, and so the yes-pattern is executed and a closing parenthesis +is required. Otherwise, since no-pattern is not present, the subpattern matches +nothing. In other words, this pattern matches a sequence of non-parentheses, +optionally enclosed in parentheses.

+If the condition is the string (R), +it is satisfied if a recursive call to the pattern or subpattern has been +made. At "top level", the condition is false. This is a PCRE extension. Recursive +patterns are described in the next section.

+If the condition is not a sequence +of digits or (R), it must be an assertion. This may be a positive or negative +lookahead or lookbehind assertion. Consider this pattern, again containing +non-significant white space, and with the two alternatives on the second +line:

+ (?(?=[^a-z]*[a-z])
+ \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
+

+The condition is a positive lookahead assertion that matches an optional +sequence of non-letters followed by a letter. In other words, it tests for +the presence of at least one letter in the subject. If a letter is found, +the subject is matched against the first alternative; otherwise it is matched +against the second. This pattern matches strings in one of the two forms +dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits. +

Comments

+ +

+The sequence (?# marks the start of a comment that continues up to the +next closing parenthesis. Nested parentheses are not permitted. The characters +that make up a comment play no part in the pattern matching at all.

+If the +PCRE_EXTENDED option is set, an unescaped # character outside a character +class introduces a comment that continues up to the next newline character +in the pattern. +

Recursive Patterns

+

+Consider the problem of matching a +string in parentheses, allowing for unlimited nested parentheses. Without +the use of recursion, the best that can be done is to use a pattern that +matches up to some fixed depth of nesting. It is not possible to handle +an arbitrary nesting depth. Perl provides a facility that allows regular +expressions to recurse (amongst other things). It does this by interpolating +Perl code in the expression at run time, and the code can refer to the +expression itself. A Perl pattern to solve the parentheses problem can be +created like this:

+ $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
+

+The (?p{...}) item interpolates Perl code at run time, and in this case refers +recursively to the pattern in which it appears. Obviously, PCRE cannot support +the interpolation of Perl code. Instead, it supports some special syntax +for recursion of the entire pattern, and also for individual subpattern +recursion.

+The special item that consists of (? followed by a number greater +than zero and a closing parenthesis is a recursive call of the subpattern +of the given number, provided that it occurs inside that subpattern. (If +not, it is a "subroutine" call, which is described in the next section.) +The special item (?R) is a recursive call of the entire regular expression. +

+For example, this PCRE pattern solves the nested parentheses problem (assume +the PCRE_EXTENDED option is set so that white space is ignored):

+ \( ( +(?>[^()]+) | (?R) )* \)
+

+First it matches an opening parenthesis. Then it matches any number of +substrings which can either be a sequence of non-parentheses, or a recursive +match of the pattern itself (that is a correctly parenthesized substring). +Finally there is a closing parenthesis.

+If this were part of a larger pattern, +you would not want to recurse the entire pattern, so instead you could +use this:

+ ( \( ( (?>[^()]+) | (?1) )* \) )
+

+We have put the pattern into parentheses, and caused the recursion to +refer to them instead of the whole pattern. In a larger pattern, keeping +track of parenthesis numbers can be tricky. It may be more convenient to +use named parentheses instead. For this, PCRE uses (?P>name), which is an +extension to the Python syntax that PCRE uses for named parentheses (Perl +does not provide named parentheses). We could rewrite the above example +as follows:

+ (?P<pn> \( ( (?>[^()]+) | (?P>pn) )* \) )
+

+This particular example pattern contains nested unlimited repeats, and +so the use of atomic grouping for matching strings of non-parentheses is +important when applying the pattern to strings that do not match. For example, +when this pattern is applied to

+ (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
+

+it yields "no match" quickly. However, if atomic grouping is not used, +the match runs for a very long time indeed because there are so many different +ways the + and * repeats can carve up the subject, and all have to be tested +before failure can be reported.

+At the end of a match, the values set for +any capturing subpatterns are those from the outermost level of the recursion +at which the subpattern value is set. If you want to obtain intermediate +values, a callout function can be used (see the next section and the pcrecallout + documentation). If the pattern above is matched against

+ (ab(cd)ef)
+

+the value for the capturing parentheses is "ef", which is the last value +taken on at the top level. If additional parentheses are added, giving

+ + \( ( ( (?>[^()]+) | (?R) )* ) \)
+ ^ ^
+ ^ ^
+

+the string they capture is "ab(cd)ef", the contents of the top level parentheses. +If there are more than 15 capturing parentheses in a pattern, PCRE has +to obtain extra memory to store data during a recursion, which it does +by using pcre_malloc, freeing it via pcre_free afterwards. If no memory +can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.

+Do +not confuse the (?R) item with the condition (R), which tests for recursion. +Consider this pattern, which matches text in angle brackets, allowing for +arbitrary nesting. Only digits are allowed in nested brackets (that is, +when recursing), whereas any characters are permitted at the outer level. +

+ < (?: (?(R) \d++ | [^<>]*+) | (?R)) * >
+

+In this pattern, (?(R) is the start of a conditional subpattern, with +two different alternatives for the recursive and non-recursive cases. The +(?R) item is the actual recursive call. +

Subpatterns As Subroutines

+

+If +the syntax for a recursive subpattern reference (either by number or by +name) is used outside the parentheses to which it refers, it operates like +a subroutine in a programming language. An earlier example pointed out that +the pattern

+ (sens|respons)e and \1ibility
+

+matches "sense and sensibility" and "response and responsibility", but +not "sense and responsibility". If instead the pattern

+ (sens|respons)e +and (?1)ibility
+

+is used, it does match "sense and responsibility" as well as the other +two strings. Such references must, however, follow the subpattern to which +they refer. +

Callouts

+

+Perl has a feature whereby using the sequence (?{...}) +causes arbitrary Perl code to be obeyed in the middle of matching a regular +expression. This makes it possible, amongst other things, to extract different +substrings that match the same pair of parentheses when there is a repetition. +

+PCRE provides a similar feature, but of course it cannot obey arbitrary +Perl code. The feature is called "callout". The caller of PCRE provides an +external function by putting its entry point in the global variable pcre_callout. +By default, this variable contains NULL, which disables all calling out. +

+Within a regular expression, (?C) indicates the points at which the external +function is to be called. If you want to identify different callout points, +you can put a number less than 256 after the letter C. The default value +is zero. For example, this pattern has two callout points:

+ (?C1)dabc(?C2)def
+

+If the PCRE_AUTO_CALLOUT flag is passed to pcre_compile(), callouts are +automatically installed before each item in the pattern. They are all numbered +255.

+During matching, when PCRE reaches a callout point (and pcre_callout +is set), the external function is called. It is provided with the number +of the callout, the position in the pattern, and, optionally, one item +of data originally supplied by the caller of pcre_exec(). The callout function +may cause matching to proceed, to backtrack, or to fail altogether. A complete +description of the interface to the callout function is given in the pcrecallout + documentation.

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcreperform.3.html b/Utilities/PCRE/man/html/pcreperform.3.html new file mode 100644 index 0000000..a4fea50 --- /dev/null +++ b/Utilities/PCRE/man/html/pcreperform.3.html @@ -0,0 +1,86 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Performance

+

+Certain items +that may appear in regular expression patterns are more efficient than +others. It is more efficient to use a character class like [aeiou] than +a set of alternatives such as (a|e|i|o|u). In general, the simplest construction +that provides the required behaviour is usually the most efficient. Jeffrey +Friedl’s book contains a lot of useful general discussion about optimizing +regular expressions for efficient performance. This document contains a +few observations about PCRE.

+Using Unicode character properties (the \p, +\P, and \X escapes) is slow, because PCRE has to scan a structure that contains +data for over fifteen thousand characters whenever it needs a character’s +property. If you can find an alternative pattern that does not use character +properties, it will probably be faster.

+When a pattern begins with .* not +in parentheses, or in parentheses that are not the subject of a backreference, +and the PCRE_DOTALL option is set, the pattern is implicitly anchored by +PCRE, since it can match only at the start of a subject string. However, +if PCRE_DOTALL is not set, PCRE cannot make this optimization, because +the . metacharacter does not then match a newline, and if the subject string +contains newlines, the pattern may match from the character immediately +following one of them instead of from the very start. For example, the pattern +

+ .*second
+

+matches the subject "first\nand second" (where \n stands for a newline character), +with the match starting at the seventh character. In order to do this, PCRE +has to retry the match starting after every newline in the subject.

+If you +are using such a pattern with subject strings that do not contain newlines, +the best performance is obtained by setting PCRE_DOTALL, or starting the +pattern with ^.* to indicate explicit anchoring. That saves PCRE from having +to scan along the subject looking for a newline to restart at.

+Beware of +patterns that contain nested indefinite repeats. These can take a long time +to run when applied to a string that does not match. Consider the pattern +fragment

+ (a+)*
+

+This can match "aaaa" in 33 different ways, and this number increases +very rapidly as the string gets longer. (The * repeat can match 0, 1, 2, +3, or 4 times, and for each of those cases other than 0, the + repeats +can match different numbers of times.) When the remainder of the pattern +is such that the entire match is going to fail, PCRE has in principle to +try every possible variation, and this can take an extremely long time. +

+An optimization catches some of the more simple cases such as

+ (a+)*b
+

+where a literal character follows. Before embarking on the standard matching +procedure, PCRE checks that there is a "b" later in the subject string, +and if there is not, it fails the match immediately. However, when there +is no following literal this optimization cannot be used. You can see the +difference by comparing the behaviour of

+ (a+)*\d
+

+with the pattern above. The former gives a failure almost instantly when +applied to a whole line of "a" characters, whereas the latter takes an +appreciable time with strings longer than about 20 characters.

+In many cases, +the solution to this kind of performance issue is to use an atomic group +or a possessive quantifier.

+ Last updated: 09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcreposix.3.html b/Utilities/PCRE/man/html/pcreposix.3.html new file mode 100644 index 0000000..0e7cafd --- /dev/null +++ b/Utilities/PCRE/man/html/pcreposix.3.html @@ -0,0 +1,187 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions. +

Synopsis of Posix API

+

+#include +<pcreposix.h>

+ +
+int regcomp(regex_t *preg, const char *pattern, int cflags);

+
+int regexec(regex_t *preg, const char *string, size_t nmatch, regmatch_t +pmatch[], int eflags);

+
+size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t +errbuf_size);

+
+void regfree(regex_t *preg); +

Description

+

+This set of functions provides +a POSIX-style API to the PCRE regular expression package. See the pcreapi + documentation for a description of PCRE’s native API, which contains additional +functionality.

+The functions described here are just wrapper functions that +ultimately call the PCRE native API. Their prototypes are defined in the +pcreposix.h header file, and on Unix systems the library itself is called +pcreposix.a, so can be accessed by adding -lpcreposix to the command for +linking an application that uses them. Because the POSIX functions call +the native ones, it is also necessary to add -lpcre.

+I have implemented only +those option bits that can be reasonably mapped to PCRE native options. +In addition, the options REG_EXTENDED and REG_NOSUB are defined with the +value zero. They have no effect, but since programs that are written to +the POSIX interface often use them, this makes it easier to slot in PCRE +as a replacement library. Other POSIX options are not even defined.

+When +PCRE is called via these functions, it is only the API that is POSIX-like +in style. The syntax and semantics of the regular expressions themselves +are still those of Perl, subject to the setting of various PCRE options, +as described below. "POSIX-like in style" means that the API approximates +to the POSIX definition; it is not fully POSIX-compatible, and in multi-byte +encoding domains it is probably even less compatible.

+The header for these +functions is supplied as pcreposix.h to avoid any potential clash with other +POSIX libraries. It can, of course, be renamed or aliased as regex.h, which +is the "correct" name. It provides two structure types, regex_t for compiled +internal forms, and regmatch_t for returning captured substrings. It also +defines some constants whose names start with "REG_"; these are used for +setting options and identifying error codes.

+ +

Compiling a Pattern

+

+The function +regcomp() is called to compile a pattern into an internal form. The pattern +is a C string terminated by a binary zero, and is passed in the argument +pattern. The preg argument is a pointer to a regex_t structure that is used +as a base for storing information about the compiled expression.

+The argument +cflags is either zero, or contains one or more of the bits defined by the +following macros:

+ REG_ICASE
+

+The PCRE_CASELESS option is set when the expression is passed for compilation +to the native function.

+ REG_NEWLINE
+

+The PCRE_MULTILINE option is set when the expression is passed for compilation +to the native function. Note that this does not mimic the defined POSIX +behaviour for REG_NEWLINE (see the following section).

+In the absence of +these flags, no options are passed to the native function. This means the +the regex is compiled with PCRE default semantics. In particular, the way +it handles newline characters in the subject string is the Perl way, not +the POSIX way. Note that setting PCRE_MULTILINE has only some of the effects +specified for REG_NEWLINE. It does not affect the way newlines are matched +by . (they aren’t) or by a negative class such as [^a] (they are).

+The yield +of regcomp() is zero on success, and non-zero otherwise. The preg structure +is filled in on success, and one member of the structure is public: re_nsub +contains the number of capturing subpatterns in the regular expression. +Various error codes are defined in the header file. +

Matching Newline Characters

+ +

+This area is not simple, because POSIX and Perl take different views of +things. It is not possible to get PCRE to obey POSIX semantics, but then +PCRE was never intended to be a POSIX engine. The following table lists +the different possibilities for matching newline characters in PCRE:

+ + Default Change with
+

+ . matches newline no PCRE_DOTALL
+ newline matches [^a] yes not changeable
+ $ matches \n at end yes PCRE_DOLLARENDONLY
+ $ matches \n in middle no PCRE_MULTILINE
+ ^ matches \n in middle no PCRE_MULTILINE
+

+This is the equivalent table for POSIX:

+ Default + Change with
+

+ . matches newline yes REG_NEWLINE
+ newline matches [^a] yes REG_NEWLINE
+ $ matches \n at end no REG_NEWLINE
+ $ matches \n in middle no REG_NEWLINE
+ ^ matches \n in middle no REG_NEWLINE
+

+PCRE’s behaviour is the same as Perl’s, except that there is no equivalent +for PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is no way +to stop newline from matching [^a].

+The default POSIX newline handling can +be obtained by setting PCRE_DOTALL and PCRE_DOLLAR_ENDONLY, but there is +no way to make PCRE behave exactly as for the REG_NEWLINE action. +

Matching +a Pattern

+

+The function regexec() is called to match a compiled pattern +preg against a given string, which is terminated by a zero byte, subject +to the options in eflags. These can be:

+ REG_NOTBOL
+

+The PCRE_NOTBOL option is set when calling the underlying PCRE matching +function.

+ REG_NOTEOL
+

+The PCRE_NOTEOL option is set when calling the underlying PCRE matching +function.

+The portion of the string that was matched, and also any captured +substrings, are returned via the pmatch argument, which points to an array +of nmatch structures of type regmatch_t, containing the members rm_so and +rm_eo. These contain the offset to the first character of each substring +and the offset to the first character after the end of each substring, +respectively. The 0th element of the vector relates to the entire portion +of string that was matched; subsequent elements relate to the capturing +subpatterns of the regular expression. Unused entries in the array have +both structure members set to -1.

+A successful match yields a zero return; +various error codes are defined in the header file, of which REG_NOMATCH +is the "expected" failure code. +

Error Messages

+

+The regerror() function +maps a non-zero errorcode from either regcomp() or regexec() to a printable +message. If preg is not NULL, the error should have arisen from the use +of that structure. A message terminated by a binary zero is placed in errbuf. +The length of the message, including the zero, is limited to errbuf_size. +The yield of the function is the size of buffer needed to hold the whole +message. +

Memory Usage

+

+Compiling a regular expression causes memory to +be allocated and associated with the preg structure. The function regfree() +frees all such memory, after which preg may no longer be used as a compiled +expression. +

Author

+

+Philip Hazel <ph10@cam.ac.uk>
+University Computing Service,
+Cambridge CB2 3QG, England.

+ Last updated: 07 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcresample.3.html b/Utilities/PCRE/man/html/pcresample.3.html new file mode 100644 index 0000000..6fad4a9 --- /dev/null +++ b/Utilities/PCRE/man/html/pcresample.3.html @@ -0,0 +1,72 @@ + + + + + +PCRE(3) manual page + + +Table of Contents

+ +

Name

+PCRE - Perl-compatible regular expressions +

Pcre Sample Program

+

+A simple, +complete demonstration program, to get you started with using PCRE, is +supplied in the file pcredemo.c in the PCRE distribution.

+The program compiles +the regular expression that is its first argument, and matches it against +the subject string in its second argument. No PCRE options are set, and +default character tables are used. If matching succeeds, the program outputs +the portion of the subject that matched, together with the contents of +any captured substrings.

+If the -g option is given on the command line, the +program then goes on to check for further matches of the same regular expression +in the same subject string. The logic is a little bit tricky because of +the possibility of matching an empty string. Comments in the code explain +what is going on.

+If PCRE is installed in the standard include and library +directories for your system, you should be able to compile the demonstration +program using this command:

+ gcc -o pcredemo pcredemo.c -lpcre
+

+If PCRE is installed elsewhere, you may need to add additional options +to the command line. For example, on a Unix-like system that has PCRE installed +in /usr/local, you can compile the demonstration program using a command +like this:

+ gcc -o pcredemo -I/usr/local/include pcredemo.c \
+ -L/usr/local/lib -lpcre
+

+Once you have compiled the demonstration program, you can run simple tests +like this:

+ ./pcredemo ’cat|dog’ ’the cat sat on the mat’
+ ./pcredemo -g ’cat|dog’ ’the dog sat on the cat’
+

+Note that there is a much more comprehensive test program, called pcretest, + which supports many more facilities for testing regular expressions and +the PCRE library. The pcredemo program is provided as a simple coding example. +

+On some operating systems (e.g. Solaris), when PCRE is not installed in the +standard library directory, you may get an error like this when you try +to run pcredemo:

+ ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such +file or directory
+

+This is caused by the way shared library support works on those systems. +You need to add

+ -R/usr/local/lib
+

+(for example) to the compile command to get round this problem.

+ Last updated: +09 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/man/html/pcretest.1.html b/Utilities/PCRE/man/html/pcretest.1.html new file mode 100644 index 0000000..e96293e --- /dev/null +++ b/Utilities/PCRE/man/html/pcretest.1.html @@ -0,0 +1,433 @@ + + + + + +PCRETEST(1) manual page + + +Table of Contents

+ +

Name

+pcretest - a program for testing Perl-compatible regular expressions. + +

Synopsis

+

+pcretest "[-C] [-d] [-i] [-m] [-o osize] [-p] [-t] [source]" [destination] +

+pcretest was written as a test program for the PCRE regular expression +library itself, but it can also be used for experimenting with regular +expressions. This document describes the features of the test program; for +details of the regular expressions themselves, see the pcrepattern documentation. +For details of the PCRE library function calls and their options, see the + pcreapi documentation. +

Options

+ +
+ +
-C
+
Output the version number of the PCRE +library, and all available information about the optional features that +are included, and then exit.
+ +
-d
+
Behave as if each regex had the /D (debug) +modifier; the internal form is output after compilation.
+ +
-i
+
Behave as if +each regex had the /I modifier; information about the compiled pattern +is given after compilation.
+ +
-m
+
Output the size of each compiled pattern after +it has been compiled. This is equivalent to adding /M to each regular expression. +For compatibility with earlier versions of pcretest, -s is a synonym for +-m.
+ +
-o osize
+
Set the number of elements in the output vector that is used +when calling pcre_exec() to be osize. The default value is 45, which is +enough for 14 capturing subexpressions. The vector size can be changed for +individual matching calls by including \O in the data line (see below).
+ +
-p +
+
Behave as if each regex has /P modifier; the POSIX wrapper API is used +to call PCRE. None of the other options has any effect when -p is set.
+ +
-t
+
Run +each compile, study, and match many times with a timer, and output resulting +time per compile or match (in milliseconds). Do not set -m with -t, because +you will then get the size output a zillion times, and the timing will +be distorted.
+
+ +

Description

+

+If pcretest is given two filename arguments, +it reads from the first and writes to the second. If it is given only one +filename argument, it reads from that file and writes to stdout. Otherwise, +it reads from stdin and writes to stdout, and prompts for each line of +input, using "re>" to prompt for regular expressions, and "data>" to prompt +for data lines.

+The program handles any number of sets of input on a single +input file. Each set starts with a regular expression, and continues with +any number of data lines to be matched against the pattern.

+Each data line +is matched separately and independently. If you want to do multiple-line +matches, you have to use the \n escape sequence in a single line of input +to encode the newline characters. The maximum length of data line is 30,000 +characters.

+An empty line signals the end of the data lines, at which point +a new regular expression is read. The regular expressions are given enclosed +in any non-alphanumeric delimiters other than backslash, for example

+ /(a|bc)x+yz/
+

+White space before the initial delimiter is ignored. A regular expression +may be continued over several input lines, in which case the newline characters +are included within it. It is possible to include the delimiter within the +pattern by escaping it, for example

+ /abc\/def/
+

+If you do so, the escape and the delimiter form part of the pattern, but +since delimiters are always non-alphanumeric, this does not affect its interpretation. +If the terminating delimiter is immediately followed by a backslash, for +example,

+ /abc/\
+

+then a backslash is added to the end of the pattern. This is done to provide +a way of testing the error condition that arises if a pattern finishes +with a backslash, because

+ /abc\/
+

+is interpreted as the first line of a pattern that starts with "abc/", +causing pcretest to read the next line as a continuation of the regular +expression. +

Pattern Modifiers

+

+A pattern may be followed by any number +of modifiers, which are mostly single characters. Following Perl usage, +these are referred to below as, for example, "the /i modifier", even though +the delimiter of the pattern need not always be a slash, and no slash is +used when writing modifiers. Whitespace may appear between the final pattern +delimiter and the first modifier, and between the modifiers themselves. +

+The /i, /m, /s, and /x modifiers set the PCRE_CASELESS, PCRE_MULTILINE, +PCRE_DOTALL, or PCRE_EXTENDED options, respectively, when pcre_compile() +is called. These four modifier letters have the same effect as they do in +Perl. For example:

+ /caseless/i
+

+The following table shows additional modifiers for setting PCRE options +that do not correspond to anything in Perl:

+ /A PCRE_ANCHORED
+ /C PCRE_AUTO_CALLOUT
+ /E PCRE_DOLLAR_ENDONLY
+ /N PCRE_NO_AUTO_CAPTURE
+ /U PCRE_UNGREEDY
+ /X PCRE_EXTRA
+

+Searching for all possible matches within each subject string can be requested +by the /g or /G modifier. After finding a match, PCRE is called again to +search the remainder of the subject string. The difference between /g and +/G is that the former uses the startoffset argument to pcre_exec() to start +searching at a new point within the entire string (which is in effect what +Perl does), whereas the latter passes over a shortened substring. This makes +a difference to the matching process if the pattern begins with a lookbehind +assertion (including \b or \B).

+If any call to pcre_exec() in a /g or /G sequence +matches an empty string, the next call is done with the PCRE_NOTEMPTY and +PCRE_ANCHORED flags set in order to search for another, non-empty, match +at the same point. If this second match fails, the start offset is advanced +by one, and the normal match is retried. This imitates the way Perl handles +such cases when using the /g modifier or the split() function.

+There are +yet more modifiers for controlling the way pcretest operates.

+The /+ modifier +requests that as well as outputting the substring that matched the entire +pattern, pcretest should in addition output the remainder of the subject +string. This is useful for tests where the subject contains multiple copies +of the same substring.

+The /L modifier must be followed directly by the +name of a locale, for example,

+ /pattern/Lfr_FR
+

+For this reason, it must be the last modifier. The given locale is set, +pcre_maketables() is called to build a set of character tables for the +locale, and this is then passed to pcre_compile() when compiling the regular +expression. Without an /L modifier, NULL is passed as the tables pointer; +that is, /L applies only to the expression on which it appears.

+The /I modifier +requests that pcretest output information about the compiled pattern (whether +it is anchored, has a fixed first character, and so on). It does this by +calling pcre_fullinfo() after compiling a pattern. If the pattern is studied, +the results of that are also output.

+The /D modifier is a PCRE debugging +feature, which also assumes /I. It causes the internal form of compiled +regular expressions to be output after compilation. If the pattern was studied, +the information returned is also output.

+The /F modifier causes pcretest +to flip the byte order of the fields in the compiled pattern that contain +2-byte and 4-byte numbers. This facility is for testing the feature in PCRE +that allows it to execute patterns that were compiled on a host with a +different endianness. This feature is not available when the POSIX interface +to PCRE is being used, that is, when the /P pattern modifier is specified. +See also the section about saving and reloading compiled patterns below. +

+The /S modifier causes pcre_study() to be called after the expression has +been compiled, and the results used when the expression is matched.

+The +/M modifier causes the size of memory block used to hold the compiled pattern +to be output.

+The /P modifier causes pcretest to call PCRE via the POSIX +wrapper API rather than its native API. When this is done, all other modifiers +except /i, /m, and /+ are ignored. REG_ICASE is set if /i is present, and +REG_NEWLINE is set if /m is present. The wrapper functions force PCRE_DOLLAR_ENDONLY +always, and PCRE_DOTALL unless REG_NEWLINE is set.

+The /8 modifier causes +pcretest to call PCRE with the PCRE_UTF8 option set. This turns on support +for UTF-8 character handling in PCRE, provided that it was compiled with +this support enabled. This modifier also causes any non-printing characters +in output strings to be printed using the \x{hh...} notation if they are valid +UTF-8 sequences.

+If the /? modifier is used with /8, it causes pcretest to +call pcre_compile() with the PCRE_NO_UTF8_CHECK option, to suppress the +checking of the string for UTF-8 validity. +

Data Lines

+

+Before each data +line is passed to pcre_exec(), leading and trailing whitespace is removed, +and it is then scanned for \ escapes. Some of these are pretty esoteric features, +intended for checking out some of the more complicated features of PCRE. +If you are just testing "ordinary" regular expressions, you probably don’t +need any of these. The following escapes are recognized:

+ \a alarm +(= BEL)
+ \b backspace
+ \e escape
+ \f formfeed
+ \n newline
+ \r carriage return
+ \t tab
+ \v vertical tab
+ \nnn octal character (up to 3 octal digits)
+ \xhh hexadecimal character (up to 2 hex digits)
+ \x{hh...} hexadecimal character, any number of digits
+ in UTF-8 mode
+ \A pass the PCRE_ANCHORED option to pcre_exec()
+ \B pass the PCRE_NOTBOL option to pcre_exec()
+ \Cdd call pcre_copy_substring() for substring dd
+ after a successful match (number less than 32)
+ \Cname call pcre_copy_named_substring() for substring
+ "name" after a successful match (name termin-
+ ated by next non alphanumeric character)
+ \C+ show the current captured substrings at callout
+ time
+ \C- do not supply a callout function
+ \C!n return 1 instead of 0 when callout number n is
+ reached
+ \C!n!m return 1 instead of 0 when callout number n is
+ reached for the nth time
+ \C*n pass the number n (may be negative) as callout
+ data; this is used as the callout return value
+ \Gdd call pcre_get_substring() for substring dd
+ after a successful match (number less than 32)
+ \Gname call pcre_get_named_substring() for substring
+ "name" after a successful match (name termin-
+ ated by next non-alphanumeric character)
+ \L call pcre_get_substringlist() after a
+ successful match
+ \M discover the minimum MATCH_LIMIT setting
+ \N pass the PCRE_NOTEMPTY option to pcre_exec()
+ \Odd set the size of the output vector passed to
+ pcre_exec() to dd (any number of digits)
+ \P pass the PCRE_PARTIAL option to pcre_exec()
+ \S output details of memory get/free calls during matching
+ \Z pass the PCRE_NOTEOL option to pcre_exec()
+ \? pass the PCRE_NO_UTF8_CHECK option to
+ pcre_exec()
+ \>dd start the match at offset dd (any number of digits);
+ this sets the startoffset argument for pcre_exec()
+

+A backslash followed by anything else just escapes the anything else. If +the very last character is a backslash, it is ignored. This gives a way +of passing an empty line as data, since a real empty line terminates the +data input.

+If \M is present, pcretest calls pcre_exec() several times, with +different values in the match_limit field of the pcre_extra data structure, +until it finds the minimum number that is needed for pcre_exec() to complete. +This number is a measure of the amount of recursion and backtracking that +takes place, and checking it out can be instructive. For most simple matches, +the number is quite small, but for patterns with very large numbers of +matching possibilities, it can become large very quickly with increasing +length of subject string.

+When \O is used, the value specified may be higher +or lower than the size set by the -O command line option (or defaulted to +45); \O applies only to the call of pcre_exec() for the line in which it +appears.

+If the /P modifier was present on the pattern, causing the POSIX +wrapper API to be used, only \B and \Z have any effect, causing REG_NOTBOL +and REG_NOTEOL to be passed to regexec() respectively.

+The use of \x{hh...} +to represent UTF-8 characters is not dependent on the use of the /8 modifier +on the pattern. It is recognized always. There may be any number of hexadecimal +digits inside the braces. The result is from one to six bytes, encoded according +to the UTF-8 rules. +

Output from Pcretest

+

+When a match succeeds, pcretest +outputs the list of captured substrings that pcre_exec() returns, starting +with number 0 for the string that matched the whole pattern. Otherwise, +it outputs "No match" or "Partial match" when pcre_exec() returns PCRE_ERROR_NOMATCH +or PCRE_ERROR_PARTIAL, respectively, and otherwise the PCRE negative error +number. Here is an example of an interactive pcretest run.

+ $ pcretest
+ PCRE version 5.00 07-Sep-2004
+

+ re> /^abc(\d+)/
+ data> abc123
+ 0: abc123
+ 1: 123
+ data> xyz
+ No match
+

+If the strings contain any non-printing characters, they are output as +\0x escapes, or as \x{...} escapes if the /8 modifier was present on the pattern. +If the pattern has the /+ modifier, the output for substring 0 is followed +by the the rest of the subject string, identified by "0+" like this:

+ + re> /cat/+
+ data> cataract
+ 0: cat
+ 0+ aract
+

+If the pattern has the /g or /G modifier, the results of successive matching +attempts are output in sequence, like this:

+ re> /\Bi(\w\w)/g
+ data> Mississippi
+ 0: iss
+ 1: ss
+ 0: iss
+ 1: ss
+ 0: ipp
+ 1: pp
+

+"No match" is output only if the first match attempt fails.

+If any of the +sequences \C, \G, or \L are present in a data line that is successfully matched, +the substrings extracted by the convenience functions are output with C, +G, or L after the string number instead of a colon. This is in addition +to the normal full list. The string length (that is, the return from the +extraction function) is given in parentheses after each string for \C and +\G.

+Note that while patterns can be continued over several lines (a plain +">" prompt is used for continuations), data lines may not. However newlines +can be included in data by means of the \n escape. +

Callouts

+

+If the pattern +contains any callout requests, pcretest’s callout function is called during +matching. By default, it displays the callout number, the start and current +positions in the text at the callout time, and the next pattern item to +be tested. For example, the output

+ --->pqrabcdef
+ 0 ^ ^ \d
+

+indicates that callout number 0 occurred for a match attempt starting +at the fourth character of the subject string, when the pointer was at +the seventh character of the data, and when the next pattern item was \d. +Just one circumflex is output if the start and current positions are the +same.

+Callouts numbered 255 are assumed to be automatic callouts, inserted +as a result of the /C pattern modifier. In this case, instead of showing +the callout number, the offset in the pattern, preceded by a plus, is output. +For example:

+ re> /\d?[A-E]\*/C
+ data> E*
+ --->E*
+ +0 ^ \d?
+ +3 ^ [A-E]
+ +8 ^^ \*
+ +10 ^ ^
+ 0: E*
+

+The callout function in pcretest returns zero (carry on matching) by default, +but you can use an \C item in a data line (as described above) to change +this.

+Inserting callouts can be helpful when using pcretest to check complicated +regular expressions. For further information about callouts, see the pcrecallout + documentation. +

Saving and Reloading Compiled Patterns

+

+The facilities +described in this section are not available when the POSIX inteface to +PCRE is being used, that is, when the /P pattern modifier is specified. +

+When the POSIX interface is not in use, you can cause pcretest to write +a compiled pattern to a file, by following the modifiers with > and a file +name. For example:

+ /pattern/im >/some/file
+

+See the pcreprecompile documentation for a discussion about saving and +re-using compiled patterns.

+The data that is written is binary. The first +eight bytes are the length of the compiled pattern data followed by the +length of the optional study data, each written as four bytes in big-endian +order (most significant byte first). If there is no study data (either the +pattern was not studied, or studying did not return any data), the second +length is zero. The lengths are followed by an exact copy of the compiled +pattern. If there is additional study data, this follows immediately after +the compiled pattern. After writing the file, pcretest expects to read a +new pattern.

+A saved pattern can be reloaded into pcretest by specifing +< and a file name instead of a pattern. The name of the file must not contain +a < character, as otherwise pcretest will interpret the line as a pattern +delimited by < characters. For example:

+ re> </some/file
+ Compiled regex loaded from /some/file
+ No study data
+

+When the pattern has been loaded, pcretest proceeds to read data lines +in the usual way.

+You can copy a file written by pcretest to a different +host and reload it there, even if the new host has opposite endianness +to the one on which the pattern was compiled. For example, you can compile +on an i86 machine and run on a SPARC machine.

+File names for saving and +reloading can be absolute or relative, but note that the shell facility +of expanding a file name that starts with a tilde (~) is not available. +

+The ability to save and reload files in pcretest is intended for testing +and experimentation. It is not intended for production use because only +a single pattern can be written to a file. Furthermore, there is no facility +for supplying custom character tables for use with a reloaded pattern. If +the original pattern was compiled with custom tables, an attempt to match +a subject string using a reloaded pattern is likely to cause pcretest to +crash. Finally, if you attempt to load a file that is not in the correct +format, the result is undefined. +

Author

+

+Philip Hazel <ph10@cam.ac.uk>
+University Computing Service,
+Cambridge CB2 3QG, England.

+ Last updated: 10 September 2004
+Copyright (c) 1997-2004 University of Cambridge.

+ +

+Table of Contents

+

+ + diff --git a/Utilities/PCRE/manifest/pcre-5.0-doc.mft b/Utilities/PCRE/manifest/pcre-5.0-doc.mft new file mode 100644 index 0000000..a2ac5c9 --- /dev/null +++ b/Utilities/PCRE/manifest/pcre-5.0-doc.mft @@ -0,0 +1,58 @@ +man/html/pcre.3.html +man/html/pcre_compile.3.html +man/html/pcre_config.3.html +man/html/pcre_copy_named_substring.3.html +man/html/pcre_copy_substring.3.html +man/html/pcre_exec.3.html +man/html/pcre_free_substring.3.html +man/html/pcre_free_substring_list.3.html +man/html/pcre_fullinfo.3.html +man/html/pcre_get_named_substring.3.html +man/html/pcre_get_stringnumber.3.html +man/html/pcre_get_substring.3.html +man/html/pcre_get_substring_list.3.html +man/html/pcre_info.3.html +man/html/pcre_maketables.3.html +man/html/pcre_study.3.html +man/html/pcre_version.3.html +man/html/pcreapi.3.html +man/html/pcrebuild.3.html +man/html/pcrecallout.3.html +man/html/pcrecompat.3.html +man/html/pcregrep.1.html +man/html/pcrepattern.3.html +man/html/pcreperform.3.html +man/html/pcreposix.3.html +man/html/pcresample.3.html +man/html/pcretest.1.html +man/man1/pcregrep.1 +man/man1/pcretest.1 +man/man3/pcre.3 +man/man3/pcre_compile.3 +man/man3/pcre_config.3 +man/man3/pcre_copy_named_substring.3 +man/man3/pcre_copy_substring.3 +man/man3/pcre_exec.3 +man/man3/pcre_free_substring.3 +man/man3/pcre_free_substring_list.3 +man/man3/pcre_fullinfo.3 +man/man3/pcre_get_named_substring.3 +man/man3/pcre_get_stringnumber.3 +man/man3/pcre_get_substring.3 +man/man3/pcre_get_substring_list.3 +man/man3/pcre_info.3 +man/man3/pcre_maketables.3 +man/man3/pcre_study.3 +man/man3/pcre_version.3 +man/man3/pcreapi.3 +man/man3/pcrebuild.3 +man/man3/pcrecallout.3 +man/man3/pcrecompat.3 +man/man3/pcrepattern.3 +man/man3/pcreperform.3 +man/man3/pcreposix.3 +man/man3/pcresample.3 +man/pdf/pcre-man.pdf +man/ps/pcre-man.ps.gz +manifest/pcre-5.0-doc.mft +manifest/pcre-5.0-doc.ver diff --git a/Utilities/PCRE/manifest/pcre-5.0-doc.ver b/Utilities/PCRE/manifest/pcre-5.0-doc.ver new file mode 100644 index 0000000..6a4adaa --- /dev/null +++ b/Utilities/PCRE/manifest/pcre-5.0-doc.ver @@ -0,0 +1,2 @@ +Pcre 5.0: Documentation +Pcre: Perl-compatible regular-expression library diff --git a/Utilities/PCRE/manifest/pcre-5.0-lib.mft b/Utilities/PCRE/manifest/pcre-5.0-lib.mft new file mode 100644 index 0000000..aabb128 --- /dev/null +++ b/Utilities/PCRE/manifest/pcre-5.0-lib.mft @@ -0,0 +1,12 @@ +include/pcre.h +include/pcreposix.h +lib/libpcre-bcc.lib +lib/libpcre.def +lib/libpcre.dll.a +lib/libpcre.lib +lib/libpcreposix-bcc.lib +lib/libpcreposix.def +lib/libpcreposix.dll.a +lib/libpcreposix.lib +manifest/pcre-5.0-lib.mft +manifest/pcre-5.0-lib.ver diff --git a/Utilities/PCRE/manifest/pcre-5.0-lib.ver b/Utilities/PCRE/manifest/pcre-5.0-lib.ver new file mode 100644 index 0000000..288da85 --- /dev/null +++ b/Utilities/PCRE/manifest/pcre-5.0-lib.ver @@ -0,0 +1,2 @@ +Pcre 5.0: Developer files +Pcre: Perl-compatible regular-expression library diff --git a/Utilities/PCRE/pcre_subst/pcre_subst.3 b/Utilities/PCRE/pcre_subst/pcre_subst.3 new file mode 100644 index 0000000..b3c269b --- /dev/null +++ b/Utilities/PCRE/pcre_subst/pcre_subst.3 @@ -0,0 +1,73 @@ +.TH PCRE 3 +.SH NAME +pcre_subst - Perl-compatible regular expression subsitution. +.SH SYNOPSIS +.B #include +.br +.B #include +.PP +.SM +.br +int pcre_exec(const pcre *\fIcode\fR, const pcre_extra *\fIextra\fR, +.ti +5n +const char *\fIsubject\fR, int \fIlength\fR, int \fIstartoffset\fR, +.ti +5n +int \fIoptions\fR, char *\fIreplacement\fR); + + + +.SH DESCRIPTION +\fBpcre_subst\fR is a convenience routine that calls \fIpcre_exec\fR, +and returns a freshly allocated string based on the \fIsubject\fR with +the \fIreplacement\fR action applied. Unlike \fIsubject\fR, whics is +passed as a byte array with a length, \fIreplacement\fR is expected to +be a zero terminated string (most users will just pass \fIstrlen(subject)\fR +as the \fIlength\fR). + +.br +If no match is found, pcre_subst returns NULL. The returned string is zero +terminated (note that \fIsubject\fR doesn't have to be). For information +on the \fIcode\fR, \fIextra\fR, \fIsubject\fR, \fIlength\fR, +\fIstartoffset\fR and \fIoptions\fR parameters, please see \fBpcre(3)\fR. + +.SH REPLACEMENT STRING +The replacement string supports a subset of the PERL replacement string. +In particular, \\1 style escapes are not supported (actually, only the +$1 style is handled). + +.SH EXAMPLE +.Bd -literal -compact +#include +#include +#include "pcre_subst.h" + +int +main() +{ + char *pat = "quick\\\\s(\\\\w+)\\\\s(fox)"; + char *rep = "$1ish $2"; + char *str = "The quick brown foxy"; + char *newstr; + const char *err; + int erroff; + pcre_extra *extra; + pcre *p = pcre_compile(pat, 0, &err, &erroff, NULL); + if (p == NULL) { + fprintf(stderr, "%s at %d\\n", err, erroff); + exit(1); + } + extra = pcre_study(p, 0, &err); + if (err != NULL) + fprintf(stderr, "Study %s: %s\\n", pat, err); + newstr = pcre_subst(ppat, extra, str, strlen(str), + 0, 0, rep); + if (newstr) { + printf("New string: %s\\n", newstr); + pcre_free(newstr); + }; + return 0; +} +.Ed + +.SH SEE ALSO +pcre(3) diff --git a/Utilities/PCRE/pcre_subst/pcre_subst.c b/Utilities/PCRE/pcre_subst/pcre_subst.c new file mode 100644 index 0000000..3f34f97 --- /dev/null +++ b/Utilities/PCRE/pcre_subst/pcre_subst.c @@ -0,0 +1,191 @@ +/************************************************* +* PCRE string replacement * +*************************************************/ + +/* +PCRE is a library of functions to support regular expressions whose syntax +and semantics are as close as possible to those of the Perl 5 language. +pcre_subst is a wrapper around pcre_exec designed to make it easier to +perform PERL style replacements with PCRE. + +Written by: Bert Driehuis + + Copyright (c) 2000 Bert Driehuis + +----------------------------------------------------------------------------- +Permission is granted to anyone to use this software for any purpose on any +computer system, and to redistribute it freely, subject to the following +restrictions: + +1. This software is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +2. The origin of this software must not be misrepresented, either by + explicit claim or by omission. + +3. Altered versions must be plainly marked as such, and must not be + misrepresented as being the original software. + +4. If PCRE is embedded in any software that is released under the GNU + General Purpose Licence (GPL), then the terms of that licence shall + supersede any condition above with which it is incompatible. +*/ + +#include +#include +#include +#include +#include "pcre_subst.h" + +#define MAXCAPTURE 50 + +#ifdef DEBUG_PCRE_SUBST +static void +dumpstr(const char *str, int len, int start, int end) +{ + int i; + for (i = 0; i < strlen(str); i++) { + if (i >= start && i < end) + putchar(str[i]); + else + putchar('-'); + } + putchar('\n'); +} + +static void +dumpmatch(const char *str, int len, const char *rep, int nmat, const int *ovec) +{ + int i; + printf("%s Input\n", str); + printf("nmat=%d", nmat); + for (i = 0; i < nmat * 2; i++) + printf(" %d", ovec[i]); + printf("\n"); + for (i = 0; i < nmat * 2; i += 2) + dumpstr(str, len, ovec[i], ovec[i+1]); + printf("\n"); +} +#endif + +static int +findreplen(const char *rep, int nmat, const int *replen) +{ + int len = 0; + int val; + char *cp = (char *)rep; + while(*cp) { + if (*cp == '$' && isdigit(cp[1])) { + val = strtoul(&cp[1], &cp, 10); + if (val && val <= nmat + 1) + len += replen[val -1]; + else + fprintf(stderr, "repl %d out of range\n", val); + } else { + cp++; + len++; + } + } + return len; +} + +static void +doreplace(char *out, const char *rep, int nmat, int *replen, const char **repstr) +{ + int val; + char *cp = (char *)rep; + while(*cp) { + if (*cp == '$' && isdigit(cp[1])) { + val = strtoul(&cp[1], &cp, 10); + if (val && val <= nmat + 1) { + strncpy(out, repstr[val - 1], replen[val - 1]); + out += replen[val -1]; + } + } else { + *out++ = *cp++; + } + } +} + +static char * +edit(const char *str, int len, const char *rep, int nmat, const int *ovec) +{ + int i, slen, rlen; + const int *mvec = ovec; + char *res, *cp; + int replen[MAXCAPTURE]; + const char *repstr[MAXCAPTURE]; + nmat--; + ovec += 2; + for (i = 0; i < nmat; i++) { + replen[i] = ovec[i * 2 + 1] - ovec[i * 2]; + repstr[i] = &str[ovec[i * 2]]; +#ifdef DEBUG_PCRE_SUBST + printf(">>>%d %d %.*s\n", i, replen[i], replen[i], repstr[i]); +#endif + } + slen = len; + len -= mvec[1] - mvec[0]; + len += rlen = findreplen(rep, nmat, replen); +#ifdef DEBUG_PCRE_SUBST + printf("resulting length %d (srclen=%d)\n", len, slen); +#endif + cp = res = pcre_malloc(len + 1); + if (mvec[0] > 0) { + strncpy(cp, str, mvec[0]); + cp += mvec[0]; + } + doreplace(cp, rep, nmat, replen, repstr); + cp += rlen; + if (mvec[1] < slen) + strcpy(cp, &str[mvec[1]]); + res[len] = 0; + return res; +} + +char * +pcre_subst(const pcre *ppat, const pcre_extra *extra, const char *str, int len, + int offset, int options, const char *rep) +{ + int nmat; + int ovec[MAXCAPTURE * 3]; + nmat = pcre_exec(ppat, extra, str, len, offset, options, + ovec, sizeof(ovec)); +#ifdef DEBUG_PCRE_SUBST + dumpmatch(str, len, rep, nmat, ovec); +#endif + if (nmat <= 0) + return NULL; + return(edit(str, len, rep, nmat, ovec)); +} + +#ifdef DEBUG_BUILD +int +main() +{ + char *pat = "quick\\s(\\w+)\\s(fox)"; + char *rep = "$1ish $2"; + char *str = "The quick brown foxy"; + char *newstr; + const char *err; + int erroffset; + pcre_extra *extra; + pcre *ppat = pcre_compile(pat, 0, &err, &erroffset, NULL); + if (ppat == NULL) { + fprintf(stderr, "%s at %d\n", err, erroffset); + exit(1); + } + extra = pcre_study(ppat, 0, &err); + if (err != NULL) + fprintf(stderr, "Study %s failed: %s\n", pat, err); + newstr = pcre_subst(ppat, extra, str, strlen(str), 0, 0, rep); + if (newstr) { + printf("Newstr\t%s\n", newstr); + pcre_free(newstr); + } else { + printf("No match\n"); + } + return 0; +} +#endif diff --git a/Utilities/PCRE/pcre_subst/pcre_subst.h b/Utilities/PCRE/pcre_subst/pcre_subst.h new file mode 100644 index 0000000..e4f4c44 --- /dev/null +++ b/Utilities/PCRE/pcre_subst/pcre_subst.h @@ -0,0 +1,35 @@ +/************************************************* +* PCRE string replacement * +*************************************************/ + +/* +PCRE is a library of functions to support regular expressions whose syntax +and semantics are as close as possible to those of the Perl 5 language. +pcre_subst is a wrapper around pcre_exec designed to make it easier to +perform PERL style replacements with PCRE. + +Written by: Bert Driehuis + + Copyright (c) 2000 Bert Driehuis + +----------------------------------------------------------------------------- +Permission is granted to anyone to use this software for any purpose on any +computer system, and to redistribute it freely, subject to the following +restrictions: + +1. This software is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +2. The origin of this software must not be misrepresented, either by + explicit claim or by omission. + +3. Altered versions must be plainly marked as such, and must not be + misrepresented as being the original software. + +4. If PCRE is embedded in any software that is released under the GNU + General Purpose Licence (GPL), then the terms of that licence shall + supersede any condition above with which it is incompatible. +*/ + +char *pcre_subst(const pcre *, const pcre_extra *, const char *, int, int, int, const char *); -- cgit v1.2.3