// kerninfo.cpp

// 

// Copyright (c) 2008 - 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 <fshell/ioutils.h>

#include <fshell/memoryaccesscmd.h>

#include <fshell/qr3dll.h>

#include <fshell/ltkutils.h>

#include <fshell/descriptorutils.h>

#ifdef FSHELL_SPCRE_SUPPORT

#include <fshell/pcre/cregex.h>

#endif

using namespace IoUtils;

class CRegEx;

class CCmdKerninfo : public CMemoryAccessCommandBase

	{

public:

	static CCommandBase* NewLC();

	~CCmdKerninfo();

private:

	CCmdKerninfo();

	TInt InfoL(TInt aIndex, TBool aUseId, TBool aVerbose);

	void PrintInfoForL(TInt aIndex, TBool aUseId=EFalse);

	static TBool SupportsIds(TKernelObjectType aType);

	static void ChompBlankLines(TDes& aDes);

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual void DoRunL();

	virtual void ArgumentsL(RCommandArgumentList& aArguments);

	virtual void OptionsL(RCommandOptionList& aOptions);

private:

	TKernelObjectType iType; 

	TInt iObjectIndex;

	TBool iVerbose;

	TBool iVerboseMatch;

	HBufC* iMatch;

	HBufC* iRegexMatch;

	CKernelObjectList* iModel;

	RBuf iTitle, iInfo;

	LtkUtils::RLtkBuf8 iNarrowBuf;

	CRegEx* iRegex;

	};

CCommandBase* CCmdKerninfo::NewLC()

	{

	CCmdKerninfo* self = new(ELeave) CCmdKerninfo();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdKerninfo::~CCmdKerninfo()

	{

	delete iModel;

	iTitle.Close();

	iInfo.Close();

	iNarrowBuf.Close();

	delete iMatch;

	delete iRegexMatch;

#ifdef FSHELL_SPCRE_SUPPORT

	delete iRegex;

#endif

	}

CCmdKerninfo::CCmdKerninfo()

	{

	}

const TDesC& CCmdKerninfo::Name() const

	{

	_LIT(KName, "kerninfo");	

	return KName;

	}

void CCmdKerninfo::ArgumentsL(RCommandArgumentList& aArguments)

	{

	aArguments.AppendEnumL((TInt&)iType, _L("object-type"));

	aArguments.AppendIntL(iObjectIndex, _L("object-index"));

	}

void CCmdKerninfo::OptionsL(RCommandOptionList& aOptions)

	{

	aOptions.AppendStringL(iMatch, _L("match"));

#ifdef FSHELL_SPCRE_SUPPORT

	aOptions.AppendStringL(iRegexMatch, _L("regex-match"));

#endif

	aOptions.AppendBoolL(iVerbose, _L("verbose"));

	aOptions.AppendBoolL(iVerboseMatch, _L("verbosematch"));

	}

EXE_BOILER_PLATE(CCmdKerninfo)

void CCmdKerninfo::DoRunL()

	{

	LoadMemoryAccessL();

	iModel = CKernelObjectList::NewL(&iMemAccess);

	iModel->SetCurrentType(iType);

	TRAPL(iModel->RefreshDataL(), _L("Couldn't get model data"));

	iTitle.CreateL(256);

	iInfo.CreateL(256);

#ifdef FSHELL_SPCRE_SUPPORT

	if (iRegexMatch)

		{

		if (iMatch) LeaveIfErr(KErrArgument, _L("Can't specify both --match and --regex-match, use one or the other"));

		iRegex = CRegEx::NewL(*iRegexMatch, TRegExOptions(EPcreExtended|EPcreNewlineAny));

		}

#endif

	if (iVerboseMatch) iVerbose = ETrue; // verbosematch implies verbose

	const TInt n = iModel->Count();

	TBool listAll = !iArguments.IsPresent(&iObjectIndex);

	if (listAll)

		{

		for (TInt i = 0; i < n; i++)

			{

			PrintInfoForL(i);

			}

		}

	else

		{

		TBool usingId = SupportsIds(iType);

		if (!usingId && (iObjectIndex < 0 || iObjectIndex >= n))

			{

			LeaveIfErr(KErrArgument, _L("Bad argument %d. Number of objects in this category: %d"), iObjectIndex, n);

			}

		PrintInfoForL(iObjectIndex, usingId);

		}

	}

TInt CCmdKerninfo::InfoL(TInt aIndex, TBool aUseId, TBool aVerbose)

	{

	TInt err = KErrNone;

	TInt itemid = 0;

	if (aUseId)

		{

		TRAP(err, iModel->GetInfoByIdL(aIndex, aVerbose, iTitle, iInfo));

		}

	else

		{

		TRAP(err, itemid = iModel->GetInfoByIndexL(aIndex, aVerbose, iTitle, iInfo));

		}

	LeaveIfErr(err, _L("Couldn't get info for item %d"), aIndex);

	return itemid;

	}

void CCmdKerninfo::PrintInfoForL(TInt aIndex, TBool aUseId /* =EFalse */)

	{

	TInt itemid = 0;

	if (iMatch || iRegexMatch)

		{

		// Filter out anything not matching iMatch/iRegexMatch

		// Unless --verbosematch is specified, match on the non-verbose (but display the verbose if specified). This is because calculating the verbose can be really slow so don't do it until we know we match.

		itemid = InfoL(aIndex, aUseId, (TBool)iVerboseMatch);

		const TDesC& toMatchAgainst = iVerboseMatch ? iInfo : iTitle;

		TBool match = EFalse;

		if (iMatch)

			{

			match = (toMatchAgainst.MatchF(*iMatch) != KErrNotFound);

			}

#ifdef FSHELL_SPCRE_SUPPORT

		else if (iRegexMatch)

			{

			iNarrowBuf.Zero();

			iNarrowBuf.AppendL(toMatchAgainst);

			match = iRegex->PartialMatchL(iNarrowBuf);

			}

#endif

		if (!match) return;

		}

	if ((!iMatch && !iRegexMatch) || (iVerbose && !iVerboseMatch))

		{

		// Need to get info for first time (if !iMatch) or re-get the verbose info (in the case of we just did a match on the non-verbose info)

		itemid = InfoL(aIndex, aUseId, iVerbose);

		}

	TInt idxToDisplay = (SupportsIds(iType) && !aUseId) ? itemid : aIndex;

	if (iVerbose)

		{

		// In verbose mode the title is always just "Process info" (etc) so no point displaying it

		Printf(_L("%d:\n"), idxToDisplay);

		ChompBlankLines(iInfo); // When doing a verbose listing (specially multiple ones) it's easier to remove the blank lines that the model adds for readability in the QResources dialog

		Write(iInfo);

		Write(_L("\n\n"));

		}

	else

		{

		Printf(_L("%d: %S\t%S\n"), idxToDisplay, &iTitle, &iInfo);

		}

	}

TBool CCmdKerninfo::SupportsIds(TKernelObjectType aType)

	{

	// These types can (and should) be looked up directly by id and not by index into the list.

	return (aType == EListThread || aType == EListProcess || aType == EListHal);

	}

void CCmdKerninfo::ChompBlankLines(TDes& aDes)

	{

	_LIT(KLfLf, "\n\n");

	TInt found;

	while ((found = aDes.Find(KLfLf)) != KErrNotFound)

		{

		aDes.Delete(found, 1); // Nuke one of the newlines

		}

	}