--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingappbase/obexmtms/TObexMTM/testutils/msgth/src/testframeparse.cpp	Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,289 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "testframeparse.h"
+
+
+_LIT(KTestErrorUnknown, "No more details available");
+_LIT(KInvalidNumberOfArguments, "[%4d] Invalid number of arguments, actual: %d, expected: %d");
+_LIT(KGeneralParseError, "[%4d] Error in command: %S, section: %S");
+_LIT(KNotParsedError, "[%4d] Command not recognised: %S, in section: %S");
+
+//
+//
+// CTestBaseCommandParser
+//
+
+EXPORT_C CBaseCommandParser::~CBaseCommandParser()
+	{
+	delete iArgumentList;
+	delete iSupportedCommands;
+	delete iCurrentCommand;
+	delete iLastError;
+	}
+
+EXPORT_C void CBaseCommandParser::ConstructL()
+	{
+	iArgumentList = new (ELeave) CDesCArrayFlat(3);
+	iSupportedCommands = new (ELeave) CDesCArrayFlat(1);
+	iLastError = HBufC::NewL(0);
+	iCurrentCommand = 0;
+	}
+
+// TODO: this function should really use TLex!
+EXPORT_C void CBaseCommandParser::ParseL(const TDesC& aCommand, TTestDebugInfo aDebugInfo)
+// Extract the command and any argments from the given string
+	{
+	iDebugInfo = aDebugInfo;
+	iArgumentList->Reset();
+
+	delete iCurrentCommand;
+	iCurrentCommand = 0;
+	TInt commandIter = 0;
+	TInt commandStart = 0;
+	TBool inQuotes = EFalse;
+	while (commandIter <= aCommand.Length())
+		{
+		TBool commandFound = EFalse;
+
+		if (commandIter < aCommand.Length())
+			{
+			if (aCommand[commandIter] == '"')
+				{
+				// We assume that quotes only occur at the beginning and end
+				// of arguments. Hence, if we've just found a new quote, we should
+				// not make it part of the argument.
+				if (!inQuotes)
+					{
+					inQuotes = ETrue;
+					commandStart++;
+					}
+				else
+					{
+					// Assume we've got to the end of the argument and skip the
+					// following space.
+					commandFound = ETrue;
+					commandIter++;
+					}
+				}
+			else if ((aCommand[commandIter] == ' ') && (!inQuotes))
+				{
+				commandFound = ETrue;
+				}
+			}
+		else
+			{
+			commandFound = ETrue;
+			}
+		
+		if (commandFound)
+			{
+			if (commandIter > commandStart)
+			// Command or argument found
+				{
+				TInt commandLength = commandIter - commandStart;
+
+				// If the argument ended in quotes, modify the length to exclude them.
+				if (inQuotes)
+					{
+					inQuotes = EFalse;
+					commandLength--;
+					}
+				
+				if (iCurrentCommand == NULL)
+				// This is the main command
+					{
+					iCurrentCommand = HBufC::NewL(commandLength);
+					(*iCurrentCommand) = aCommand.Mid(commandStart, commandLength);
+					}
+				else
+				// This is a command argument
+					{
+					iArgumentList->AppendL(aCommand.Mid(commandStart, commandLength));
+					}
+
+				// Set the start of the next argument.
+				commandStart = commandIter + 1;
+				}
+			}
+
+		commandIter++;
+		}
+
+	ProcessL();
+	}
+
+EXPORT_C TBool CBaseCommandParser::CanParse(const TDesC& aCommand) const
+	{
+	TBool canParse = EFalse;
+
+	TInt commandCounter = iSupportedCommands->Count();
+	while ((commandCounter-- > 0) && (!canParse))
+	// Scan through each of the supported commands
+		{
+		TInt commandSize = (*iSupportedCommands)[commandCounter].Length();
+		if (commandSize <= aCommand.Length())
+		// The given command must be at least as long as the one it is being compared to
+			{
+			if (aCommand.Left(commandSize) == (*iSupportedCommands)[commandCounter])
+			// If the first character match
+				{
+				// Check that there are no more characters or that the next one is a whitespace
+				if (commandSize < aCommand.Length())
+					{
+					if (aCommand[commandSize] == ' ')
+						{
+						canParse = ETrue;
+						}
+					}
+				else
+					{
+					canParse = ETrue;
+					}
+				}
+			}
+		}
+
+	return canParse;
+	}
+
+EXPORT_C CBaseCommandParser::CBaseCommandParser()
+	{
+	}
+
+EXPORT_C void CBaseCommandParser::AddCommandL(const TDesC& aCommand)
+	{
+	iSupportedCommands->AppendL(aCommand);
+	}
+
+
+EXPORT_C TDesC& CBaseCommandParser::Error()
+	{
+	if (iLastError->Length() == 0)
+		{
+		delete iLastError;
+		iLastError = 0;
+		iLastError = HBufC::NewL(KTestErrorUnknown().Length());
+		(*iLastError) = KTestErrorUnknown;
+		}
+
+	return *iLastError;
+	}
+
+EXPORT_C void CBaseCommandParser::CheckNumberOfArgumentsL(TInt aNumberOfArguments)
+	{
+	if (iArgumentList->Count() != aNumberOfArguments)
+		{
+		TBuf<128> errorString;
+		errorString.Format(KInvalidNumberOfArguments, iDebugInfo.LineNumber(), iArgumentList->Count(), aNumberOfArguments);
+		SetErrorL(errorString);
+		User::Leave(KErrArgument);
+		}
+	}
+
+EXPORT_C void CBaseCommandParser::SetErrorL(const TDesC& aError)
+	{
+	delete iLastError;
+	iLastError = 0;
+	iLastError = HBufC::NewL(aError.Length());
+	(*iLastError) = aError;
+	}
+
+
+//
+//
+// CBaseSectionParser
+//
+
+void CBaseSectionParser::SetSectionL(const TDesC& aSectionName)
+	{
+	delete iSection;
+	iSection = 0;
+	iSection = iScript.GetSectionL(aSectionName);
+	}
+
+EXPORT_C void CBaseSectionParser::ParseL()
+	{
+	// Go through each command in the section and parse it
+	TBool parsed = EFalse;
+	TBuf<512> currentCommand;
+	TBool commandNotRecognised = EFalse;
+	TInt lineNumber = 0;
+
+	while (((lineNumber = iSection->GetCurrentCommand(currentCommand)) > 0) && (!commandNotRecognised))
+		{
+		TInt commandParserIndex = iCommandParsers->Count();
+		parsed = EFalse;
+		while (commandParserIndex--)
+			// Look for a command parser that can parse the current command
+			{
+			if ((*iCommandParsers)[commandParserIndex]->CanParse(currentCommand))
+				{
+				TTestDebugInfo debugInfo(iScript, iSection->SectionPosition(), iSection->CurrentCommandPosition(), lineNumber);
+				TRAPD(err, (*iCommandParsers)[commandParserIndex]->ParseL(currentCommand, debugInfo));
+				if (err != KErrNone)
+					{
+					TBuf<128> errorString;
+					errorString.Format(KGeneralParseError, lineNumber, &currentCommand, &(iSection->SectionName()));
+					LogCommentL(errorString);
+					LogCommentL((*iCommandParsers)[commandParserIndex]->Error());
+					User::Leave(err);
+					}
+				parsed = ETrue;
+				}
+			}
+
+		if (!parsed)
+			{
+			commandNotRecognised = ETrue;
+			TBuf<256> aError;
+			aError.Format(KNotParsedError, lineNumber, &currentCommand, &(iSection->SectionName()));
+			LogCommentL(aError);
+			User::Leave(KErrNotFound);
+			}
+
+		iSection->NextCommand();
+		}
+	}
+
+EXPORT_C CBaseSectionParser::~CBaseSectionParser()
+	{
+	iCommandParsers->ResetAndDestroy();
+	delete iCommandParsers;
+	delete iSection;
+	}
+
+EXPORT_C CBaseSectionParser::CBaseSectionParser(CTestScript& aScript) : iScript(aScript)
+	{
+	}
+
+EXPORT_C void CBaseSectionParser::AddCommandParserL(CBaseCommandParser* aParser)
+	{
+	TRAPD(err, iCommandParsers->AppendL(aParser));
+	// If the parser can't be appended then delete it.
+	// Then leave with the original error.
+	if (err != KErrNone)
+		{
+		delete aParser;
+		User::Leave(err);
+		}
+	}
+
+EXPORT_C void CBaseSectionParser::ConstructL(const TDesC& aSectionName)
+	{
+	iCommandParsers = new (ELeave) CArrayPtrFlat<CBaseCommandParser>(5);
+	SetSectionL(aSectionName);
+	}
+