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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 77 by nigel, Sat Feb 24 21:40:45 2007 UTC revision 83 by nigel, Sat Feb 24 21:41:06 2007 UTC
# Line 7  separate text files for the pcregrep and Line 7  separate text files for the pcregrep and
7  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
8    
9    
10    PCRE(3)                                                                PCRE(3)
11    
12    
13  NAME  NAME
14         PCRE - Perl-compatible regular expressions         PCRE - Perl-compatible regular expressions
# Line 51  INTRODUCTION Line 53  INTRODUCTION
53         data  tables  that  are  used by more than one of the exported external         data  tables  that  are  used by more than one of the exported external
54         functions, but which are not intended  for  use  by  external  callers.         functions, but which are not intended  for  use  by  external  callers.
55         Their  names  all begin with "_pcre_", which hopefully will not provoke         Their  names  all begin with "_pcre_", which hopefully will not provoke
56         any name clashes.         any name clashes. In some environments, it is possible to control which
57           external  symbols  are  exported when a shared library is built, and in
58           these cases the undocumented symbols are not exported.
59    
60    
61  USER DOCUMENTATION  USER DOCUMENTATION
# Line 203  AUTHOR Line 207  AUTHOR
207    
208  Last updated: 07 March 2005  Last updated: 07 March 2005
209  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
210  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
211    
212    
213    PCREBUILD(3)                                                      PCREBUILD(3)
214    
215    
216  NAME  NAME
# Line 230  PCRE BUILD-TIME OPTIONS Line 236  PCRE BUILD-TIME OPTIONS
236         not described.         not described.
237    
238    
239    C++ SUPPORT
240    
241           By default, the configure script will search for a C++ compiler and C++
242           header files. If it finds them, it automatically builds the C++ wrapper
243           library for PCRE. You can disable this by adding
244    
245             --disable-cpp
246    
247           to the configure command.
248    
249    
250  UTF-8 SUPPORT  UTF-8 SUPPORT
251    
252         To build PCRE with support for UTF-8 character strings, add         To build PCRE with support for UTF-8 character strings, add
# Line 377  USING EBCDIC CODE Line 394  USING EBCDIC CODE
394    
395         to the configure command.         to the configure command.
396    
397  Last updated: 28 February 2005  Last updated: 15 August 2005
398  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
399  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
400    
401    
402    PCREMATCHING(3)                                                PCREMATCHING(3)
403    
404    
405  NAME  NAME
# Line 545  DISADVANTAGES OF THE DFA ALGORITHM Line 564  DISADVANTAGES OF THE DFA ALGORITHM
564    
565  Last updated: 28 February 2005  Last updated: 28 February 2005
566  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
567  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
568    
569    
570    PCREAPI(3)                                                          PCREAPI(3)
571    
572    
573  NAME  NAME
574         PCRE - Perl-compatible regular expressions         PCRE - Perl-compatible regular expressions
# Line 1833  EXTRACTING CAPTURED SUBSTRINGS BY NAME Line 1854  EXTRACTING CAPTURED SUBSTRINGS BY NAME
1854         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-
1855         ber.  For example, for this pattern         ber.  For example, for this pattern
1856    
1857           (a+)b(?<xxx>\d+)...           (a+)b(?P<xxx>\d+)...
1858    
1859         the number of the subpattern called "xxx" is 2. You can find the number         the number of the subpattern called "xxx" is 2. You can find the number
1860         from the name by calling pcre_get_stringnumber(). The first argument is         from the name by calling pcre_get_stringnumber(). The first argument is
# Line 2033  MATCHING A PATTERN: THE ALTERNATIVE FUNC Line 2054  MATCHING A PATTERN: THE ALTERNATIVE FUNC
2054    
2055  Last updated: 16 May 2005  Last updated: 16 May 2005
2056  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
2057  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
2058    
2059    
2060    PCRECALLOUT(3)                                                  PCRECALLOUT(3)
2061    
2062    
2063  NAME  NAME
2064         PCRE - Perl-compatible regular expressions         PCRE - Perl-compatible regular expressions
# Line 2190  RETURN VALUES Line 2213  RETURN VALUES
2213    
2214  Last updated: 28 February 2005  Last updated: 28 February 2005
2215  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
2216  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
2217    
2218    
2219    PCRECOMPAT(3)                                                    PCRECOMPAT(3)
2220    
2221    
2222  NAME  NAME
2223         PCRE - Perl-compatible regular expressions         PCRE - Perl-compatible regular expressions
# Line 2307  DIFFERENCES BETWEEN PCRE AND PERL Line 2332  DIFFERENCES BETWEEN PCRE AND PERL
2332    
2333  Last updated: 28 February 2005  Last updated: 28 February 2005
2334  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
2335  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
2336    
2337    
2338    PCREPATTERN(3)                                                  PCREPATTERN(3)
2339    
2340    
2341  NAME  NAME
2342         PCRE - Perl-compatible regular expressions         PCRE - Perl-compatible regular expressions
# Line 3735  CALLOUTS Line 3762  CALLOUTS
3762    
3763  Last updated: 28 February 2005  Last updated: 28 February 2005
3764  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
3765  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
3766    
3767    
3768    PCREPARTIAL(3)                                                  PCREPARTIAL(3)
3769    
3770    
3771  NAME  NAME
# Line 3923  MULTI-SEGMENT MATCHING WITH pcre_dfa_exe Line 3952  MULTI-SEGMENT MATCHING WITH pcre_dfa_exe
3952    
3953  Last updated: 28 February 2005  Last updated: 28 February 2005
3954  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
3955  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
3956    
3957    
3958    PCREPRECOMPILE(3)                                            PCREPRECOMPILE(3)
3959    
3960    
3961  NAME  NAME
# Line 4032  COMPATIBILITY WITH DIFFERENT PCRE RELEAS Line 4063  COMPATIBILITY WITH DIFFERENT PCRE RELEAS
4063         any saved patterns that were compiled with  previous  releases  (not  a         any saved patterns that were compiled with  previous  releases  (not  a
4064         facility  that  was  previously advertised), you will have to recompile         facility  that  was  previously advertised), you will have to recompile
4065         them for release 5.0. However, from now on, it should  be  possible  to         them for release 5.0. However, from now on, it should  be  possible  to
4066         make changes in a compabible manner.         make changes in a compatible manner.
4067    
4068  Last updated: 28 February 2005  Last updated: 28 February 2005
4069  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
4070  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
4071    
4072    
4073    PCREPERFORM(3)                                                  PCREPERFORM(3)
4074    
4075    
4076  NAME  NAME
# Line 4118  PCRE PERFORMANCE Line 4151  PCRE PERFORMANCE
4151    
4152  Last updated: 28 February 2005  Last updated: 28 February 2005
4153  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
4154  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
4155    
4156    
4157    PCREPOSIX(3)                                                      PCREPOSIX(3)
4158    
4159    
4160  NAME  NAME
# Line 4313  AUTHOR Line 4348  AUTHOR
4348    
4349  Last updated: 28 February 2005  Last updated: 28 February 2005
4350  Copyright (c) 1997-2005 University of Cambridge.  Copyright (c) 1997-2005 University of Cambridge.
4351  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
4352    
4353    
4354    PCRECPP(3)                                                          PCRECPP(3)
4355    
4356    
4357  NAME  NAME
# Line 4328  SYNOPSIS OF C++ WRAPPER Line 4365  SYNOPSIS OF C++ WRAPPER
4365    
4366  DESCRIPTION  DESCRIPTION
4367    
4368         The  C++  wrapper  for  PCRE was provided by Google Inc. This brief man         The  C++  wrapper  for PCRE was provided by Google Inc. Some additional
4369         page was constructed from the notes in the pcrecpp.h file, which should         functionality was added by Giuseppe Maxia. This brief man page was con-
4370         be consulted for further details.         structed  from  the  notes  in the pcrecpp.h file, which should be con-
4371           sulted for further details.
4372    
4373    
4374  MATCHING INTERFACE  MATCHING INTERFACE
4375    
4376         The  "FullMatch" operation checks that supplied text matches a supplied         The "FullMatch" operation checks that supplied text matches a  supplied
4377         pattern exactly. If pointer arguments are supplied, it  copies  matched         pattern  exactly.  If pointer arguments are supplied, it copies matched
4378         sub-strings that match sub-patterns into them.         sub-strings that match sub-patterns into them.
4379    
4380           Example: successful match           Example: successful match
# Line 4350  MATCHING INTERFACE Line 4388  MATCHING INTERFACE
4388           Example: creating a temporary RE object:           Example: creating a temporary RE object:
4389              pcrecpp::RE("h.*o").FullMatch("hello");              pcrecpp::RE("h.*o").FullMatch("hello");
4390    
4391         You  can pass in a "const char*" or a "string" for "text". The examples         You can pass in a "const char*" or a "string" for "text". The  examples
4392         below tend to use a const char*. You can, as in the different  examples         below  tend to use a const char*. You can, as in the different examples
4393         above,  store the RE object explicitly in a variable or use a temporary         above, store the RE object explicitly in a variable or use a  temporary
4394         RE object. The examples below use one mode or  the  other  arbitrarily.         RE  object.  The  examples below use one mode or the other arbitrarily.
4395         Either could correctly be used for any of these examples.         Either could correctly be used for any of these examples.
4396    
4397         You must supply extra pointer arguments to extract matched subpieces.         You must supply extra pointer arguments to extract matched subpieces.
# Line 4379  MATCHING INTERFACE Line 4417  MATCHING INTERFACE
4417           Example: fails because string cannot be stored in integer           Example: fails because string cannot be stored in integer
4418              !pcrecpp::RE("(.*)").FullMatch("ruby", &i);              !pcrecpp::RE("(.*)").FullMatch("ruby", &i);
4419    
4420         The  provided  pointer  arguments can be pointers to any scalar numeric         The provided pointer arguments can be pointers to  any  scalar  numeric
4421         type, or one of:         type, or one of:
4422    
4423            string        (matched piece is copied to string)            string        (matched piece is copied to string)
# Line 4387  MATCHING INTERFACE Line 4425  MATCHING INTERFACE
4425            T             (where "bool T::ParseFrom(const char*, int)" exists)            T             (where "bool T::ParseFrom(const char*, int)" exists)
4426            NULL          (the corresponding matched sub-pattern is not copied)            NULL          (the corresponding matched sub-pattern is not copied)
4427    
4428         The function returns true iff all of the following conditions are  sat-         The  function returns true iff all of the following conditions are sat-
4429         isfied:         isfied:
4430    
4431           a. "text" matches "pattern" exactly;           a. "text" matches "pattern" exactly;
# Line 4401  MATCHING INTERFACE Line 4439  MATCHING INTERFACE
4439              number of sub-patterns, "i"th captured sub-pattern is              number of sub-patterns, "i"th captured sub-pattern is
4440              ignored.              ignored.
4441    
4442         The  matching interface supports at most 16 arguments per call.  If you         The matching interface supports at most 16 arguments per call.  If  you
4443         need   more,   consider    using    the    more    general    interface         need    more,    consider    using    the    more   general   interface
4444         pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.         pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.
4445    
4446    
4447  PARTIAL MATCHES  PARTIAL MATCHES
4448    
4449         You  can  use the "PartialMatch" operation when you want the pattern to         You can use the "PartialMatch" operation when you want the  pattern  to
4450         match any substring of the text.         match any substring of the text.
4451    
4452           Example: simple search for a string:           Example: simple search for a string:
# Line 4423  PARTIAL MATCHES Line 4461  PARTIAL MATCHES
4461    
4462  UTF-8 AND THE MATCHING INTERFACE  UTF-8 AND THE MATCHING INTERFACE
4463    
4464         By default, pattern and text are plain text, one  byte  per  character.         By  default,  pattern  and text are plain text, one byte per character.
4465         The  UTF8  flag,  passed  to  the  constructor, causes both pattern and         The UTF8 flag, passed to  the  constructor,  causes  both  pattern  and
4466         string to be treated as UTF-8 text, still a byte stream but potentially         string to be treated as UTF-8 text, still a byte stream but potentially
4467         multiple  bytes  per character. In practice, the text is likelier to be         multiple bytes per character. In practice, the text is likelier  to  be
4468         UTF-8 than the pattern, but the match returned may depend on  the  UTF8         UTF-8  than  the pattern, but the match returned may depend on the UTF8
4469         flag,  so  always use it when matching UTF8 text. For example, "." will         flag, so always use it when matching UTF8 text. For example,  "."  will
4470         match one byte normally but with UTF8 set may match up to  three  bytes         match  one  byte normally but with UTF8 set may match up to three bytes
4471         of a multi-byte character.         of a multi-byte character.
4472    
4473           Example:           Example:
# Line 4446  UTF-8 AND THE MATCHING INTERFACE Line 4484  UTF-8 AND THE MATCHING INTERFACE
4484               --enable-utf8 flag.               --enable-utf8 flag.
4485    
4486    
4487    PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE
4488    
4489           PCRE defines some modifiers to  change  the  behavior  of  the  regular
4490           expression   engine.  The  C++  wrapper  defines  an  auxiliary  class,
4491           RE_Options, as a vehicle to pass such modifiers to  a  RE  class.  Cur-
4492           rently, the following modifiers are supported:
4493    
4494              modifier              description               Perl corresponding
4495    
4496              PCRE_CASELESS         case insensitive match      /i
4497              PCRE_MULTILINE        multiple lines match        /m
4498              PCRE_DOTALL           dot matches newlines        /s
4499              PCRE_DOLLAR_ENDONLY   $ matches only at end       N/A
4500              PCRE_EXTRA            strict escape parsing       N/A
4501              PCRE_EXTENDED         ignore whitespaces          /x
4502              PCRE_UTF8             handles UTF8 chars          built-in
4503              PCRE_UNGREEDY         reverses * and *?           N/A
4504              PCRE_NO_AUTO_CAPTURE  disables capturing parens   N/A (*)
4505    
4506           (*)  Both Perl and PCRE allow non capturing parentheses by means of the
4507           "?:" modifier within the pattern itself. e.g. (?:ab|cd) does  not  cap-
4508           ture, while (ab|cd) does.
4509    
4510           For  a  full  account on how each modifier works, please check the PCRE
4511           API reference page.
4512    
4513           For each modifier, there are two member functions whose  name  is  made
4514           out  of  the  modifier  in  lowercase,  without the "PCRE_" prefix. For
4515           instance, PCRE_CASELESS is handled by
4516    
4517             bool caseless()
4518    
4519           which returns true if the modifier is set, and
4520    
4521             RE_Options & set_caseless(bool)
4522    
4523           which sets or unsets the  modifier.  Moreover,  PCRE_CONFIG_MATCH_LIMIT
4524           can  be accessed through the set_match_limit() and match_limit() member
4525           functions. Setting match_limit to a non-zero value will limit the  exe-
4526           cution  of pcre to keep it from doing bad things like blowing the stack
4527           or taking an eternity to return a result.  A  value  of  5000  is  good
4528           enough  to stop stack blowup in a 2MB thread stack. Setting match_limit
4529           to zero disables match limiting.
4530    
4531           Normally, to pass one or more modifiers to a RE class,  you  declare  a
4532           RE_Options object, set the appropriate options, and pass this object to
4533           a RE constructor. Example:
4534    
4535              RE_options opt;
4536              opt.set_caseless(true);
4537              if (RE("HELLO", opt).PartialMatch("hello world")) ...
4538    
4539           RE_options has two constructors. The default constructor takes no argu-
4540           ments  and creates a set of flags that are off by default. The optional
4541           parameter option_flags is to facilitate transfer of legacy code from  C
4542           programs.  This lets you do
4543    
4544              RE(pattern,
4545                RE_Options(PCRE_CASELESS|PCRE_MULTILINE)).PartialMatch(str);
4546    
4547           However, new code is better off doing
4548    
4549              RE(pattern,
4550                RE_Options().set_caseless(true).set_multiline(true))
4551                  .PartialMatch(str);
4552    
4553           If you are going to pass one of the most used modifiers, there are some
4554           convenience functions that return a RE_Options class with the appropri-
4555           ate  modifier  already  set: CASELESS(), UTF8(), MULTILINE(), DOTALL(),
4556           and EXTENDED().
4557    
4558           If you need to set several options at once, and you don't  want  to  go
4559           through  the pains of declaring a RE_Options object and setting several
4560           options, there is a parallel method that give you such ability  on  the
4561           fly.  You  can  concatenate several set_xxxxx() member functions, since
4562           each of them returns a reference to its class object. For  example,  to
4563           pass  PCRE_CASELESS, PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one
4564           statement, you may write:
4565    
4566              RE(" ^ xyz \\s+ .* blah$",
4567                RE_Options()
4568                  .set_caseless(true)
4569                  .set_extended(true)
4570                  .set_multiline(true)).PartialMatch(sometext);
4571    
4572    
4573  SCANNING TEXT INCREMENTALLY  SCANNING TEXT INCREMENTALLY
4574    
4575         The  "Consume"  operation may be useful if you want to repeatedly match         The "Consume" operation may be useful if you want to  repeatedly  match
4576         regular expressions at the front of a string and skip over them as they         regular expressions at the front of a string and skip over them as they
4577         match.  This requires use of the "StringPiece" type, which represents a         match. This requires use of the "StringPiece" type, which represents  a
4578         sub-range of a real string. Like RE,  StringPiece  is  defined  in  the         sub-range  of  a  real  string.  Like RE, StringPiece is defined in the
4579         pcrecpp namespace.         pcrecpp namespace.
4580    
4581           Example: read lines of the form "var = value" from a string.           Example: read lines of the form "var = value" from a string.
# Line 4465  SCANNING TEXT INCREMENTALLY Line 4589  SCANNING TEXT INCREMENTALLY
4589                ...;                ...;
4590              }              }
4591    
4592         Each  successful  call  to  "Consume"  will  set  "var/value", and also         Each successful call  to  "Consume"  will  set  "var/value",  and  also
4593         advance "input" so it points past the matched text.         advance "input" so it points past the matched text.
4594    
4595         The "FindAndConsume" operation is similar to  "Consume"  but  does  not         The  "FindAndConsume"  operation  is  similar to "Consume" but does not
4596         anchor  your  match  at  the  beginning of the string. For example, you         anchor your match at the beginning of  the  string.  For  example,  you
4597         could extract all words from a string by repeatedly calling         could extract all words from a string by repeatedly calling
4598    
4599           pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)           pcrecpp::RE("(\\w+)").FindAndConsume(&input, &word)
# Line 4478  SCANNING TEXT INCREMENTALLY Line 4602  SCANNING TEXT INCREMENTALLY
4602  PARSING HEX/OCTAL/C-RADIX NUMBERS  PARSING HEX/OCTAL/C-RADIX NUMBERS
4603    
4604         By default, if you pass a pointer to a numeric value, the corresponding         By default, if you pass a pointer to a numeric value, the corresponding
4605         text  is  interpreted  as  a  base-10  number. You can instead wrap the         text is interpreted as a base-10  number.  You  can  instead  wrap  the
4606         pointer with a call to one of the operators Hex(), Octal(), or CRadix()         pointer with a call to one of the operators Hex(), Octal(), or CRadix()
4607         to  interpret  the text in another base. The CRadix operator interprets         to interpret the text in another base. The CRadix  operator  interprets
4608         C-style "0" (base-8) and  "0x"  (base-16)  prefixes,  but  defaults  to         C-style  "0"  (base-8)  and  "0x"  (base-16)  prefixes, but defaults to
4609         base-10.         base-10.
4610    
4611           Example:           Example:
# Line 4496  PARSING HEX/OCTAL/C-RADIX NUMBERS Line 4620  PARSING HEX/OCTAL/C-RADIX NUMBERS
4620    
4621  REPLACING PARTS OF STRINGS  REPLACING PARTS OF STRINGS
4622    
4623         You  can  replace the first match of "pattern" in "str" with "rewrite".         You can replace the first match of "pattern" in "str"  with  "rewrite".
4624         Within "rewrite", backslash-escaped digits (\1 to \9) can  be  used  to         Within  "rewrite",  backslash-escaped  digits (\1 to \9) can be used to
4625         insert  text  matching  corresponding parenthesized group from the pat-         insert text matching corresponding parenthesized group  from  the  pat-
4626         tern. \0 in "rewrite" refers to the entire matching text. For example:         tern. \0 in "rewrite" refers to the entire matching text. For example:
4627    
4628           string s = "yabba dabba doo";           string s = "yabba dabba doo";
4629           pcrecpp::RE("b+").Replace("d", &s);           pcrecpp::RE("b+").Replace("d", &s);
4630    
4631         will leave "s" containing "yada dabba doo". The result is true  if  the         will  leave  "s" containing "yada dabba doo". The result is true if the
4632         pattern matches and a replacement occurs, false otherwise.         pattern matches and a replacement occurs, false otherwise.
4633    
4634         GlobalReplace  is  like Replace except that it replaces all occurrences         GlobalReplace is like Replace except that it replaces  all  occurrences
4635         of the pattern in the string with the  rewrite.  Replacements  are  not         of  the  pattern  in  the string with the rewrite. Replacements are not
4636         subject to re-matching. For example:         subject to re-matching. For example:
4637    
4638           string s = "yabba dabba doo";           string s = "yabba dabba doo";
4639           pcrecpp::RE("b+").GlobalReplace("d", &s);           pcrecpp::RE("b+").GlobalReplace("d", &s);
4640    
4641         will  leave  "s"  containing  "yada dada doo". It returns the number of         will leave "s" containing "yada dada doo". It  returns  the  number  of
4642         replacements made.         replacements made.
4643    
4644         Extract is like Replace, except that if the pattern matches,  "rewrite"         Extract  is like Replace, except that if the pattern matches, "rewrite"
4645         is  copied into "out" (an additional argument) with substitutions.  The         is copied into "out" (an additional argument) with substitutions.   The
4646         non-matching portions of "text" are ignored. Returns true iff  a  match         non-matching  portions  of "text" are ignored. Returns true iff a match
4647         occurred and the extraction happened successfully;  if no match occurs,         occurred and the extraction happened successfully;  if no match occurs,
4648         the string is left unaffected.         the string is left unaffected.
4649    
# Line 4528  AUTHOR Line 4652  AUTHOR
4652    
4653         The C++ wrapper was contributed by Google Inc.         The C++ wrapper was contributed by Google Inc.
4654         Copyright (c) 2005 Google Inc.         Copyright (c) 2005 Google Inc.
4655  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
4656    
4657    
4658    PCRESAMPLE(3)                                                    PCRESAMPLE(3)
4659    
4660    
4661  NAME  NAME
# Line 4594  PCRE SAMPLE PROGRAM Line 4720  PCRE SAMPLE PROGRAM
4720    
4721  Last updated: 09 September 2004  Last updated: 09 September 2004
4722  Copyright (c) 1997-2004 University of Cambridge.  Copyright (c) 1997-2004 University of Cambridge.
4723  -----------------------------------------------------------------------------  ------------------------------------------------------------------------------
   

Legend:
Removed from v.77  
changed lines
  Added in v.83

  ViewVC Help
Powered by ViewVC 1.1.5