diff -r c1f20ce4abcf -r 3e88ff8f41d5 kernel/eka/euser/us_exec.cpp --- a/kernel/eka/euser/us_exec.cpp Tue Aug 31 16:34:26 2010 +0300 +++ b/kernel/eka/euser/us_exec.cpp Wed Sep 01 12:34:56 2010 +0100 @@ -2887,18 +2887,13 @@ after calling this function. @param aLocaleDllName The name of the locale DLL to be loaded -@return KErrNone if successful, KErrNotSupported if the DLL name matches the pattern -of a new-style locale library, system wide error otherwise +@return KErrNone if successful, system wide error if not @see TExtendedLocale::SaveSystemSettings */ EXPORT_C TInt TExtendedLocale::LoadLocale(const TDesC& aLocaleDllName) { #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL - if (aLocaleDllName.Find(KFindLan) != KErrNotFound || aLocaleDllName.Find(KFindReg) != KErrNotFound || aLocaleDllName.Find(KFindCol) != KErrNotFound) - { - return KErrNotSupported; // Only try to load old-style locale libraries - } TLibraryFunction data[KNumLocaleExports]; TInt r = DoLoadLocale(aLocaleDllName, &data[0]); if(r == KErrNone) @@ -2998,9 +2993,6 @@ the locale information in the DLL, you can call TExtendedLocale::SaveSystemSettings after calling this function. -If the function fails then it will call LoadSystemSettings() to return its members -to a known, good state. - @param aLanguageLocaleDllName The name of the language locale DLL to be loaded @param aRegionLocaleDllName The name of the region locale DLL to be loaded @param aCollationLocaleDllName The name of the collation locale DLL to be loaded @@ -3014,16 +3006,18 @@ const TDesC& aRegionLocaleDllName, const TDesC& aCollationLocaleDllName) { + TInt err = LoadLocaleAspect(aLanguageLocaleDllName); - - if(err == KErrNone) - err = LoadLocaleAspect(aRegionLocaleDllName); - - if(err == KErrNone) - err = LoadLocaleAspect(aCollationLocaleDllName); - + if(err != KErrNone) + return err; + + err = LoadLocaleAspect(aRegionLocaleDllName); if(err != KErrNone) - LoadSystemSettings(); + return err; + + err = LoadLocaleAspect(aCollationLocaleDllName); + if(err != KErrNone) + return err; return err; } @@ -3774,59 +3768,8 @@ */ EXPORT_C void RMutex::Wait() { - Exec::MutexWait(iHandle, 0); - } - - - - -/** -Acquire the mutex if it is currently free, but don't wait for it. - -This function checks if the mutex is currently held. If not the mutex is marked -as held by the current thread and the call returns immediately indicating -success. If the mutex is held by another thread the call returns immediately -indicating failure. If the mutex is already held by the current thread a count -is maintained of how many times the thread has acquired the mutex. - -@return KErrNone if the mutex was acquired - KErrTimedOut if the mutex could not be acquired - KErrGeneral if the semaphore is being reset, i.e the semaphore - is about to be deleted. -*/ -EXPORT_C TInt RMutex::Poll() - { - return Exec::MutexWait(iHandle, -1); - } - - - - -/** -Acquire the mutex, if necessary waiting up to a specified maximum amount of time -for it to become free. - -This function checks if the mutex is currently held. If not the mutex is marked -as held by the current thread and the call returns immediately. If the mutex is -held by another thread the current thread will suspend until the mutex becomes -free or until the specified timeout period has elapsed. If the mutex is already -held by the current thread a count is maintained of how many times the thread -has acquired the mutex. - -@param aTimeout The timeout value in microseconds - -@return KErrNone if the mutex was acquired successfully. - KErrTimedOut if the timeout has expired. - KErrGeneral if the mutex is being reset, i.e the mutex - is about to be deleted. - KErrArgument if aTimeout is negative; - otherwise one of the other system wide error codes. -*/ -EXPORT_C TInt RMutex::Wait(TInt aTimeout) - { - if (aTimeout>=0) - return Exec::MutexWait(iHandle, aTimeout); - return KErrArgument; + + Exec::MutexWait(iHandle); } @@ -4365,6 +4308,7 @@ +EXPORT_C void RSemaphore::Wait() /** Waits for a signal on the semaphore. @@ -4380,16 +4324,19 @@ If the semaphore is deleted, all threads waiting on that semaphore are released. */ -EXPORT_C void RSemaphore::Wait() - { + { + Exec::SemaphoreWait(iHandle, 0); } + + +EXPORT_C TInt RSemaphore::Wait(TInt aTimeout) /** Waits for a signal on the semaphore, or a timeout. -@param aTimeout The timeout value in microseconds +@param aTimeout The timeout value in micoseconds @return KErrNone if the wait has completed normally. KErrTimedOut if the timeout has expired. @@ -4398,26 +4345,12 @@ KErrArgument if aTimeout is negative; otherwise one of the other system wide error codes. */ -EXPORT_C TInt RSemaphore::Wait(TInt aTimeout) - { - if (aTimeout>=0) - return Exec::SemaphoreWait(iHandle, aTimeout); - return KErrArgument; - } - - -/** -Acquires the semaphore if that is possible without waiting. - -@return KErrNone if the semaphore was acquired successfully - KErrTimedOut if the semaphore could not be acquired - KErrGeneral if the semaphore is being reset, i.e the semaphore - is about to be deleted. -*/ -EXPORT_C TInt RSemaphore::Poll() - { - return Exec::SemaphoreWait(iHandle, -1); - } + { + + return Exec::SemaphoreWait(iHandle, aTimeout); + } + + EXPORT_C void RSemaphore::Signal() @@ -4456,54 +4389,6 @@ -#ifndef __CPU_ARM -/** -Acquire the lock, if necessary waiting up to a specified maximum amount of time -for it to become free. - -This function checks if the lock is currently held. If not the lock is marked -as held by the current thread and the call returns immediately. If the lock is -held by another thread the current thread will suspend until the lock becomes -free or until the specified timeout period has elapsed. - -@param aTimeout The timeout value in microseconds - -@return KErrNone if the lock was acquired successfully. - KErrTimedOut if the timeout has expired. - KErrGeneral if the lock is being reset, i.e the lock - is about to be deleted. - KErrArgument if aTimeout is negative; - otherwise one of the other system wide error codes. -*/ -EXPORT_C TInt RFastLock::Wait(TInt aTimeout) - { - if (aTimeout<=0) - return KErrArgument; - TInt orig = __e32_atomic_add_acq32(&iCount, TUint32(-1)); - if (orig == 0) - return KErrNone; - FOREVER - { - TInt r = Exec::SemaphoreWait(iHandle, aTimeout); - if (r != KErrTimedOut) // got lock OK or lock deleted - return r; - // Before we can return KErrTimedOut we must increment iCount (since we - // previously decremented it in anticipation of acquiring the lock. - // However we must not increment iCount if it would become zero, since - // the semaphore will have been signalled (to counterbalance the Wait() - // which timed out and thus never happened). This would result in two - // threads being able to acquire the lock simultaneously - one by - // decrementing iCount from 0 to -1 without looking at the semaphore, - // and the other by decrementing iCount from -1 to -2 and then absorbing - // the spurious semaphore signal. - orig = __e32_atomic_tas_ord32(&iCount, -1, 0, 1); // don't release lock completely - if (orig < -1) - return KErrTimedOut; // count corrected - don't need to touch semaphore - // lock is actually free at this point, try again to claim it - aTimeout = 1; - } - } -#endif EXPORT_C RCriticalSection::RCriticalSection() : iBlocked(1) @@ -5447,45 +5332,6 @@ -/** -Requests an event at a specified time after the last expiry of the this -timer object, to a resolution of 1ms. If the last usage of this timer object -was not via either this function or RTimer::HighRes(), this call behaves the -same as RTimer::HighRes(). -The "HighRes timer" counter stops during power-down (the same as "after timer"). - -@param aStatus On completion, contains the status of the request. - This is KErrNone if the timer completed normally at the - requested time, otherwise another of the - system-wide error codes. In particular KErrArgument indicates - that the requested expiry time has already passed. - -@param aInterval The time interval, in microseconds, after which an event - is to occur, measured from the last expiry time (or intended - expiry time in the case where the timer was cancelled) of this - timer object. - Note that the interval is allowed to be negative. To see why - this might be useful consider the following sequence of timer - operations: - 1. Timer expires at time T - 2. AgainHighRes(1000000) - timer is queued for T + 1 sec - 3. Cancel() - timer is not queued but last scheduled expiry - is still at T + 1 second - 4. AgainHighRes(-500000) - 5. Timer expires at time T + 0.5 second - -@panic KERN-EXEC 15, if this function is called while a request for a timer - event is still outstanding. -*/ -EXPORT_C void RTimer::AgainHighRes(TRequestStatus &aStatus,TTimeIntervalMicroSeconds32 aInterval) - { - aStatus=KRequestPending; - Exec::TimerAgainHighRes(iHandle,aStatus,aInterval.Int()); - } - - - - EXPORT_C void RTimer::At(TRequestStatus &aStatus,const TTime &aTime) // // Request an absolute timer.