// 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.

#define PCRE_EXP_DECL IMPORT_C // We need to define this because the config.h that defines it when building libpcre isn't exported.

#include <fshell/descriptorutils.h>

#include "pcre.h"

#include "cregex.h"

#include "tregexarg.h"

/**

 * Maximum number of optional arguments supported by the matching interface.

 * If more arguments are required then use the more generic DoMatchL() function.

 */

static const TInt KMaxArgs = 4;

/**

 * Multiplier used to calculate size of vector that stores results from PCRE.

 * @see KVecSize

 */

static const TInt KPcreWorkspaceMultiplier = 3;

/**

* "The first two-thirds of the vector is used to pass back captured subpatterns,

* each subpattern using a pair of integers. The remaining third of the vector

* is used as workspace by pcre_exec() while matching capturing subpatterns,

* and is not available for passing back information. The number passed in 

* vecsize should always be a multiple of three. If it is not, it is rounded

* down."

*/ 

static const TInt KVecSize = (1 + KMaxArgs) * KPcreWorkspaceMultiplier;

/**

 * Number of characters in a triplet escape sequence.

 */

static const TInt KEscapeTripletLength = 3;

/**

 * Number of characters to reserve for escape sequences

 * Reserves enough room for several.

 */

static const TInt KReserveForEscapeChars = KEscapeTripletLength * 4;

// Public Functions //

/**

 * 2-Phase constructor for CRegEx objects.

 * @param aPattern regular expression pattern

 * @return a pre-compiled regular expression object ready to perform matching.

 */

EXPORT_C CRegEx* CRegEx::NewL(const TDesC8& aPattern)

	{

	CRegEx* self = NewLC(aPattern);

	CleanupStack::Pop(self);

	return self;

	}

/**

 * 2-Phase constructor for CRegEx objects.

 * @param aPattern regular expression pattern.

 * @param aOptions options to use when compiling regular expression.

 * @return a pre-compiled regular expression object ready to perform matching.

 */

EXPORT_C CRegEx* CRegEx::NewL(const TDesC8& aPattern,

	const TRegExOptions& aOptions)

	{

	CRegEx* self = NewLC(aPattern, aOptions);

	CleanupStack::Pop(self);

	return self;	

	}

/**

 * 2-Phase constructor for CRegEx objects. Object is left on the cleanup stack.

 * @param aPattern regular expression pattern.

 * @return a pre-compiled regular expression object ready to perform matching.

 */

EXPORT_C CRegEx* CRegEx::NewLC(const TDesC8& aPattern)

	{

	CRegEx* self = new(ELeave) CRegEx();

	CleanupStack::PushL(self);

	self->ConstructL(aPattern);

	return self;

	}

/**

 * 2-Phase constructor for CRegEx objects. Object is left on the cleanup stack.

 * @param aPattern regular expression pattern.

 * @param aOptions options to use when compiling regular expression.

 * @return a pre-compiled regular expression object ready to perform matching.

 */

EXPORT_C CRegEx* CRegEx::NewLC(const TDesC8& aPattern,

	const TRegExOptions& aOptions)

	{

	CRegEx* self = new(ELeave) CRegEx(aOptions);

	CleanupStack::PushL(self);

	self->ConstructL(aPattern);

	return self;	

	}

EXPORT_C CRegEx* CRegEx::NewL(const TDesC16& aPattern, const TRegExOptions& aOptions)

	{

	CRegEx* self = new(ELeave) CRegEx(aOptions);

	CleanupStack::PushL(self);

	self->ConstructL(aPattern);

	CleanupStack::Pop(self);

	return self;

	}

/**

 * Standard destructor to free resources.

 */

EXPORT_C CRegEx::~CRegEx()

	{

	delete iNoArg;

	delete iPattern;

	Cleanup();

	}

// Public matching interface //

/**

 * Checks if the regular expression (RE) matches the supplied text entirely.

 * @param aText the text to match against the regular expression.

 * @return ETrue if the RE matches the supplied text entirely, EFalse otherwise.

 * @see PartialMatchL()

 */

EXPORT_C TBool CRegEx::FullMatchL(const TDesC8& aText) const

	{

	return FullMatchL(aText, *iNoArg, *iNoArg, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches the supplied text entirely.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @return ETrue if the RE matches the supplied text entirely, EFalse otherwise.

 * @see PartialMatchL()

 */

EXPORT_C TBool CRegEx::FullMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1) const

	{

	return FullMatchL(aText, aArg1, *iNoArg, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches the supplied text entirely.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @return ETrue if the RE matches the supplied text entirely, EFalse otherwise.

 * @see PartialMatchL()

 */

EXPORT_C TBool CRegEx::FullMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2) const

	{

	return FullMatchL(aText, aArg1, aArg2, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches the supplied text entirely.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @return ETrue if the RE matches the supplied text entirely, EFalse otherwise.

 * @see PartialMatchL()

 */

EXPORT_C TBool CRegEx::FullMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3) const

	{

	return FullMatchL(aText, aArg1, aArg2, aArg3, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches the supplied text entirely.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @param aArg4 contains the fourth extracted subpattern.

 * @return ETrue if the RE matches the supplied text entirely, EFalse otherwise.

 * @see PartialMatchL()

 */

EXPORT_C TBool CRegEx::FullMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3,

		  const TRegExArg& aArg4) const

	{

	RPointerArray<const TRegExArg> args;

	CleanupClosePushL(args);

	args.ReserveL(KMaxArgs);

	if (&aArg1 != iNoArg)

		{

		args.AppendL(&aArg1);

		}

	if (&aArg2 != iNoArg)

		{

		args.AppendL(&aArg2);		

		}

	if (&aArg3 != iNoArg)

		{

		args.AppendL(&aArg3);		

		}

	if (&aArg4 != iNoArg)

		{

		args.AppendL(&aArg4);		

		}

	TInt consumed = 0;

	TInt vector[KVecSize];

	TBool r =  DoMatchImpl(aText, EAnchorBoth, consumed, args, vector, KVecSize);

	CleanupStack::PopAndDestroy(&args);

	return r;

	}

/**

 * Checks if the regular expression (RE) matches any substring of the text.

 * @param aText the text to match against the regular expression.

 * @return ETrue if the RE  matches any substring of the supplied text,

 * EFalse otherwise.

 * @see FullMatchL()

 */

EXPORT_C TBool CRegEx::PartialMatchL(const TDesC8& aText) const

	{

	return PartialMatchL(aText, *iNoArg, *iNoArg, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches any substring of the text.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @return ETrue if the RE  matches any substring of the supplied text,

 * EFalse otherwise.

 * @see FullMatchL()

 */

EXPORT_C TBool CRegEx::PartialMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1) const

	{

	return PartialMatchL(aText, aArg1, *iNoArg, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches any substring of the text.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @return ETrue if the RE  matches any substring of the supplied text,

 * EFalse otherwise.

 * @see FullMatchL()

 */

EXPORT_C TBool CRegEx::PartialMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2) const

	{

	return PartialMatchL(aText, aArg1, aArg2, *iNoArg, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches any substring of the text.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @return ETrue if the RE  matches any substring of the supplied text,

 * EFalse otherwise.

 * @see FullMatchL()

 */

EXPORT_C TBool CRegEx::PartialMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3) const

	{

	return PartialMatchL(aText, aArg1, aArg2, aArg3, *iNoArg);

	}

/**

 * Checks if the regular expression (RE) matches any substring of the text.

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @param aArg4 contains the fourth extracted subpattern. 

 * @return ETrue if the RE  matches any substring of the supplied text,

 * EFalse otherwise.

 * @see FullMatchL()

 */

EXPORT_C TBool CRegEx::PartialMatchL(const TDesC8& aText,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3,

		  const TRegExArg& aArg4) const

	{

	RPointerArray<const TRegExArg> args;

	CleanupClosePushL(args);

	args.ReserveL(KMaxArgs);

	if (&aArg1 != iNoArg)

		{

		args.AppendL(&aArg1);

		}

	if (&aArg2 != iNoArg)

		{

		args.AppendL(&aArg2);		

		}

	if (&aArg3 != iNoArg)

		{

		args.AppendL(&aArg3);		

		}

	if (&aArg4 != iNoArg)

		{

		args.AppendL(&aArg4);		

		}

	TInt consumed = 0;

	TInt vector[KVecSize];

	TBool r =  DoMatchImpl(aText, EUnanchored, consumed, args, vector,

					KVecSize);

	CleanupStack::PopAndDestroy(&args);

	return r;

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed) const

	{

	return DoMatchL(aText, aAnchor, aConsumed, *iNoArg, *iNoArg, *iNoArg,

				*iNoArg);

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @param aArg1 contains the first extracted subpattern.

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed,

		  const TRegExArg& aArg1) const

	{

	return DoMatchL(aText, aAnchor, aConsumed, aArg1, *iNoArg, *iNoArg,

				*iNoArg);

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2) const

	{

	return DoMatchL(aText, aAnchor, aConsumed, aArg1, aArg2, *iNoArg, *iNoArg);

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3) const

	{

	return DoMatchL(aText, aAnchor, aConsumed, aArg1, aArg2, aArg3, *iNoArg);

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @param aArg1 contains the first extracted subpattern.

 * @param aArg2 contains the second extracted subpattern.

 * @param aArg3 contains the third extracted subpattern.

 * @param aArg4 contains the fourth extracted subpattern. 

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed,

		  const TRegExArg& aArg1,

		  const TRegExArg& aArg2,

		  const TRegExArg& aArg3,

		  const TRegExArg& aArg4) const

	{

	RPointerArray<const TRegExArg> args;

	CleanupClosePushL(args);

	args.ReserveL(KMaxArgs);

	if (&aArg1 != iNoArg)

		{

		args.AppendL(&aArg1);

		}

	if (&aArg2 != iNoArg)

		{

		args.AppendL(&aArg2);		

		}

	if (&aArg3 != iNoArg)

		{

		args.AppendL(&aArg3);		

		}

	if (&aArg4 != iNoArg)

		{

		args.AppendL(&aArg4);		

		}	

	TInt r = DoMatchL(aText, aAnchor, aConsumed, args);

	CleanupStack::PopAndDestroy(&args);

	return r;

	}

/**

 * General function to perform a regular expression (RE) match on a substring

 * of the text.

 * @param aText the text to match against the regular expression.

 * @param aAnchor the type of match to perform

 * @param array of arguments that will contain the extracted subpatterns.

 * @return ETrue if the RE  matches a substring of the supplied text,

 * EFalse otherwise.

 */

EXPORT_C TBool CRegEx::DoMatchL(const TDesC8& aText,

		  TAnchor aAnchor,

		  TInt&	aConsumed,			

		  const RPointerArray<const TRegExArg>& aArgs) const

	{

	const TInt vectorSize = (1 + aArgs.Count()) * KPcreWorkspaceMultiplier;

	TInt* vector = new( ELeave ) TInt[ vectorSize ];

	CleanupArrayDeletePushL( vector );	

	TBool r =  DoMatchImpl(aText, aAnchor, aConsumed, aArgs, vector,

					vectorSize);

	CleanupStack::PopAndDestroy(vector);

	return r;	

	}

/**

 * Allows text to be scanned incrementally. Call this function repeatidly to

 * match regular expressions at the front of a string and skip over them as

 * they match. 

 * @param aText the text to match against the regular expression.

 * @return ETrue if the RE matched and a substring was consumed,

 * EFalse otherwise.

 * @see FindAndConsumeL()

 */

EXPORT_C TBool CRegEx::ConsumeL(TDes8& aText) const

	{

	return ConsumeL(aText, *iNoArg, *iNoArg, *iNoArg, *iNoArg);

	}

/**

 * Allows text to be scanned incrementally. Repeatidly call this function to

 * match regular expressions at the front of a string and skip over them as

 * they match. 

 * @param aText the text to match against the regular expression.

 * @param aArg1 contains the first extracted subpattern.

 * @return ETrue if the RE matched and a substring was consumed,

 * EFalse otherwise.

 * @see FindAndConsumeL()

 */