// command_base.cpp

// 

// Copyright (c) 2005 - 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 "iocons.h"

#include "ioutils.h"

#include "command_base.h"

#include <fshell/ltkutils.h>

#include <fshell/line_editor.h> // for definition of CTRL()

using namespace IoUtils;

#define RETURN_IF_ERROR(x) {TInt _err = (x); if (_err<0) return _err;}

//

// Constants.

//

_LIT(KHelpName, "help");

_LIT(KHelpDescription, "Display help.");

_LIT(KOptConsole, "console");

_LIT(KOptConsoleTitle, "console-title");

_LIT(KOptConsoleSize, "console-size");

_LIT(KOptPersistentConsole, "persistent-console");

_LIT(KDllExt, ".dll");

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

const TUint KValueTypeUninitialized		= 0x0000ffff;

const TUint KValueTypeFlagMultiple 		= 0x00010000;

const TUint KValueTypeFlagMask     		= 0x0000ffff;

const TUint KPublicFlagsMask			= 0x0000ffff;

const TUint KPrivateFlagsMask			= 0xffff0000;

//

// Misc.

//

void IoUtils::Panic(TCmdBasePanic aReason)

	{

	_LIT(KCategory, "iocli");

	User::Panic(KCategory, aReason);

	}

// If any of these asserts fail, it constitutes a BC break

__ASSERT_COMPILE(sizeof(RChildProcess) == 7*4);

__ASSERT_COMPILE(sizeof(RCommandOptionList) == 8*4);

__ASSERT_COMPILE(sizeof(RCommandArgumentList) == 8*4);

__ASSERT_COMPILE(sizeof(RIoConsoleReadHandle) == 6*4);

__ASSERT_COMPILE(sizeof(RIoReadHandle) == 2*4);

__ASSERT_COMPILE(sizeof(RIoConsoleWriteHandle) == 2*4);

// The member variables of CCommandBase actually sum to 59 words, and from subclasses' point of view it's 59 words,

// but EABI rounds the sizeof up to an 8-byte boundary. We can't change CCommandBase to be 60 words so that it's

// handled the same on all platforms, because that in itself would be a BC break.

#ifdef __EABI__

__ASSERT_COMPILE(sizeof(CCommandBase) == 60*4);

#else

__ASSERT_COMPILE(sizeof(CCommandBase) == 59*4);

#endif

//

// TEnumLex.

//

class TEnumLex

	{

public:

	TEnumLex(const TDesC& aCommaSeparatedList);

	TBool More();

	TPtrC Next();

private:

	TPtrC iRemainder;

	};

TEnumLex::TEnumLex(const TDesC& aCommaSeparatedList)

	: iRemainder(aCommaSeparatedList)

	{

	}

TBool TEnumLex::More()

	{

	return iRemainder.Length() > 0;

	}

_LIT(KComma, ",");

TPtrC TEnumLex::Next()

	{

	TInt commaPos = iRemainder.Find(KComma);

	if (commaPos<0) commaPos = iRemainder.Length();

	TPtrC value(iRemainder.Mid(0, commaPos));

	iRemainder.Set(iRemainder.Mid(commaPos));

	if (iRemainder.Length()) iRemainder.Set(iRemainder.Mid(1));

	return value;

	}

//

// TEnum.

//

EXPORT_C TEnum::TEnum()

	{

	}

EXPORT_C TEnum::TEnum(const TDesC& aEnumValueList)

	: iEnumValueList(aEnumValueList)

	{

	ValidateValues();

	}

EXPORT_C TEnum::TEnum(const TDesC& aEnumValueList, const TDesC& aEnumDescriptionList)

	: iEnumValueList(aEnumValueList), iEnumDescriptionList(aEnumDescriptionList)

	{

	ValidateValues();

	}

TInt TEnum::GetMatches(const TDesC& aString, RArray<TInt>& aMatches, TInt& aExactMatch)

	{

	TEnumLex lex(iEnumValueList);

	TInt i = 0;

	aExactMatch = KErrNotFound;

	while ((lex.More()) && (aExactMatch == KErrNotFound))

		{

		TPtrC value(lex.Next());

		if (value.Compare(aString)==0)

			{

			aExactMatch = i;

			}

		if (value.Find(aString)==0)

			{

			TInt err = aMatches.Append(i);

			if (err) return err;

			}

		++i;

		}

	return KErrNone;

	}

EXPORT_C TInt TEnum::Parse(const TDesC& aString, TInt& aValue)

	{

	RArray<TInt> matches;

	TInt exactMatch;

	TInt err = GetMatches(aString, matches, exactMatch);

	if (err==KErrNone)

		{

		if (exactMatch != KErrNotFound)

			{

			aValue = exactMatch;

			}

		else if (matches.Count()==1)

			{

			aValue = matches[0];

			}

		else

			{

			err = KErrArgument;

			}

		}

	matches.Close();

	return err;	

	}

EXPORT_C TInt TEnum::ParseL(const TDesC& aString)

	{

	RArray<TInt> matches;

	TInt exactMatch;

	CleanupClosePushL(matches);

	User::LeaveIfError(GetMatches(aString, matches, exactMatch));

	TInt value = 0;

	if ((matches.Count()==1) || (exactMatch != KErrNotFound))

		{

		value = exactMatch != KErrNotFound ? exactMatch : matches[0];

		}

	else if (matches.Count()==0)

		{

		if (CCommandBase::HaveStatic())

			{

			CTextBuffer* buf = CTextBuffer::NewLC(0x20);

			buf->AppendL(_L("String '"));

			buf->AppendL(aString);

			buf->AppendL(_L("' does not match any of "));

			AppendValuesL(*buf);

			PrintError(KErrArgument, buf->Descriptor());

			}

		User::Leave(KErrArgument);

		}

	else

		{

		if (CCommandBase::HaveStatic())

			{

			CTextBuffer* buf = CTextBuffer::NewLC(0x20);

			buf->AppendL(_L("String '"));

			buf->AppendL(aString);

			buf->AppendL(_L("' does not match a unique value (matches "));

			TInt enumCount = -1;

			TEnumLex lex(iEnumValueList);

			// here we rely on the fact the matches will be sorted, due to the way the array was populated above.

			for (TInt i=0; i<matches.Count(); ++i)

				{

				TPtrC enumValue;

				while (matches[i]>enumCount)

					{

					++enumCount;

					enumValue.Set(lex.Next());

					}

				buf->AppendL(enumValue);

				if (i<matches.Count()-1) buf->AppendL(_L(", "));

				}

			buf->AppendL(')');

			PrintError(KErrArgument, buf->Descriptor());

			}

		User::Leave(KErrArgument);

		}

	CleanupStack::PopAndDestroy(); //matches

	return value;

	}

EXPORT_C const TDesC& TEnum::ValueList() const

	{

	return iEnumValueList;

	}

EXPORT_C const TDesC& TEnum::DescriptionList() const

	{

	return iEnumDescriptionList;

	}

void TEnum::ValidateValues() const

	{

	for (TInt i=0; i<iEnumValueList.Length(); ++i)

		{

		__ASSERT_ALWAYS(!TChar(iEnumValueList[i]).IsSpace(), IoUtils::Panic(EEnumValueContainsSpace));

		}

	}

EXPORT_C void TEnum::AppendValuesL(CTextBuffer& aBuf) const

	{

	TEnumLex values(iEnumValueList);

	while (values.More())

		{

		aBuf.AppendL(values.Next());

		if (values.More())

			{

			aBuf.AppendL(_L(", "));

			}

		}

	}

EXPORT_C const TPtrC TEnum::GetString(TInt aIndex) const

	{

	TEnumLex lex(iEnumValueList);

	while (aIndex)

		{

		lex.Next();

		--aIndex;

		__ASSERT_ALWAYS(lex.More(), Panic(EEnumValueOutOfRange));

		}

	return lex.Next();

	}

EXPORT_C void TEnum::SetValueList(const TDesC& aValueList)

	{

	__ASSERT_ALWAYS(iEnumValueList.Length() == 0, IoUtils::Panic(EEnumValueListAlreadySet));

	iEnumValueList.Set(aValueList);

	}

EXPORT_C void TEnum::SetDescriptionList(const TDesC& aDescriptionList)

	{

	__ASSERT_ALWAYS(iEnumDescriptionList.Length() == 0, IoUtils::Panic(EEnumDescriptionListAlreadySet));

	iEnumDescriptionList.Set(aDescriptionList);

	}

EXPORT_C void TEnum::operator=(const TEnum& aEnum)

	{

	iEnumValueList.Set(aEnum.iEnumValueList);

	iEnumDescriptionList.Set(aEnum.iEnumDescriptionList);

	}

//

// TValue.

//

TValue::TValue(TUint aValueType, void* aValuePointer, const TDesC& aName)

	: iValueType(aValueType), iValue(aValuePointer), iIsSet(EFalse), iEnum(KNullDesC, KNullDesC), iName(aName)

	{

	}

TValue::TValue(TUint aValueType, void* aValuePointer, const TDesC& aName, const TDesC& aDescription, const TDesC& aEnvVar)

	: iValueType(aValueType), iValue(aValuePointer), iIsSet(EFalse), iEnvVar(aEnvVar), iEnum(KNullDesC, KNullDesC), iName(aName), iDescription(aDescription)

	{

	__ASSERT_ALWAYS(aValueType != KValueTypeEnum, IoUtils::Panic(EInvalidUseOfEnum));

	}

TValue::TValue(TUint aValueType, const TDesC& aEnumValueList, const TDesC& aEnumDescriptionList, void* aValuePointer, const TDesC& aName, const TDesC& aDescription, const TDesC& aEnvVar)

	: iValueType(aValueType), iValue(aValuePointer), iIsSet(EFalse), iEnvVar(aEnvVar), iEnum(aEnumValueList, aEnumDescriptionList), iName(aName), iDescription(aDescription)

	{

	}

TUint TValue::ValueType() const

	{

	return iValueType;

	}

EXPORT_C TUint TValue::Type() const

	{

	return iValueType & KPublicFlagsMask;

	}

void TValue::SetValue()

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeBool, IoUtils::Panic(EIncorrectCommandOptionType1));

	if (iValueType & KValueTypeFlagMultiple)

		{

		(*(TInt*)iValue)++;

		}

	else

		{

		*(TBool*)iValue = ETrue;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(TInt aInt)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeInt, IoUtils::Panic(EIncorrectCommandOptionType2));

	if (iValueType & KValueTypeFlagMultiple)

		{

		User::LeaveIfError(((RArray<TInt>*)iValue)->Append(aInt));

		}

	else

		{

		*(TInt*)iValue = aInt;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(TInt64 aInt)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeInt64, IoUtils::Panic(EIncorrectCommandOptionType11));

	if (iValueType & KValueTypeFlagMultiple)

		{

		User::LeaveIfError(((RArray<TInt64>*)iValue)->Append(aInt));

		}

	else

		{

		*(TInt64*)iValue = aInt;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(TUint aUint)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeUint, IoUtils::Panic(EIncorrectCommandOptionType3));

	if (iValueType & KValueTypeFlagMultiple)

		{

		User::LeaveIfError(((RArray<TUint>*)iValue)->Append(aUint));

		}

	else

		{

		*(TUint*)iValue = aUint;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(TUint64 aUint)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeUint64, IoUtils::Panic(EIncorrectCommandOptionType10));

	if (iValueType & KValueTypeFlagMultiple)

		{

		User::LeaveIfError(((RArray<TUint64>*)iValue)->Append(aUint));

		}

	else

		{

		*(TUint64*)iValue = aUint;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(TReal64 aReal)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeReal, IoUtils::Panic(EIncorrectCommandOptionType4));

	if (iValueType & KValueTypeFlagMultiple)

		{

		User::LeaveIfError(((RArray<TReal64>*)iValue)->Append(aReal));

		}

	else

		{

		*(TReal64*)iValue = aReal;

		}

	iIsSet = ETrue;

	}

void TValue::SetValueL(HBufC* aString)

	{

	__ASSERT_ALWAYS( ((iValueType & KValueTypeFlagMask) == KValueTypeString) || (iValueType & KValueTypeFlagMask) == KValueTypeEnum, IoUtils::Panic(EIncorrectCommandOptionType5));

	if ((iValueType & KValueTypeFlagMask) == KValueTypeEnum)

		{

		TInt value = iEnum.ParseL(*aString);

		if (iValueType & KValueTypeFlagMultiple)

			{

			User::LeaveIfError(((RArray<TInt>*)iValue)->Append(value));

			}

		else

			{

			*(TInt*)iValue = value;

			}

		iIsSet = ETrue;

		}

	else // string

		{

		if (iValueType & KValueTypeFlagMultiple)

			{

			User::LeaveIfError(((RPointerArray<HBufC>*)iValue)->Append(aString));

			}

		else

			{

			*(HBufC**)iValue = aString;

			}

		iIsSet = ETrue;

		}

	}

void TValue::SetValueL(const TFileName2& aFileName, RFs& aFs)

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeFileName, IoUtils::Panic(EIncorrectCommandOptionType6));

	if (AcceptsMultiple())

		{

		if (aFileName.IsWild())

			{

			CDir* matches;

			User::LeaveIfError(aFs.GetDir(aFileName, KEntryAttMaskSupported, ESortByName, matches));

			CleanupStack::PushL(matches);

			for (TInt i = 0; i < matches->Count(); ++i)

				{

				TFileName2 expandedFileName((*matches)[i].iName);

				expandedFileName.MakeAbsoluteL(aFileName.DriveAndPath());

				((RArray<TFileName2>*)iValue)->AppendL(expandedFileName);

				}

			CleanupStack::PopAndDestroy(matches);

			}

		else

			{

			((RArray<TFileName2>*)iValue)->AppendL(aFileName);

			}

		}

	else

		{

		((TFileName2*)iValue)->SetL(aFileName);

		}

	iIsSet = ETrue;

	}

void TValue::SetEnumValues(const TEnum& aEnum)

	{

	iEnum = aEnum;

	}

TBool TValue::IsSet() const

	{

	return iIsSet;

	}

EXPORT_C TBool TValue::AcceptsMultiple() const

	{

	return (iValueType & KValueTypeFlagMultiple);

	}

EXPORT_C const TDesC& TValue::EnumValueList() const

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeEnum, IoUtils::Panic(EIncorrectCommandOptionType7));

	return iEnum.ValueList();

	}

const TDesC& TValue::EnumDescriptionList() const

	{

	__ASSERT_ALWAYS((iValueType & KValueTypeFlagMask) == KValueTypeEnum, IoUtils::Panic(EIncorrectCommandOptionType8));

	return iEnum.DescriptionList();

	}

EXPORT_C const TDesC& TValue::EnvVar() const

	{

	return iEnvVar;

	}

EXPORT_C const TDesC& TValue::Name() const

	{

	return iName;

	}

const TDesC& TValue::Description() const

	{

	return iDescription;

	}

EXPORT_C void* TValue::ValuePtr() const

	{

	return iValue;

	}

TPtrC TValue::AsString() const

	{

	if (!IsSet()) return KNullDesC();

	if (AcceptsMultiple()) return KNullDesC();

	switch (iValueType)

		{

	case KValueTypeString:

		return *(HBufC*)iValue;

	case KValueTypeFileName:

		return *(TFileName2*)iValue;

	case KValueTypeEnum:

		return iEnum.GetString(*(TInt*)iValue);

	default:

		return KNullDesC();

		}