Библиотека preg для регулярных выражений как в PHP

     preg pregIntNumber("^[\-\+]?[0-9]+$");

     if (preg("....").FindIn(sSubject).IsFound())
         Xxxx();

     ASSERTM(
         !preg("\\\\[a-z]+\-").FindIn(sRtf).IsFound(),
         "this sRtf cannot contain negative command args like \\cmd-123");

     if (preg(
             "^"  // anchor - checking the whole string, we are NOT searching here
                 "\\\\" // single slash: RTF command prefix
                 "[a-z]+" // command is lowercase one or more letters
                 "\-?" // hypen may precede negative argument
                 "[0-9]*"  // optional argument is a number
                 "$"). // (close anchor)
             FindIn(sRtf).IsFound())
     {
         HandleValidRtfCommand();

     str sSubject =
         "win 98 OSR 2.1 driver released 97- 6 - 11 provide support for USB 1.0";
 
     // Pattern names
     #define C_szCaptureYear "Year"
     #define C_szCaptureMonth "Month"
     #define C_szCaptureDay "Day"
 
     // Template for date extraction in form of year - month - day
     preg pregDate =
         preg(
             ""
                 "(?P<" C_szCaptureYear ">"
                     "[0-9]{2,4}"
                 ")"
 
                 Preg_space "*"
                 "\\-"
                 Preg_space "*"
 
                 "(?P<" C_szCaptureMonth ">"
                     "[0-9]{1,2}"
                 ")"
 
                 Preg_space "*"
                 "\\-"
                 Preg_space "*"
 
                 "(?P<" C_szCaptureDay ">"
                     "[0-9]{1,2}"
                 ")"
 
                 "");
 
     pregfind pregfindDate = pregDate.FindIn(sSubject);
 
     if (pregfindDate.IsFound())
     {
         str sYear = pregfindDate.GetCaptureByName(C_szCaptureYear);
         str sMonth = pregfindDate.GetCaptureByName(C_szCaptureMonth);
         str sDay = pregfindDate.GetCaptureByName(C_szCaptureDay);
 
         ASSERT(sYear == "97");
         ASSERT(sMonth == "6");
         ASSERT(sDay == "11");
     }

     str sSubject = "abc 123 def 555 1 xxx";
     str sReplaceNumbers = "#";
 
     sResult = preg("[0-9]+").ReplaceInSubjectWithText(sSubject, sReplaceNumbers);
 
     ASSERT(sResult == "abc # def # # xxx");

//VL: 2010-07-23
    // Replace with substitutions.
    //   In textReplaceWith array every other item is eiter a capture name
    //   or a special reference:
    #define C_szReplaceWithMatchSubstring "*"
    //   So the literal strings and capture name references are
    //   INTERLEAVED in the text array. This way we don't need any special
    //   syntax ($1, \1, ...) to reference the captures.
    //   Literal text can be an empty string.
    //   A capture name must be present in the pattern.
    //   C_szReplaceWithMatchSubstring references the whole found text fragment.
    //
    //   example: replace:  [COLOR=red]Text[/COLOR]
    //               with:  <font color'red'>Text</font>
    //     preg(
    //        Preg_MultilineSubject
    //        Preg_IgnoreCase
    //        "\\[COLOR\\=(?P<Color>[^\\]]+)\\]"
    //            "(?P<Content>.+" Preg_Ungreedy ")\\[\\/COLOR\\]").
    //        ReplaceInSubjectWithCaptures(
    //            sResult,
    //            text(
    //                array<str>()
    //                    << "<font color='"    // literal
    //                    << "Color"            // capture name
    //                    << "'>"               // another literal
    //                    << "Content"          // another capture name
    //                    << "</font>"));       // literal ending
    //
    str ReplaceInSubjectWithCaptures(
            str sSubject,
            text textReplaceWith,
            int nLimitMaxCount = off)
            const;
//VL.

     str sSubject = "some Example 9text to caPITALIZE with Preg_word-check";
     str sExpect =  "Some Example 9text To CaPITALIZE With Preg_word-Check";
     str sResult;
 
     preg pregPattern(Preg_word "+");
 
     pregfind pregfindIter;
     for (iter i; pregPattern.IterateSkipMatchPairs(*& i, *& pregfindIter, sSubject);)
     {
         // Always append mismatched fragment verbatim
         str sSkip = pregfindIter.GetSkipSubstring();
         sResult += sSkip;
 
         if (pregfindIter.IsFound())
         {
             // Modify and append matching fragment
             sResult += pregfindIter.GetMatchSubstring().CapFirst();
         }
     }
 
     ASSERT(sResult == sExpect);

    int GetN();
    str GetText();
    void NonGetFn();
 
  // a comment line
    ref<CXxxx> GetXxxx();
 
        friend long double GetAstronomical(P* pThis);

     str sSubject =
         ""
             "   int GetN();\n"
             "   str GetText();\n"
             "   void NonGetFn();\n"
             "                            \n"
             " // a comment line          \n"
             "   ref<CXxxx> GetXxxx(); \n"
             "\n"
             "       friend long double GetAstronomical(P* pThis);\n"
       ;
 
     str sExpect =
         ""
             "   void SetN(int value);\n"
             "   void SetText(str value);\n"
             "   void NonGetFn();\n"
             "                            \n"
             " // a comment line          \n"
             "   void SetXxxx(ref<CXxxx> value); \n"
             "\n"
             "       friend void SetAstronomical(P* pThis, long double value);\n"
       ;
 
     // Declare all captured subpatterns as named
     #define C_szCaptureModifier "Modifier"
     #define C_szCaptureType "Type"
     #define C_szCaptureFunctionStart "FunctionStart"
     #define C_szCaptureFirstArgs "FirstArgs"
 
     // Patter (is constant here, despite symbolic names present)
     preg pregPattern =
         preg(
             ""
                 // 'friend' keyword may be present, this is not a part of type
                 "(?P<" C_szCaptureModifier ">"
                     "friend"
                     Preg_space "+" // include the following space
                 ")"
                 "?" // 'friend' modifier is optional
 
                 // type spec may be anything not startng as Get function name
                 "(?P<" C_szCaptureType ">"
                     "("
                         // type is restricted to a space separated word starting with
                         //   a lowercase letter but containing any
                         //   non-space/non-newline chars
                         "[a-z]" "[^" Preg_space "\\n]*" "[ \\t]+"
                     ")+" // multiple words allowed (see 'long double')
                 ")"
 
                 // function name and optional parameters
                 "Get" // we only interested in Get functions,
                       //   and dont wanna capture the 'Get' word itself
                 "(?P<" C_szCaptureFunctionStart ">"
                     Preg_word "+" "\\(" // GetXxxx( ...
                     "(?P<" C_szCaptureFirstArgs ">"
                         "[^\\)]*" // optional 1st arg
                     ")"
                 ")"
 
                 // declaration ending
                 "\\)");
 
     str sResult;
 
     // Stylized Loop
     pregfind pregfindIter;
     int nFoundCount = 0;
     for (iter i; pregPattern.IterateSkipMatchPairs(*& i, *& pregfindIter, sSubject);)
     {
         // Always append mismatched fragment verbatim
         str sSkip = pregfindIter.GetSkipSubstring();
         sResult += sSkip;
 
         if (pregfindIter.IsFound())
         {
             nFoundCount++;
 
             // Lookup captures (some maybe empty)
             str sModifier = pregfindIter.GetCaptureByName(C_szCaptureModifier);
             str sType = pregfindIter.GetCaptureByName(C_szCaptureType);
             str sFunctionStart = pregfindIter.GetCaptureByName(C_szCaptureFunctionStart);
             str sFirstArgs = pregfindIter.GetCaptureByName(C_szCaptureFirstArgs);
 
             // (dont need pregfindIter.GetMatchSubstring(); here)
 
             // Compose the result
 
             // note slow: sResult += sModifier + "void Set" + sFunctionStart;
             sResult += sModifier;
             sResult += "void Set";
             sResult += sFunctionStart;
 
             if (sFirstArgs.GetLength() > 0)
             {
                 ASSERT(sFunctionStart.FindPos(sFirstArgs) > 0);
                 sResult += ", ";
             }
 
             sResult += sType;
             sResult += "value)";
         }
     }
 
     ASSERT(nFoundCount == 4);
     ASSERT(sResult == sExpect);

META CHARACTERS

 There are two different sets of meta-characters: those that are recognized

 anywhere in the pattern except within square brackets, and those

 that are recognized in square brackets. Outside square brackets, the

 meta-characters are as follows:

     \ general escape character with several uses

     ^ assert start of string (or line, in multiline mode)

     $ assert end of string (or line, in multiline mode)

     . match any character except including newline

     | start of alternative branch

     ( start subpattern

     ) end subpattern

     ? extends the meaning of (

         also 0 or 1 quantifier

         also quantifier minimizer

     * 0 or more quantifier

     + 1 or more quantifier

         also "possessive quantifier"

     { start min/max quantifier

     [ start character class definition

 Part of a pattern that is in square brackets is called a character class.

 In a character class the only meta-characters are:

     \ general escape character

     ^ negate the class, but only if the first character

     - indicates character range

     [ POSIX character class (only if followed by POSIX syntax)

     ] terminates the character class

PREDEFINED CLASSES (enabled in []class):

     Islib Macro PCRE Description

     

     Preg_digit \d any decimal digit

     Preg_notDigit \D any character that is not a decimal digit

     Preg_space \s any whitespace character

     Preg_notSpace \S any character that is not a whitespace character

     Preg_word \w any "word" character (letter or digit or the underscore)

     Preg_notWord \W any "non-word" character

BOUNDARY ASSERTIONS (disabled in []class):

     Islib Macro PCRE Description

     Preg_boundary \b matches at a word boundary (prev xor next char isn't word)

     Preg_notBoundary \B matches when not at a word boundary

     Preg_AtStart \A (^-anchor) matches at start of subject

     Preg_GlobalNext \G (^-anchor) matches at first matching position in subject

                             (matches both original subject start pos and subsequent

                             initial restart pos for the next calls)

     Preg_ZeeEndOrEol \Z ($-anchor) matches at end of subject or before \n at end

     Preg_zeeEnd \z ($-anchor) matches at end of subject

 Lookahead assertions start with

     (?= positive assertions and

     (?! negative assertions.

 Lookbehind assertions start with

     (?<= positive assertions and

     (?<! negative assertions

 Note: If you want to force a matching failure at some point in a pattern, the

       most convenient way: "(?!)"

Capturing

 The Python syntax (?P<SubstringName>...) is used.

     Names consist of alphanumeric characters and underscores,

     and must be unique within a pattern.

 Back references to named subpatterns use the Python syntax (?P=name).

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

     matches "rah rah" and "RAH RAH", but not "RAH rah", even though the

     original capturing subpattern is matched caselessly.

Repetitions

 {3} - strict count

 {2,4} - strict range

 {2,} - to infinity

 {,4} - error!

     * = {0,}

     + = {1,}

     ? = {0,1}

 (a?)* - infinite loop, stops if does not match anything

 ? after quantifier removes greediness

CONDITIONAL SUBPATTERNS

 (?(condition)yes-pattern)

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

 1) If the text between the parentheses

     consists of a sequence of digits, the condition is satisfied if the

     capturing subpattern of that number has previously matched.

     example: ( \( )? [^()]+ (?(1) \) ) -- checks for closing paren if needed

 2) If the condition is the string ®, it is satisfied if a recursive call

     to the pattern or subpattern has been made.

 3) Otherwise it must be an assertion.

     This may be a positive or negative lookahead or lookbehind assertion.

 see pcre.txt

RECURSIVE PATTERNS

 For example, this PCRE pattern solves the nested parentheses problem

     (assume the PCRE_EXTENDED option is set so that white space is ignored):

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

 PCRE uses (?P>name), which is an extension to the Python syntax that PCRE

     uses for named parentheses.

     We could rewrite the above example as follows:

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

 see pcre.txt

ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS

 (?>\d+)foo

 see pcre.txt

    if (preg("[0-9A-Fa-f]+").FindIn(sInput).IsFound())

    if (preg("^[0-9A-Fa-f]+$").FindIn(sInput).IsFound())