Strip trailing spaces/tabs.

svn-id: r47541

1 files changed, 52 insertions, 52 deletions

diff --git a/backends/platform/psp/powerman.cpp b/backends/platform/psp/powerman.cpp
index 89741f3fc9..f00272384d 100644
--- a/backends/platform/psp/powerman.cpp
+++ b/backends/platform/psp/powerman.cpp
@@ -25,7 +25,7 @@
 
 #include <psppower.h>
 #include <pspthreadman.h>
- 
+
 #include "./powerman.h"
 #include "./trace.h"
 #include "engine.h"
@@ -47,19 +47,19 @@ void PowerManager::debugPM() {
 *
 *	Constructor
 *
-********************************************/ 
+********************************************/
 PowerManager::PowerManager() {
-	
+
 	_flagMutex = NULL;					/* Init mutex handle */
 	_listMutex = NULL;					/* Init mutex handle */
 	_condSuspendable = NULL;			/* Init condition variable */
 	_condPM = NULL;
-	
+
 	_condSuspendable = SDL_CreateCond();
 	if (_condSuspendable <= 0) {
 		PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condSuspendable\n");
 	}
-	
+
 	_condPM = SDL_CreateCond();
 	if (_condPM <= 0) {
 		PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condPM\n");
@@ -79,18 +79,18 @@ PowerManager::PowerManager() {
 	_criticalCounter = 0;
 	_pauseFlag = 0; _pauseFlagOld = 0; _pauseClientState = 0;
 
-#ifdef __PSP_DEBUG_SUSPEND__	
+#ifdef __PSP_DEBUG_SUSPEND__
 	_listCounter = 0;
 	PMStatusSet(kInitDone);
-	_error = 0;	
+	_error = 0;
 #endif
  }
- 
+
 /*******************************************
 *
 *	Function to register to be notified when suspend/resume time comes
 *
-********************************************/ 
+********************************************/
 int PowerManager::registerSuspend(Suspendable *item) {
 	// Register in list
 	PSPDebugSuspend("In registerSuspend\n");
@@ -111,7 +111,7 @@ int PowerManager::registerSuspend(Suspendable *item) {
 
 	PSPDebugSuspend("Out of registerSuspend\n");
 	debugPM();
-	
+
 	return 0;
 }
 
@@ -119,7 +119,7 @@ int PowerManager::registerSuspend(Suspendable *item) {
 *
 *	Function to unregister to be notified when suspend/resume time comes
 *
-********************************************/  
+********************************************/
 int PowerManager::unregisterSuspend(Suspendable *item) {
 
 	PSPDebugSuspend("In unregisterSuspend\n");
@@ -133,32 +133,32 @@ int PowerManager::unregisterSuspend(Suspendable *item) {
 	_suspendList.remove(item);
 #ifdef __PSP_DEBUG_SUSPEND__
 	_listCounter--;
-#endif	
-	
+#endif
+
 	if (SDL_mutexV(_listMutex) != 0) {
 		PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex);
 	}
 
 	PSPDebugSuspend("Out of unregisterSuspend\n");
 	debugPM();
-	
+
 	return 0;
  }
- 
+
  /*******************************************
 *
 *	Destructor
 *
-********************************************/ 
+********************************************/
  PowerManager::~PowerManager() {
 
 #ifdef __PSP_DEBUG_SUSPEND__
 	PMStatusSet(kDestroyPM);
 #endif
- 
+
 	SDL_DestroyCond(_condSuspendable);
 	_condSuspendable = 0;
-	
+
 	SDL_DestroyCond(_condPM);
 	_condPM = 0;
 
@@ -173,11 +173,11 @@ int PowerManager::unregisterSuspend(Suspendable *item) {
 *
 *	Unsafe function to poll for a pause event (first stage of suspending)
 *   Only for pausing the engine, which doesn't need high synchronization ie. we don't care if it misreads
-*   the flag a couple of times since there is NO mutex protection (for performance reasons). 
+*   the flag a couple of times since there is NO mutex protection (for performance reasons).
 *   Polling the engine happens regularly.
 *	On the other hand, we don't know if there will be ANY polling which prevents us from using proper events.
 *
-********************************************/  
+********************************************/
 void PowerManager::pollPauseEngine() {
 
 	bool pause = _pauseFlag;		// We copy so as not to have multiple values
@@ -194,17 +194,17 @@ void PowerManager::pollPauseEngine() {
 			PSPDebugSuspend("Unpausing for resume in PowerManager::pollPauseEngine()\n");
 			_pauseClientState = PowerManager::Unpaused;	// Tell PM we're in the middle of pausing
 		}
-			
+
 		_pauseFlagOld = pause;
 	}
-} 
- 
+}
+
 /*******************************************
 *
 *	Function to be called by threads wanting to block on the PSP entering suspend
 *   Use this for small critical sections where you can easily restore the previous state.
 *
-********************************************/  
+********************************************/
  int PowerManager::blockOnSuspend()  {
 	return beginCriticalSection(true);
 }
@@ -214,7 +214,7 @@ void PowerManager::pollPauseEngine() {
 *	Function to block on a suspend, then start a non-suspendable critical section
 *   Use this for large or REALLY critical critical-sections.
 *	Make sure to call endCriticalSection or the PSP won't suspend.
-********************************************/  
+********************************************/
 
   int PowerManager::beginCriticalSection(bool justBlock) {
 	int ret = NotBlocked;
@@ -238,7 +238,7 @@ void PowerManager::pollPauseEngine() {
 		PSPDebugSuspend("We got blocked!!\n");
 		debugPM();
 	}
-	
+
 	// Now prevent the PM from suspending until we're done
 	if (justBlock == false)
 		_criticalCounter++;
@@ -261,14 +261,14 @@ int PowerManager::endCriticalSection() {
 
 	// We're done with our critical section
 	_criticalCounter--;
-	
+
 	if (_criticalCounter <= 0) {
 		if (_suspendFlag == true) {	// If the PM is sleeping, this flag must be set
 			PSPDebugSuspend("Unblocked thread waking up the PM.\n");
 			debugPM();
 
 			SDL_CondBroadcast(_condPM);
-			
+
 			PSPDebugSuspend("Woke up the PM\n");
 			debugPM();
 		}
@@ -291,10 +291,10 @@ int PowerManager::endCriticalSection() {
 *
 *	Callback function to be called to put every Suspendable to suspend
 *
-********************************************/  
+********************************************/
 int PowerManager::suspend() {
 	int ret = 0;
-	
+
 	if (_pauseFlag) return ret;	// Very important - make sure we only suspend once
 
 	scePowerLock(0);			// Critical to make sure PSP doesn't suspend before we're done
@@ -302,14 +302,14 @@ int PowerManager::suspend() {
 	// The first stage of suspend is pausing the engine if possible. We don't want to cause files
 	// to block, or we might not get the engine to pause. On the other hand, we might wait for polling
 	// and it'll never happen. We also want to do this w/o mutexes (for speed) which is ok in this case.
-	_pauseFlag = true;		
+	_pauseFlag = true;
 
 	PMStatusSet(kWaitForClientPause);
-	
+
 	// Now we wait, giving the engine thread some time to find our flag.
 	for (int i = 0; i < 10 && _pauseClientState == Unpaused; i++)
 		sceKernelDelayThread(50000);	// We wait 50 msec x 10 times = 0.5 seconds
-	
+
 	if (_pauseClientState == Pausing) {	// Our event has been acknowledged. Let's wait until the client is done.
 		PMStatusSet(kWaitForClientToFinishPausing);
 
@@ -317,13 +317,13 @@ int PowerManager::suspend() {
 			sceKernelDelayThread(50000);	// We wait 50 msec at a time
 	}
 
-	// It's possible that the polling thread missed our pause event, but there's nothing we can do about that. 
+	// It's possible that the polling thread missed our pause event, but there's nothing we can do about that.
 	// We can't know if there's polling going on or not. It's usually not a critical thing anyway.
-	
+
 	PMStatusSet(kGettingFlagMutexSuspend);
-	
+
 	// Now we set the suspend flag to true to cause reading threads to block
-	
+
 	if (SDL_mutexP(_flagMutex) != 0) {
 		PSPDebugTrace("PowerManager::suspend(): Couldn't lock flagMutex %d\n", _flagMutex);
 		_error = Error;
@@ -331,9 +331,9 @@ int PowerManager::suspend() {
 	}
 
 	PMStatusSet(kGotFlagMutexSuspend);
-	
+
 	_suspendFlag = true;
-	
+
 	// Check if anyone is in a critical section. If so, we'll wait for them
 	if (_criticalCounter > 0) {
 		PMStatusSet(kWaitCritSectionSuspend);
@@ -348,7 +348,7 @@ int PowerManager::suspend() {
 	}
 
 	PMStatusSet(kGettingListMutexSuspend);
-	
+
 	// Loop over list, calling suspend()
 	if (SDL_mutexP(_listMutex) != 0) {
 		PSPDebugTrace("PowerManager::suspend(): Couldn't lock listMutex %d\n", _listMutex);
@@ -362,7 +362,7 @@ int PowerManager::suspend() {
 	for (; i != _suspendList.end(); ++i) {
 		(*i)->suspend();
 	}
-	
+
 	PMStatusSet(kDoneIteratingListSuspend);
 
 	if (SDL_mutexV(_listMutex) != 0) {
@@ -373,7 +373,7 @@ int PowerManager::suspend() {
 	PMStatusSet(kDoneSuspend);
 
 	scePowerUnlock(0);				// Allow the PSP to go to sleep now
-	
+
 	return ret;
 }
 
@@ -381,17 +381,17 @@ int PowerManager::suspend() {
 *
 *	Callback function to resume every Suspendable
 *
-********************************************/  
+********************************************/
 int PowerManager::resume() {
 	int ret = 0;
 
 	// Make sure we can't get another suspend
 	scePowerLock(0);
-	
+
 	if (!_pauseFlag) return ret;				// Make sure we can only resume once
-	
+
 	PMStatusSet(kGettingListMutexResume);
-	
+
 	// First we notify our Suspendables. Loop over list, calling resume()
 	if (SDL_mutexP(_listMutex) != 0) {
 		PSPDebugTrace("PowerManager::resume(): Couldn't lock listMutex %d\n", _listMutex);
@@ -405,7 +405,7 @@ int PowerManager::resume() {
 	for (; i != _suspendList.end(); ++i) {
 		(*i)->resume();
 	}
-	
+
 	PMStatusSet(kDoneIteratingListResume);
 
 	if (SDL_mutexV(_listMutex) != 0) {
@@ -413,7 +413,7 @@ int PowerManager::resume() {
 		_error = Error;
 		ret = Error;
 	}
-	
+
 	PMStatusSet(kGettingFlagMutexResume);
 
 	// Now we set the suspend flag to false
@@ -423,11 +423,11 @@ int PowerManager::resume() {
 		ret = Error;
 	}
 	PMStatusSet(kGotFlagMutexResume);
-	
+
 	_suspendFlag = false;
 
 	PMStatusSet(kSignalSuspendedThreadsResume);
-	
+
 	// Signal the other threads to wake up
 	if (SDL_CondBroadcast(_condSuspendable) != 0) {
 		PSPDebugTrace("PowerManager::resume(): Couldn't broadcast condition %d\n", _condSuspendable);
@@ -442,10 +442,10 @@ int PowerManager::resume() {
 		ret = Error;
 	}
 	PMStatusSet(kDoneResume);
-	
+
 	_pauseFlag = false;	// Signal engine to unpause
 
 	scePowerUnlock(0);	// Allow new suspends
-	
+
 	return ret;
 }