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

CBaseCommandParser::~CBaseCommandParser()

{

	delete iArgumentList;

	delete iSupportedCommands;

	delete iCurrentCommand;

	delete iLastError;

}

void CBaseCommandParser::ConstructL()

{

	iArgumentList = new (ELeave) CDesCArrayFlat(3);

	iSupportedCommands = new (ELeave) CDesCArrayFlat(1);

	iLastError = HBufC::NewL(0);

	iCurrentCommand = 0;

}

//

// Extract the command and any argments from the given string

void CBaseCommandParser::ParseL(const TDesC& aCommand, TTestDebugInfo aDebugInfo)

{

	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)

				{

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

}

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])

			{

				//

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

}

void CBaseCommandParser::AddCommandL(const TDesC& aCommand)

{

	iSupportedCommands->AppendL(aCommand);

}

TDesC& CBaseCommandParser::ErrorL()

{

	if (iLastError->Length() == 0)

	{

		delete iLastError;

		iLastError = 0;

		iLastError = HBufC::NewL(KTestErrorUnknown().Length());

		(*iLastError) = KTestErrorUnknown;

	}

	return *iLastError;

}

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

	}

}

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

}

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

					LogComment(errorString);

					LogComment((*iCommandParsers)[commandParserIndex]->ErrorL());

					User::Leave(err);

				}

				parsed = ETrue;

			}

		}

		if (!parsed)

		{

			commandNotRecognised = ETrue;

			TBuf<256> aError;

			aError.Format(KNotParsedError, lineNumber, &currentCommand, &(iSection->SectionName()));

			LogComment(aError);

			User::Leave(KErrNotFound);

		}

		iSection->NextCommand();

	}

}

CBaseSectionParser::~CBaseSectionParser()

{

	iCommandParsers->ResetAndDestroy();

	delete iCommandParsers;

	delete iSection;

}

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

	}

}

void CBaseSectionParser::ConstructL(const TDesC& aSectionName)

{

	iCommandParsers = new (ELeave) CArrayPtrFlat<CBaseCommandParser>(5);

	SetSectionL(aSectionName);

}