/[pcre]/code/trunk/doc/pcre.txt

Diff of /code/trunk/doc/pcre.txt

Parent Directory | Revision Log | View Patch Patch

-revision 148 by ph10,
Mon Apr 16 13:25:10 2007 UTC
+revision 150 by ph10,
Tue Apr 17 08:22:40 2007 UTC
 Line 312 
 CODE VALUE OF NEWLINE
         to the configure command. There is a fourth option, specified by
+          --enable-newline-is-anycrlf
+        which causes PCRE to recognize any of the three sequences  CR,  LF,  or
+        CRLF as indicating a line ending. Finally, a fifth option, specified by
           --enable-newline-is-any
-        which causes PCRE to recognize any Unicode newline sequence.
+        causes PCRE to recognize any Unicode newline sequence.
         Whatever line ending convention is selected when PCRE is built  can  be
         overridden  when  the library functions are called. At build time it is
-Line 468 
 AUTHOR
+Line 473 
 AUTHOR
  REVISION
-        Last updated: 20 March 2007
+        Last updated: 16 April 2007
         Copyright (c) 1997-2007 University of Cambridge.
  ------------------------------------------------------------------------------
-Line 841 
 PCRE API OVERVIEW
+Line 846 
 PCRE API OVERVIEW
  NEWLINES
-        PCRE  supports four different conventions for indicating line breaks in
+        PCRE  supports five different conventions for indicating line breaks in
         strings: a single CR (carriage return) character, a  single  LF  (line-
-        feed)  character,  the two-character sequence CRLF, or any Unicode new-
+        feed) character, the two-character sequence CRLF, any of the three pre-
-        line sequence.  The Unicode newline sequences are the three  just  men-
+        ceding, or any Unicode newline sequence. The Unicode newline  sequences
-        tioned, plus the single characters VT (vertical tab, U+000B), FF (form-
+        are  the  three just mentioned, plus the single characters VT (vertical
-        feed, U+000C), NEL (next line, U+0085), LS  (line  separator,  U+2028),
+        tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS  (line
-        and PS (paragraph separator, U+2029).
+        separator, U+2028), and PS (paragraph separator, U+2029).
         Each  of  the first three conventions is used by at least one operating
         system as its standard newline sequence. When PCRE is built, a  default
-Line 912 
 CHECKING BUILD-TIME OPTIONS
+Line 917 
 CHECKING BUILD-TIME OPTIONS
         The output is an integer whose value specifies  the  default  character
         sequence  that is recognized as meaning "newline". The four values that
-        are supported are: 10 for LF, 13 for CR, 3338 for CRLF, and -1 for ANY.
+        are supported are: 10 for LF, 13 for CR, 3338 for CRLF, -2 for ANYCRLF,
-        The default should normally be the standard sequence for your operating
+        and  -1  for  ANY. The default should normally be the standard sequence
-        system.
+        for your operating system.
           PCRE_CONFIG_LINK_SIZE
-Line 1138 
 COMPILING A PATTERN
+Line 1143 
 COMPILING A PATTERN
           PCRE_NEWLINE_CR
           PCRE_NEWLINE_LF
           PCRE_NEWLINE_CRLF
+          PCRE_NEWLINE_ANYCRLF
           PCRE_NEWLINE_ANY
         These  options  override the default newline definition that was chosen
         when PCRE was built. Setting the first or the second specifies  that  a
         newline  is  indicated  by a single character (CR or LF, respectively).
         Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by  the
-        two-character  CRLF  sequence.  Setting PCRE_NEWLINE_ANY specifies that
+        two-character  CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF specifies
-        any Unicode newline sequence should be recognized. The Unicode  newline
+        that any of the three preceding sequences should be recognized. Setting
-        sequences  are  the three just mentioned, plus the single characters VT
+        PCRE_NEWLINE_ANY  specifies that any Unicode newline sequence should be
-        (vertical tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085),
+        recognized. The Unicode newline sequences are the three just mentioned,
-        LS  (line separator, U+2028), and PS (paragraph separator, U+2029). The
+        plus  the  single  characters  VT (vertical tab, U+000B), FF (formfeed,
-        last two are recognized only in UTF-8 mode.
+        U+000C), NEL (next line, U+0085), LS (line separator, U+2028),  and  PS
+        (paragraph  separator,  U+2029).  The  last  two are recognized only in
+        UTF-8 mode.
         The newline setting in the  options  word  uses  three  bits  that  are
-        treated  as  a  number, giving eight possibilities. Currently only five
+        treated as a number, giving eight possibilities. Currently only six are
-        are used (default plus the four values above). This means that  if  you
+        used (default plus the five values above). This means that if  you  set
-        set  more  than  one  newline option, the combination may or may not be
+        more  than one newline option, the combination may or may not be sensi-
-        sensible. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is  equiva-
+        ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
-        lent  to PCRE_NEWLINE_CRLF, but other combinations yield unused numbers
+        PCRE_NEWLINE_CRLF,  but other combinations may yield unused numbers and
-        and cause an error.
+        cause an error.
         The only time that a line break is specially recognized when  compiling
         a  pattern  is  if  PCRE_EXTENDED  is set, and an unescaped # outside a
-Line 1725 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1733 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_NEWLINE_CR
           PCRE_NEWLINE_LF
           PCRE_NEWLINE_CRLF
+          PCRE_NEWLINE_ANYCRLF
           PCRE_NEWLINE_ANY
         These options override  the  newline  definition  that  was  chosen  or
-Line 1732 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1741 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         tion of pcre_compile()  above.  During  matching,  the  newline  choice
         affects  the  behaviour  of the dot, circumflex, and dollar metacharac-
         ters. It may also alter the way the match position is advanced after  a
-        match  failure  for  an  unanchored  pattern. When PCRE_NEWLINE_CRLF or
+        match  failure  for  an  unanchored  pattern.  When  PCRE_NEWLINE_CRLF,
-        PCRE_NEWLINE_ANY is set, and a match attempt  fails  when  the  current
+        PCRE_NEWLINE_ANYCRLF, or PCRE_NEWLINE_ANY is set, and a  match  attempt
-        position  is  at a CRLF sequence, the match position is advanced by two
+        fails  when the current position is at a CRLF sequence, the match posi-
-        characters instead of one, in other words, to after the CRLF.
+        tion is advanced by two characters instead of one, in other  words,  to
+        after the CRLF.
           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
+        the beginning of a line, so the  circumflex  metacharacter  should  not
-        match before it. Setting this without PCRE_MULTILINE (at compile  time)
+        match  before it. Setting this without PCRE_MULTILINE (at compile time)
-        causes  circumflex  never to match. This option affects only the behav-
+        causes circumflex never to match. This option affects only  the  behav-
         iour 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
+        of a line, so the dollar metacharacter should not match it nor  (except
-        in multiline mode) a newline immediately before it. Setting this  with-
+        in  multiline mode) a newline immediately before it. Setting this with-
         out PCRE_MULTILINE (at compile time) causes dollar never to match. This
-        option affects only the behaviour of the dollar metacharacter. It  does
+        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
+        set.  If  there are alternatives in the pattern, they are tried. If all
-        the  alternatives  match  the empty string, the entire match fails. For
+        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
+        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
+        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 occur-
         rences of "a" or "b".
         Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a spe-
-        cial case of a pattern match of the empty  string  within  its  split()
+        cial  case  of  a  pattern match of the empty string within its split()
-        function,  and  when  using  the /g modifier. It is possible to emulate
+        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
+        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
+        UTF-8 string is automatically checked when pcre_exec() is  subsequently
-        called.  The value of startoffset is also checked  to  ensure  that  it
+        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
+        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
+        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
+        If  you  already  know that your subject is valid, and you want to skip
-        these    checks    for   performance   reasons,   you   can   set   the
+        these   checks   for   performance   reasons,   you   can    set    the
-        PCRE_NO_UTF8_CHECK option when calling pcre_exec(). You might  want  to
+        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
+        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
+        making  repeated  calls  to  find  all  the matches in a single subject
-        string.  However,  you  should  be  sure  that the value of startoffset
+        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
+        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
+        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  char-
+        value  of startoffset that does not point to the start of a UTF-8 char-
         acter, is undefined. Your program may crash.
           PCRE_PARTIAL
-        This  option  turns  on  the  partial  matching feature. If the subject
+        This option turns on the  partial  matching  feature.  If  the  subject
-        string fails to match the pattern, but at some point during the  match-
+        string  fails to match the pattern, but at some point during the match-
-        ing  process  the  end of the subject was reached (that is, the subject
+        ing process the end of the subject was reached (that  is,  the  subject
-        partially matches the pattern and the failure to  match  occurred  only
+        partially  matches  the  pattern and the failure to match occurred only
-        because  there were not enough subject characters), pcre_exec() returns
+        because there were not enough subject characters), pcre_exec()  returns
-        PCRE_ERROR_PARTIAL instead of PCRE_ERROR_NOMATCH. When PCRE_PARTIAL  is
+        PCRE_ERROR_PARTIAL  instead of PCRE_ERROR_NOMATCH. When PCRE_PARTIAL is
-        used,  there  are restrictions on what may appear in the pattern. These
+        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
+        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
+        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.
+        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.
+        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
+        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
+        A non-zero starting offset is useful when searching for  another  match
-        in the same subject by calling pcre_exec() again after a previous  suc-
+        in  the same subject by calling pcre_exec() again after a previous suc-
-        cess.   Setting  startoffset differs from just passing over a shortened
+        cess.  Setting startoffset differs from just passing over  a  shortened
-        string and setting PCRE_NOTBOL in the case of  a  pattern  that  begins
+        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
+        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.)
+        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()
+        When applied to the string "Mississipi" the first call  to  pcre_exec()
-        finds the first occurrence. If pcre_exec() is called  again  with  just
+        finds  the  first  occurrence. If pcre_exec() is called again with just
-        the  remainder  of  the  subject,  namely  "issipi", it does not match,
+        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
+        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 occur-
-        rence  of "iss" because it is able to look behind the starting point to
+        rence 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,
+        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
+        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
+        In general, a pattern matches a certain portion of the subject, and  in
-        addition, further substrings from the subject  may  be  picked  out  by
+        addition,  further  substrings  from  the  subject may be picked out by
-        parts  of  the  pattern.  Following the usage in Jeffrey Friedl's book,
+        parts of the pattern. Following the usage  in  Jeffrey  Friedl's  book,
-        this is called "capturing" in what follows, and the  phrase  "capturing
+        this  is  called "capturing" in what follows, and the phrase "capturing
-        subpattern"  is  used for a fragment of a pattern that picks out a sub-
+        subpattern" is used for a fragment of a pattern that picks out  a  sub-
-        string. PCRE supports several other kinds of  parenthesized  subpattern
+        string.  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
+        Captured substrings are returned to the caller via a vector of  integer
-        offsets whose address is passed in ovector. The number of  elements  in
+        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.
+        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  sub-
+        The  first  two-thirds of the vector is used to pass back captured sub-
-        strings,  each  substring using a pair of integers. The remaining third
+        strings, each substring using a pair of integers. The  remaining  third
-        of the vector is used as workspace by pcre_exec() while  matching  cap-
+        of  the  vector is used as workspace by pcre_exec() while matching cap-
-        turing  subpatterns, and is not available for passing back information.
+        turing subpatterns, and is not available for passing back  information.
-        The length passed in ovecsize should always be a multiple of three.  If
+        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
+        When a match is successful, information about  captured  substrings  is
-        returned in pairs of integers, starting at the  beginning  of  ovector,
+        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
+        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 sub-
-        string,  and  the  second  is  set to the offset of the first character
+        string, and the second is set to the  offset  of  the  first  character
-        after the end of a substring. The  first  pair,  ovector[0]  and  ovec-
+        after  the  end  of  a  substring. The first pair, ovector[0] and ovec-
-        tor[1],  identify  the  portion  of  the  subject string matched by the
+        tor[1], identify the portion of  the  subject  string  matched  by  the
-        entire pattern. The next pair is used for the first  capturing  subpat-
+        entire  pattern.  The next pair is used for the first capturing subpat-
         tern, and so on. The value returned by pcre_exec() is one more than the
         highest numbered pair that has been set. For example, if two substrings
-        have  been captured, the returned value is 3. If there are no capturing
+        have been captured, the returned value is 3. If there are no  capturing
-        subpatterns, the return value from a successful match is 1,  indicating
+        subpatterns,  the return value from a successful match is 1, indicating
         that just the first pair of offsets has been set.
         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,
+        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  off-
+        function  returns a value of zero. In particular, if the substring off-
         sets are not of interest, pcre_exec() may be called with ovector passed
-        as NULL and ovecsize as zero. However, if  the  pattern  contains  back
+        as  NULL  and  ovecsize  as zero. However, if the pattern contains back
-        references  and  the  ovector is not big enough to remember the related
+        references and the ovector is not big enough to  remember  the  related
-        substrings, PCRE has to get additional memory for use during  matching.
+        substrings,  PCRE has to get additional memory for use during matching.
         Thus it is usually advisable to supply an ovector.
-        The  pcre_info()  function  can  be used to find out how many capturing
+        The pcre_info() function can be used to find  out  how  many  capturing
-        subpatterns there are in a compiled  pattern.  The  smallest  size  for
+        subpatterns  there  are  in  a  compiled pattern. The smallest size for
-        ovector  that  will allow for n captured substrings, in addition to the
+        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.
-        It is possible for capturing subpattern number n+1 to match  some  part
+        It  is  possible for 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)  the
+        if  the  string  "abc"  is  matched against the pattern (a|(z))(bc) the
         return from the function is 4, and subpatterns 1 and 3 are matched, but
-is not. When this happens, both values in  the  offset  pairs  corre-
+ is  not.  When  this happens, both values in the offset pairs corre-
         sponding to unused subpatterns are set to -1.
-        Offset  values  that correspond to unused subpatterns at the end of the
+        Offset values that correspond to unused subpatterns at the end  of  the
-        expression are also set to -1. For example,  if  the  string  "abc"  is
+        expression  are  also  set  to  -1. For example, if the string "abc" is
-        matched  against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are not
+        matched against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are  not
-        matched. The return from the function is 2, because  the  highest  used
+        matched.  The  return  from the function is 2, because the highest used
         capturing subpattern number is 1. However, you can refer to the offsets
-        for the second and third capturing subpatterns if  you  wish  (assuming
+        for  the  second  and third capturing subpatterns if you wish (assuming
         the vector is large enough, of course).
-        Some  convenience  functions  are  provided for extracting the captured
+        Some convenience functions are provided  for  extracting  the  captured
         substrings as separate strings. These are described below.
     Error return values from pcre_exec()
-        If pcre_exec() fails, it returns a negative number. The  following  are
+        If  pcre_exec()  fails, it returns a negative number. The following are
         defined in the header file:
           PCRE_ERROR_NOMATCH        (-1)
-Line 1924 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1934 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_NULL           (-2)
-        Either  code  or  subject  was  passed as NULL, or ovector was NULL and
+        Either code or subject was passed as NULL,  or  ovector  was  NULL  and
         ovecsize was not zero.
           PCRE_ERROR_BADOPTION      (-3)
-Line 1933 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1943 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_BADMAGIC       (-4)
-        PCRE stores a 4-byte "magic number" at the start of the compiled  code,
+        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
+        an environment with the other endianness. This is the error  that  PCRE
         gives when the magic number is not present.
           PCRE_ERROR_UNKNOWN_OPCODE (-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
+        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
+        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
+        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
+        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(),
+        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 backtracking limit, as specified by  the  match_limit  field  in  a
+        The  backtracking  limit,  as  specified  by the match_limit field in a
-        pcre_extra  structure  (or  defaulted) was reached. See the description
+        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.
+        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
+        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  charac-
+        value  of startoffset did not point to the beginning of a UTF-8 charac-
         ter.
           PCRE_ERROR_PARTIAL        (-12)
-        The  subject  string did not match, but it did match partially. See the
+        The subject string did not match, but it did match partially.  See  the
         pcrepartial documentation for details of partial matching.
           PCRE_ERROR_BADPARTIAL     (-13)
-        The PCRE_PARTIAL option was used with  a  compiled  pattern  containing
+        The  PCRE_PARTIAL  option  was  used with a compiled pattern containing
-        items  that are not supported for partial matching. See the pcrepartial
+        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
+        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.
+        This error is given if the value of the ovecsize argument is  negative.
           PCRE_ERROR_RECURSIONLIMIT (-21)
         The internal recursion limit, as specified by the match_limit_recursion
-        field  in  a  pcre_extra  structure (or defaulted) was reached. See the
+        field in a pcre_extra structure (or defaulted)  was  reached.  See  the
         description above.
           PCRE_ERROR_NULLWSLIMIT    (-22)
-        When a group that can match an empty  substring  is  repeated  with  an
+        When  a  group  that  can  match an empty substring is repeated with an
-        unbounded  upper  limit, the subject position at the start of the group
+        unbounded upper limit, the subject position at the start of  the  group
         must be remembered, so that a test for an empty string can be made when
-        the  end  of the group is reached. Some workspace is required for this;
+        the end of the group is reached. Some workspace is required  for  this;
         if it runs out, this error is given.
           PCRE_ERROR_BADNEWLINE     (-23)
-Line 2036 
 EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
+Line 2046 
 EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
         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
+        Captured  substrings  can  be  accessed  directly  by using the offsets
-        returned  by  pcre_exec()  in  ovector.  For convenience, the functions
+        returned by pcre_exec() in  ovector.  For  convenience,  the  functions
         pcre_copy_substring(),    pcre_get_substring(),    and    pcre_get_sub-
-        string_list()  are  provided for extracting captured substrings as new,
+        string_list() are provided for extracting captured substrings  as  new,
-        separate, zero-terminated strings. These functions identify  substrings
+        separate,  zero-terminated strings. These functions identify substrings
-        by  number.  The  next section describes functions for extracting named
+        by number. The next section describes functions  for  extracting  named
         substrings.
-        A substring that contains a binary zero is correctly extracted and  has
+        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
+        a further zero added on the end, but the result is not, of course, a  C
-        string.  However, you can process such a string  by  referring  to  the
+        string.   However,  you  can  process such a string by referring to the
-        length  that  is  returned  by  pcre_copy_substring() and pcre_get_sub-
+        length that is  returned  by  pcre_copy_substring()  and  pcre_get_sub-
         string().  Unfortunately, the interface to pcre_get_substring_list() is
-        not  adequate for handling strings containing binary zeros, because the
+        not adequate for handling strings containing binary zeros, because  the
         end of the final string is not independently indicated.
-        The first three arguments are the same for all  three  of  these  func-
+        The  first  three  arguments  are the same for all three of these func-
-        tions:  subject  is  the subject string that has just been successfully
+        tions: 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
+        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  is greater than zero. If pcre_exec() returned zero, indicating that
-        it  ran out of space in ovector, the value passed as stringcount should
+        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
+        The  functions pcre_copy_substring() and pcre_get_substring() extract a
-        single  substring,  whose  number  is given as stringnumber. A value of
+        single substring, whose number is given as  stringnumber.  A  value  of
-        zero extracts the substring that matched the  entire  pattern,  whereas
+        zero  extracts  the  substring that matched the entire pattern, whereas
-        higher  values  extract  the  captured  substrings.  For pcre_copy_sub-
+        higher values  extract  the  captured  substrings.  For  pcre_copy_sub-
-        string(), the string is placed in buffer,  whose  length  is  given  by
+        string(),  the  string  is  placed  in buffer, whose length is given by
-        buffersize,  while  for  pcre_get_substring()  a new block of memory is
+        buffersize, while for pcre_get_substring() a new  block  of  memory  is
-        obtained via pcre_malloc, and its address is  returned  via  stringptr.
+        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 yield of the function is the length of the  string,  not  including
         the terminating zero, or one of these error codes:
           PCRE_ERROR_NOMEMORY       (-6)
-        The buffer was too small for pcre_copy_substring(), or the  attempt  to
+        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 sub-
+        The pcre_get_substring_list()  function  extracts  all  available  sub-
-        strings and builds a list of pointers to them. All this is  done  in  a
+        strings  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  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
+        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  the
+        pointer.  The  yield  of  the function is zero if all went well, or the
         error code
           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
+        When any of these functions encounter a substring that is unset,  which
-        can happen when capturing subpattern number n+1 matches  some  part  of
+        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
+        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 sub-
-        string  by inspecting the appropriate offset in ovector, which is nega-
+        string by inspecting the appropriate offset in ovector, which is  nega-
         tive for unset substrings.
-        The two convenience functions pcre_free_substring() and  pcre_free_sub-
+        The  two convenience functions pcre_free_substring() and pcre_free_sub-
-        string_list()  can  be  used  to free the memory returned by a previous
+        string_list() can be used to free the memory  returned  by  a  previous
         call  of  pcre_get_substring()  or  pcre_get_substring_list(),  respec-
-        tively.  They  do  nothing  more  than  call the function pointed to by
+        tively. They do nothing more than  call  the  function  pointed  to  by
-        pcre_free, which of course could be called directly from a  C  program.
+        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 spe-
+        However, PCRE is used in some situations where it is linked via a  spe-
-        cial  interface  to  another  programming  language  that  cannot   use
+        cial   interface  to  another  programming  language  that  cannot  use
-        pcre_free  directly;  it is for these cases that the functions are pro-
+        pcre_free directly; it is for these cases that the functions  are  pro-
         vided.
-Line 2126 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
+Line 2136 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
              int stringcount, const char *stringname,
              const char **stringptr);
-        To extract a substring by name, you first have to find associated  num-
+        To  extract a substring by name, you first have to find associated num-
         ber.  For example, for this pattern
           (a+)b(?<xxx>\d+)...
-Line 2135 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
+Line 2145 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
         be unique (PCRE_DUPNAMES was not set), you can find the number from the
         name by calling pcre_get_stringnumber(). The first argument is the com-
         piled 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
+        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
+        Most    of    the    arguments   of   pcre_copy_named_substring()   and
-        pcre_get_named_substring()  are  the  same  as  those for the similarly
+        pcre_get_named_substring() are the same  as  those  for  the  similarly
-        named functions that extract by number. As these are described  in  the
+        named  functions  that extract by number. As these are described in the
-        previous  section,  they  are not re-described here. There are just two
+        previous section, they are not re-described here. There  are  just  two
         differences:
-        First, instead of a substring number, a substring name is  given.  Sec-
+        First,  instead  of a substring number, a substring name is given. Sec-
         ond, 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
+        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
+        These functions call pcre_get_stringnumber(), and if it succeeds,  they
-        then call pcre_copy_substring() or pcre_get_substring(),  as  appropri-
+        then  call  pcre_copy_substring() or pcre_get_substring(), as appropri-
-        ate.  NOTE:  If PCRE_DUPNAMES is set and there are duplicate names, the
+        ate. NOTE: If PCRE_DUPNAMES is set and there are duplicate  names,  the
         behaviour may not be what you want (see the next section).
-Line 2164 
 DUPLICATE SUBPATTERN NAMES
+Line 2174 
 DUPLICATE SUBPATTERN NAMES
         int pcre_get_stringtable_entries(const pcre *code,
              const char *name, char **first, char **last);
-        When a pattern is compiled with the  PCRE_DUPNAMES  option,  names  for
+        When  a  pattern  is  compiled with the PCRE_DUPNAMES option, names for
-        subpatterns  are  not  required  to  be unique. Normally, patterns with
+        subpatterns are not required to  be  unique.  Normally,  patterns  with
-        duplicate names are such that in any one match, only one of  the  named
+        duplicate  names  are such that in any one match, only one of the named
-        subpatterns  participates. An example is shown in the pcrepattern docu-
+        subpatterns participates. An example is shown in the pcrepattern  docu-
         mentation. When duplicates are present, pcre_copy_named_substring() and
-        pcre_get_named_substring()  return the first substring corresponding to
+        pcre_get_named_substring() return the first substring corresponding  to
-        the given name that is set.  If  none  are  set,  an  empty  string  is
+        the  given  name  that  is  set.  If  none  are set, an empty string is
         returned.  The pcre_get_stringnumber() function returns one of the num-
-        bers that are associated with the name, but it is not defined which  it
+        bers  that are associated with the name, but it is not defined which it
         is.
-        If  you want to get full details of all captured substrings for a given
+        If you want to get full details of all captured substrings for a  given
-        name, you must use  the  pcre_get_stringtable_entries()  function.  The
+        name,  you  must  use  the pcre_get_stringtable_entries() function. The
         first argument is the compiled pattern, and the second is the name. The
-        third and fourth are pointers to variables which  are  updated  by  the
+        third  and  fourth  are  pointers to variables which are updated by the
         function. After it has run, they point to the first and last entries in
-        the name-to-number table  for  the  given  name.  The  function  itself
+        the  name-to-number  table  for  the  given  name.  The function itself
-        returns  the  length  of  each entry, or PCRE_ERROR_NOSUBSTRING (-7) if
+        returns the length of each entry,  or  PCRE_ERROR_NOSUBSTRING  (-7)  if
-        there are none. The format of the table is described above in the  sec-
+        there  are none. The format of the table is described above in the sec-
-        tion  entitled  Information  about  a  pattern.  Given all the relevant
+        tion entitled Information about a  pattern.   Given  all  the  relevant
-        entries for the name, you can extract each of their numbers, and  hence
+        entries  for the name, you can extract each of their numbers, and hence
         the captured data, if any.
  FINDING ALL POSSIBLE MATCHES
-        The  traditional  matching  function  uses a similar algorithm to Perl,
+        The traditional matching function uses a  similar  algorithm  to  Perl,
         which stops when it finds the first match, starting at a given point in
-        the  subject.  If you want to find all possible matches, or the longest
+        the subject. If you want to find all possible matches, or  the  longest
-        possible match, consider using the alternative matching  function  (see
+        possible  match,  consider using the alternative matching function (see
-        below)  instead.  If you cannot use the alternative function, but still
+        below) instead. If you cannot use the alternative function,  but  still
-        need to find all possible matches, you can kludge it up by  making  use
+        need  to  find all possible matches, you can kludge it up by making use
         of the callout facility, which is described in the pcrecallout documen-
         tation.
         What you have to do is to insert a callout right at the end of the pat-
-        tern.   When your callout function is called, extract and save the cur-
+        tern.  When your callout function is called, extract and save the  cur-
-        rent matched substring. Then return  1,  which  forces  pcre_exec()  to
+        rent  matched  substring.  Then  return  1, which forces pcre_exec() to
-        backtrack  and  try other alternatives. Ultimately, when it runs out of
+        backtrack and try other alternatives. Ultimately, when it runs  out  of
         matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
-Line 2213 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2223 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
              int options, int *ovector, int ovecsize,
              int *workspace, int wscount);
-        The function pcre_dfa_exec()  is  called  to  match  a  subject  string
+        The  function  pcre_dfa_exec()  is  called  to  match  a subject string
-        against  a  compiled pattern, using a matching algorithm that scans the
+        against a compiled pattern, using a matching algorithm that  scans  the
-        subject string just once, and does not backtrack.  This  has  different
+        subject  string  just  once, and does not backtrack. This has different
-        characteristics  to  the  normal  algorithm, and is not compatible with
+        characteristics to the normal algorithm, and  is  not  compatible  with
-        Perl. Some of the features of PCRE patterns are not  supported.  Never-
+        Perl.  Some  of the features of PCRE patterns are not supported. Never-
-        theless,  there are times when this kind of matching can be useful. For
+        theless, there are times when this kind of matching can be useful.  For
         a discussion of the two matching algorithms, see the pcrematching docu-
         mentation.
-        The  arguments  for  the  pcre_dfa_exec()  function are the same as for
+        The arguments for the pcre_dfa_exec() function  are  the  same  as  for
         pcre_exec(), plus two extras. The ovector argument is used in a differ-
-        ent  way,  and  this is described below. The other common arguments are
+        ent way, and this is described below. The other  common  arguments  are
-        used in the same way as for pcre_exec(), so their  description  is  not
+        used  in  the  same way as for pcre_exec(), so their description is not
         repeated here.
-        The  two  additional  arguments provide workspace for the function. The
+        The two additional arguments provide workspace for  the  function.  The
-        workspace vector should contain at least 20 elements. It  is  used  for
+        workspace  vector  should  contain at least 20 elements. It is used for
         keeping  track  of  multiple  paths  through  the  pattern  tree.  More
-        workspace will be needed for patterns and subjects where  there  are  a
+        workspace  will  be  needed for patterns and subjects where there are a
         lot of potential matches.
         Here is an example of a simple call to pcre_dfa_exec():
-Line 2253 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2263 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
     Option bits for pcre_dfa_exec()
-        The  unused  bits  of  the options argument for pcre_dfa_exec() must be
+        The unused bits of the options argument  for  pcre_dfa_exec()  must  be
-        zero. The only bits  that  may  be  set  are  PCRE_ANCHORED,  PCRE_NEW-
+        zero.  The  only  bits  that  may  be  set are PCRE_ANCHORED, PCRE_NEW-
-        LINE_xxx,  PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NO_UTF8_CHECK,
+        LINE_xxx, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY,  PCRE_NO_UTF8_CHECK,
         PCRE_PARTIAL, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART. All but the last
         three of these are the same as for pcre_exec(), so their description is
         not repeated here.
           PCRE_PARTIAL
-        This has the same general effect as it does for  pcre_exec(),  but  the
+        This  has  the  same general effect as it does for pcre_exec(), but the
-        details   are   slightly   different.  When  PCRE_PARTIAL  is  set  for
+        details  are  slightly  different.  When  PCRE_PARTIAL   is   set   for
-        pcre_dfa_exec(), the return code PCRE_ERROR_NOMATCH is  converted  into
+        pcre_dfa_exec(),  the  return code PCRE_ERROR_NOMATCH is converted into
-        PCRE_ERROR_PARTIAL  if  the  end  of the subject is reached, there have
+        PCRE_ERROR_PARTIAL if the end of the subject  is  reached,  there  have
         been no complete matches, but there is still at least one matching pos-
-        sibility.  The portion of the string that provided the partial match is
+        sibility. The portion of the string that provided the partial match  is
         set as the first matching string.
           PCRE_DFA_SHORTEST
-        Setting the PCRE_DFA_SHORTEST option causes the matching  algorithm  to
+        Setting  the  PCRE_DFA_SHORTEST option causes the matching algorithm to
         stop as soon as it has found one match. Because of the way the alterna-
-        tive algorithm works, this is necessarily the shortest  possible  match
+        tive  algorithm  works, this is necessarily the shortest possible match
         at the first possible matching point in the subject string.
           PCRE_DFA_RESTART
-        When  pcre_dfa_exec()  is  called  with  the  PCRE_PARTIAL  option, and
+        When pcre_dfa_exec()  is  called  with  the  PCRE_PARTIAL  option,  and
-        returns a partial match, it is possible to call it  again,  with  addi-
+        returns  a  partial  match, it is possible to call it again, with addi-
-        tional  subject  characters,  and have it continue with the same match.
+        tional subject characters, and have it continue with  the  same  match.
-        The PCRE_DFA_RESTART option requests this action; when it is  set,  the
+        The  PCRE_DFA_RESTART  option requests this action; when it is set, the
-        workspace  and wscount options must reference the same vector as before
+        workspace and wscount options must reference the same vector as  before
-        because data about the match so far is left in  them  after  a  partial
+        because  data  about  the  match so far is left in them after a partial
-        match.  There  is  more  discussion of this facility in the pcrepartial
+        match. There is more discussion of this  facility  in  the  pcrepartial
         documentation.
     Successful returns from pcre_dfa_exec()
-        When pcre_dfa_exec() succeeds, it may have matched more than  one  sub-
+        When  pcre_dfa_exec()  succeeds, it may have matched more than one sub-
         string in the subject. Note, however, that all the matches from one run
-        of the function start at the same point in  the  subject.  The  shorter
+        of  the  function  start  at the same point in the subject. The shorter
-        matches  are all initial substrings of the longer matches. For example,
+        matches are all initial substrings of the longer matches. For  example,
         if the pattern
           <.*>
-Line 2308 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2318 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
           <something> <something else>
           <something> <something else> <something further>
-        On success, the yield of the function is a number  greater  than  zero,
+        On  success,  the  yield of the function is a number greater than zero,
-        which  is  the  number of matched substrings. The substrings themselves
+        which is the number of matched substrings.  The  substrings  themselves
-        are returned in ovector. Each string uses two elements;  the  first  is
+        are  returned  in  ovector. Each string uses two elements; the first is
-        the  offset  to  the start, and the second is the offset to the end. In
+        the offset to the start, and the second is the offset to  the  end.  In
-        fact, all the strings have the same start  offset.  (Space  could  have
+        fact,  all  the  strings  have the same start offset. (Space could have
-        been  saved by giving this only once, but it was decided to retain some
+        been saved by giving this only once, but it was decided to retain  some
-        compatibility with the way pcre_exec() returns data,  even  though  the
+        compatibility  with  the  way pcre_exec() returns data, even though the
         meaning of the strings is different.)
         The strings are returned in reverse order of length; that is, the long-
-        est matching string is given first. If there were too many  matches  to
+        est  matching  string is given first. If there were too many matches to
-        fit  into ovector, the yield of the function is zero, and the vector is
+        fit into ovector, the yield of the function is zero, and the vector  is
         filled with the longest matches.
     Error returns from pcre_dfa_exec()
-        The pcre_dfa_exec() function returns a negative number when  it  fails.
+        The  pcre_dfa_exec()  function returns a negative number when it fails.
-        Many  of  the  errors  are  the  same as for pcre_exec(), and these are
+        Many of the errors are the same  as  for  pcre_exec(),  and  these  are
-        described above.  There are in addition the following errors  that  are
+        described  above.   There are in addition the following errors that are
         specific to pcre_dfa_exec():
           PCRE_ERROR_DFA_UITEM      (-16)
-        This  return is given if pcre_dfa_exec() encounters an item in the pat-
+        This return is given if pcre_dfa_exec() encounters an item in the  pat-
-        tern that it does not support, for instance, the use of \C  or  a  back
+        tern  that  it  does not support, for instance, the use of \C or a back
         reference.
           PCRE_ERROR_DFA_UCOND      (-17)
-        This  return  is  given  if pcre_dfa_exec() encounters a condition item
+        This return is given if pcre_dfa_exec()  encounters  a  condition  item
-        that uses a back reference for the condition, or a test  for  recursion
+        that  uses  a back reference for the condition, or a test for recursion
         in a specific group. These are not supported.
           PCRE_ERROR_DFA_UMLIMIT    (-18)
-        This  return  is given if pcre_dfa_exec() is called with an extra block
+        This return is given if pcre_dfa_exec() is called with an  extra  block
         that contains a setting of the match_limit field. This is not supported
         (it is meaningless).
           PCRE_ERROR_DFA_WSSIZE     (-19)
-        This  return  is  given  if  pcre_dfa_exec()  runs  out of space in the
+        This return is given if  pcre_dfa_exec()  runs  out  of  space  in  the
         workspace vector.
           PCRE_ERROR_DFA_RECURSE    (-20)
-        When a recursive subpattern is processed, the matching  function  calls
+        When  a  recursive subpattern is processed, the matching function calls
-        itself  recursively,  using  private vectors for ovector and workspace.
+        itself recursively, using private vectors for  ovector  and  workspace.
-        This error is given if the output vector  is  not  large  enough.  This
+        This  error  is  given  if  the output vector is not large enough. This
         should be extremely rare, as a vector of size 1000 is used.
  SEE ALSO
-        pcrebuild(3),  pcrecallout(3), pcrecpp(3)(3), pcrematching(3), pcrepar-
+        pcrebuild(3), pcrecallout(3), pcrecpp(3)(3), pcrematching(3),  pcrepar-
-        tial(3), pcreposix(3), pcreprecompile(3), pcresample(3),  pcrestack(3).
+        tial(3),  pcreposix(3), pcreprecompile(3), pcresample(3), pcrestack(3).
  AUTHOR
-Line 2375 
 AUTHOR
+Line 2385 
 AUTHOR
  REVISION
-        Last updated: 06 March 2007
+        Last updated: 16 April 2007
         Copyright (c) 1997-2007 University of Cambridge.
  ------------------------------------------------------------------------------

 Legend:



Removed from v.148
 


changed lines


 
Added in v.150
 Legend:



Removed from v.148
 


changed lines


 
Added in v.150
-Removed from v.148
+Added in v.150

	ViewVC Help
Powered by ViewVC 1.1.5