// 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:
// e32\euser\cbase\ub_act.cpp
// 
//

#include "ub_std.h"
#include "us_data.h"

#ifdef __SMP__
#include <e32atomics.h>
#endif



#pragma warning( disable : 4705 )	// statement has no effect
EXPORT_C CActive::CActive(TInt aPriority)
/**
Constructs the active object with the specified priority.

Derived classes must define and implement a constructor through which the
priority can be specified. A typical implementation calls this active object
constructor through a constructor initialization list.

@param aPriority An integer specifying the priority of this active object.
                 CActive::TPriority defines a standard set of priorities.
*/
	{
	iLink.iPriority=aPriority;
	}
#pragma warning( default : 4705 )




EXPORT_C CActive::~CActive()
/**
Frees resources prior to destruction.

Specifically, it removes this active object from the active scheduler's
list of active objects.

Typically, a derived class calls Cancel() in its destructor.

@panic E32USER-CBase 40 if the active object has an outstanding request when
       the destructor is called,

@see CActive::Cancel
*/
	{
	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(EReqStillActiveOnDestruct));
	if (IsAdded())
		iLink.Deque();
	}




EXPORT_C void CActive::Cancel()
/**
Cancels the wait for completion of an outstanding request.

If there is no request outstanding, then the function does nothing.

If there is an outstanding request, the function:

1. calls the active object's DoCancel() function, provided by
   the derived class to implement cancellation of the request.

2. waits for the cancelled request to complete; this must complete as fast as
   possible.

3. marks the active object's request as complete (i.e. the request is no longer
   outstanding).

@see CActive::DoCancel
@see CActive::IsActive
@see CActive::~CActive
@see User::WaitForRequest
*/
	{
	if (iStatus.iFlags&TRequestStatus::EActive)
		{
		DoCancel();
		User::WaitForRequest(iStatus);
    	iStatus.iFlags&=~(TRequestStatus::EActive | TRequestStatus::ERequestPending); //iActive=EFalse;
		}
	}




EXPORT_C void CActive::Deque()
/**
Removes the active object from the active scheduler's list of active objects.

Before being removed from the active scheduler's list, the function cancels
any outstanding request.

@see CActive::Cancel
*/
	{
	__ASSERT_ALWAYS(IsAdded(),Panic(EActiveNotAdded));
	Cancel();
	iLink.Deque();
	iLink.iNext=NULL; // Must do this or object cannot be re-queued
	}




EXPORT_C void CActive::SetActive()
/**
Indicates that the active object has issued a request and that
it is now outstanding.

Derived classes must call this function after issuing a request.

A request is automatically marked as complete (i.e. it is no longer
outstanding) by:

1. the active scheduler, immediately before it calls the active object's RunL()
   function.

or

2. the active object within the implementation of the Cancel() function.

E32USER-CBase 46 panics may occur if an active object is set active but
no request is made on its TRequestStatus, or vice-versa. This panic happens
no earlier than the next time that the active scheduler assesses which
objects are ready to run, and may happen much later. This panic is termed 
a 'stray event' because it indicates that some entity has sent an event 
to this thread, but this thread is not in a state ready to handle it.

@see CActive::IsActive
@see CActive::RunL
@see CActive::Cancel

@panic E32USER-CBase 42 if this active object is already active
@panic E32USER-CBase 49 if this active object has not been added to the active
       scheduler.
*/
	{
	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(EReqAlreadyActive));
	__ASSERT_ALWAYS(IsAdded(),Panic(EActiveNotAdded));
	iStatus.iFlags|=TRequestStatus::EActive;
	}




EXPORT_C void CActive::SetPriority(TInt aPriority)
/**
Sets the priority of the active object.

@param aPriority An integer specifying the new priority of this active object.
                 CActive::TPriority defines a standard set of priorities.

@panic E32USER-CBase 50 if this function is called while a request
       is outstanding.
*/
	{
	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(ESetPriorityActive));
	iLink.iPriority=aPriority;
	if (IsAdded())
		{
		Deque();
		iLink.iNext=NULL; // Make this not added
		CActiveScheduler::Add(this);
		}
	}




EXPORT_C TInt CActive::RunError(TInt aError)
/**
Handles a leave occurring in the request completion event handler RunL().

The active scheduler calls this function if this active object's RunL()
function leaves. This gives this active object the opportunity to perform
any necessary cleanup.

A derived class implementation should handle the leave and return KErrNone.
Returning any other value results in the active scheduler function
CActiveScheduler::Error() being called.

The default implementation simply returns the leave code.

Note that if the active scheduler is to handle the error, a suitably derived
CActiveScheduler::Error() function must be supplied.

@param aError The leave code

@return The default implementation returns aError. A derived class
        implementation should return KErrNone, if it handles the leave;
        otherwise it should return any suitable value to cause the handling
        of the error to be propagated back to the active scheduler.

@see CActiveScheduler::Error
*/
	{
	return aError;
	}




/**
Extension function


*/
EXPORT_C TInt CActive::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
	{
	return CBase::Extension_(aExtensionId, a0, a1);
	}




EXPORT_C CIdle* CIdle::New(TInt aPriority)
/**
Allocates and initialises an Idle time active object and adds it to the active
scheduler.

@param aPriority An integer specifying the priority of this active object.
                 It must be lower than that of all other active objects on
                 the active scheduler.
                 The value CActive::TPriority::EPriorityIdle is recommended.

@return Pointer to the new Idle time active object, or NULL if the object could
        not be created.
*/
	{
	CIdle *pI=new CIdle(aPriority);
	if (pI!=NULL)
		CActiveScheduler::Add(pI);
	return(pI);
	}




EXPORT_C CIdle* CIdle::NewL(TInt aPriority)
/**
Allocates and initialises an Idle time active object, adds it to the active
scheduler, but leaves on failure.

@param aPriority An integer specifying the priority of this active object.
                 It must be lower than that of all other active objects on
                 the active scheduler.
                 The value CActive::TPriority::EPriorityIdle is recommended.

@return Pointer to the new Idle time active object.
*/
	{
	CIdle *pI=new(ELeave) CIdle(aPriority);
	CActiveScheduler::Add(pI);
	return(pI);
	}





EXPORT_C CIdle::CIdle(TInt aPriority)
	: CActive(aPriority)
/**
Protected constructor taking a priority value.

Sets this active object's priority value.

@param aPriority The active object priority value.
*/
	{}




EXPORT_C CIdle::~CIdle()
/**
Frees resources prior to destruction.

Specifically, it cancels any outstanding request.
*/
	{
	Cancel();
	}




EXPORT_C void CIdle::Start(TCallBack aCallBack)
/**
Starts the background task.

The background task is encapsulated in the callback. The function represented
by this callback is called every time this Idle time active object is scheduled
to run.

The callback function should be structured to perform a background task in
many increments, i.e. it should voluntarily relinquish control (i.e. return)
after a suitable time interval to allow other, higher priority events to be
handled.

If the callback function has further work to do, it should return a true value.
This ensures that the active object is scheduled to run again later.

Once the callback function has finally completed its work, it should return
a false value. The active object is then no longer scheduled to run.

@param aCallBack A callback object encapsulating a function which is called
                 when no higher priority active object is ready to run.
*/
	{
	iCallBack=aCallBack;
	iStatus=KRequestPending;
	TRequestStatus *pS=(&iStatus);
	User::RequestComplete(pS,0);
	SetActive();
	}




EXPORT_C void CIdle::RunL()
/**
Handles this idle active object's request completion event.

It is called when nothing of a higher priority can be scheduled.

@see CActive::RunL
*/
	{
	if (iCallBack.CallBack())
		Start(iCallBack);
	}




EXPORT_C void CIdle::DoCancel()
/**
Implements the cancellation of an outstanding request.

This function is called by the active object's Cancel() function.

@see CActive::DoCancel
*/
	{
	}




EXPORT_C void CAsyncOneShot::Call()
/**
Queues this active object to be run once.

@panic E32USER-CBase 2 In debug builds only, if this active object has not
       already been added to the active scheduler.
*/
	{
	__ASSERT_DEBUG(IsAdded(),Panic(ECAsyncOneShotNotAdded));
	TRequestStatus *pS=(&iStatus);
	iStatus = KRequestPending;
	SetActive();
	iThread.RequestComplete(pS,0);
	}




EXPORT_C void CAsyncOneShot::DoCancel()
/**
Implements cancellation of an outstanding request.

The class provides an empty implementation.

This is called by the destructor.
*/
	{
	// Empty
	}




EXPORT_C CAsyncOneShot::CAsyncOneShot(TInt aPriority)
	:CActive(aPriority)
/**
Constructor taking a priority value.

Specifically, the constructor:

1. sets this active object's priority value

2. opens a handle to the current thread to ensure that the thread cannot be
   closed until this CAsyncOneShot object is destroyed

3. adds this active object to the current active scheduler.

@param aPriority The active object priority value. CActive::TPriority defines
                 a standard set of priorities.

@panic E32USER-CBase 93 if the attempt to open a handle to the current thread
       fails.
*/
	{
	Setup();
	}




void CAsyncOneShot::Setup()
//
// ensures that we are added to the Scheduler.
//
	{
	// No error checking was done initially.  As this function is called from
	// the c'tor, there is no way to fix it properly without breaking BC.  So
	// we panic if something goes wrong (should only happen in extreme
	// circumstances if the kernel heap is exhausted or heavily fragmented).
	__ASSERT_ALWAYS(iThread.Duplicate(RThread()) == KErrNone, Panic(EAsyncOneShotSetupFailed));

	// Add ourself to the current active scheduler
	// This is because we might be being used as an inter thread call
	// we need to make sure that we're on the correct scheduler for
	// the RThread were going to duplicate.
	CActiveScheduler::Add(this);
	}




EXPORT_C CAsyncOneShot::~CAsyncOneShot()
/**
Frees resources prior to destruction.

Specifically, it closes the handle to the current thread.

@see CActive::~CActive
*/
	{
	Cancel();
	iThread.Close();
	}




EXPORT_C CAsyncCallBack::CAsyncCallBack(TInt aPriority)
	: CAsyncOneShot(aPriority), iCallBack(NULL)
/**
Constructor taking a priority value.

Specifically, the constructor sets this active object's priority value through
a call to the base class constructor in its ctor list.

No call back is set, which means that it must be set subsequently through
a call to the Set() function.

@param aPriority The active object priority value. CActive::TPriority defines
                 a standard set of priorities.

@see CAsyncCallBack::Set
*/
	{
	}




EXPORT_C CAsyncCallBack::CAsyncCallBack(const TCallBack& aCallBack, TInt aPriority)
	: CAsyncOneShot(aPriority), iCallBack(aCallBack)
/**
Constructor taking a priority value and a callback.

Specifically, the constructor:

1. sets this active object's priority value through a call to the base class
   constructor in its ctor list

2. sets the callback; the function encapsulated by the callback is called when
   this active object is scheduled to run.

@param aCallBack A reference to a callback object encapsulating a function
                 which is called when this active object is ready to run.
                 The constructor takes a copy of this callback object, which
                 means that it can be safely discarded after construction.
@param aPriority The active object priority value.
*/
	{
	}




EXPORT_C CAsyncCallBack::~CAsyncCallBack()
/**
Destructor.
*/
	{
	}




EXPORT_C void CAsyncCallBack::CallBack()
/**
Queues this active object to be run, if it is not already queued.
*/
	{
	if (!IsActive())
		Call();
	}




EXPORT_C void CAsyncCallBack::Set(const TCallBack& aCallBack)
/**
Sets the call back.

@param aCallBack A reference to a callback object encapsulating a function
                 which is called when this active object is ready to run.

@panic E32USER-CBase 1 if the active object is currently active.
*/
	{
	__ASSERT_ALWAYS(!IsActive(), Panic(ECAsyncCBIsActive));
	iCallBack = aCallBack;
	}




void CAsyncCallBack::RunL()
/**
Calls the callback function.

@see TCallBack::CallBack
*/
	{
	iCallBack.CallBack();
	}




struct CActiveScheduler::TLoop
	{
	TLoop* iNext;
	CActiveScheduler::TLoopOwner* iOwner;
	TCallBack iCallback;
	TInt iExitCode;
	};

CActiveScheduler::TLoopOwner* const KLoopNoOwner=reinterpret_cast<CActiveScheduler::TLoopOwner*>(1);
CActiveScheduler::TLoopOwner* const KLoopInactive=0;




EXPORT_C CActiveSchedulerWait::CActiveSchedulerWait()
/**
Default constructor.
*/
	{}





EXPORT_C CActiveSchedulerWait::~CActiveSchedulerWait()
/**
Ensures that the attached scheduler loop, and all nested loops, are stopped
prior to destruction.

@see AsyncStop()
*/
	{
	if (IsStarted())
		AsyncStop();
	}




EXPORT_C void CActiveSchedulerWait::Start()
/**
Starts a new wait loop under the control of the current active scheduler.

Compared with CActiveScheduler::Start(), this object owns control of
the scheduling loop that is started, and that loop can only be stopped
by using this objects AsyncStop() function or the CActiveScheduler::Halt()
function. Start() only returns when either of thos has occurred.

This is the preferred way to start a nested wait loop. Typically, a nested
wait loop is used when the handling of a completed event in an active object
requires processing further events from the other active objects before it
can complete. This is a form of modal processing.

@panic E32USER-CBase 44 if the thread does not have an active scheduler installed.
@panic E32USER-CBase 91 if this object has already been started.

@see CActiveSchedulerWait::AsyncStop
@see CActiveSchedulerWait::IsStarted
@see CActiveScheduler::Start
@see CActiveScheduler::Halt
*/
	{
	__ASSERT_ALWAYS(!IsStarted(), Panic(EActiveSchedulerWaitAlreadyStarted));		// can only start a CActiveSchedulerWait if it isn't already started
	CActiveScheduler::Start(&iLoop);
	}




EXPORT_C void CActiveSchedulerWait::AsyncStop()
/**
Stops the scheduling loop owned by this object.

Note that the corresponding call to Start() only returns once all nested
scheduler loops have stopped.

@panic E32USER-CBase 92 if the wait object has not been started.
*/
	{
	AsyncStop(TCallBack());
	}




EXPORT_C void CActiveSchedulerWait::AsyncStop(const TCallBack& aCallMeWhenStopped)
/**
Stops the scheduling loop owned by this object, specifying a callback.

This version of AsyncStop() provides a callback which is invoked immediately
after the scheduler loop actually stops before the corresponding call
to Start() returns.

Note that the corresponding call to Start() only returns once all nested
scheduler loops have stopped.

@param aCallMeWhenStopped The callback to invoke when the scheduler loop exits.

@panic E32USER-CBase 92 if the wait object has not been started.
 */
	{
	CActiveScheduler::TLoopOwner loop=iLoop;
	__ASSERT_ALWAYS(loop, Panic(EActiveSchedulerWaitNotStarted));		// can only stop a CActiveSchedulerWait if it's started
	__ASSERT_DEBUG(loop->iOwner==&iLoop, User::Invariant());

	loop->iCallback = aCallMeWhenStopped;
	loop->iOwner = KLoopInactive;			// disconnect from owner
	iLoop = 0;
	}




EXPORT_C TBool CActiveSchedulerWait::CanStopNow() const
/**
Reports whether stopping will have immediate effect.

This returns an indication of whether a call to AsyncStop() would be
expected to stop the scheduler loop immediately, or whether it will
have to wait until nested scheduler loops have stopped. This may alter
which version of AsyncStop() you would want to call.

@return Boolean indicating if the scheduling loop would stop immediately.

@panic E32USER-CBase 92 if the wait object has not been started.

@see CActiveSchedulerWait::Start
@see CActiveSchedulerWait::AsyncStop
*/
 	{
	__ASSERT_ALWAYS(IsStarted(), Panic(EActiveSchedulerWaitNotStarted));		// Scheduler must be running
	for (CActiveScheduler::TLoop* loop=GetActiveScheduler()->iStack; loop; loop=loop->iNext)
		{
		if (loop==iLoop)
			return ETrue;
		if (loop->iOwner != KLoopInactive)
			break;
		}
	return EFalse;
	}



EXPORT_C CActiveScheduler::CActiveScheduler()
	: iActiveQ(_FOFF(CActive,iLink))
/**
Constructs an active scheduler.

After construction, the scheduler should be installed.

@see CActiveScheduler::Install
*/
	{}




EXPORT_C CActiveScheduler::~CActiveScheduler()
/**
Frees resources prior to destruction.

Specifically, it removes all active objects from the active scheduler's list
of active objects.

An active scheduler should only be destroyed when the top-level call to Start()
has returned.

@see CActiveScheduler::Start
@see CActiveScheduler::Stop
*/
	{
	while (!iActiveQ.IsEmpty())
		iActiveQ.First()->Deque();
	if (GetActiveScheduler()==this)
		SetActiveScheduler(NULL);
	}




EXPORT_C void CActiveScheduler::Install(CActiveScheduler *aManager)
/**
Installs the specified active scheduler as the current active scheduler.

The installed active scheduler now handles events for this thread.

The current active scheduler can be uninstalled by passing a NULL pointer.

@param aManager A pointer to the active scheduler to be installed.
                If this is NULL, the current active scheduler is uninstalled.

@panic E32USER-CBase 43 if If there is already an installed active scheduler.
*/
	{
	if (aManager!=NULL)
		__ASSERT_ALWAYS(GetActiveScheduler()==NULL,Panic(EReqManagerAlreadyExists));
	SetActiveScheduler(aManager);
	}




EXPORT_C void CActiveScheduler::Add(CActive *aRequest)
/**
Adds the specified active object to the current active scheduler.

An active object can be removed from an active scheduler either by
destroying the active object or by using its Deque() member function.

@param aRequest Pointer to the active object to be added.

@panic E32USER-CBase 41 if the active object aRequest has already been added
       to the current active scheduler.
@panic E32USER-CBase 48 if aRequest is NULL.
@panic E32USER-CBase 44 if the thread does not have an installed
       active scheduler.

@see CActive::Deque
*/
	{
	CActiveScheduler *pS=GetActiveScheduler();
	__ASSERT_ALWAYS(pS!=NULL,Panic(EReqManagerDoesNotExist));
	__ASSERT_ALWAYS(aRequest,Panic(EReqNull));
	__ASSERT_ALWAYS(!aRequest->IsAdded(),Panic(EReqAlreadyAdded));
	pS->iActiveQ.Add(*aRequest);
	}




EXPORT_C void CActiveScheduler::WaitForAnyRequest()
/**
Wait for an asynchronous request to complete.

The default implementation just calls User::WaitForAnyRequest().

Derived classes can replace this. Typically, this would be done to implement
code for maintaining an outstanding request; this would be followed by a call
to User::WaitForAnyRequest().

@see User::WaitForAnyRequest
*/
	{
	User::WaitForAnyRequest();
	}




EXPORT_C void CActiveScheduler::Start()
/**
Starts a new wait loop under the control of the current active scheduler.

At least one active object, with an outstanding request, must be added
to the scheduler before the wait loop is started, otherwise no events
will occur and the thread will hang, or any events that do occur will be
counted as stray signals, raising a panic.

While Start() is executing, user code runs only:

1. in the RunL() function of active objects known to the current active scheduler

2. in the RunError() function of an active object that leaves from its RunL()

3. in the current active scheduler’s Error() function, if an active object’s
   RunError() returns an error code.

Start() returns only when a corresponding Stop() or Halt() is issued.

Although this can be used to start a nested wait loop, this API is deprecated
for that specific functionality, and a CActiveSchedulerWait object should be
used instead.

(Note that a nested wait loop is used when the handling of a completed event
 in an active object requires the processing of further events from the other
 active objects before it can complete. This is a form of modal processing.)

@panic E32USER-CBase 44 if the thread does not have an active
       scheduler installed.

@see CActiveScheduler::Stop
@see CActiveScheduler::Halt
@see CActive::RunL
@see CActive::RunError
@see CActiveScheduler::Error
@see CActiveSchedulerWait
*/
	{
	Start(KLoopNoOwner);
	}




void CActiveScheduler::Start(TLoopOwner* aOwner)
/**
@internalComponent

Start a new nesting level
*/
	{
	CActiveScheduler* pS=GetActiveScheduler();
	__ASSERT_ALWAYS(pS!=NULL, Panic(EReqManagerDoesNotExist));

	// Instantiate the local loop control
	TLoop loop;
	loop.iOwner=aOwner;
	if (aOwner != KLoopNoOwner)
		*aOwner=&loop;
	loop.iNext=pS->iStack;
	pS->iStack=&loop;
	loop.iExitCode=0;

	// Run the scheduler loop
#if 1
	// FIXME!!! Will support old-style leave-from-Error() transiently
	// in order to avoid simultaneous integration requirement.
	// This should be reverted to the conditionally excluded code once
	// fixes have been made elsewhere
	TRAPD(r,pS->Run(loop.iOwner));
	if (r!=KErrNone)
		{
		loop.iExitCode = r;
		TLoopOwner* owner=loop.iOwner;
		if (TUint(owner) > TUint(KLoopNoOwner))
			*owner = NULL;
		}
#else	// fixme
#ifdef _DEBUG
	// catch old-style bad behaviour - leaving from Error()
	TRAPD(r,pS->Run(loop.iOwner));
	__ASSERT_DEBUG(r==KErrNone,User::Invariant());
#else
	pS->Run(loop.iOwner);
#endif
#endif

	pS->iStack=loop.iNext;
	loop.iCallback.CallBack();
	// propagate the exit-code via a leave (yuck, but blame BAFL & co.)
	if (loop.iExitCode)
		User::Leave(loop.iExitCode);
	}

/*
@internalComponent

Dummy Function. This is used as a dummy object to put onto the cleanupstack in order
to check for imbalance in the CActiveScheduler::DoRunL.
 */
void DummyFunc(TAny* /*aPtr*/)
	{}


#ifdef __LEAVE_EQUALS_THROW__
/**
@internalComponent

Start dispatching request completions.

Stop when aLoop becomes 'Inactive'

This version uses the implementation of TRAP/Leave in terms of C++ exceptions.
We have to make sure here that we don't call Active Object's RunError() or Active Scheduler's Error()
while we are still in exception (within 'catch' brackets), as it can lead to nested-exceptions scenario.
It is not fatal by default, but if two nested exceptions are due to OOM condition, RVCT implementation
of exception will run out of emergency buffers and terminate the thread.
*/
void CActiveScheduler::Run(TLoopOwner* const volatile& aLoop)
	{
	CActive * volatile curr_obj = 0;
	TBool leaveException = EFalse;
	TInt exceptionReason = 0;
	do
		{
		try	{
			__WIN32SEHTRAP
			TTrapHandler* t = User::MarkCleanupStack();
			
#ifdef _DEBUG
			//We cache the cleanupstack here do avoid repeated exec calls in DoRunL
			TCleanupTrapHandler *pH=(TCleanupTrapHandler *)GetTrapHandler();
			CCleanup* cleanupPtr=NULL;
			TCleanupBundle cleanupBundle;

			if(pH!=NULL) // test whether there's a CleanupTrapHandler installed
				{
				CCleanup& ccleanup =pH->Cleanup();
				//Store pointer as need the scope of ccleanup increased
				cleanupPtr = &ccleanup; 
				cleanupBundle.iCleanupPtr = cleanupPtr;
				
				//Push a dummy item onto the stack - we check it after the AO's RunL has returned
				//and we check to make sure its still at the top.
				ccleanup.PushL(TCleanupItem(DummyFunc, &(cleanupBundle.iDummyInt)));
				
				DoRunL(aLoop, curr_obj, &cleanupBundle);

				//Dummy Int must (will) be at the top
				//Cleanup our stack
				cleanupPtr->Pop(1);
				} 
			else // no cleanup stack installed
				{
				DoRunL(aLoop, curr_obj, NULL);
				}
			
#else
			DoRunL(aLoop, curr_obj, NULL);
#endif
			
			User::UnMarkCleanupStack(t);
			__WIN32SEHUNTRAP
			return;
			}
		catch (XLeaveException& l)
			{
			Exec::LeaveEnd();
			leaveException = ETrue;
			exceptionReason = l.Reason();
			}
		catch (...)
			{
			User::Invariant();
			}

		if (leaveException)
			{
			if (exceptionReason != KErrNone)
				{
				TInt r = curr_obj->RunError(exceptionReason);
				if (r != KErrNone)
					Error(r);
				}
			leaveException = EFalse;
			}

		} while (aLoop != KLoopInactive);
	}

#else

/**
@internalComponent

Start dispatching request completions.

Stop when aLoop becomes 'Inactive'

This version uses the original implementation of TRAP/Leave.
*/
void CActiveScheduler::Run(TLoopOwner* const volatile& aLoop)
	{
	CActive * volatile curr_obj = 0;
	do
		{
		// explicitly expand the TRAPD macro here to enable single-step debugging
		// of the scheduler loop
		TInt r;
		TTrap trap;
		if (trap.Trap(r)==0)
			{
#ifdef _DEBUG
			//We cache the cleanupstack here do avoid repeated exec calls in DoRunL
			TCleanupTrapHandler *pH=(TCleanupTrapHandler *)GetTrapHandler();
			CCleanup* cleanupPtr=NULL;
			TCleanupBundle cleanupBundle;

			if(pH!=NULL) // test whether there's a CleanupTrapHandler installed
				{
				CCleanup& ccleanup =pH->Cleanup();
				//Store pointer as need the scope of ccleanup increased
				cleanupPtr = &ccleanup; 
				cleanupBundle.iCleanupPtr = cleanupPtr;
				
				//Push a dummy item onto the stack - we check it after the AO's RunL has returned
				//and we check to make sure its still at the top.
				ccleanup.PushL(TCleanupItem(DummyFunc, &(cleanupBundle.iDummyInt)));
				
				DoRunL(aLoop, curr_obj, &cleanupBundle);

				//Dummy Int must (will) be at the top
				//Cleanup our stack
				cleanupPtr->Pop(1);
				} 
			else // no cleanup stack installed
				{
				DoRunL(aLoop, curr_obj, NULL);
				}
#else
			DoRunL(aLoop, curr_obj, NULL);
#endif
			
			TTrap::UnTrap();
			return;		// exit level
			}
		if (r != KErrNone)
			{
			r = curr_obj->RunError(r);
			if (r != KErrNone)
				Error(r);
			}
		} while (aLoop != KLoopInactive);
	}
#endif

#ifndef __CACTIVESCHEDULER_MACHINE_CODED__
/**
@internalComponent

The inner active scheduler loop. This repeatedly waits for a signal and then
dispatches the highest priority ready active object. The loop terminates either
if one of the RunLs stops the current active scheduler level or leaves.

Stop when aLoop becomes 'Inactive'
@panic EClnCheckFailed 90 This will panic when the RunL has left the cleanup stack in an unbalanced state.
*/
#ifdef _DEBUG
void CActiveScheduler::DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj, TCleanupBundle* aCleanupBundlePtr)
#else
void CActiveScheduler::DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj, TCleanupBundle* /*aCleanupBundlePtr*/)
#endif
	{
	TDblQueIter<CActive> q(iActiveQ);
	do
		{
		WaitForAnyRequest();
		q.SetToFirst();
		CActive* pR;
		do
			{
			pR=q++;
			__ASSERT_ALWAYS(pR!=NULL,Panic(EReqStrayEvent));
			//if the line below panics it's either because you made a request but you haven't
			//SetActive the object (pR->iStatus.iFlags&TRequestStatus::EActive==0) or you didn't set the iStatus
			//to KRequestPending (pR->iStatus.iFlags&TRequestStatus::ERequestPending==0)
			__ASSERT_DEBUG(!(pR->iStatus.iFlags&TRequestStatus::EActive)==!(pR->iStatus.iFlags&TRequestStatus::ERequestPending),Panic(EReqStrayEvent));
			} while (!pR->IsActive() || pR->iStatus==KRequestPending);
#ifdef __SMP__
		__e32_memory_barrier();
#endif
		pR->iStatus.iFlags&=~(TRequestStatus::EActive | TRequestStatus::ERequestPending); //pR->iActive=EFalse;
		aCurrentObj = pR;
		pR->RunL();

#ifdef _DEBUG
		if(aCleanupBundlePtr!=NULL)
			{
			//If the following line panics, the RunL left the
			//cleanup stack in an umbalanced state.
			TInt* dummyInt = &(aCleanupBundlePtr->iDummyInt);
			aCleanupBundlePtr->iCleanupPtr->Check(dummyInt);
			}
#endif

		} while (aLoop != KLoopInactive);
	return;		// exit level
	}

#else

extern "C" void PanicStrayEvent()
	{
	Panic(EReqStrayEvent);
	}
#endif




EXPORT_C void CActiveScheduler::Stop()
/**
Stops the wait loop started by the most recent call to Start().

Typically, this is called by the RunL() of one of the scheduler’s active
objects. When this RunL() finishes, the scheduler’s wait loop terminates,
i.e. it does not wait for the completion of the next request.

It will not stop a wait loop started by a call
to CActiveSchedulerWait::Start().

Stop() may also be called from Error().

Note that stopping a nested wait loop is deprecated using this functionality,
use a CActiveSchedulerWait object instead.

@see CActiveSchedulerWait::Start
@see CActive::RunL
@see CActiveSchedulerWait::Error
@see CActiveSchedulerWait::AsyncStop
*/
	{
	CActiveScheduler *pS=GetActiveScheduler();
	__ASSERT_ALWAYS(pS!=NULL,Panic(EReqManagerDoesNotExist));

	for (CActiveScheduler::TLoop* loop=pS->iStack; loop; loop=loop->iNext)
		{
		if (loop->iOwner == KLoopNoOwner)
			{
			loop->iOwner=KLoopInactive;
			return;
			}
		}
	Panic(EReqTooManyStops);
	}




EXPORT_C void CActiveScheduler::Halt(TInt aExitCode) const
/**
Unilaterally terminates the current scheduler loop.

This causes the current scheduler loop to stop, whether it was started
using CActiveSchedulerWait::Start() or CActiveScheduler::Start(). It can
also trigger a leave from Start() if an exit code is provided. If the
current level has already been stopped, then this still records the exit code.

@param aExitCode If non-zero, the reason code reported by Start().
*/
	{
	CActiveScheduler::TLoop* loop=iStack;
	__ASSERT_ALWAYS(loop!=NULL,Panic(EReqTooManyStops));
	TLoopOwner* owner=loop->iOwner;
	if (TUint(owner) > TUint(KLoopNoOwner))
		*owner = NULL;
	loop->iOwner = KLoopInactive;			// disconnect from owner
	loop->iExitCode = aExitCode;
	}




EXPORT_C TInt CActiveScheduler::StackDepth() const
/**
Gets the current number of nested wait loops.

@return The number of nested calls to Start().
*/
	{
	TInt depth=0;
	for (CActiveScheduler::TLoop* loop=iStack; loop; loop=loop->iNext)
		++depth;
	return depth;
	}




EXPORT_C CActiveScheduler* CActiveScheduler::Current()
/**
Gets a pointer to the currently installed active scheduler.

@return A pointer to the active scheduler which is currently installed.
*/
	{
	return GetActiveScheduler();
	}




EXPORT_C void CActiveScheduler::Error(TInt /*aError*/) const
/**
Handles the result of a leave occurring in an active object’s RunL()
function.

An active scheduler always invokes an active object’s RunL()
function under a trap harness.

The default implementation must be replaced.

Any cleanup relevant to the possible causes of leaving should
be performed. If Stop() or Halt() is called from within this function, the
current wait loop terminates. This may be an appropriate response to
catastrophic error conditions.

@param aError The leave code propagated from the active object’s RunL() function

@panic E32USER-CBase 47 if the default implementation is invoked.

@see CActive::RunL
@see CActiveScheduler::Stop
@see CActiveScheduler::Halt
*/
	{
	Panic(EReqActiveObjectLeave);
	}




EXPORT_C TBool CActiveScheduler::RunIfReady(TInt& aError, TInt aMinimumPriority)
/**
@deprecated

Causes the RunL() function of at most one pending active object of priority
aMinimumPriority or greater to be run.

@param aError Error returned by called active object.
@param aMinimumPriority Minimum priority of active object to run.

@return EFalse if no active object's RunL() function was run, i.e. if there
        were no active objects of priority aMinimumPriority or greater pending.
*/
	{
	aError=KErrNone;
	CActiveScheduler* pS=GetActiveScheduler();
	if (pS!=NULL)
		{
		TDblQueIter<CActive> iterator(pS->iActiveQ);
		for (CActive* active=iterator++; (active!=NULL) && (active->Priority()>=aMinimumPriority); active=iterator++)
			{
			if (active->IsActive() && (active->iStatus!=KRequestPending))
				{
				active->iStatus.iFlags&=~(TRequestStatus::EActive | TRequestStatus::ERequestPending); //pR->iActive=EFalse;
				TRAP(aError, active->RunL());
				if (aError!=KErrNone)
					aError=active->RunError(aError);
				return ETrue;
				}
			}
		}
	return EFalse;
	}




EXPORT_C CActiveScheduler* CActiveScheduler::Replace(CActiveScheduler* aNewActiveScheduler)
/**
Allows the current active scheduler to be replaced, while retaining its active
objects.

@param aNewActiveScheduler The new active scheduler.

@return Previous active scheduler.
*/
	{
	__ASSERT_ALWAYS(aNewActiveScheduler!=NULL, Panic(EReqManagerDoesNotExist));
	CActiveScheduler* oldActiveScheduler=GetActiveScheduler();
	__ASSERT_ALWAYS(aNewActiveScheduler!=oldActiveScheduler, Panic(EActiveSchedulerReplacingSelf));
	if (oldActiveScheduler!=NULL)
		{
		// steal all the CActive objects from oldActiveScheduler (without canceling any of them)
		TPriQue<CActive>& oldActiveQ=oldActiveScheduler->iActiveQ;
		TPriQue<CActive>& newActiveQ=aNewActiveScheduler->iActiveQ;
		while (!oldActiveQ.IsEmpty())
			{
			CActive& active=*oldActiveQ.First();
			// call the lower-level function active.iLink.Deque() rather than active.Deque()
			// as the latter would also call active.Cancel() (which we don't want)
			active.iLink.Deque();
			newActiveQ.Add(active);
			}
		}
	SetActiveScheduler(aNewActiveScheduler);
	return oldActiveScheduler;
	}




EXPORT_C void CActiveScheduler::OnStarting()
/**
@removed

Dummy EXPORT for Binary Compatibility reasons.
This method is never called.
*/
	{
	}




EXPORT_C void CActiveScheduler::OnStopping()
/**
@removed

Dummy EXPORT for Binary Compatibility reasons.
This method is never called.
*/
	{
	}



EXPORT_C void CActiveScheduler::Reserved_1()
/**
@internalComponent

Dummy EXPORT for Binary Compatibility reasons.
*/
	{
	}



EXPORT_C void CActiveScheduler::Reserved_2()
/**
@internalComponent

Dummy EXPORT for Binary Compatibility reasons.
*/
	{
	}


/**
Extension function


*/
EXPORT_C TInt CActiveScheduler::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
	{
	return CBase::Extension_(aExtensionId, a0, a1);
	}
