diff -r 000000000000 -r 96e5fb8b040d userlibandfileserver/fileserver/etshell/ts_edshl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/etshell/ts_edshl.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1315 @@
+// 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<0x140> 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<0x140> 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;			
+	}