// command_info_file.cpp

// 

// Copyright (c) 2009 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <f32file.h>

#include "ioutils.h"

#include "command_base.h"

_LIT(KCifExt, ".cif");

_LIT(KCifPathVar, "CIF_PATH");

_LIT(KCifPath, "\\resource\\cif\\fshell");

_LIT(KEnumSeparator, ",");

_LIT(KEnumQuote, "\"");

_LIT(KNewLine, "\r\n");

_LIT(KPartialCommandStart, "==");

_LIT(KCommandStart, "\r\n==");

_LIT(KCmndName, "name");

_LIT(KCmndShortDescription, "short-description");

_LIT(KCmndLongDescription, "long-description");

_LIT(KCmndSeeAlso, "see-also");

_LIT(KCmndCopyright, "copyright");

_LIT(KCmndArgument, "argument");

_LIT(KCmndOption, "option");

_LIT(KCmndInclude, "include");

_LIT(KCmndSubCommand, "sub-command");

_LIT(KCmndEnumValue, "enum-value");

_LIT(KCmndFlagOptional, "optional");

_LIT(KCmndFlagMultiple, "multiple");

_LIT(KCmndFlagLast, "last");

_LIT(KTypeBool, "bool");

_LIT(KTypeInt, "int");

_LIT(KTypeUint, "uint");

_LIT(KTypeString, "string");

_LIT(KTypeFileName, "filename");

_LIT(KTypeEnum, "enum");

_LIT(KTypeReal, "real");

_LIT(KTypeUint64, "uint64");

_LIT(KTypeInt64, "int64");

using namespace IoUtils;

TInt SkipTo(TLex& aLex, const TDesC& aDes)

	{

	TInt ret = aLex.Remainder().Find(aDes);

	if (ret >= 0)

		{

		aLex.Inc(ret);

		return KErrNone;

		}

	return KErrNotFound;

	}

TInt SkipToEnd(TLex& aLex, const TDesC& aDes)

	{

	TInt ret = aLex.Remainder().Find(aDes);

	if (ret >= 0)

		{

		aLex.Inc(ret + aDes.Length());

		return KErrNone;

		}

	return KErrNotFound;

	}

TInt SkipToNextCommand(TLex& aLex)

	{

	if ((aLex.Offset() == 0) && (aLex.Remainder().Find(KPartialCommandStart) == 0))

		{

		return KErrNone;

		}

	return SkipTo(aLex, KCommandStart);

	}

TPtrC NextCommand(TLex& aLex)

	{

	TPtrC command;

	if (SkipToNextCommand(aLex) == KErrNone)

		{

		SkipToEnd(aLex, KPartialCommandStart);

		aLex.Mark();

		aLex.SkipCharacters();

		command.Set(aLex.MarkedToken());

		}

	else

		{

		aLex.Inc(aLex.Remainder().Length());

		}

	return command;

	}

TPtrC LineRemainder(TLex& aLex)

	{

	aLex.Mark();

	if (SkipTo(aLex, KNewLine) == KErrNone)

		{

		return aLex.MarkedToken();

		}

	else

		{

		return aLex.Remainder();

		}

	}

TPtrC NextWord(TLex& aLex)

	{

	aLex.SkipSpaceAndMark();

	aLex.SkipCharacters();

	TPtrC word(aLex.MarkedToken());

	return word;

	}

TPtrC TextToNextCommand(TLex& aLex)

	{

	aLex.Mark();

	if (SkipToNextCommand(aLex) != KErrNone)

		{

		aLex.Inc(aLex.Remainder().Length());

		}

	TLex lex(aLex.MarkedToken());

	// Strip leading white space.

	while (!lex.Eos())

		{

		if (lex.Peek().IsSpace())

			{

			lex.Get();

			}

		else

			{

			break;

			}

		}

	lex.Mark();

	TInt startOffset = lex.Offset();

	// Remove trailing white space.

	lex.Inc(lex.Remainder().Length());

	while (lex.Offset() > startOffset)

		{

		lex.UnGet();

		if (!lex.Peek().IsSpace())

			{

			lex.Get();

			break;

			}

		}

	return lex.MarkedToken();

	}

void AppendL(RBuf& aBuf, const TDesC& aDes, TBool aQuote)

	{

	const TInt requiredSpace = aDes.Length() + ((aBuf.Length() == 0) ? 0 : KEnumSeparator().Length()) + (aQuote ? 2 : 0);

	if ((aBuf.Length() + requiredSpace) > aBuf.MaxLength())

		{

		aBuf.ReAllocL(Max(aBuf.Length() * 2, aBuf.Length() + requiredSpace));

		}

	if (aBuf.Length() > 0)

		{

		aBuf.Append(KEnumSeparator);

		}

	if (aQuote)

		{

		aBuf.Append(KEnumQuote);

		}

	aBuf.Append(aDes);

	if (aQuote)

		{

		aBuf.Append(KEnumQuote);

		}

	}

void GetEnumValuesL(TLex& aLex, RBuf& aValues, RBuf& aDescriptions)

	{

	aValues.CreateL(0x100);

	aDescriptions.CreateL(0x100);

	while (!aLex.Eos())

		{

		TLexMark mark;

		aLex.Mark(mark);

		TPtrC command(NextCommand(aLex));

		if (command == KCmndEnumValue)

			{

			TPtrC value(NextWord(aLex));

			TPtrC description(TextToNextCommand(aLex));

			if (value.Length() == 0)

				{

				User::Leave(KErrArgument);

				}

			AppendL(aValues, value, EFalse);

			if (description.Length() > 0)

				{

				AppendL(aDescriptions, description, ETrue);

				}

			}

		else

			{

			aLex.UnGetToMark(mark);

			break;

			}

		}

	}

EXPORT_C CCommandInfoFile* CCommandInfoFile::NewL(RFs& aFs, const TDesC& aFileName)

	{

	CCommandInfoFile* self = new(ELeave) CCommandInfoFile(aFileName);

	CleanupStack::PushL(self);

	self->ConstructL(aFs);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CCommandInfoFile* CCommandInfoFile::NewL(RFs& aFs, const CEnvironment& aEnvironment, const TDesC& aCommandName)

	{

	TFileName2 fileName;

	TRAPD(err, fileName.Copy(aEnvironment.GetAsDesL(KCifPathVar)));

	if (err) fileName.Copy(KCifPath);

	// Search the drive the command is running from first (rather than what the session path happens to be, which was the previous behaviour)

	if (!fileName.HasDriveLetter()) fileName.Insert(0, _L("?:"));

	fileName[0] = RProcess().FileName()[0];

	fileName.AppendComponentL(aCommandName);

	fileName.SetExtL(KCifExt);

	StaticLeaveIfErr(fileName.FindFile(aFs), _L("Couldn't find \"%S\""), &fileName);

	CCommandInfoFile* cif = CCommandInfoFile::NewL(aFs, fileName);

	if (cif->Name() != aCommandName)

		{

		CleanupStack::PushL(cif);

		StaticLeaveIfErr(KErrArgument, _L("Command named \"%S\" in implementation but \"%S\" in \"%S\""), &aCommandName, &cif->Name(), &fileName);

		}

	return cif;

	}

void CCommandInfoFile::ConstructL(RFs& aFs)

	{

	ReadFileL(aFs, iFileName);

	}

void CCommandInfoFile::ReadFileL(RFs& aFs, const TDesC& aFileName)

	{

	// Read the file into a buffer.

	RFile file;

	StaticLeaveIfErr(file.Open(aFs, aFileName, EFileRead | EFileShareReadersOnly), _L("Couldn't open '%S' for reading"), &aFileName);

	CleanupClosePushL(file);

	TInt fileSize;

	User::LeaveIfError(file.Size(fileSize));

	RBuf8 buf8;

	buf8.CreateL(fileSize);

	buf8.CleanupClosePushL();

	User::LeaveIfError(file.Read(buf8));

	RBuf& buf = NewBuffer();

	buf.CreateL(fileSize);

	buf.Copy(buf8);

	CleanupStack::PopAndDestroy(2, &file);

	TLex lex(buf);

	while (!lex.Eos())

		{

		if (iProcessInclude || !iCurrentChild)

			{

			ReadDetailsL(lex, aFs, aFileName);

			}

		else

			{

			iCurrentChild->ReadDetailsL(lex, aFs, aFileName);

			}

		}

	}

void CCommandInfoFile::ReadDetailsL(TLex& aLex, RFs& aFs, const TDesC& aFileName)

	{

	SkipToNextCommand(aLex); // Ignore everything before the first '==' command.

	while (!aLex.Eos())

		{

		TLexMark mark;

		aLex.Mark(mark);

		TPtrC command(NextCommand(aLex));

		if (command == KNullDesC)

			{

			// Do nothing - we're at the end of the string.

			}

		else if (command == KCmndName)

			{

			aLex.SkipSpaceAndMark();

			aLex.SkipCharacters();

			iName.Set(aLex.MarkedToken());

			}

		else if (command == KCmndShortDescription)

			{

			iShortDescription.Set(TextToNextCommand(aLex));

			}

		else if (command == KCmndLongDescription)

			{

			iLongDescription.Set(TextToNextCommand(aLex));

			}

		else if (command == KCmndSeeAlso)

			{

			iSeeAlso.Set(TextToNextCommand(aLex));

			}

		else if (command == KCmndCopyright)

			{

			iCopyright.Set(TextToNextCommand(aLex));

			}

		else if (command == KCmndArgument)

			{

			ReadArgumentL(aLex, aFileName);

			}

		else if (command == KCmndOption)

			{

			ReadOptionL(aLex, aFileName);

			}

		else if (command == KCmndInclude)

			{

			if (iParent == NULL)

				{

				iProcessInclude = EFalse;

				TLex lineLex(LineRemainder(aLex));

				TPtrC fileName(NextWord(lineLex));

				TFileName2* fullFileName = new(ELeave) TFileName2(aFileName);

				CleanupStack::PushL(fullFileName);

				fullFileName->SetNameAndExtL(fileName);

				ReadFileL(aFs, *fullFileName);

				CleanupStack::PopAndDestroy(fullFileName);

				break;

				}

			else

				{

				// We're a sub-command. Let control return to the root to handle the include.

				aLex.UnGetToMark(mark);

				iParent->ProcessInclude(*this);

				break;

				}

			}

		else if (command == KCmndSubCommand)

			{

			if (iParent == NULL)

				{

				TLex lineLex(LineRemainder(aLex));

				AddSubCommandL(lineLex, aLex, aFs, aFileName);

				}

			else

				{

				// We're a sub-command. Let control return to the root to handle the next sub-command.

				aLex.UnGetToMark(mark);

				iParent->ProcessNewChild();

				break;

				}

			}

		else

			{

			StaticLeaveIfErr(KErrArgument, _L("Unknown command \"%S\" in \"%S\""), &command, &aFileName);

			}

		}

	}

void CCommandInfoFile::ReadArgumentL(TLex& aLex, const TDesC& aFileName)

	{

	TLex lineLex(LineRemainder(aLex));

	TUint flags = 0;

	TBool multiple(EFalse);

	TPtrC argType(NextWord(lineLex));

	TPtrC argName(NextWord(lineLex));

	TPtrC envVar;

	while (!lineLex.Eos())

		{

		TPtrC word(NextWord(lineLex));

		if (word == KCmndFlagOptional)

			{

			flags |= KValueTypeFlagOptional;

			}

		else if (word == KCmndFlagMultiple)

			{

			multiple = ETrue;

			}

		else if (word == KCmndFlagLast)

			{

			flags |= KValueTypeFlagLast;

			}

		else

			{

			envVar.Set(word);

			}

		}

	if (argType.Length() == 0)

		{

		StaticLeaveIfErr(KErrArgument, _L("Argument missing type"));

		}

	else if (argName.Length() == 0)

		{

		StaticLeaveIfErr(KErrArgument, _L("Argument missing name"));

		}

	else

		{

		TPtrC argDescription = TextToNextCommand(aLex);

		if (argType == KTypeEnum)

			{

			RBuf& enumValues = NewBuffer();

			RBuf& enumDescriptions = NewBuffer();

			GetEnumValuesL(aLex, enumValues, enumDescriptions);

			if (multiple)

				{

				RArray<TInt> dummyArray;

				if (enumDescriptions.Length() > 0)

					{

					iArguments.AppendEnumL(dummyArray, argName, argDescription, enumValues, enumDescriptions, flags, envVar);

					}

				else

					{

					iArguments.AppendEnumL(dummyArray, argName, argDescription, enumValues, flags, envVar);

					}

				}

			else

				{

				TInt dummyInt;

				if (enumDescriptions.Length() > 0)

					{

					iArguments.AppendEnumL(dummyInt, argName, argDescription, enumValues, enumDescriptions, flags, envVar);

					}

				else

					{

					iArguments.AppendEnumL(dummyInt, argName, argDescription, enumValues, flags, envVar);

					}

				}

			}

		else if (argType == KTypeInt)

			{

			if (multiple)

				{

				RArray<TInt> dummyArray;

				iArguments.AppendIntL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TInt dummyInt;

				iArguments.AppendIntL(dummyInt, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeUint)

			{

			if (multiple)

				{

				RArray<TUint> dummyArray;

				iArguments.AppendUintL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TUint dummyUint;

				iArguments.AppendUintL(dummyUint, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeString)

			{

			if (multiple)

				{

				RPointerArray<HBufC> dummyArray;

				iArguments.AppendStringL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				HBufC* dummyHBufC;

				iArguments.AppendStringL(dummyHBufC, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeFileName)

			{

			if (multiple)

				{

				RArray<TFileName2> dummyArray;

				iArguments.AppendFileNameL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TFileName2 dummyFileName;

				iArguments.AppendFileNameL(dummyFileName, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeReal)

			{

			if (multiple)

				{

				RArray<TReal64> dummyArray;

				iArguments.AppendRealL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TReal64 dummyReal;

				iArguments.AppendRealL(dummyReal, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeUint64)

			{

			if (multiple)

				{

				RArray<TUint64> dummyArray;

				iArguments.AppendUintL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TUint64 dummyUint64;

				iArguments.AppendUintL(dummyUint64, argName, argDescription, flags, envVar);

				}

			}

		else if (argType == KTypeInt64)

			{

			if (multiple)

				{

				RArray<TInt64> dummyArray;

				iArguments.AppendIntL(dummyArray, argName, argDescription, flags, envVar);

				}

			else

				{

				TInt64 dummyInt64;

				iArguments.AppendIntL(dummyInt64, argName, argDescription, flags, envVar);