// Copyright (c) 1998-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:

 // e32utils\profiler\profiler.cpp

 // 

 //

 #include <e32cons.h>

 #include <f32file.h>

 #include "profiler.h"

 #include "sampler.h"

 // The name of the output file use to save the sample data

 _LIT(KFileName,"?:\\PROFILER.DAT");

 const TInt KFileNameLen=15;

 // The name of the DLL used as an alternative UI controller

 _LIT(KProfilerKeysDll,"ProfilerKeys");

 // The size of the buffers used for reading sample data and writing to file

 const TInt KBufferSize = 0x800;

 // The sample rate used by the profiler

 const TInt KSampleRate = 1000;

 const TInt KCommandMask  = 0x00ff;

 const TInt KCommandNone  = 0x0010;

 const TInt KCommandNoUi  = 0x0100;

 const TInt KCommandXIPOnly = 0x0200;

 // The controller class used to provide the Profiler functions.

 // This runs as a server in the engine thread

 class CPServer : public CServer2, public MProfilerController

 	{

 public:

 	static MProfilerController* NewL(TInt aPriority, MProfilerEngine& aEngine);

 private:

 	CPServer(TInt aPriority, MProfilerEngine& aEngine);

 	void Release();

 	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

 	};

 // The session class used by the server controller

 class CPSession : public CSession2

 	{

 private:

 	inline const CPServer& Server() const;

 	void ServiceL(const RMessage2& aMessage);

 	};

 // The default UI controller class which uses a Console

 class CConsole : public CActive, private MProfilerController

 	{

 public:

 	static MProfilerController* NewL(TInt aPriority, MProfilerEngine& aEngine);

 private:

 	CConsole(TInt aPriority, MProfilerEngine& aEngine);

 	void ConstructL();

 	~CConsole();

 	void Release();

 //

 	void Help();

 	void Queue();

 //

 	void RunL();

 	void DoCancel();

 private:

 	CConsoleBase* iConsole;

 	};

 // The buffers used for transferring data from the device driver to the file

 struct TBuffer

 	{

 	TBuffer* iNext;

 	TBuf8<KBufferSize> iBuf;

 	};

 class CProfiler;

 // The active object responsible for reading data from the device

 class CReader : public CActive

 	{

 public:

 	CReader(TInt aPriority, CProfiler& aProfiler);

 	~CReader();

 //

 	void ConstructL();

 	void Queue(TBuffer* aBuf);

 private:

 	void RunL();

 	void DoCancel();

 private:

 	CProfiler& iProfiler;

 	TBuffer* iBuf;

 public:

 	RSampler iSampler;

 	};

 // The active object responsible for writing data out (to file)

 class CWriter : public CActive

 	{

 public:

 	CWriter(TInt aPriority, CProfiler& aProfiler);

 	~CWriter();

 	void ConstructL();

 	TInt Open(const TDesC& aFile);

 	void Close();

 	void Queue(TBuffer* aBuf);

 private:

 	void RunL();

 	void DoCancel();

 private:

 	CProfiler& iProfiler;

 	TBuffer* iBuf;

 	RFile iFile;

 	RFs iFs;

 	};

 // The profiler engine itself.

 class CProfiler : public CBase, private MProfilerEngine

 	{

 	enum {EControlPriority = 10, EReaderPriority = 0, EWriterPriority = -10};

 	/** Specifies the state of the engine*/

 	enum TState 

 		{

 		/**

 		Initial state. The file is closed. Driver is inactive

 		*/

 		EClosed,

 		/**

 		Engine enters this state on client's Start request (if -xiponly is not specified).

 		Opens the file.

 		Resets the driver and nonXIP code segments.

 		Sends GetSegments calls to the driver until driver returns zero length reply.

 		Leaves this state (goes into ERunning) when the last data (obtained by GetSegment) is

 		written into the file.		 

 		*/

 		EGettingSegments,

 		/**

 		Sends async. read request to the driver. Once completed, it immediately sends another while 

 		writing the collected records into the file.

 		*/

 		ERunning,

 		/**

 		Get into this state from ERunning on the client's Stop, Close or Exit request.

 		Sends Drain calls to the driver until driver returns zero length reply.

 		Leaves this state when all records are written into the file.

 		*/

 		EDraining,

 		/**

 		No active calls to the driver. On the client's Start request, will go back into ERunning mode.

 		*/

 		EStopped,

 		/**

 		Get into this state on client's Close or Exit request.

 		Sends a single GetErrorReport request to the driver. After data has been recorded into the file,

 		it closes the file and goes into EClosed state or terminates application..

 		*/

 		EGettingErrors

 		};

 public:

 	static CProfiler* NewLC(TInt aCmd, TDesC* aDrive);

 //

 	TInt Control(Profiler::TState aCommand);

 //

 	void ReadComplete(TBuffer* aBuf);

 	void WriteComplete(TBuffer* aBuf);

 private:

 	CProfiler();

 	~CProfiler();

 	void ConstructL(TInt aCmd, TDesC* aDrive);

 	MProfilerController* CreateUiL();

 //

 	void Read();

 	void Write();

 	TBool GetSegments();

 	TBool Drain();

 	void GetErrors();

 //

 	Profiler::TState State() const;

 private:

 	CReader* iReader;

 	CWriter* iWriter;

 	MProfilerController* iServer;

 	RLibrary iUiCode;

 	MProfilerController* iUi;

 	TState iState;

 	TBool iXIPOnly;

 	Profiler::TState iLastCommand;

 //

 	// The FIFO queue of data that has to be written

 	TBuffer* iHead;

 	TBuffer* iTail;

 //

 	// The LIFO list of free buffers 

 	TBuffer* iFree;

 	TDesC* iDrive;

 	};

 CProfiler* CProfiler::NewLC(TInt aCmd, TDesC* aDrive)

 	{

 	CProfiler* self = new(ELeave) CProfiler;

 	CleanupStack::PushL(self);

 	self->ConstructL(aCmd, aDrive);

 	return self;

 	}

 CProfiler::CProfiler()

 	{}

 CProfiler::~CProfiler()

 	{

 	delete iReader;

 	delete iWriter;

 	if (iServer)

 		iServer->Release();

 	if (iUi)

 		iUi->Release();

 	iUiCode.Close();

 	// discard the buffers in the free list

 	TBuffer* b=iFree;

 	while (b)

 		{

 		TBuffer* n = b->iNext;

 		delete b;

 		b = n;

 		}

 	// discard any buffers in the holding queue

 	b=iHead;

 	while (b)

 		{

 		TBuffer* n = b->iNext;

 		delete b;

 		b = n;

 		}

 	}

 void CProfiler::ConstructL(TInt aCmd, TDesC* aDrive)

 //

 // Build the profiler engine

 //

 	{

 	// Set drive letter of where to store profiler data

 	iDrive = aDrive;

 	// Run the engine at maximum priority to try and ensure that the sampler device

 	// does not get choked and start dropping samples

 	RThread me;

 	me.SetPriority(EPriorityRealTime);

 	User::LeaveIfError(User::RenameThread(KProfilerName));

 	CActiveScheduler::Install(new(ELeave) CActiveScheduler);

 	iReader = new(ELeave) CReader(EReaderPriority,*this);

 	iReader->ConstructL();

 	iWriter = new(ELeave) CWriter(EWriterPriority,*this);

 	iWriter->ConstructL();

 	iServer = CPServer::NewL(EControlPriority,*this);

 	if (!(aCmd & KCommandNoUi))

 		iUi = CreateUiL();

 	// Start off with two buffers in the free list for sample data

 	TBuffer* buf = new(ELeave) TBuffer;

 	buf->iNext = 0;

 	iFree = buf;

 	buf = new(ELeave) TBuffer;

 	buf->iNext = iFree;

 	iFree = buf;

 	// idenify the running mode

 	iXIPOnly = aCmd & KCommandXIPOnly;

 	// start profiling if requested

 	if ((aCmd & KCommandMask) == Profiler::EStart)

 		User::LeaveIfError(Control(Profiler::EStart));

 	}

 MProfilerController* CProfiler::CreateUiL()

 //

 // deal with the UI acquisition part of construction

 // If ProfilerKeys.Dll is available, use it; otherwise create a text console

 //

 	{

 	_LIT(KWindowServerName,"*WindowServer");

 	TFindServer find(KWindowServerName);

 	TFullName n;

 	if (find.Next(n) == KErrNotFound)

 		{

 		// No UI on this device [yet]. Run without one.

 		return 0;

 		}

 	if (iUiCode.Load(KProfilerKeysDll,TUidType(KNullUid, KUidProfilerKeys)) == KErrNone)

 		{

 		TProfilerControllerFactoryL factoryL = TProfilerControllerFactoryL(iUiCode.Lookup(1));

 		MProfilerController* ui = NULL;

 		TRAPD(error, ui = factoryL(EControlPriority, *this));

 		if (error == KErrNone)

 			return ui;

 		// Couldn't create alternative UI, so use the console

 		iUiCode.Close();

 		}

 	return CConsole::NewL(EControlPriority, *this);

 	}

 TInt CProfiler::Control(Profiler::TState aCommand)

 //

 // Handle a command from one of the controllers.

 // This method specifies the flow of the engine state (iState attr).

 // The most of transtions is not performed immediately but after all 

 // current data are recorded into the file - see WriteComplete method.

 //

 	{

 	DEBUG_PROFILER(RDebug::Printf("*CTRL %d",iState);)

 	TInt r = KErrNone;

 	Profiler::TState oldCommand = iLastCommand;

 	//Record the command. In most cases, it is WriteComplete method

 	//to perform state transition (based on this value)

 	iLastCommand = aCommand;

 	switch (aCommand)

 		{

 	case Profiler::EStart:

 		switch (iState)

 			{

 		case EClosed:

 			{

 			// Set the path of the output file to include the drive letter

 			// specified at the command line or the default

 			TBuf<KFileNameLen> path;

 			path.Copy(KFileName);

 			path[0] = (*iDrive)[0];

 		 	r = iWriter->Open(path);

 			}

 			if (KErrNone != r)	 	// Re-open the file

 				return r;

 			iReader->iSampler.Reset(iXIPOnly);				// Reset the sampler

 			if(iXIPOnly)

 				{

 				iState = ERunning;

 				iReader->iSampler.Start(KSampleRate);		// Start sampler

 				if (!iReader->IsActive())

 					Read();									// Start reading

 				}

 			else	

 				{

 				iState = EGettingSegments;

 				iReader->iSampler.ResetSegments();			// Reset segments

 				GetSegments();								// Start getting segments

 				}

 			break;

 		case EStopped:

 			iState = ERunning;

 			iReader->iSampler.Start(KSampleRate);			// Start sampler

 			if (!iReader->IsActive())

 				Read();										//Start reading

 			break;

 		case ERunning:			//Already started. No action required.

 		case EGettingSegments:	//Already started. No action required.

 		case EDraining:			//Will restart after draining is completed.

 		case EGettingErrors:    //Will restart after getting errors is completed;

 			break;

 			}

 		break; //end of case Profiler::EStart

 	case Profiler::EStop:

 		switch (iState)

 			{

 		case EClosed:

 		case EGettingErrors:

 			iLastCommand = oldCommand; 		

 			return KErrGeneral; 			//The command makes no sense in this state

 		case ERunning:

 			iReader->iSampler.Stop();		//Stop sampling.

 			break;

 		case EGettingSegments:	//Will do GettingSegments->Running->Stopped transitions

 		case EDraining:			//Stopping already in progress

 		case EStopped:			//Already stopped.

 			break;

 			}

 		break; //end of case Profiler::EStop

 	case Profiler::EClose:

 		switch (iState)

 			{

 		case EStopped:

 			iState = EGettingErrors;

 			GetErrors();

 			break;

 		case ERunning:

 			iReader->iSampler.Stop();

 			break;

 		case EClosed:   		//Already closed.

 		case EGettingErrors:	//Closing in progress

 		case EGettingSegments:

 		case EDraining:

 			break;

 			}

 		break; //end of case Profiler::EStop

 	case Profiler::EUnload:

 		switch (iState)

 			{

 		case EClosed:

 			CActiveScheduler::Stop();	// Terminate application.

 			break;

 		case EStopped:

 			iState = EGettingErrors;

 			GetErrors();

 			break;

 		case ERunning:

 			iReader->iSampler.Stop();

 			break;

 		case EDraining:

 		case EGettingErrors:

 		case EGettingSegments:

 			break;

 			}

 		break;//end of case Profiler::Unload

 		}

 	DEBUG_PROFILER(RDebug::Printf("*CTRL end %d",iState);)

 	return KErrNone;

 	}

 Profiler::TState CProfiler::State() const

 //

 // Report the current state of the engine

 //

 	{

 	switch (iState)

 		{

 	case EGettingErrors:

 	case EStopped:

 		return Profiler::EStop;

 	case EClosed:

 		return Profiler::EClose;

 	default:

 		return Profiler::EStart;

 		}

 	}

 void CProfiler::Read()

 //

 // Pass a free buffer to the reader, allocating one if necessary

 //

 	{

 	TBuffer* buf = iFree;

 	if (buf)

 		iFree = buf->iNext;

 	else

 		{

 		buf = new TBuffer;

 		if(!buf)

 			{

 			RDebug::Print(_L("PROFILER: No more memory ... stopping"));

 			CProfiler::Control(Profiler::EStop);

 			return;

 			}

 		}

 	iReader->Queue(buf);

 	}

 TBool CProfiler::GetSegments()

 //

 // Gets the list of the current non-XIP segments from device.

 // Returns true if zero-length desc is returned, otherwise ...

 // ...passes the buffer to write engine and returns false.

 	{

 	TBuffer* buf = iFree;

 	if (buf)

 		iFree = buf->iNext;

 	else

 		{

 		RDebug::Printf("PROFILER: No available buffer for GetSegments");

 		User::Invariant();

 		}

 	iReader->iSampler.GetSegments(buf->iBuf);

 	if (!buf->iBuf.Length())

 		{

 		buf->iNext = iFree;//Return empty buffer to the free list

 		iFree = buf;

 		return ETrue;

 		}

 	iWriter->Queue(buf);//Pass the buffer to the write engine.

 	return EFalse;

 	}

 TBool CProfiler::Drain()

 //

 // Drains all remaining records from the device

 // Returns true if zero-length desc is returned, otherwise ...

 // ...passes the buffer to the write engine and returns false.

 	{

 	TBuffer* buf = iFree;

 	if (buf)

 		iFree = buf->iNext;

 	else

 		{

 		RDebug::Printf("PROFILER: No available buffer for Drain");

 		User::Invariant();

 		}

 	iReader->iSampler.Drain(buf->iBuf);

 	if (!buf->iBuf.Length())

 		{

 		buf->iNext = iFree;//Return empty buffer to the free list

 		iFree = buf;

 		return ETrue;

 		}

 	iWriter->Queue(buf); //Pass the buffer to the write engine.

 	return EFalse;

 	}

 void CProfiler::GetErrors()

 //

 // Gets error report from the device and pass the buffer to the write engine

 //

 	{

 	TBuffer* buf = iFree;

 	if (buf)

 		iFree = buf->iNext;

 	else

 		{

 		RDebug::Printf("PROFILER: No available buffer for GetErrors");

 		User::Invariant();

 		}

 	iReader->iSampler.GetErrors(buf->iBuf);

 	iWriter->Queue(buf);

 	}

 void CProfiler::Write()

 //

 // Pass a queued buffer to the writer

 //

 	{

 	TBuffer* buf = iHead;

 	iHead = buf->iNext;

 	if (iHead == 0)

 		iTail = 0;

 	iWriter->Queue(buf);

 	}

 void CProfiler::ReadComplete(TBuffer* aBuf)

 //

 // Handle a completed read buffer

 //

 	{

 	DEBUG_PROFILER(RDebug::Printf("*RC %d",iState);)

 	//Add the buffer to the queue

 	aBuf->iNext = 0;

 	if (iTail)

 		iTail->iNext = aBuf;

 	else

 		iHead = aBuf;

 	iTail = aBuf;

 	if (!iWriter->IsActive())

 		Write();

 	if (iLastCommand == Profiler::EStart)

 		Read();	//Request another read

 	DEBUG_PROFILER(RDebug::Printf("*RC end %d",iState);)

 	}

 void CProfiler::WriteComplete(TBuffer* aBuf)

 //

 // Handle a flushed write buffer.

 //

 	{

 	DEBUG_PROFILER(RDebug::Printf("*WC %d",iState);)

 	aBuf->iNext = iFree;//Return empty buffer to the free list

 	iFree = aBuf;

 	switch (iState)

 		{

 	case EGettingSegments:

 		if (!GetSegments())

 			break;//More code segments to be completed

 		//Always go to the running state after the segments are collected....

 		iState = ERunning;

 		iReader->iSampler.Start(KSampleRate);

 		Read();

 		//...but stop sampler immediately if we got another user command 

 		if (iLastCommand != Profiler::EStart)

 			{

 			iReader->iSampler.Stop();

 			}

 		break; //the end of EGettingSegments case

 	case ERunning:

 		if (iHead)

 			{

 			Write(); // There are more buffers to go to the file.

 			break;

 			}

 		if (iLastCommand != Profiler::EStart)

 			{//The user has stopped the profiler.

 			iState = EDraining;

 			if (!Drain())

 				break;//More data to drain.

 			//Drain returned empty. May progress further with the engine state

 			if (iLastCommand == Profiler::EStop)

 				iState = EStopped;

 			else

 				{

 				iState = EGettingErrors;

 				GetErrors();

 				}

 			}

 		break;//the end of ERunning case

 	case EDraining:

 		if (!Drain())

 			break; //still draining;

 		//Drain is completed

 		switch (iLastCommand)

 			{

 		case Profiler::EStart:

 			//While draining, we received another Start command	

 			iState = ERunning;

 			iReader->iSampler.Start(KSampleRate);

 			Read();

 			break;

 		case Profiler::EStop:

 			iState = EStopped;

 			break;

 		default:			

 			iState = EGettingErrors;

 			GetErrors();

 			}

 		break; //the end of EDraining case

 	case EGettingErrors:

 		iWriter->Close();

 		iState = EClosed;

 		switch (iLastCommand)

 			{

 		case Profiler::EUnload:

 			CActiveScheduler::Stop(); //Terminate application.

 			break;

 		case Profiler::EStart:

 			Control(Profiler::EStart);

 			break;			

 		default:

 			break;			

 			}

 		break; //the end of EGettingErrors case

 	default:

 		RDebug::Printf("PROFILER: WriteComplete in %d state", iState);

 		User::Invariant();

 		break;

 		}

 	DEBUG_PROFILER(RDebug::Printf("*WC end %d",iState);)

 	}

 CReader::CReader(TInt aPriority, CProfiler& aProfiler)

 	:CActive(aPriority), iProfiler(aProfiler)

 	{

 	CActiveScheduler::Add(this);

 	}

 CReader::~CReader()

 	{

 	Cancel();

 	delete iBuf;

 	iSampler.Close();

 	User::FreeLogicalDevice(KSamplerName);

 	}

 void CReader::ConstructL()

 	{

 	TInt r=User::LoadLogicalDevice(KSamplerName);

 	if (r!=KErrNone && r!=KErrAlreadyExists)

 		User::Leave(r);

 	User::LeaveIfError(iSampler.Open());

 	}

 void CReader::RunL()

 //

 // Pass the full buffer to the engine

 //

 	{

 	TBuffer* data=iBuf;

 	iBuf = 0;

 	iProfiler.ReadComplete(data);

 	}

 void CReader::DoCancel()

 	{

 	iSampler.ReadCancel();

 	}

 void CReader::Queue(TBuffer* aBuf)

 //

 // Queue a request to read data into the empty buffer

 //

 	{

 	iBuf = aBuf;

 	iSampler.Read(aBuf->iBuf, iStatus);

 	SetActive();

 	}

 CWriter::CWriter(TInt aPriority, CProfiler& aProfiler)

 	:CActive(aPriority), iProfiler(aProfiler)

 	{

 	CActiveScheduler::Add(this);

 	}

 CWriter::~CWriter()

 	{

 	Cancel();

 	delete iBuf;

 	iFile.Close();

 	iFs.Close();

 	}

 void CWriter::ConstructL()

 	{

 	User::LeaveIfError(iFs.Connect());

 	}

 TInt CWriter::Open(const TDesC& aFile)

 //

 // Open the file for saving the sample data

 //

 	{

 	return iFile.Replace(iFs,aFile,EFileWrite);

 	}

 void CWriter::Close()

 //

 // Release the file

 //

 	{

 	iFile.Close();

 	}

 void CWriter::Queue(TBuffer* aBuf)

 //

 // Queue a request to write the full buffer into the file

 //

 	{

 	iBuf = aBuf;

 	iFile.Write(aBuf->iBuf, iStatus);

 	SetActive();

 	}

 void CWriter::RunL()

 //

 // Return the empty buffer back to the engine

 //

 	{

 	TBuffer* data=iBuf;

 	iBuf = 0;

 	iProfiler.WriteComplete(data);

 	}

 void CWriter::DoCancel()

 //

 // RFile does not provide a WriteCancel() function

 //

 	{}

 // Server controller

 inline const CPServer& CPSession::Server() const

 	{return *static_cast<const CPServer*>(CSession2::Server());}

 void CPSession::ServiceL(const RMessage2& aMessage)

 //

 // Handle a IPC request to control the profiler

 //

 	{

 	aMessage.Complete(Server().Control(Profiler::TState(aMessage.Function())));

 	}

 MProfilerController* CPServer::NewL(TInt aPriority, MProfilerEngine& aEngine)

 //

 // Create and start the server to provide the Profiler interface

 //

 	{

 	CPServer* self = new(ELeave) CPServer(aPriority, aEngine);

 	CleanupStack::PushL(self);

 	self->StartL(KProfilerName);

 	CleanupStack::Pop();

 	return self;

 	}

 CPServer::CPServer(TInt aPriority, MProfilerEngine& aEngine)

 	:CServer2(aPriority), MProfilerController(aEngine)

 	{}

 void CPServer::Release()

 	{

 	delete this;

 	}

 CSession2* CPServer::NewSessionL(const TVersion&,const RMessage2&) const

 	{

 	return new(ELeave) CPSession();

 	}

 // Console Controller

 MProfilerController* CConsole::NewL(TInt aPriority, MProfilerEngine& aEngine)

 //

 // Create and start the console UI for the profiler

 //

 	{

 	CConsole* self = new(ELeave) CConsole(aPriority, aEngine);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 CConsole::CConsole(TInt aPriority, MProfilerEngine& aEngine)

 	:CActive(aPriority), MProfilerController(aEngine)

 	{

 	CActiveScheduler::Add(this);

 	}

 void CConsole::ConstructL()

 	{

 	iConsole = Console::NewL(KProfilerName, TSize(KConsFullScreen,KConsFullScreen));

 	Help();

 	Queue();

 	}

 CConsole::~CConsole()

 	{

 	Cancel();

 	delete iConsole;

 	}

 void CConsole::Release()

 	{

 	delete this;

 	}

 void CConsole::Help()

 //

 // Display the instructions on the console

 //

 	{

 	_LIT(KInstructions,"[S]tart, Sto[p], [C]lose or E[x]it\r\n");

 	iConsole->Write(KInstructions);

 	}

 void CConsole::Queue()

 //

 // Request a key press from the console

 //

 	{

 	iConsole->Read(iStatus);

 	SetActive();

 	}

 void CConsole::RunL()

 //

 // Handle a key press from the console

 //

 	{

 	TInt key = iConsole->KeyCode();

 	Queue();

 	Profiler::TState command;

 	switch (key)

 		{

 	case 's': case 'S':

 		command = Profiler::EStart;

 		break;

 	case 'p': case 'P':

 		command = Profiler::EStop;

 		break;

 	case 'c': case 'C':

 		command = Profiler::EClose;

 		break;

 	case 'x': case 'X':

 		command = Profiler::EUnload;

 		break;

 	case '?': case 'h': case 'H':

 		Help();

 		return;

 	default:

 		return;

 		}

 	Control(command);

 	}

 void CConsole::DoCancel()

 	{

 	iConsole->ReadCancel();

 	}

 void MainL(TInt aCmd, TDesC* aDrive)

 //

 // Construct and run the profile engine

 //

 	{

 	CProfiler* p = CProfiler::NewLC(aCmd, aDrive);

 	CActiveScheduler::Start();

 	CleanupStack::PopAndDestroy(p);

 	}

 TInt GetCommand(TDes &aDrive)

 //

 // Decode the command line arguments into a profiler control request

 //		aDrive is the drive number to store the profiler data on

 //

 	{

 	_LIT(KStart,"start");

 	_LIT(KStop,"stop");

 	_LIT(KClose,"close");

 	_LIT(KUnload,"unload");

 	_LIT(KExit,"exit");

 	_LIT(KNoUi,"-noui");

 	_LIT(KXIPOnly,"-xiponly");

 	_LIT(KDrive,"-drive=");

 	const TInt KDriveOffset=7;

 	TBuf<64> c;

 	User::CommandLine(c);

 	TInt cmd = 0;

 	if (c.FindF(KNoUi) >= 0)

 		cmd |= KCommandNoUi;

 	if (c.FindF(KXIPOnly) >= 0)

 		cmd |= KCommandXIPOnly;

 	// get the drive letter if any

 	TInt pos = c.FindF(KDrive);

 	if(pos >= 0)

 		{

 		pos += KDriveOffset;

 		TBuf<1> driveLet;

 		driveLet.SetLength(1);

 		driveLet[0] = c[pos];

 		driveLet.UpperCase();

 		if (driveLet[0] >= 'A' && driveLet[0] <= 'Z')

 			{

 			aDrive[0] = driveLet[0];

 			}

 		}

 	if (c.FindF(KStart) >= 0)

 		return cmd | Profiler::EStart;

 	if (c.FindF(KStop) >= 0)

 		return cmd | Profiler::EStop;

 	if (c.FindF(KClose) >= 0)

 		return cmd | Profiler::EClose;

 	if (c.FindF(KUnload) >= 0)

 		return cmd | Profiler::EUnload;

 	if (c.FindF(KExit) >= 0)

 		return cmd | Profiler::EUnload;

 	return cmd | KCommandNone;

 	}

 TInt E32Main()

 //

 // Profiler.exe entry point

 // Decode any command-line argument - which can be used to control a running profile engine

 // Otherwise start the engine in this process

 //

 	{

 	TBuf<1> drive;

 	drive.SetLength(1);

 	drive[0] = 'C';

 	TInt command = GetCommand(drive);

 	if ((command & KCommandMask) != KCommandNone)

 		{

 		TInt r = Profiler::Control(Profiler::TState(command & KCommandMask));

 		if (r != KErrNotFound || (command & KCommandMask) != Profiler::EStart)

 			return r;

 		}

 	CTrapCleanup::New();

 	TRAPD(r,MainL(command, &drive));

 	if (r != KErrNone)

 		RDebug::Print(_L("PROFILER: Error starting profiler"));

 	return r;

 	}