// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // f32\etshell\ts_edshl.cpp

 // CLineEdit and CShell code

 // 

 //

 #include <e32hal.h>

 #include "ts_std.h"

 #include "ts_clicomp.h"

 #include "cleanuputils.h"

 CLineEdit* CShell::TheEditor;

 CFileMan* CShell::TheFileMan;

 TBuf<KMaxFileName> CShell::currentPath;

 RFs CShell::TheFs;

 CConsoleBase* CShell::TheConsole;

 CCliCompleter* CShell::TheCliCompleter;

 class CFileManObserver : public MFileManObserver

 	{

 	TControl NotifyFileManEnded();

 	};

 MFileManObserver::TControl CFileManObserver::NotifyFileManEnded()

 //

 // Print out what CFileMan is doing

 //

 	{

 	TInt err=CShell::TheFileMan->GetLastError();

 	TFileName srcfile;

 	CShell::TheFileMan->GetCurrentSource(srcfile);

 	if (err!=KErrNone)

 		{

 		if(err == KErrNotReady)

 			{

 			FOREVER

 				{

 				CShell::TheConsole->Printf(_L("Not ready - Retry? [y/n]\n"));

 				TChar key = CShell::TheConsole->Getch();

 				key.UpperCase();

 				if(key == 'Y')

 					{

 					return(MFileManObserver::ERetry);

 					}

 				if(key == 'N')

 					{

 					return(MFileManObserver::EAbort);

 					}

 				}

 			}

 		else

 			{

 			CShell::TheConsole->Printf(_L("Error %d\n"),err);

 			}

 		}

 	else

 		{			

 		switch (CShell::TheFileMan->CurrentAction())

 			{

 			case CFileMan::ECopy:

 				CShell::TheConsole->Printf(_L("Copied %S\n"),&srcfile);

 				break;

 			case CFileMan::EAttribs:

 				CShell::TheConsole->Printf(_L("Setting Attributes for %S\n"),&srcfile);

 				break;

 			case CFileMan::EDelete:

 				CShell::TheConsole->Printf(_L("Deleted %S\n"),&srcfile);

 				break;

 			case CFileMan::EMove:

 				CShell::TheConsole->Printf(_L("Moved %S\n"),&srcfile);

 				break;

 			case CFileMan::ERename:

 				CShell::TheConsole->Printf(_L("Renamed %S\n"),&srcfile);

 				break;

 			case CFileMan::ERmDir:

 				CShell::TheConsole->Printf(_L("RmDir deleted %S\n"),&srcfile);

 				break;

 			default:

 				CShell::TheConsole->Printf(_L("Unknown action %S\n"),&srcfile);

 				break;

 				}

 		}

 	return(MFileManObserver::EContinue);

 	}

 LOCAL_C TInt charToDrive(TChar aChar,TInt& aDrive)

 //

 // Convert the drive character to a drive index.

 //

 	{

 	TInt r=RFs::CharToDrive(aChar,aDrive);

 	return(r);

 	}

 CLineEdit::CLineEdit()

 //

 // Constructor

 //

 	{

 	}

 CLineEdit::~CLineEdit()

 //

 // Destroy the line editor

 //

 	{

     if (iHistory)

         {

         TInt count=iHistory->Count();

         while (count--)

             User::Free((*iHistory)[count]);

         delete iHistory;

         }

 	}

 CLineEdit* CLineEdit::NewL(CConsoleBase* aConsole,TInt aMaxHistory)

 //

 // Create a new line editor

 //

 	{

 	CLineEdit* pE=new(ELeave) CLineEdit;

     CleanupStack::PushL(pE);

 	pE->iHistory=new(ELeave) CArrayFixFlat<HBufC*>(aMaxHistory+2);

 	pE->iConsole=aConsole;

 	pE->iMaxHistory=aMaxHistory;

 	pE->iWidth=CShell::TheConsole->ScreenSize().iWidth;

 	pE->iHeight=CShell::TheConsole->ScreenSize().iHeight;

 	// !E32WindowServer Text Shell Console has frame 

 	// of 2 characters each vertically and horizontally.

 	// !Windowserver Shell Console does not.

 	// Assume no Frame is present !

 	TFindServer findServer;

 	TFullName wsName;

 	TInt err = KErrNone;

 	pE->iFrameSizeChar=TSize(0,0);

 	// Find: !E32WindowServer is running?

 	while (err=findServer.Next(wsName), err==KErrNone)

 		{

 		if(err=wsName.FindF(KE32WindowServer), err!=KErrNotFound)

 			{

 			// E32WindowServer is running. 

 			// Frame is present ! Frame Size is (2,2) !

 			pE->iFrameSizeChar=TSize(2,2);

 			break;

 			}

 		}

     CleanupStack::Pop();

 	return(pE);

 	}

 TInt CLineEdit::Lines()

 //

 // The number of lines being edited.

 //

     {

     TInt nL=1;

     if (Buf().Length()>=iWidth-iFrameSizeChar.iWidth-iOrigin)

 		nL+=(Buf().Length()+iOrigin)/(iWidth-iFrameSizeChar.iWidth);

     return(nL);

     }

 TPoint CLineEdit::Where()

 //

 // Return the real cursor position.

 //

     {

     if (iPos>=(iWidth-iFrameSizeChar.iWidth-iOrigin))

 		return(TPoint((iPos+iOrigin)%(iWidth-iFrameSizeChar.iWidth),((iPos+iOrigin)/(iWidth-iFrameSizeChar.iWidth))+iLine));

 	return(TPoint(iPos+iOrigin,iLine));

     }

 void CLineEdit::ClearLine()

 //

 // Clears the line being edited.

 //

     {

     if (Buf().Length())

 		{

 		TInt nL=Lines();

 		while (nL--)

 	    	{

 	    	iConsole->SetPos(nL ? 0 : iOrigin,iLine+nL);

 	    	iConsole->ClearToEndOfLine();

 	    	}

 		Buf().Zero();

 		iPos=0;

 		}

     }

 void CLineEdit::ClearLast(TInt aCnt)

 //

 // Clears the last aCnt characters.

 //

     {

     TInt aPos=iPos;

     iPos=((TInt)Buf().Length())-aCnt;

     while (iPos<((TInt)Buf().Length()))

 		{

 		TPoint p=Where();

 		iConsole->SetCursorPosAbs(p);

 		iConsole->ClearToEndOfLine();

 		iPos+=(iWidth-p.iX);

 		}

     iPos=aPos;

     }

 void CLineEdit::Recall()

 //

 // Recall a line for editing.

 //

     {

 	if (iRecall!=(-1))

 		{

 		ClearLine();

 		HBufC* pL=(*iHistory)[iRecall];

 		Buf()=(*pL);

 		iConsole->Write(Buf());

 		iPos=Buf().Length();

 		TInt nL=Lines();

 		if ((iLine+nL)>iHeight)

 			iLine -= iLine + nL - iHeight;	

 		}

     }

 TInt CLineEdit::WordLeft()

 //

 // Position the cursor to the next word left.

 //

     {

     TInt x=iPos-1;

     while (x && TChar(Buf()[x]).IsSpace())

 		x--;

     while (x && TChar(Buf()[x]).IsGraph())

 		x--;

     if (TChar(Buf()[x]).IsSpace())

 		x++;

     return(x);

     }

 TInt CLineEdit::WordRight()

 //

 // Position the cursor to the next word right.

 //

     {

     TInt x=iPos;

     while (x<(TInt)Buf().Length() && TChar(Buf()[x]).IsGraph())

 		x++;

     while (x<(TInt)Buf().Length() && TChar(Buf()[x]).IsSpace())

 		x++;

     return(x);

     }

 void CLineEdit::Cursor()

 //

 // Position the cursor.

 //

     {

     iConsole->SetCursorPosAbs(Where());

     }

 void CLineEdit::Refresh()

 //

 // Refresh the line.

 //

     {

 	iConsole->SetCursorHeight(ECursorNone);

     iConsole->SetPos(iOrigin,iLine);

     iConsole->Write(Buf());

 	Cursor();

 	iConsole->SetCursorHeight(iMode==EEditOverWrite ? ECursorNormal : ECursorInsert);

     }

 TLineEditAction CLineEdit::Edit(const TDesC& aPrompt, TDes* aBuf, TBool aNewLine)

 //

 // Start the editor or a single key fetch.

 //

 	{

 	iBuf = aBuf;

 	if(aNewLine)

 		{

 		iMode = EEditInsert;

 		iConsole->Write(aPrompt);

 		iConsole->SetCursorHeight(iMode == EEditOverWrite ? ECursorNormal : ECursorInsert);

 		iOrigin = iConsole->WhereX();

 		iLine = iConsole->WhereY();  

 		}

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

 		{			

 		iPos = 0;

 		}

 	Refresh();

 	iRecall = (-1);

 	TInt hCount = iHistory->Count();

 	if (hCount > iMaxHistory)

 		{

 		hCount = iMaxHistory;

 		}

 	FOREVER

 		{

 		TChar gChar = iConsole->Getch();

 		switch (gChar)

 	    	{

 		case EKeyEscape:

 	    	ClearLine();

 			iRecall=(-1);

 	    	break;

 		case EKeyHome:

 	    	iPos=0;

 	    	Cursor();

 	    	break;

 		case EKeyLeftArrow:

 	    	if (iPos)

                 {

                 if(iConsole->KeyModifiers()==EModifierCtrl)

                     iPos=WordLeft();

                 else

     				iPos--;

                 Cursor();

                 }

 	    	break;

 		case EKeyRightArrow:

 	    	if (iPos<((TInt)Buf().Length()))

                 {

                 if(iConsole->KeyModifiers()==EModifierCtrl)

                     iPos=WordRight();

                 else

     				iPos++;

                 Cursor();

                 }

 	    	break;

 		case EKeyEnd:

 	    	iPos=((TInt)Buf().Length());

 	    	Cursor();

 	    	break;

 		case EKeyPageUp:

 	    	if (hCount==0)

 				break;

 	    	iRecall=hCount-1;

 	    	Recall();

 	    	break;

 		case EKeyUpArrow:

 	    	if (iRecall==(-1))	//	Beginning of history

 				{

 				if (hCount==0)

 		    		break;

 				iRecall=0;

 				}

 	    	else if (iRecall>=(hCount-1))	//	End

 				{

 				ClearLine();

 				iRecall=(-1);

 				break;

 				}

 	    	else

 				iRecall++;

 	    	Recall();

 	    	break;

 		case EKeyDownArrow:

 	    	if (iRecall==(-1))

 				{

 				if (hCount==0)

 		    		break;

 				iRecall=hCount-1;

 				}

 	    	else if (iRecall==0)

 				{

 				ClearLine();

 				iRecall=(-1);

 				break;

 				}

 	    	else

 				iRecall--;

 	    	Recall();

 	    	break;

 		case EKeyPageDown:

 	    	if (hCount==0)

 				break;

 	    	iRecall=0;

 	    	Recall();

 	    	break;

 		case EKeyEnter:

 			NewLine();

 			StoreBufferHistory();		

 	    	return EShellCommand;

 		case EKeyBackspace:

 	    	if (iPos)

 				{

 				TInt iN=1;

 				if (iConsole->KeyModifiers()==EModifierCtrl)

 		    		iN=iPos-WordLeft();

 				ClearLast(iN);

 				iPos-=iN;

 				Buf().Delete(iPos,iN);

 				Refresh();

 				}

 	    	break;

 		case EKeyDelete:

 	    	if (iPos<((TInt)Buf().Length()))

 				{

 				TInt iN=1;

 				if (iConsole->KeyModifiers()==EModifierCtrl)

 		    		iN=WordRight()-iPos;

 				ClearLast(iN);

 				Buf().Delete(iPos,iN);

 				Refresh();

 				}

 	    	break;

 		case EKeyInsert:

 	    	iMode=(iMode==EEditOverWrite ? EEditInsert : EEditOverWrite);

 			iConsole->SetCursorHeight(iMode==EEditOverWrite ? ECursorNormal : ECursorInsert);

 	    	break;

 		case EKeyTab:

 			return ECommandCompletion;

 		default:

    	    	if (!gChar.IsPrint())

 				break;

 	    	if (iMode==EEditOverWrite && iPos<((TInt)Buf().Length()))

 				Buf()[iPos++]=(TText)gChar;

 	    	else if (Buf().Length()<KShellMaxCommandLine)

 				{

 				TInt oL=Lines();

 				TBuf<0x02> b;

 				b.Append(gChar);

 				Buf().Insert(iPos++,b);

 				TInt nL=Lines();

 				if (nL!=oL)

 		    		{

 		    		iConsole->SetCursorHeight(ECursorNone);

 		    		iConsole->SetPos(0,iLine+oL-1);

 		    		iConsole->Write(_L("\n"));

 		    		iConsole->SetPos(0,iLine);

 		    		if (iLine+nL>iHeight-iFrameSizeChar.iHeight)

 						iLine=iHeight-iFrameSizeChar.iHeight-nL;

 		    		}

 				}

 			else

 				{

 				iConsole->Write(_L("\7"));

 				iConsole->SetPos((iOrigin+iPos)%(iWidth-iFrameSizeChar.iWidth),iLine+Lines()-1);

 				break;

 				}

 			Refresh();

 			}

 		}

 	}

 void CLineEdit::NewLine()

 	{

  	iConsole->SetCursorHeight(ECursorNone);

  	iLine += (Lines() - 1);

  	iConsole->SetPos(0, iLine);

  	iConsole->Write(_L("\n")); // Just a line feed

  	iRecall = (-1);

 	}

 void CLineEdit::StoreBufferHistory()

 	{

     Buf().TrimRight(); 

 	if (Buf().Length()>=1)

 		{

         //-- find out if we already have exactly the same command in the history.

         //-- if it is there, don't add a new item, just move it to the top

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

         {

             HBufC* pCmd = iHistory->At(i);    

             const TDesC& cmdLine = pCmd->Des();

             if(cmdLine == Buf())

             {

                 iHistory->Delete(i);

                 TRAP_IGNORE(iHistory->InsertL(0, pCmd));

                 return;

             }

         }

         if (iHistory->Count()==iMaxHistory+1)

 			{

 			User::Free((*iHistory)[iMaxHistory]);

     		iHistory->Delete(iMaxHistory);

 			}

         HBufC* pB=Buf().Alloc();

 		if(pB != NULL)

 			{

 			TRAP_IGNORE(iHistory->InsertL(0, pB));

 			}

 		}

 	}

 //////////////////////////////////////

 //CShell

 //////////////////////////////////////

 TShellCommand::TShellCommand(const TDesC& aName,const TDesC& aHelp,const TDesC& aHelpDetail,TUint aSwitches,TInt (*aFunction)(TDes&,TUint))

 	:iName(aName),

 	iHelp(aHelp),

 	iHelpDetail(aHelpDetail),

 	iSwitchesSupported(aSwitches),

 	iFunction(aFunction)

 	{

 	}

 CShell* CShell::NewL()

 	{

 	CShell *pS = new(ELeave) CShell;

 	CleanupStack::PushL(pS);

 	// No need to PushL these, if CShell::NewL leaves then eshell

 	// fails in its entirety.

 	TheConsole = Console::NewL(_L("ESHELL"), TSize(KConsFullScreen, KConsFullScreen));

 	TheEditor = CLineEdit::NewL(TheConsole, KDefaultHistorySize);

 	TheCliCompleter = CCliCompleter::NewL();

 	CleanupStack::Pop();

 	return(pS);

 	}

 CShell::~CShell()

 	{

 	ShellFunction::TheShell=NULL;

 	TheFs.Close();

 	delete TheEditor;

   	delete TheFileMan;

   	delete TheConsole;

   	delete TheCliCompleter;

  	}

 void CShell::DoBanner()

 	{

 	TBuf<40> shlver=TheShellVersion.Name();

 	TheConsole->Printf(_L("ESHELL %S   CFG="),&shlver);

 #ifdef _UNICODE

 	TheConsole->Printf(_L("U"));

 #endif

 #ifdef _DEBUG

 	TheConsole->Printf(_L("DEB\r\n"));

 #else

 	TheConsole->Printf(_L("REL\r\n"));

 #endif

 #if !defined(__WINS__)

 	TMachineStartupType reason;

 	UserHal::StartupReason(reason);

 	switch (reason)

 		{

 		case EStartupCold:		TheConsole->Printf(_L("Cold Start\n")); break;

 		case EStartupColdReset: 	TheConsole->Printf(_L("Cold Reset\n")); break;

 		case EStartupNewOs: 		TheConsole->Printf(_L("New OS\n")); break;

 		case EStartupPowerFail:		TheConsole->Printf(_L("Power failed\n")); break;

 		case EStartupWarmReset:		TheConsole->Printf(_L("Warm Reset\n")); break;

 		case EStartupKernelFault:	

 			TInt faultno;

 			UserHal::FaultReason(faultno);

 			if (faultno == 0x10000000)

 				{

 				TheConsole->Printf(_L("Kernel Exception\n"));

 				}

 			else 

 				{

 				TExcInfo exceptInfo;

 				UserHal::ExceptionInfo(exceptInfo);

 				TUint32 decode[3];

 				decode[0]=TUint32(exceptInfo.iCodeAddress);

 				decode[1]=TUint32(exceptInfo.iDataAddress);

 				decode[2]=0;

 			//	interpret decode as null-terminated string

 				TPtrC category((TText*)&decode[0]);

 				if (faultno >= 0x10000)

 					TheConsole->Printf(_L("Kernel PANIC: %S %d\n"),&category, faultno-0x10000);

 				else

 					TheConsole->Printf(_L("Kernel FAULT: %S %d\n"),&category, faultno);

 				}

 			break;

 		case EStartupSafeReset:		TheConsole->Printf(_L("Safe Reset\n")); break;

 		default:

 			TheConsole->Printf(_L("<?reason=%d>\n"), reason);

 			break;

 		}

 	if (reason==EStartupWarmReset || reason==EStartupKernelFault)

 		{

 		TInt excId;

 		TExcInfo excInfo;

 		UserHal::ExceptionId(excId);

 		UserHal::ExceptionInfo(excInfo);

 		TheConsole->Printf(_L("(last exception %d: code %08x data %08x extra %08x) "),

 			excId, excInfo.iCodeAddress, excInfo.iDataAddress, excInfo.iExtraData);

 		}

 #endif

 	TheConsole->Printf(_L("\r\n\nCopyright (c) 1998 Symbian Ltd\r\n\n"));

 	}

 _LIT(KRootdir,"?:\\");

 void CShell::RunL()

 	{

 	DoBanner();

 	TBuf<sizeof(KRootdir)> rootdir(KRootdir);

 	rootdir[0] = (TUint8) RFs::GetSystemDriveChar();

 	__ASSERT_ALWAYS(TheFs.Connect()==KErrNone,User::Panic(_L("Connect"),0));

 	__ASSERT_ALWAYS(TheFs.SetSessionPath(rootdir) == KErrNone, User::Panic(_L("Set Session path"),0)); 

 	__ASSERT_ALWAYS(TheFs.SessionPath(currentPath)==KErrNone,User::Panic(_L("Session path"),0));

 	TInt drive;

 	__ASSERT_ALWAYS(charToDrive(currentPath[0],drive)==KErrNone,User::Panic(_L("Invalid Path"),0));

 	drivePaths[drive]=currentPath;

 //

 //	going to creat the shell's private path here

 //	TheFs.

 //

 	CFileManObserver* fileManObserver=new(ELeave) CFileManObserver;

 	CleanupStack::PushL(fileManObserver);

 	TheFileMan=CFileMan::NewL(TheFs,fileManObserver);

 //

 	TBuf<16> startupFile=_L("0:\\AUTOEXEC.BAT");

 	TEntry startEntry;

 //	Search all drives for autoexec.bat starting y,x,...,a then z

 	const TInt KIndexDriveA=0;

 	const TInt KIndexDriveY=24;

 	const TInt KIndexDriveZ=25;

 	TBuf<KMaxFileName>* searchDrive;

 	for (searchDrive=&drivePaths[KIndexDriveY];searchDrive>=&drivePaths[KIndexDriveA];searchDrive--)

 		{

 		currentPath=*searchDrive;

 		startupFile[0]=currentPath[0];

 		if (TheFs.Entry(startupFile,startEntry)==KErrNone)

 			{

 #ifdef __X86__

 			if (startEntry.iSize != 0)

 #endif

 				{

 				RunBatch(startupFile);

 				break;

 				}

 			}

 		if (searchDrive==&drivePaths[KIndexDriveA])

 			{

 			currentPath=drivePaths[KIndexDriveZ];

 			startupFile[0]=currentPath[0];

 			if (TheFs.Entry(startupFile,startEntry)==KErrNone)

 				{

 				RunBatch(startupFile);

 				break;

 				}

 			}

 		}

 	TLineEditAction result;

 	TBuf<KShellMaxCommandLine> commandText;

 	TBool exit = EFalse;

 	TInt tabCount = 0;

 	TBuf<KMaxPath + 1> prompt;

 	TBool newLine = ETrue;

 	FOREVER

 		{

 		__ASSERT_ALWAYS(TheFs.SessionPath(currentPath)==KErrNone,User::Panic(_L("Session path"),0));

       TInt drive;

        __ASSERT_ALWAYS(charToDrive(currentPath[0],drive)==KErrNone,User::Panic(_L("Invalid Path"),0));

 		drivePaths[drive] = currentPath;

 		if(currentPath[currentPath.Length() - 2] == KDriveDelimiter)

 			{

 			prompt = currentPath;		

 			}

 		else 

 			{

 			TInt i = (currentPath.LocateReverse(KPathDelimiter));

 			prompt = currentPath.Left(i);

 			}

 		prompt.Append(_L(">"));

 		result = TheEditor->Edit(prompt, &commandText, newLine);

 		switch(result)

 			{

 			case EShellCommand:

 				tabCount = 0;

 #if !defined(_EPOC)

 				if(commandText.CompareF(_L("EXIT")) == 0)

 					{

 					exit = ETrue;

 					break;

 					}

 #endif

 				commandText.Trim();

 				DoCommand(commandText);

 				commandText.Zero();

 				newLine = ETrue;

 				break;

 			case ECommandCompletion:

 				{

 				tabCount++;

 				TBuf<KMaxPath> knownPart;

 				TheCliCompleter->EstablishCompletionContext(commandText, TheEditor->Pos(), knownPart);

 				TInt preCompletedLength = knownPart.Length();

 				newLine = EFalse;

 				RPointerArray<HBufC> alternatives;

  				CleanupResetAndDestroyPushL(alternatives);

 				if(TheCliCompleter->AttemptCompletionL(knownPart, alternatives))

 					{ // We completed something successfully

 					tabCount = 0;

 					}

 				if(knownPart.Length() > preCompletedLength) 

 					{

 					commandText.Delete(TheEditor->Pos() - preCompletedLength, preCompletedLength);

 					// Don't allow the completion to cause the line buffer length to be exceeded

 					TInt excess = ((TheEditor->Pos() - preCompletedLength) + knownPart.Length()) - KShellMaxCommandLine;

 					if(excess > 0)

 						{

 						knownPart.Delete(knownPart.Length() - excess, excess);

 						}						

 					else

 						{

 						excess = (commandText.Length() + knownPart.Length()) - KShellMaxCommandLine;

 						if(excess > 0)

 							{

 							commandText.Delete(commandText.Length() - excess, excess);

 							}

 						}

 					commandText.Insert(TheEditor->Pos() - preCompletedLength, knownPart);

 					TheEditor->SetPos(TheEditor->Pos() + (knownPart.Length() - preCompletedLength));

 					}

 				if(alternatives.Count() > 0)

 					{

 					if(tabCount == 2)

 						{

 						tabCount = 0;

 						TheCliCompleter->DisplayAlternatives(alternatives);

 						newLine = ETrue;

 						}

 					}

 				CleanupStack::PopAndDestroy(&alternatives);

 				break;

 				}

 			case ENoAction:

 			default:

 				tabCount = 0;

 				break;

 			}

 		if(exit) 

 			{

 			break;

 			}

 		}

 	CleanupStack::PopAndDestroy(fileManObserver);

 	}

 void CShell::DoCommand(TDes& aCommand)

 //

 // Evaluate the commandline and run the command or file

 //

 	{

 	aCommand.TrimAll();

 	const TShellCommand* commandPtr=&iCommand[0];

 	for (;commandPtr<=&iCommand[ENoShellCommands-1];commandPtr++)

 		{

 		TInt length=commandPtr->iName.Length();

 		if ((aCommand.Length()>length && aCommand.Left(length).CompareF(commandPtr->iName)==0 && !TChar(aCommand[length]).IsAlphaDigit())

 			|| (aCommand.Length()==length && aCommand.CompareF(commandPtr->iName)==0))

 				{

 				aCommand.Delete(0,length);

 				break;

 				}

 		}

 	if (commandPtr<=&iCommand[ENoShellCommands-1])

 		{

 		if (aCommand.Find(_L("/?"))>=0)

 			PrintHelp(commandPtr);

 		else // No /? switch

 			{

 			TUint switchesSet=0;

 			TInt r;

 			while ((r=aCommand.Locate('/'))!=KErrNotFound)

 				{

 				TChar switchChar='\0';

                 TInt switchInt=switchChar;

 				if ((r+1)==aCommand.Length() || (switchChar=aCommand[r+1]).IsAlpha()==EFalse)

 					{

 					TheConsole->Printf(_L("Invalid switch - \"%c\".\n"),switchInt);

 					return;

 					}

 				switchChar.UpperCase();

 				switchesSet|=(1<<((TInt)switchChar-'A'));

 				TChar extraChar;

 				if ((r+2)<aCommand.Length() && (extraChar=aCommand[r+2])!=' ' && extraChar!='/')

 					{

                     TInt switchInt=switchChar;

                     TInt extraInt=extraChar; // Gcc debugger warning if pass TChar to ...

                     TheConsole->Printf(_L("Parameter format not correct - \"%c%c\".\n"),switchInt,extraInt);

 					return;

 					}

 				aCommand.Delete(r,2); 

 				}

 			if (switchesSet&~commandPtr->iSwitchesSupported)

 				{

 				TheConsole->Printf(_L("Switch not supported\n"));

 				return;

 				}

 			aCommand.Trim();

 		//	RUN SHELL FUNCTION	

 			r=commandPtr->iFunction(aCommand,switchesSet);

 			if (r!=KErrNone) 

 				{

 				PrintError(r);

 				}

 			}

 		}

 	else //Generic commands

 		{

 		TInt r;

 		if (aCommand.CompareF(_L("HELP"))==0)

 			PrintHelp();

 		else if (aCommand.CompareF(_L("CLS"))==0)

 			TheConsole->ClearScreen(); 

 		else if (aCommand.Length()==2 && TChar(aCommand[0]).IsAlpha() && aCommand[1]==':')

 			ChangeDrive(aCommand[0]);

 		else if (aCommand.Length()!=0)

 			{

 			r=RunBatch(aCommand);

 			if (r != KErrNone)		// Typically KErrNotFound, KErrBadName, KErrLocked...

 				r=RunExecutable(aCommand,ETrue);

 			if (r!=KErrNone)

 				PrintError(r);

 			}

 		}

 	}

 void CShell::PrintHelp()

 	{

 	for(const TShellCommand* commandPtr=&iCommand[0];commandPtr<=&iCommand[ENoShellCommands-1];commandPtr++)

 		{

 		OutputStringToConsole(ETrue,_L("%- 10S%S\n"),&commandPtr->iName,&commandPtr->iHelp);			

 		}

 	}

 void CShell::PrintHelp(const TShellCommand* aCommand)

 	{

 	OutputStringToConsole(ETrue,_L("%S\n\n  %S "),&aCommand->iHelp,&aCommand->iName);

 	OutputStringToConsole(ETrue,_L("%S\n\n"),&aCommand->iHelpDetail);

 	}

 void CShell::PrintError(TInt aError)

 	{

 	switch (aError)

 		{

 	case KErrAlreadyExists:

 		TheConsole->Printf(_L("Already exists\n"));

 		break;

 	case KErrCorrupt:

 		TheConsole->Printf(_L("Corrupt or unformatted drive\n"));

 		break;

 	case KErrNotSupported:

 		TheConsole->Printf(_L("Not supported\n"));

 		break;

 	case KErrGeneral:

 		TheConsole->Printf(_L("General Error\n"));

 		break;

 	case KErrNotFound:

 		TheConsole->Printf(_L("Not found\n"));

 		break;

 	case KErrPathNotFound:

 		TheConsole->Printf(_L("Path not found\n"));

 		break;

 	case KErrBadName:

 		TheConsole->Printf(_L("Bad name\n"));

 		break;

 	case KErrNotReady:

 		TheConsole->Printf(_L("Drive not ready\n"));

 		break;

 	case KErrAccessDenied:

 		TheConsole->Printf(_L("Access denied\n"));

 		break;

 	case KErrEof:

 		TheConsole->Printf(_L("Unexpected end of file\n"));

 		break;

 	case KErrTooBig:

 		TheConsole->Printf(_L("Too Big\n"));

 		break;

 	default:

 		TheConsole->Printf(_L("Error %d\n"),aError);

 		}

 	}

 void CShell::ChangeDrive(TChar aDrive)

 	{

     TInt drive;

     __ASSERT_ALWAYS(charToDrive(aDrive,drive)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 	TDriveList driveList;

 	TheFs.DriveList(driveList);

 	if (driveList[drive]) 

 		{

 		TInt r=TheFs.SetSessionPath(drivePaths[drive]);

 		if (r!=KErrNone)

 			PrintError(r);

 		}

 	else 

 		PrintError(KErrNotFound);

 	}  

 TInt CShell::RunBatch(TDes& aCommand)

 	{

 	TBool appendedBat=EFalse;

 	if (aCommand.FindF(_L(".BAT"))<0 && (aCommand.Length()+4)<=KShellMaxCommandLine)

 		{

 		aCommand.Append(_L(".BAT"));

 		appendedBat=ETrue;

 		}

 	RFile file;

 	TInt r=file.Open(TheFs,aCommand,EFileStreamText);

 	if (r!=KErrNone)

 		{

 		if (appendedBat)

 			aCommand.Delete(aCommand.Length()-4,4);		

 		return r;

 		}

 	__ASSERT_ALWAYS(TheFs.SessionPath(currentPath)==KErrNone,User::Panic(_L("Session path"),0));

     TInt drive;

     __ASSERT_ALWAYS(charToDrive(currentPath[0],drive)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 	drivePaths[drive]=currentPath;

 	TInt filePos=0;

 	TBuf<KShellMaxCommandLine> readBuf;

 	FOREVER

 		{

 #ifdef _UNICODE

 		TBuf8<KShellMaxCommandLine> buf8;

 		r=file.Read(filePos,buf8);

 		readBuf.Copy(buf8);		

 #else

 		r=file.Read(filePos,readBuf);

 #endif

 		if (r!=KErrNone)

 			{

 			PrintError(r);

 			break;

 			}

 		r=readBuf.Locate('\n');

 		if (r==KErrNotFound)

 			{

 			r=readBuf.Length();

 			filePos+=r;

 			}

 		else if (r<=1)					//	Indicates /n before batch file instructions

 			{

 			TInt temp=readBuf.Length();	

 			readBuf.TrimLeft();			//	Removes initial /n

 			temp-=readBuf.Length();		

 			r=readBuf.Locate('\n');

 			if(r==KErrNotFound)

 				{

 				r=readBuf.Length();

 				}

 			filePos+=r+1+temp;			//	Offsets filePos correctly in the file

 			}

 		else filePos+=r+1;

 		if (readBuf.Length()==0)

 			break;

 		readBuf.SetLength(r);

 		readBuf.Trim();

 		TheFs.SessionPath(currentPath);

 		TheConsole->Printf(currentPath);		

 		TheConsole->Printf(_L(">%S\n"),&readBuf);

 	//	If command was a drive change, reset the current path here		

 		if (readBuf.Length()==2 && TChar(readBuf[0]).IsAlpha() && readBuf[1]==':')

 			{

 			TInt drive;

 			__ASSERT_ALWAYS(charToDrive(readBuf[0],drive)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 			TDriveList driveList;

 			TheFs.DriveList(driveList);

 			if (driveList[drive]) 

 				{

 				TInt r=TheFs.SetSessionPath(drivePaths[drive]);

 				if (r!=KErrNone)

 					PrintError(r);

 				currentPath=drivePaths[drive];

 				}

 			else 

 			PrintError(KErrNotFound);

 			}

 		else if (readBuf.Length()<3 || readBuf.Left(3).CompareF(_L("REM"))!=0)

 			DoCommand(readBuf);

 		}

 	file.Close();

 	return KErrNone;

 	}

 TInt CShell::RunExecutable(TDes& aCommand,TBool aWaitForCompletion)

 	{

 	aCommand.Trim();

 	TBuf<KShellMaxCommandLine> parameters(0);

    	TInt r=aCommand.Locate(' ');	// can't be the last character because of Trim()

    	if (r!=KErrNotFound)

 		{

 		parameters=aCommand.Mid(r+1);

    		aCommand.SetLength(r);

 		}

 	// aCommand is now just the executable

 	if (aCommand.FindF(_L(".EXE"))==KErrNotFound && (aCommand.Length()+4)<=KShellMaxCommandLine)

 		aCommand.Append(_L(".EXE"));

 	TInt specificExe=1;

 	if (aCommand.Length()>2 && aCommand[1]==':' && aCommand[2]!='\\')

 		{

 		if (TChar(aCommand[0]).IsAlpha())

 			{

 			TInt drive;

 			__ASSERT_ALWAYS(charToDrive(aCommand[0],drive)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 			currentPath=drivePaths[drive];

 			aCommand.Delete(0,2);

             if (aCommand.Length()+currentPath.Length() <= KShellMaxCommandLine)

     			aCommand.Insert(0,currentPath);

 			}

 		else

 			return KErrNotFound;

 		}

 	if (aCommand.Length()>2 && aCommand[1]!=':')

 		{

 		if(aCommand[0]!='\\')

 			{

 			if (aCommand.Locate('\\')==KErrNotFound)

 				specificExe=0;	// no drive, no path - be ready to let the system find it...

             if (aCommand.Length()+currentPath.Length() <= KShellMaxCommandLine)

                 aCommand.Insert(0,currentPath);

 			}

 		else

             if (aCommand.Length()+currentPath.Left(2).Length() <= KShellMaxCommandLine)

     			aCommand.Insert(0,currentPath.Left(2));

 		}

 	RFile file;

 	r=file.Open(CShell::TheFs,aCommand,EFileStream);

 	if (r!=KErrNone)

 		{

 		if (specificExe)

 			return(r);

 		r=aCommand.LocateReverse('\\');	// must exist because this is a full filename

 		aCommand.Delete(0,r+1);

 		}

 	else

 		{

 		// If the file can be opened, it *must* exist, and we'll assume that the user

 		// really intended this specific file.

 		specificExe=1;

 		file.Close();

 		}

 	RProcess newProcess;

 	r=newProcess.Create(aCommand,parameters);

 	if (r==KErrNone)	//	Executable can run OK

 		{

 		TRequestStatus status=KRequestPending;

 		if(aWaitForCompletion)

     		newProcess.Logon(status);

 		newProcess.Resume();

 		if (aWaitForCompletion)

 			User::WaitForRequest(status);

 		if (aWaitForCompletion && (newProcess.ExitType()!=EExitKill || status!=KErrNone))

 			{

 			TBuf<KMaxExitCategoryName> exitCat=newProcess.ExitCategory();

 			TheConsole->Printf(_L("\nExit type %d,%d,%S\n"),newProcess.ExitType(),newProcess.ExitReason(),&exitCat);

 			}

 		newProcess.Close(); // get rid of our handle

 		return KErrNone;

 		}

 	//	Executable could not be run

 #if 0	//defined(__EPOC32__)

 	if (specificExe)		

 		{	

 	//	Use class CDllChecker to check the dependencies

 	//	for MARM exes only

 		CDllChecker check;

 	//	Create an array to store each dependency's name, Uid and result

 		TRAPD(leaveCode,(check.ConstructL()));	

 		if (leaveCode!=KErrNone)	//	If function leaves

 			{

 			TheConsole->Printf(_L("Dependency checking failed due to error %d\n"), leaveCode);

 			return(KErrNone);

 			}

 		TInt result=KErrNone;

 		TRAP(result,(check.GetImportDataL(aCommand,NULL)));

 		if (result==KErrNone)

 			{

 			check.ListArray();	//	Print out the results of DllCheck		

 			return(KErrNone);

 			}

 		}

 #endif

 	return (r);

 }

 void CShell::SetCurrentPath(const TDesC& aDes)

 //

 // Set the current Directory

 //

 	{

 	__ASSERT_DEBUG(currentPath.MaxLength()>=aDes.Length(),Panic(EShellFilePathTooBig));

 	currentPath=aDes;

 	}

 TDes& CShell::CurrentPath()

 //

 // Accessor function

 //

 	{

 	return currentPath;

 	}

 void CShell::SetDrivePath(const TDesC& aDrivePath)

 //

 // Set the drive path

 //

 	{

 	__ASSERT_DEBUG(aDrivePath.Length()>=3 && aDrivePath[1]==KDriveDelimiter,Panic(EShellBadDrivePath));

 	TChar drvLetter=aDrivePath[0];

 	__ASSERT_DEBUG(drvLetter.IsAlpha(),Panic(EShellBadDrivePath));

 	TInt drvNum;

     __ASSERT_ALWAYS(charToDrive(drvLetter,drvNum)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 	drivePaths[drvNum]=aDrivePath;

 	}

 TKeyCode CShell::OutputStringToConsole(TBool aPageSwitch,TRefByValue<const TDesC> aFmt,... )

 //function for output of a sring to console

 //aPageSwitch flag indicates that output should be page-by-page 

 	{

 	//create an object to truncate argument list substitution 

 	SimpleOverflowTruncate overflow;	

 	VA_LIST list;

 	VA_START(list,aFmt);

 	TBuf<0x200> aBuf;

 	//format output string using argument list

 	//coverity[uninit_use_in_call]

 	TRAP_IGNORE(aBuf.AppendFormatList(aFmt,list,&overflow)); // ignore leave in TTimeOverflowLeave::Overflow()

 	_LIT(KPrompt , "Press any key to continue\n");		

 	return OutputStringToConsole(KPrompt,aPageSwitch,_L("%S"),&aBuf);

 	}

 TKeyCode CShell::OutputStringToConsole(const TDesC& aNotification,TBool aPageSwitch,TRefByValue<const TDesC> aFmt,...)

 	//function for output of a string to console aPageSwitch flag indicates that output should be page-by-page 

 	//if aPageSwitch==ETrue user will be prompted with the message passed as aNotification

 	//code of key pressed will be returned as a return value

 	{

 	//create variable to store code of the key pressed by the user

 	TKeyCode key=EKeyNull;	

 	//create an object to truncate argument list substitution 

 	SimpleOverflowTruncate overflow;

 	VA_LIST list;

 	VA_START(list,aFmt);

 	TBuf<0x200> aBuf;

 	//format output string using argumen list

 	//coverity[uninit_use_in_call]

 	TRAP_IGNORE(aBuf.AppendFormatList(aFmt,list,&overflow)); // ignore leave in TTimeOverflowLeave::Overflow()

 	//if we are requested to wait for the user input at the end of each page, we check whether output of next piece of text will fit into the screen

 	if (aPageSwitch)

 		{

 		key=PageSwitchDisplay(aNotification);				

 		}

 	//output current string

 	TheConsole->Write(aBuf);

 	return key;			

 	}

 TKeyCode CShell::OutputStringToConsole(TBool aPageSwitch, const TDesC& aBuf)

 	{

 	_LIT(KPrompt , "Press any key to continue\n");

     TKeyCode key=EKeyNull;	

 	//if we are requested to wait for the user input at the end of each page, we check whether output of next piece of text will fit into the screen

 	if (aPageSwitch)

 		{

 		key = PageSwitchDisplay(KPrompt);				

 		}

 	//output current string

 	TheConsole->Write(aBuf);

     return key;

 	}

 TKeyCode CShell::PageSwitchDisplay(const TDesC& aNotification)

 	{

 	//create variable to store code of the key pressed by the user

 	TKeyCode key=EKeyNull;	

     //obtain a current cursor position

 	TInt line_count=TheConsole->WhereY();

     //calculate how many lines is needed to output current string in the current screen rect

 	TInt add=(TheConsole->WhereX()+aNotification.Length())/(TheConsole->ScreenSize().iWidth-2);				

 	if ((TheConsole->WhereX()+aNotification.Length())%(TheConsole->ScreenSize().iWidth-2)) 

 		{

 		add+=1;				

 		}	

 	//if we will not fit into the screen after output of the current string, then we should prompt for the user input to start new page 

 	TInt notification_height=aNotification.Length()/(TheConsole->ScreenSize().iWidth-2);//we provide 2 additional characters for the frame				

 	if (aNotification.Length()%(TheConsole->ScreenSize().iWidth-2)) 

 		{

 		notification_height+=1;	

 		}

 	if (add<(TheConsole->ScreenSize().iHeight-2))

 	if ((line_count+add+notification_height)>=(TheConsole->ScreenSize().iHeight-4))

 		{

 		TInt previous_cursor_pos_x=TheConsole->WhereX();

 		TheConsole->Printf(_L("%S"),&aNotification);

 		key=TheConsole->Getch();

 		TheConsole->ClearScreen();

 		TheConsole->SetCursorPosAbs(TPoint (previous_cursor_pos_x,0)) ;			

 		}						

 	return key;			

 	}