// 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);

	}