// Copyright (c) 2005 - 2006, Google Inc.+
−
// All rights reserved.+
−
//+
−
// Redistribution and use in source and binary forms, with or without+
−
// modification, are permitted provided that the following conditions are+
−
// met:+
−
//+
−
//     * Redistributions of source code must retain the above copyright+
−
// notice, this list of conditions and the following disclaimer.+
−
//     * Redistributions in binary form must reproduce the above+
−
// copyright notice, this list of conditions and the following disclaimer+
−
// in the documentation and/or other materials provided with the+
−
// distribution.+
−
//     * Neither the name of Google Inc. nor the names of its+
−
// contributors may be used to endorse or promote products derived from+
−
// this software without specific prior written permission.+
−
//+
−
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+
−
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+
−
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+
−
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+
−
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+
−
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+
−
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+
−
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+
−
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+
−
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+
−
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+
−
//+
−
// Author: Sanjay Ghemawat+
−
//+
−
+
−
// Heavily refactored for Symbian OS by Accenture.+
−
+
−
#ifndef CREGEX_H_+
−
#define CREGXX_H_+
−
+
−
#include <e32base.h>+
−
#include "tregexoptions.h"+
−
+
−
// Forward declarations+
−
class TRegExArg;+
−
struct real_pcre;+
−
typedef struct real_pcre pcre;+
−
struct pcre_extra;+
−
+
−
// Errors+
−
+
−
/** Base offset for CRegEx Errors */+
−
const TInt KErrRegExBase 									= -20000;+
−
+
−
/** Base offset for RegEx pattern compile errors */+
−
const TInt KErrRegExCompileBase 							= KErrRegExBase;+
−
+
−
/** \ at end of pattern */+
−
const TInt KErrRegExCmpBackslashAtEOP 						= KErrRegExCompileBase - 1;+
−
/** \c at end of pattern */+
−
const TInt KErrRegExCmpBackslashCAtEOP 						= KErrRegExCompileBase - 2;+
−
/** unrecognized character follows \ */+
−
const TInt KErrRegExCmpUnrecCharAftBackslash				= KErrRegExCompileBase - 3;+
−
/** numbers out of order in {} quantifier */+
−
const TInt KErrRegExCmpNumsOutOfOrderInBraceQuantifier		= KErrRegExCompileBase - 4;+
−
/** number too big in {} quantifier */+
−
const TInt KErrRegExCmpNumTooBigInBraceQuantifier			= KErrRegExCompileBase - 5;+
−
/** missing terminating ] for character class */+
−
const TInt KErrRegExCmpMissingTermBracketInCharClass		= KErrRegExCompileBase - 6;+
−
/** invalid escape sequence in character class */+
−
const TInt KErrRegExCmpInvalidEscapeSeqInCharClass			= KErrRegExCompileBase - 7;+
−
/** range out of order in character class */+
−
const TInt KErrRegExCmpRangeOutOfOrderInCharClass			= KErrRegExCompileBase - 8;+
−
/** nothing to repeat */+
−
const TInt KErrRegExCmpNothingToRepeat						= KErrRegExCompileBase - 9;+
−
/** operand of unlimited repeat could match the empty string - no longer used */+
−
const TInt KErrRegExCmpUnused01								= KErrRegExCompileBase - 10;+
−
/** internal error: unexpected repeat */+
−
const TInt KErrRegExCmpUnexpectedRepeat						= KErrRegExCompileBase - 11;+
−
/** unrecognized character after (? or (?-\0t */+
−
const TInt KErrRegExCmpUnexpectedCharAftParenthQuest		= KErrRegExCompileBase - 12;+
−
/** POSIX named classes are supported only within a class */+
−
const TInt KErrRegExCmpPosixNamedSupportedWithinClass		= KErrRegExCompileBase - 13;+
−
/** missing ) */+
−
const TInt KErrRegExCmpMissingCloseParenth					= KErrRegExCompileBase - 14;+
−
/** reference to non-existent subpattern */+
−
const TInt KErrRegExCmpRefNonExistSubpattern				= KErrRegExCompileBase - 15;+
−
/** internal error: erroffset passed as NULL */+
−
const TInt KErrRegExCmpErrOffsetNull						= KErrRegExCompileBase - 16;+
−
/** unknown option bit(s) set */+
−
const TInt KErrRegExCmpUnknownOptionBitsSet					= KErrRegExCompileBase - 17;+
−
/** missing ) after comment */+
−
const TInt KErrRegExCmpMissingCloseParenthAftComment		= KErrRegExCompileBase - 18;+
−
/** parentheses nested too deeply - no longer used */+
−
const TInt KErrRegExCmpUnused02								= KErrRegExCompileBase - 19;+
−
/** regular expression is too large */+
−
const TInt KErrRegExCmpExprTooLarge							= KErrRegExCompileBase - 20;+
−
/** failed to get memory */+
−
const TInt KErrRegExCmpFailedGetMemory						= KErrRegExCompileBase - 21;+
−
/** unmatched parentheses */+
−
const TInt KErrRegExCmpUnmatchedParenth						= KErrRegExCompileBase - 22;+
−
/** internal error: code overflow */+
−
const TInt KErrRegExCmpCodeOverflow							= KErrRegExCompileBase - 23;+
−
/** unrecognized character after (?< */+
−
const TInt KErrRegExCmpUnRecogCharAftParenthQuestAngle		= KErrRegExCompileBase - 24;+
−
/** lookbehind assertion is not fixed length*/+
−
const TInt KErrRegExCmpLookbehindAssertNotFixedLen			= KErrRegExCompileBase - 25;+
−
/** malformed number or name after (?( */+
−
const TInt KErrRegExCmpMalformedAftParenthQuestParenth		= KErrRegExCompileBase - 26;+
−
/** conditional group contains more than two branches */+
−
const TInt KErrRegExCmpCondGroupMoreThanTwoBranches			= KErrRegExCompileBase - 27;+
−
/** assertion expected after (?(\0 */+
−
const TInt KErrRegExCmpAssertExpAftParenthQuestParent		= KErrRegExCompileBase - 28;+
−
/** (?R or (?[+-]digits must be followed by ) */+
−
const TInt KErrRegExCmpMustFollowedByCloseParenth			= KErrRegExCompileBase - 29;+
−
/** unknown POSIX class name */+
−
const TInt KErrRegExCmpUnknownPosixClassName				= KErrRegExCompileBase - 30;+
−
/** POSIX collating elements are not supported */+
−
const TInt KErrRegExCmpPosixCollElemsNotSupported			= KErrRegExCompileBase - 31;+
−
/** this version of PCRE is not compiled with PCRE_UTF8 support */+
−
const TInt KErrRegExCmpNotCompiledWithUtf8Support			= KErrRegExCompileBase - 32;+
−
/** spare error - no longer user  */+
−
const TInt KErrRegExCmpUnused03								= KErrRegExCompileBase - 33;+
−
/** character value in \x{...} sequence is too large */+
−
const TInt KErrRegExCmpCharValueInBackslashXSeqTooLarge		= KErrRegExCompileBase - 34;+
−
/** invalid condition (?(0) */+
−
const TInt KErrRegExCmpInvalidCondition						= KErrRegExCompileBase - 35;+
−
/** \C not allowed in lookbehind assertion */+
−
const TInt KErrRegExCmpBackslashCNotAllowedinLookbehind		= KErrRegExCompileBase - 36;+
−
/** PCRE does not support \L, \l, \N, \U, or \u\0 */+
−
const TInt KErrRegExCmpLNUEscapeSeqNotSupported				= KErrRegExCompileBase - 37;+
−
/** number after (?C is > 255 */+
−
const TInt KErrRegExCmpNumAftParenthQuestCIsGreatherThan	= KErrRegExCompileBase - 38;+
−
/** closing ) for (?C expected\ */+
−
const TInt KErrRegExCmpCloseParenthAftParenthQuestCExp		= KErrRegExCompileBase - 39;+
−
/** recursive call could loop indefinitely */+
−
const TInt KErrRegExCmpRecuriveCallLoopIndef				= KErrRegExCompileBase - 40;+
−
/** unrecognized character after (?P */+
−
const TInt KErrRegExCmpUnrecCharaftParenthQuestP			= KErrRegExCompileBase - 41;+
−
/** syntax error in subpattern name (missing terminator) */+
−
const TInt KErrRegExCmpSyntaxInSubpatternName				= KErrRegExCompileBase - 42;+
−
/** two named subpatterns have the same name */+
−
const TInt KErrRegExCmpTwoSubpatternsHaveSameName			= KErrRegExCompileBase - 43;+
−
/** invalid UTF-8 string */+
−
const TInt KErrRegExCmpInvalidUtf8String					= KErrRegExCompileBase - 44;+
−
/** support for \P, \p, and \X has not been compiled */+
−
const TInt KErrRegExCmpSupportForEscapeSeqNotCompiled		= KErrRegExCompileBase - 45;+
−
/** malformed \P or \p sequence */+
−
const TInt KErrRegExCmpMalformedBackslashPSeq				= KErrRegExCompileBase - 46;+
−
/** unknown property name after \P or \p */+
−
const TInt KErrRegExCmpUnknownPropNameAftBackslashPSeq		= KErrRegExCompileBase - 47;+
−
/** subpattern name is too long. Default max = 32 chars. See MAX_NAME_SIZE */+
−
const TInt KErrRegExCmpSubpatternNameTooLong				= KErrRegExCompileBase - 48;+
−
/** subpattern name is too long. Default max = 10000. See MAX_NAME_COUNT */+
−
const TInt KErrRegExCmpTooManyNamesSubpatterns				= KErrRegExCompileBase - 49;+
−
/** repeated subpattern is too long - no longer used */+
−
const TInt KErrRegExCmpUnused04								= KErrRegExCompileBase - 50;+
−
/** octal value is greater than \\377 (not in UTF-8 mode) */+
−
const TInt KErrRegExCmpOctalValueGreatherThan377			= KErrRegExCompileBase - 51;+
−
/** internal error: overran compiling workspace */+
−
const TInt KErrRegExCmpOverranCompilingSpace				= KErrRegExCompileBase - 52;+
−
/** internal error: previously-checked referenced subpattern not found */+
−
const TInt KErrRegExCmpCheckedSubpatternNotFound			= KErrRegExCompileBase - 53;+
−
/** DEFINE group contains more than one branch */+
−
const TInt KErrRegExCmpDefineGroupMoreThanOneBranch			= KErrRegExCompileBase - 54;+
−
/** repeating a DEFINE group is not allowed */+
−
const TInt KErrRegExCmpRepeatingDefineGroupNotAllowed		= KErrRegExCompileBase - 55;+
−
/** inconsistent NEWLINE options */+
−
const TInt KErrRegExCmpInconsistantNewlineOpts				= KErrRegExCompileBase - 56;+
−
/** \g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number */+
−
const TInt KErrRegExCmpBackslashGNotFollowed				= KErrRegExCompileBase - 57;+
−
/** a numbered reference must not be zero */+
−
const TInt KErrRegExCmpNumberedRefIsZero					= KErrRegExCompileBase - 58;+
−
/** (*VERB) with an argument is not supported */+
−
const TInt KErrRegExCmpAsteriskVerbWithArgNotSupported		= KErrRegExCompileBase - 59;+
−
/** (*VERB) not recognized */+
−
const TInt KErrRegExCmpAsteriskVerbNotRecog					= KErrRegExCompileBase - 60;+
−
/** number is too big */+
−
const TInt KErrRegExCmpNumTooBig							= KErrRegExCompileBase - 61;+
−
/** subpattern name expected */+
−
const TInt KErrRegExCmpSubpatternNameExp					= KErrRegExCompileBase - 62;+
−
/** digit expected after (?+ */+
−
const TInt KErrRegExCmpDigitExpAftParenthQuestPlus			= KErrRegExCompileBase - 63;+
−
/** ] is an invalid data character in JavaScript compatibility mode */+
−
const TInt KErrRegExCloseBracketInvalidInJSCompatMode		= KErrRegExCompileBase - 64;+
−
+
−
/** Base offset for RegEx pattern general errors */+
−
const TInt KErrRegExGeneralBase 							= KErrRegExCompileBase - 512;+
−
+
−
/** Zero Matches */+
−
const TInt KErrRegExZeroMatches								= KErrRegExGeneralBase - 1;+
−
+
−
/** Regular expression has fewer capturing groups than number of args passed in */+
−
const TInt KErrRegExFewerCaptureGroupsThanArgs				= KErrRegExGeneralBase - 2;+
−
+
−
/** Failed to parse argument, e.g. the supplied argument does not have enough capacity */+
−
const TInt KErrRegExFailedToParseArg						= KErrRegExGeneralBase - 3;+
−
+
−
/** The modifiable descriptor supplied to recieve output does not have a large enough maximum length */+
−
const TInt KErrRegExOutputTooBig							= KErrRegExGeneralBase - 4;+
−
+
−
/** Invalid rewrite pattern */+
−
const TInt KErrRegExInvalidRewritePattern					= KErrRegExGeneralBase - 5;+
−
+
−
/** Error with one of the backslash substitutions in the supplied rewrite string */+
−
const TInt KErrRegExBadBackslashSubsitution					= KErrRegExGeneralBase - 6;+
−
+
−
// Panic Codes+
−
_LIT(KRegExPanic, "CRegEx");+
−
+
−
/**+
−
 * Internal CRegEx panics (Debug only)+
−
 */+
−
enum TRegExPanic+
−
	{+
−
	EInvalidMatchResults,+
−
	EUnexpectedRetValFromPcre,+
−
	EVectorTooSmall,+
−
	EInvalidNumArgs+
−
	};+
−
+
−
/*+
−
 * Newlines are indicated by a single LF character.+
−
 * @see KNewLineCr+
−
 * @see KNewLineCrLf+
−
 * @see KNewLineAnyCrLf+
−
 * @see KNewLineAny +
−
 */+
−
static const TInt KNewLineLf = 10;+
−
/*+
−
 * Newlines are indicated by a single CR character.+
−
 * @see KNewLineLf+
−
 * @see KNewLineCrLf+
−
 * @see KNewLineAnyCrLf+
−
 * @see KNewLineAny +
−
 */+
−
static const TInt KNewLineCr = 13;+
−
+
−
/* +
−
 * Newlines are indicated by the two-character CRLF sequence.+
−
 * @see KNewLineCr+
−
 * @see KNewLineLf +
−
 * @see KNewLineAnyCrLf+
−
 * @see KNewLineAny+
−
 */+
−
static const TInt KNewLineCrLf = 3338;+
−
+
−
/*+
−
 * Newlines are indicated by any of the following:+
−
 * - A single CR character.+
−
 * - A single LF character.+
−
 * - The two-character CRLF sequence. +
−
 * @see KNewLineLf+
−
 * @see KNewLineCr+
−
 * @see KNewLineCrLf +
−
 * @see KNewLineAny+
−
 */+
−
static const TInt KNewLineAnyCrLf = -2;+
−
+
−
/*+
−
 * Newlines are indicated by any Unicode sequence:+
−
 * - A single CR character.+
−
 * - A single LF character.+
−
 * - The two-character CRLF sequence. +
−
 * - A single VT character (vertical tab, U+000B).+
−
 * - A single FF character (formfeed, U+000C).+
−
 * - A single NEL character (next line, U+0085).+
−
 * - A single LS character (line separator, U+2028). +
−
 * - A single PS character (paragraph separator, U+2029).+
−
 * The last two are recognized only in UTF-8 mode. +
−
 * @see KNewLineLf+
−
 * @see KNewLineCr+
−
 * @see KNewLineCrLf+
−
 * @see KNewLineAnyCrLf+
−
 */+
−
static const TInt KNewLineAny = -1;+
−
+
−
/**+
−
 * Symbian C++ interface to the pcre regular-expression library. This class, its+
−
 * supporting classes and most of the following documentation is largely based+
−
 * on or taken from the C++ wrapper included with source distributions of PCRE+
−
 * to which all credit should be given.+
−
 * +
−
 * CRegEx supports+
−
 * Perl-style regular expressions (with extensions like \d, \w, \s,+
−
 * ...).+
−
 *+
−
 * NOTE: These following examples make liberal use of _L8() purely for clarity+
−
 * and not because it is recommend. In fact, it is strongly discouraged+
−
 * in favour of _LIT8() as per the standard Symbian coding conventions.+
−
 * -----------------------------------------------------------------------+
−
 * REGEXP SYNTAX:+
−
 *+
−
 * This module is part of the pcre library and hence supports its syntax+
−
 * for regular expressions.+
−
 *+
−
 * The syntax is pretty similar to Perl's.  For those not familiar+
−
 * with Perl's regular expressions, here are some examples of the most+
−
 * commonly used extensions:+
−
 *+
−
 *   "hello (\\w+) world"  -- \w matches a "word" character+
−
 *   "version (\\d+)"      -- \d matches a digit+
−
 *   "hello\\s+world"      -- \s matches any whitespace character+
−
 *   "\\b(\\w+)\\b"        -- \b matches empty string at a word boundary+
−
 *   "(?i)hello"           -- (?i) turns on case-insensitive matching+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * MATCHING INTERFACE:+
−
 *+
−
 * The FullMatchL() operation checks that supplied text matches a+
−
 * supplied pattern exactly.+
−
 *+
−
 * Example: successful match+
−
 * @code+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("h.*o"));+
−
 *    re->FullMatchL(_L8("hello"));+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * +
−
 * Example: unsuccessful match (requires full match):+
−
 * @code+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("e"));+
−
 *    !re->FullMatchL(_L8("hello"));+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * MATCHING WITH SUB-STRING EXTRACTION:+
−
 *+
−
 * You can supply extra pointer arguments to extract matched subpieces.+
−
 *+
−
 * Example: extracts "ruby" into "s" and 1234 into "i"+
−
 * @code+
−
 *    TInt i;+
−
 *    TBuf<4> s;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(\\w+):(\\d+)"));+
−
 *    re->FullMatchL(_L8("ruby:1234"), &s, &i);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 *+
−
 * Example: does not try to extract any extra sub-patterns+
−
 * @code+
−
 *    re->FullMatchL(_L8("ruby:1234"), &s);+
−
 * @endcode+
−
 * +
−
 * Example: does not try to extract into NULL+
−
 * @code+
−
 *    re->FullMatchL(_L8("ruby:1234"), NULL, &i);+
−
 * @endcode+
−
 * +
−
 * Example: integer overflow causes failure+
−
 * @code+
−
 *    !re.FullMatchL(_L8("ruby:1234567891234"), NULL, &i);+
−
 * @endcode+
−
 * +
−
 * Example: fails because there aren't enough sub-patterns:+
−
 * @code+
−
 *    TBuf<4> s;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("\\w+:\\d+"));+
−
 *    !re->FullMatchL(_L8("ruby:1234"), &s);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * +
−
 * Example: fails because string cannot be stored in integer+
−
 * @code+
−
 *    TInt i;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(.*)"));+
−
 *    !re->FullMatchL(_L8("ruby"), &i);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode +
−
 *+
−
 * The provided pointer arguments can be pointers to any scalar numeric+
−
 * type, or one of+
−
 *    TDes8        (matched piece is copied to descriptor)+
−
 *    TPtrC8	   (matched piece is pointed to by)+
−
 *    T            (where "TBool T::ParseFrom(const TDesC8&)" exists)+
−
 *    NULL         (the corresponding matched sub-pattern is not copied)+
−
 *+
−
 * 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):+
−
 * @code+
−
 *    TInt number;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("abc"));+
−
 *    re->FullMatchL(_L8("[a-z]+(\\d+)?"), &number);+
−
 *    CleanupStack::PopAndDestroy(re); +
−
 * @endcode+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * DO_MATCH+
−
 *+
−
 * The matching interface supports at most 4 arguments per call.+
−
 * If you need more, consider using the more general interface+
−
 * CRegEx::DoMatchL().+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * PARTIAL MATCHES+
−
 *+
−
 * You can use the PartialMatchL() operation when you want the pattern+
−
 * to match any substring of the text.+
−
 *+
−
 * Example: simple search for a string:+
−
 * @code+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("ell"));+
−
 *    re->PartialMatchL(_L8("hello"));+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * +
−
 * Example: find first number in a string:+
−
 * @code+
−
 *    TInt number;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(\\d+)"));+
−
 *    re->PartialMatchL(_L8("x*100 + 20"), &number);+
−
 *    ASSERT(number == 100);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * UTF-8 AND THE MATCHING INTERFACE:+
−
 *+
−
 * By default, pattern and text are plain text, one byte per character.+
−
 * The UTF8 flag, passed to the constructor, causes both pattern+
−
 * and string to be treated as UTF-8 text, still a byte stream but+
−
 * potentially multiple bytes per character. In practice, the text+
−
 * is likelier to be UTF-8 than the pattern, but the match returned+
−
 * may depend on the UTF8 flag, so always use it when matching+
−
 * UTF8 text.  E.g., "." will match one byte normally but with UTF8+
−
 * set may match up to three bytes of a multi-byte character.+
−
 *+
−
 * Example:+
−
 * @code+
−
 *    TRegExOptions options;+
−
 *    options.SetUtf8(ETrue);+
−
 *    CRegEx* re = CRegEx::NewLC(utf8Pattern);+
−
 *    re->FullMatchL(utf8String);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * NOTE: The UTF8 option is ignored if libpcre was not compiled with the+
−
 *       SUPPORT_UTF8 macro.+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * PASSING MODIFIERS TO THE REGULAR EXPRESSION ENGINE+
−
 *+
−
 * SPCRE defines some modifiers to change the behavior of the regular+
−
 * expression engine.+
−
 * The C++ wrapper defines an auxiliary class, TRegExOptions, as a vehicle+
−
 * to pass such modifiers to a CRegEx class.+
−
 *+
−
 * Currently, the following modifiers are supported+
−
 *+
−
 *    modifier              description               Perl corresponding+
−
 *+
−
 *    EPcreCaseless         case insensitive match    /i+
−
 *    EPcreMultiline        multiple lines match      /m+
−
 *    EPcreDotAll           dot matches newlines      /s+
−
 *    EPcreDollarEndOnly    $ matches only at end     N/A+
−
 *    EPcreExtra            strict escape parsing     N/A+
−
 *    EPcreExtended         ignore whitespaces        /x+
−
 *    EPcreUtf8             handles UTF8 chars        built-in+
−
 *    EPcreUngreedy         reverses * and *?         N/A+
−
 *    EPcreNoAutoCapture    disables matching parens  N/A (*)+
−
 *+
−
 * (For a full account on how each modifier works, please check the+
−
 * PCRE API reference manual).+
−
 *+
−
 * (*) Both Perl and PCRE allow non matching parentheses by means of the+
−
 * "?:" modifier within the pattern itself. e.g. (?:ab|cd) does not+
−
 * capture, while (ab|cd) does.+
−
 *+
−
 * For each modifier, there are two member functions whose name is made+
−
 * out of the modifier , without the "EPcre" prefix. For+
−
 * instance, EPcreCaseless is handled by+
−
 *    TBool Caseless(),+
−
 * which returns ETrue if the modifier is set, and+
−
 *    TRegExOptions SetCaseless(TBool),+
−
 * which sets or unsets the modifier.+
−
 *+
−
 * Moreover, PCRE_EXTRA_MATCH_LIMIT can be accessed through the+
−
 * SetMatchLimit() and MatchLimit() member functions.+
−
 * Setting the match limit to a non-zero value will limit the executation of+
−
 * SPCRE to keep it from doing bad things like blowing the stack or taking+
−
 * an eternity to return a result.  A value of 5000 is good enough to stop+
−
 * stack blowup in a 2MB thread stack.  Setting MathLimit to zero will+
−
 * disable match limiting.  Alternately, you can set MatchLimitRecursion()+
−
 * which uses PCRE_EXTRA_MATCH_LIMIT_RECURSION to limit how much SPCRE+
−
 * recurses.  MatchLimit() caps the number of matches pcre does;+
−
 * MatchLimitRecursion() caps the depth of recursion.+
−
 *+
−
 * Normally, to pass one or more modifiers to a CRegEx class, you declare+
−
 * a TRegExOptions object, set the appropriate options, and pass this+
−
 * object to a CRegEx constructor. Example:+
−
 *+
−
 * @code+
−
 *    TRegExOptions opt;+
−
 *    opt.setCaseless(ETrue);+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("HELLO"), opt);+
−
 *    if(re->PartialMatchL(_L8("hello world"))) ...+
−
 * @endcode+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * SCANNING TEXT INCREMENTALLY+
−
 *+
−
 * The ConsumeL() 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.+
−
 * @code+
−
 *    TBuf8<KContentLength> contents;+
−
 *    // fill contents somehow+
−
 *    TBuf8<KMaxVarLength> var;+
−
 *    TInt value;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(\\w+) = (\\d+)\n"));+
−
 *    while(re->ConsumeL(contents, &var, &value))+
−
 *    	{+
−
 *    	...+
−
 *    	}+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * +
−
 * Each successful call to ConsumeL will set "var/value", and also+
−
 * advance "contents" so it points past the matched text.+
−
 *+
−
 * The FindAndConsumeL() operation is similar to ConsumeL() but does not+
−
 * anchor your match at the beginning of the string.  For example, you+
−
 * could extract all words from a string by repeatedly calling+
−
 * @code+
−
 *    TBuf8<KContentLength> contents;+
−
 *    // fill contents somehow+
−
 *    TBuf8<KMaxWordLength> word;+
−
 *    TInt value;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(\\w+)"));+
−
 *    while(re->FindAndConsumeL(contents, &word))+
−
 *    	{+
−
 *    	...+
−
 *    	}+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * -----------------------------------------------------------------------+
−
 * PARSING HEX/OCTAL NUMBERS+
−
 *+
−
 * 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(),+
−
 * or Octal() to interpret the text in another base.  +
−
 *+
−
 * Example:+
−
 * @code+
−
 *    TInt a, b;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("(.*) (.*)"));+
−
 *    re->FullMatchL(_L8("100 40"), Hex(&a), Octal(&b));+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * will leave 64 in a and b.+
−
 *+
−
 * -----------------------------------------------------------------------+
−
 * REPLACING PARTS OF STRINGS+
−
 *+
−
 * You can replace the first match of aPattern in aString with+
−
 * aRewrite.  Within aRewrite, backslash-escaped digits (\1 to \9)+
−
 * can be used to insert text matching corresponding parenthesized+
−
 * group from the pattern.  \0 in aRewrite refers to the entire+
−
 * matching text.  E.g.,+
−
 * @code+
−
 *    _LIT8(KYabbaDabbaDoo, "yabba dabba doo"); +
−
 *    TBuf8<20> s;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("b+");+
−
 *    re->ReplaceL(KYabbaDabbaDoo(), s);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * will leave "s" containing "yada dabba doo".  The result is ETrue if+
−
 * the pattern matches and a replacement occurs, or Efalse otherwise.+
−
 *+
−
 * GlobalReplaceL() 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.  E.g.,+
−
 * @code+
−
 *    _LIT8(KYabbaDabbaDoo, "yabba dabba doo"); +
−
 *    TBuf8<20> s;+
−
 *    CRegEx* re = CRegEx::NewLC(_L8("b+");+
−
 *    re->GlobalReplaceL(_L8("d"), s);+
−
 *    CleanupStack::PopAndDestroy(re);+
−
 * @endcode+
−
 * will leave "s" containing "yada dada doo".  It returns the number+
−
 * of replacements made.+
−
 *+
−
 * ExtractL() is like Replace(), except that if the pattern matches,+
−
 * aRewrite is copied into aOut (an additional argument) with+
−
 * substitutions.  The non-matching portions of aText are ignored.+
−
 * Returns ETrue if a match occurred and the extraction happened+
−
 * successfully.  If no match occurs, the string is left unaffected.+
−
 */+
−
class CRegEx : public CBase+
−
	{+
−
public:+
−
	// Type of match (TODO: Should be restructured as part of TRegExOptions)+
−
	enum TAnchor+
−
		{+
−
		EUnanchored,		/** No anchoring */+
−
		EAnchorStart,		/** Anchor at start only */+
−
		EAnchorBoth			/** Anchor at start and end */+
−
		};+
−
	+
−
public:+
−
	IMPORT_C static CRegEx* NewL(const TDesC8& aPattern);+
−
	IMPORT_C static CRegEx* NewL(const TDesC8& aPattern, const TRegExOptions& aOptions);+
−
	IMPORT_C static CRegEx* NewLC(const TDesC8& aPattern);+
−
	IMPORT_C static CRegEx* NewLC(const TDesC8& aPattern, const TRegExOptions& aOptions);+
−
+
−
	IMPORT_C static CRegEx* NewL(const TDesC16& aPattern, const TRegExOptions& aOptions);+
−
	+
−
	IMPORT_C ~CRegEx();+
−
	+
−
	inline const TDesC8& Pattern() const;+
−
	inline TInt Error() const;+
−
+
−
	IMPORT_C TBool FullMatchL(const TDesC8& aText) const;+
−
	+
−
	IMPORT_C TBool FullMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1) const;+
−
	+
−
	IMPORT_C TBool FullMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2) const;+
−
	+
−
	IMPORT_C TBool FullMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3) const;+
−
	+
−
	IMPORT_C TBool FullMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3,+
−
			  const TRegExArg& aArg4) const;	+
−
	+
−
	IMPORT_C TBool PartialMatchL(const TDesC8& aText) const;+
−
	+
−
	IMPORT_C TBool PartialMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1) const;+
−
	+
−
	IMPORT_C TBool PartialMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2) const;+
−
	+
−
	IMPORT_C TBool PartialMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3) const;+
−
	+
−
	IMPORT_C TBool PartialMatchL(const TDesC8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3,+
−
			  const TRegExArg& aArg4) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed,+
−
			  const TRegExArg& aArg1) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3,+
−
			  const TRegExArg& aArg4) const;+
−
	+
−
	IMPORT_C TBool DoMatchL(const TDesC8& aText,+
−
			  TAnchor aAnchor,+
−
			  TInt&	aConsumed,			+
−
			  const RPointerArray<const TRegExArg>& aArgs) const;+
−
	+
−
	+
−
	IMPORT_C TBool ConsumeL(TDes8& aText) const;+
−
	+
−
	IMPORT_C TBool ConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1) const;+
−
	+
−
	IMPORT_C TBool ConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2) const;+
−
	+
−
	IMPORT_C TBool ConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3) const;+
−
	+
−
	IMPORT_C TBool ConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3,+
−
			  const TRegExArg& aArg4) const;+
−
	+
−
	IMPORT_C TBool FindAndConsumeL(TDes8& aText) const;+
−
	+
−
	IMPORT_C TBool FindAndConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1) const;+
−
	+
−
	IMPORT_C TBool FindAndConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2) const;+
−
	+
−
	IMPORT_C TBool FindAndConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3) const;+
−
	+
−
	IMPORT_C TBool FindAndConsumeL(TDes8& aText,+
−
			  const TRegExArg& aArg1,+
−
			  const TRegExArg& aArg2,+
−
			  const TRegExArg& aArg3,+
−
			  const TRegExArg& aArg4) const;+
−
	+
−
	IMPORT_C TBool ReplaceL(const TDesC8& aRewrite, TDes8& aString) const;+
−
	+
−
	IMPORT_C TInt GlobalReplaceL(const TDesC8& aRewrite, TDes8& aString) const;+
−
	+
−
	IMPORT_C TBool ExtractL(const TDesC8& aRewrite, const TDesC8& aText, TDes8& aOut) const;+
−
+
−
	IMPORT_C static TInt NewlineMode(TInt aOptions);+
−
	+
−
	IMPORT_C static HBufC8* QuoteMetaL(const TDesC8& aUnquoted);+
−
+
−
	IMPORT_C TInt NumberOfCapturingGroups() const;+
−
	+
−
	IMPORT_C void Study();	+
−
+
−
private:+
−
	CRegEx();+
−
	CRegEx(const TRegExOptions& aOptions);+
−
	+
−
	void ConstructL(const TDesC8& aPattern);+
−
	void ConstructL(const TDesC16& aPattern);+
−
	void CommonConstructL();+
−
	+
−
	pcre* CompileL(TAnchor anchor);+
−
	void Cleanup();+
−
+
−
	TInt TryMatch(const TDesC8& aText,+
−
			   TInt aStartPos,+
−
			   TAnchor aAnchor,+
−
			   TInt* aVector,+
−
			   TInt aVectorSize) const;+
−
	+
−
+
−
	TBool Rewrite(TDes8& aOut,+
−
			   const TDesC8& aRewrite,+
−
			   const TDesC8& aText,+
−
			   TInt* aVector,+
−
			   TInt aVectorSize,+
−
			   TInt aMatches) const;+
−
	+
−
	TBool DoMatchImpl(const TDesC8& aText,+
−
				   TAnchor aAnchor,+
−
				   TInt& aConsumed,+
−
				   const RPointerArray<const TRegExArg>& aArgs,+
−
				   TInt* aVector,+
−
				   TInt aVectorSize) const;+
−
	+
−
+
−
	static void Panic(TRegExPanic aPanic);+
−
+
−
	mutable TInt					iErrorCode;		// Error code for the alst unsuccessful operation.+
−
	TInt							iErrorOffset;	// Offset in pattern where error was detected+
−
	HBufC8*							iPattern;		// Regular expression pattern+
−
	TRegExOptions					iOptions;		// Options used to compile RE pattern.+
−
	pcre*							iReFull;		// For full matches+
−
	pcre*							iRePartial;		// For partial matches+
−
	pcre_extra*						iExtraPartial;	// Study Data for iRePartial+
−
	TRegExArg*						iNoArg;			// Default argument+
−
	};+
−
	+
−
#include <cregex.inl>+
−
#endif /* CREGEX_H_ */+
−