• Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads

  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           #include <pcrecpp.h>


           The  C++  wrapper  for PCRE was provided by Google Inc. Some additional
           functionality was added by Giuseppe Maxia. This brief man page was con-
           structed  from  the  notes  in the pcrecpp.h file, which should be con-
           sulted for further details.


           The "FullMatch" operation checks that supplied text matches a  supplied
           pattern  exactly.  If pointer arguments are supplied, it copies matched
           sub-strings that match sub-patterns into them.
             Example: successful match
                pcrecpp::RE re("h.*o");
             Example: unsuccessful match (requires full match):
                pcrecpp::RE re("e");
             Example: creating a temporary RE object:
           You can pass in a "const char*" or a "string" for "text". The  examples
           below  tend to use a const char*. You can, as in the different examples
           above, store the RE object explicitly in a variable or use a  temporary
           RE  object.  The  examples below use one mode or the other arbitrarily.
           Either could correctly be used for any of these examples.
           You must supply extra pointer arguments to extract matched subpieces.
             Example: extracts "ruby" into "s" and 1234 into "i"
                int i;
                string s;
                pcrecpp::RE re("(\\w+):(\\d+)");
                re.FullMatch("ruby:1234", &s, &i);
             Example: does not try to extract any extra sub-patterns
                re.FullMatch("ruby:1234", &s);
             Example: does not try to extract into NULL
                re.FullMatch("ruby:1234", NULL, &i);
             Example: integer overflow causes failure
                !re.FullMatch("ruby:1234567891234", NULL, &i);
             Example: fails because there aren't enough sub-patterns:
             a. "text" matches "pattern" exactly;
             b. The number of matched sub-patterns is >= number of supplied
             c. The "i"th argument has a suitable type for holding the
                string captured as the "i"th sub-pattern. If you pass in
                void * NULL for the "i"th argument, or a non-void * NULL
                of the correct type, or pass fewer arguments than the
                number of sub-patterns, "i"th captured sub-pattern is
           CAVEAT: An optional sub-pattern that does  not  exist  in  the  matched
           string  is  assigned  the  empty  string. Therefore, the following will
           return false (because the empty string is not a valid number):
              int number;
              pcrecpp::RE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
           The matching interface supports at most 16 arguments per call.  If  you
           need    more,    consider    using    the    more   general   interface
           pcrecpp::RE::DoMatch. See pcrecpp.h for the signature for DoMatch.


           You can use the "QuoteMeta" operation to insert backslashes before  all
           potentially  meaningful  characters  in  a string. The returned string,
           used as a regular expression, will exactly match the original string.
                string quoted = RE::QuoteMeta(unquoted);
           Note that it's legal to escape a character even if it  has  no  special
           meaning  in  a  regular expression -- so this function does that. (This
           also makes it identical to the perl function  of  the  same  name;  see
           "perldoc    -f    quotemeta".)    For   example,   "1.5-2.0?"   becomes


           You can use the "PartialMatch" operation when you want the  pattern  to
           match any substring of the text.
             Example: simple search for a string:
             Example: find first number in a string:
                int number;
                pcrecpp::RE re("(\\d+)");
                re.PartialMatch("x*100 + 20", &number);
                pcrecpp::RE_Options options;
                pcrecpp::RE re(utf8_pattern, options);
             Example: using the convenience function UTF8():
                pcrecpp::RE re(utf8_pattern, pcrecpp::UTF8());
           NOTE: The UTF8 flag is ignored if pcre was not configured with the
                 --enable-utf8 flag.


           PCRE defines some modifiers to  change  the  behavior  of  the  regular
           expression   engine.  The  C++  wrapper  defines  an  auxiliary  class,
           RE_Options, as a vehicle to pass such modifiers to  a  RE  class.  Cur-
           rently, the following modifiers are supported:
              modifier              description               Perl corresponding
              PCRE_CASELESS         case insensitive match      /i
              PCRE_MULTILINE        multiple lines match        /m
              PCRE_DOTALL           dot matches newlines        /s
              PCRE_DOLLAR_ENDONLY   $ matches only at end       N/A
              PCRE_EXTRA            strict escape parsing       N/A
              PCRE_EXTENDED         ignore white spaces         /x
              PCRE_UTF8             handles UTF8 chars          built-in
              PCRE_UNGREEDY         reverses * and *?           N/A
              PCRE_NO_AUTO_CAPTURE  disables capturing parens   N/A (*)
           (*)  Both Perl and PCRE allow non capturing parentheses by means of the
           "?:" modifier within the pattern itself. e.g. (?:ab|cd) does  not  cap-
           ture, while (ab|cd) does.
           For  a  full  account on how each modifier works, please check the PCRE
           API reference page.
           For each modifier, there are two member functions whose  name  is  made
           out  of  the  modifier  in  lowercase,  without the "PCRE_" prefix. For
           instance, PCRE_CASELESS is handled by
             bool caseless()
           which returns true if the modifier is set, and
             RE_Options & set_caseless(bool)
           which sets or unsets the modifier. Moreover, PCRE_EXTRA_MATCH_LIMIT can
           be  accessed  through  the  set_match_limit()  and match_limit() member
           functions. Setting match_limit to a non-zero value will limit the  exe-
           cution  of pcre to keep it from doing bad things like blowing the stack
              if (RE("HELLO", opt).PartialMatch("hello world")) ...
           RE_options has two constructors. The default constructor takes no argu-
           ments  and creates a set of flags that are off by default. The optional
           parameter option_flags is to facilitate transfer of legacy code from  C
           programs.  This lets you do
           However, new code is better off doing
           If you are going to pass one of the most used modifiers, there are some
           convenience functions that return a RE_Options class with the appropri-
           ate  modifier  already  set: CASELESS(), UTF8(), MULTILINE(), DOTALL(),
           and EXTENDED().
           If you need to set several options at once, and you don't  want  to  go
           through  the pains of declaring a RE_Options object and setting several
           options, there is a parallel method that give you such ability  on  the
           fly.  You  can  concatenate several set_xxxxx() member functions, since
           each of them returns a reference to its class object. For  example,  to
           pass  PCRE_CASELESS, PCRE_EXTENDED, and PCRE_MULTILINE to a RE with one
           statement, you may write:
              RE(" ^ xyz \\s+ .* blah$",


           The "Consume" operation may be useful if you want to  repeatedly  match
           regular expressions at the front of a string and skip over them as they
           match. This requires use of the "StringPiece" type, which represents  a
           sub-range  of  a  real  string.  Like RE, StringPiece is defined in the
           pcrecpp namespace.
             Example: read lines of the form "var = value" from a string.
                string contents = ...;                 // Fill string somehow
                pcrecpp::StringPiece input(contents);  // Wrap in a StringPiece
                string var;
                int value;
                pcrecpp::RE re("(\\w+) = (\\d+)\n");
                while (re.Consume(&input, &var, &value)) {
           By default, if you pass a pointer to a numeric value, the corresponding
           text is interpreted as a base-10  number.  You  can  instead  wrap  the
           pointer with a call to one of the operators Hex(), Octal(), or CRadix()
           to interpret the text in another base. The CRadix  operator  interprets
           C-style  "0"  (base-8)  and  "0x"  (base-16)  prefixes, but defaults to
               int a, b, c, d;
               pcrecpp::RE re("(.*) (.*) (.*) (.*)");
               re.FullMatch("100 40 0100 0x40",
                            pcrecpp::Octal(&a), pcrecpp::Hex(&b),
                            pcrecpp::CRadix(&c), pcrecpp::CRadix(&d));
           will leave 64 in a, b, c, and d.


           You can replace the first match of "pattern" in "str"  with  "rewrite".
           Within  "rewrite",  backslash-escaped  digits (\1 to \9) can be used to
           insert text matching corresponding parenthesized group  from  the  pat-
           tern. \0 in "rewrite" refers to the entire matching text. For example:
             string s = "yabba dabba doo";
             pcrecpp::RE("b+").Replace("d", &s);
           will  leave  "s" containing "yada dabba doo". The result is true if the
           pattern matches and a replacement occurs, false otherwise.
           GlobalReplace is like Replace except that it replaces  all  occurrences
           of  the  pattern  in  the string with the rewrite. Replacements are not
           subject to re-matching. For example:
             string s = "yabba dabba doo";
             pcrecpp::RE("b+").GlobalReplace("d", &s);
           will leave "s" containing "yada dada doo". It  returns  the  number  of
           replacements made.
           Extract  is like Replace, except that if the pattern matches, "rewrite"
           is copied into "out" (an additional argument) with substitutions.   The
           non-matching  portions  of "text" are ignored. Returns true iff a match
           occurred and the extraction happened successfully;  if no match occurs,
           the string is left unaffected.


           The C++ wrapper was contributed by Google Inc.
           Copyright (c) 2007 Google Inc.



  • Linux

    The Distributions


    The Software


    The News


  • Toll Free
Copyright © 1999 - 2016 by LinuxGuruz