Index: src/OFMutex.h ================================================================== --- src/OFMutex.h +++ src/OFMutex.h @@ -25,11 +25,11 @@ * * @brief A class for creating mutual exclusions. */ @interface OFMutex: OFObject { - of_mutex_t _mutex; + OFPlainMutex _mutex; bool _initialized; OFString *_Nullable _name; OF_RESERVE_IVARS(OFMutex, 4) } Index: src/OFMutex.m ================================================================== --- src/OFMutex.m +++ src/OFMutex.m @@ -35,11 +35,11 @@ - (instancetype)init { self = [super init]; - if (of_mutex_new(&_mutex) != 0) { + if (OFPlainMutexNew(&_mutex) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -49,11 +49,11 @@ } - (void)dealloc { if (_initialized) { - int error = of_mutex_free(&_mutex); + int error = OFPlainMutexFree(&_mutex); if (error != 0) { OF_ENSURE(error == EBUSY); @throw [OFStillLockedException exceptionWithLock: self]; @@ -65,20 +65,20 @@ [super dealloc]; } - (void)lock { - int error = of_mutex_lock(&_mutex); + int error = OFPlainMutexLock(&_mutex); if (error != 0) @throw [OFLockFailedException exceptionWithLock: self errNo: error]; } - (bool)tryLock { - int error = of_mutex_trylock(&_mutex); + int error = OFPlainMutexTryLock(&_mutex); if (error != 0) { if (error == EBUSY) return false; else @@ -89,11 +89,11 @@ return true; } - (void)unlock { - int error = of_mutex_unlock(&_mutex); + int error = OFPlainMutexUnlock(&_mutex); if (error != 0) @throw [OFUnlockFailedException exceptionWithLock: self errNo: error]; } Index: src/OFRecursiveMutex.h ================================================================== --- src/OFRecursiveMutex.h +++ src/OFRecursiveMutex.h @@ -27,11 +27,11 @@ * recursively. */ OF_SUBCLASSING_RESTRICTED @interface OFRecursiveMutex: OFObject { - of_rmutex_t _rmutex; + OFPlainRecursiveMutex _rmutex; bool _initialized; OFString *_Nullable _name; } /** Index: src/OFRecursiveMutex.m ================================================================== --- src/OFRecursiveMutex.m +++ src/OFRecursiveMutex.m @@ -35,11 +35,11 @@ - (instancetype)init { self = [super init]; - if (of_rmutex_new(&_rmutex) != 0) { + if (OFPlainRecursiveMutexNew(&_rmutex) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -49,11 +49,11 @@ } - (void)dealloc { if (_initialized) { - int error = of_rmutex_free(&_rmutex); + int error = OFPlainRecursiveMutexFree(&_rmutex); if (error != 0) { OF_ENSURE(error == EBUSY); @throw [OFStillLockedException exceptionWithLock: self]; @@ -65,20 +65,20 @@ [super dealloc]; } - (void)lock { - int error = of_rmutex_lock(&_rmutex); + int error = OFPlainRecursiveMutexLock(&_rmutex); if (error != 0) @throw [OFLockFailedException exceptionWithLock: self errNo: error]; } - (bool)tryLock { - int error = of_rmutex_trylock(&_rmutex); + int error = OFPlainRecursiveMutexTryLock(&_rmutex); if (error != 0) { if (error == EBUSY) return false; else @@ -89,11 +89,11 @@ return true; } - (void)unlock { - int error = of_rmutex_unlock(&_rmutex); + int error = OFPlainRecursiveMutexUnlock(&_rmutex); if (error != 0) @throw [OFUnlockFailedException exceptionWithLock: self errNo: error]; } Index: src/condition.h ================================================================== --- src/condition.h +++ src/condition.h @@ -51,18 +51,18 @@ extern "C" { #endif extern int of_condition_new(of_condition_t *condition); extern int of_condition_signal(of_condition_t *condition); extern int of_condition_broadcast(of_condition_t *condition); -extern int of_condition_wait(of_condition_t *condition, of_mutex_t *mutex); +extern int of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex); extern int of_condition_timed_wait(of_condition_t *condition, - of_mutex_t *mutex, OFTimeInterval timeout); + OFPlainMutex *mutex, OFTimeInterval timeout); #ifdef OF_AMIGAOS extern int of_condition_wait_or_signal(of_condition_t *condition, - of_mutex_t *mutex, ULONG *signalMask); + OFPlainMutex *mutex, ULONG *signalMask); extern int of_condition_timed_wait_or_signal(of_condition_t *condition, - of_mutex_t *mutex, OFTimeInterval timeout, ULONG *signalMask); + OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask); #endif extern int of_condition_free(of_condition_t *condition); #ifdef __cplusplus } #endif Index: src/exceptions/OFException.m ================================================================== --- src/exceptions/OFException.m +++ src/exceptions/OFException.m @@ -67,20 +67,20 @@ extern int _Unwind_VRS_Get(struct _Unwind_Context *, int, uint32_t, int, void *); #endif #if !defined(HAVE_STRERROR_R) && defined(OF_HAVE_THREADS) -static of_mutex_t mutex; +static OFPlainMutex mutex; OF_CONSTRUCTOR() { - OF_ENSURE(of_mutex_new(&mutex) == 0); + OF_ENSURE(OFPlainMutexNew(&mutex) == 0); } OF_DESTRUCTOR() { - of_mutex_free(&mutex); + OFPlainMutexFree(&mutex); } #endif OFString * of_strerror(int errNo) @@ -189,21 +189,21 @@ ret = [OFString stringWithCString: buffer encoding: [OFLocale encoding]]; #else # ifdef OF_HAVE_THREADS - if (of_mutex_lock(&mutex) != 0) + if (OFPlainMutexLock(&mutex) != 0) @throw [OFLockFailedException exception]; @try { # endif ret = [OFString stringWithCString: strerror(errNo) encoding: [OFLocale encoding]]; # ifdef OF_HAVE_THREADS } @finally { - if (of_mutex_unlock(&mutex) != 0) + if (OFPlainMutexUnlock(&mutex) != 0) @throw [OFUnlockFailedException exception]; } # endif #endif Index: src/mutex.h ================================================================== --- src/mutex.h +++ src/mutex.h @@ -26,57 +26,57 @@ #import "macros.h" #if defined(OF_HAVE_PTHREADS) # include -typedef pthread_mutex_t of_mutex_t; +typedef pthread_mutex_t OFPlainMutex; #elif defined(OF_WINDOWS) # include -typedef CRITICAL_SECTION of_mutex_t; +typedef CRITICAL_SECTION OFPlainMutex; #elif defined(OF_AMIGAOS) # include -typedef struct SignalSemaphore of_mutex_t; +typedef struct SignalSemaphore OFPlainMutex; #endif #if defined(OF_HAVE_ATOMIC_OPS) # import "atomic.h" typedef volatile int of_spinlock_t; # define OF_SPINCOUNT 10 #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) typedef pthread_spinlock_t of_spinlock_t; #else -typedef of_mutex_t of_spinlock_t; +typedef OFPlainMutex of_spinlock_t; #endif #ifdef OF_HAVE_SCHED_YIELD # include #endif #if defined(OF_HAVE_RECURSIVE_PTHREAD_MUTEXES) || defined(OF_WINDOWS) || \ defined(OF_AMIGAOS) -# define of_rmutex_t of_mutex_t +# define OFPlainRecursiveMutex OFPlainMutex #else # import "tlskey.h" typedef struct { - of_mutex_t mutex; + OFPlainMutex mutex; OFTLSKey count; -} of_rmutex_t; +} OFPlainRecursiveMutex; #endif #ifdef __cplusplus extern "C" { #endif -extern int of_mutex_new(of_mutex_t *mutex); -extern int of_mutex_lock(of_mutex_t *mutex); -extern int of_mutex_trylock(of_mutex_t *mutex); -extern int of_mutex_unlock(of_mutex_t *mutex); -extern int of_mutex_free(of_mutex_t *mutex); -extern int of_rmutex_new(of_rmutex_t *rmutex); -extern int of_rmutex_lock(of_rmutex_t *rmutex); -extern int of_rmutex_trylock(of_rmutex_t *rmutex); -extern int of_rmutex_unlock(of_rmutex_t *rmutex); -extern int of_rmutex_free(of_rmutex_t *rmutex); +extern int OFPlainMutexNew(OFPlainMutex *mutex); +extern int OFPlainMutexLock(OFPlainMutex *mutex); +extern int OFPlainMutexTryLock(OFPlainMutex *mutex); +extern int OFPlainMutexUnlock(OFPlainMutex *mutex); +extern int OFPlainMutexFree(OFPlainMutex *mutex); +extern int OFPlainRecursiveMutexNew(OFPlainRecursiveMutex *rmutex); +extern int OFPlainRecursiveMutexLock(OFPlainRecursiveMutex *rmutex); +extern int OFPlainRecursiveMutexTryLock(OFPlainRecursiveMutex *rmutex); +extern int OFPlainRecursiveMutexUnlock(OFPlainRecursiveMutex *rmutex); +extern int OFPlainRecursiveMutexFree(OFPlainRecursiveMutex *rmutex); #ifdef __cplusplus } #endif /* Spinlocks are inlined for performance. */ @@ -98,11 +98,11 @@ *spinlock = 0; return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_init(spinlock, 0); #else - return of_mutex_new(spinlock); + return OFPlainMutexNew(spinlock); #endif } static OF_INLINE int of_spinlock_trylock(of_spinlock_t *spinlock) @@ -115,11 +115,11 @@ return EBUSY; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_trylock(spinlock); #else - return of_mutex_trylock(spinlock); + return OFPlainMutexTryLock(spinlock); #endif } static OF_INLINE int of_spinlock_lock(of_spinlock_t *spinlock) @@ -136,11 +136,11 @@ return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_lock(spinlock); #else - return of_mutex_lock(spinlock); + return OFPlainMutexLock(spinlock); #endif } static OF_INLINE int of_spinlock_unlock(of_spinlock_t *spinlock) @@ -152,11 +152,11 @@ return (ret ? 0 : EINVAL); #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_unlock(spinlock); #else - return of_mutex_unlock(spinlock); + return OFPlainMutexUnlock(spinlock); #endif } static OF_INLINE int of_spinlock_free(of_spinlock_t *spinlock) @@ -164,8 +164,8 @@ #if defined(OF_HAVE_ATOMIC_OPS) return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_destroy(spinlock); #else - return of_mutex_free(spinlock); + return OFPlainMutexFree(spinlock); #endif } Index: src/platform/amiga/condition.m ================================================================== --- src/platform/amiga/condition.m +++ src/platform/amiga/condition.m @@ -72,19 +72,19 @@ return 0; } int -of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) +of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) { ULONG signalMask = 0; return of_condition_wait_or_signal(condition, mutex, &signalMask); } int -of_condition_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, +of_condition_wait_or_signal(of_condition_t *condition, OFPlainMutex *mutex, ULONG *signalMask) { struct of_condition_waiting_task waitingTask = { .task = FindTask(NULL), .sigBit = AllocSignal(-1) @@ -95,21 +95,21 @@ if (waitingTask.sigBit == -1) return EAGAIN; Forbid(); - if ((error = of_mutex_unlock(mutex)) != 0) { + if ((error = OFPlainMutexUnlock(mutex)) != 0) { FreeSignal(waitingTask.sigBit); return error; } waitingTask.next = condition->waitingTasks; condition->waitingTasks = &waitingTask; mask = Wait((1ul << waitingTask.sigBit) | *signalMask); if (mask & (1ul << waitingTask.sigBit) || (*signalMask &= mask)) - error = of_mutex_lock(mutex); + error = OFPlainMutexLock(mutex); else /* * This should not happen - it means something interrupted the * Wait(), so the best we can do is return EINTR. */ @@ -121,22 +121,22 @@ return error; } int -of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, +of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { ULONG signalMask = 0; return of_condition_timed_wait_or_signal(condition, mutex, timeout, &signalMask); } int -of_condition_timed_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, - OFTimeInterval timeout, ULONG *signalMask) +of_condition_timed_wait_or_signal(of_condition_t *condition, + OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask) { struct of_condition_waiting_task waitingTask = { .task = FindTask(NULL), .sigBit = AllocSignal(-1) }; @@ -192,11 +192,11 @@ goto fail; } Forbid(); - if ((error = of_mutex_unlock(mutex)) != 0) { + if ((error = OFPlainMutexUnlock(mutex)) != 0) { Permit(); goto fail; } waitingTask.next = condition->waitingTasks; @@ -205,11 +205,11 @@ SendIO((struct IORequest *)&request); mask = Wait((1ul << waitingTask.sigBit) | (1ul << port.mp_SigBit) | *signalMask); if (mask & (1ul << waitingTask.sigBit) || (*signalMask &= mask)) - error = of_mutex_lock(mutex); + error = OFPlainMutexLock(mutex); else if (mask & (1ul << port.mp_SigBit)) error = ETIMEDOUT; else /* * This should not happen - it means something interrupted the Index: src/platform/amiga/mutex.m ================================================================== --- src/platform/amiga/mutex.m +++ src/platform/amiga/mutex.m @@ -20,72 +20,72 @@ #import "mutex.h" #include int -of_mutex_new(of_mutex_t *mutex) +OFPlainMutexNew(OFPlainMutex *mutex) { InitSemaphore(mutex); return 0; } int -of_mutex_lock(of_mutex_t *mutex) +OFPlainMutexLock(OFPlainMutex *mutex) { ObtainSemaphore(mutex); return 0; } int -of_mutex_trylock(of_mutex_t *mutex) +OFPlainMutexTryLock(OFPlainMutex *mutex) { if (!AttemptSemaphore(mutex)) return EBUSY; return 0; } int -of_mutex_unlock(of_mutex_t *mutex) +OFPlainMutexUnlock(OFPlainMutex *mutex) { ReleaseSemaphore(mutex); return 0; } int -of_mutex_free(of_mutex_t *mutex) +OFPlainMutexFree(OFPlainMutex *mutex) { return 0; } int -of_rmutex_new(of_rmutex_t *rmutex) -{ - return of_mutex_new(rmutex); -} - -int -of_rmutex_lock(of_rmutex_t *rmutex) -{ - return of_mutex_lock(rmutex); -} - -int -of_rmutex_trylock(of_rmutex_t *rmutex) -{ - return of_mutex_trylock(rmutex); -} - -int -of_rmutex_unlock(of_rmutex_t *rmutex) -{ - return of_mutex_unlock(rmutex); -} - -int -of_rmutex_free(of_rmutex_t *rmutex) -{ - return of_mutex_free(rmutex); +OFPlainRecursiveMutexNew(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexNew(rmutex); +} + +int +OFPlainRecursiveMutexLock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexLock(rmutex); +} + +int +OFPlainRecursiveMutexTryLock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexTryLock(rmutex); +} + +int +OFPlainRecursiveMutexUnlock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexUnlock(rmutex); +} + +int +OFPlainRecursiveMutexFree(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexFree(rmutex); } Index: src/platform/posix/condition.m ================================================================== --- src/platform/posix/condition.m +++ src/platform/posix/condition.m @@ -34,17 +34,17 @@ { return pthread_cond_broadcast(condition); } int -of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) +of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) { return pthread_cond_wait(condition, mutex); } int -of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, +of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { struct timespec ts; ts.tv_sec = (time_t)timeout; Index: src/platform/posix/mutex.m ================================================================== --- src/platform/posix/mutex.m +++ src/platform/posix/mutex.m @@ -16,42 +16,42 @@ #include "config.h" #import "mutex.h" int -of_mutex_new(of_mutex_t *mutex) +OFPlainMutexNew(OFPlainMutex *mutex) { return pthread_mutex_init(mutex, NULL); } int -of_mutex_lock(of_mutex_t *mutex) +OFPlainMutexLock(OFPlainMutex *mutex) { return pthread_mutex_lock(mutex); } int -of_mutex_trylock(of_mutex_t *mutex) +OFPlainMutexTryLock(OFPlainMutex *mutex) { return pthread_mutex_trylock(mutex); } int -of_mutex_unlock(of_mutex_t *mutex) +OFPlainMutexUnlock(OFPlainMutex *mutex) { return pthread_mutex_unlock(mutex); } int -of_mutex_free(of_mutex_t *mutex) +OFPlainMutexFree(OFPlainMutex *mutex) { return pthread_mutex_destroy(mutex); } #ifdef OF_HAVE_RECURSIVE_PTHREAD_MUTEXES int -of_rmutex_new(of_rmutex_t *rmutex) +OFPlainRecursiveMutexNew(OFPlainRecursiveMutex *rmutex) { int error; pthread_mutexattr_t attr; if ((error = pthread_mutexattr_init(&attr)) != 0) @@ -69,49 +69,74 @@ return 0; } int -of_rmutex_lock(of_rmutex_t *rmutex) +OFPlainRecursiveMutexLock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexLock(rmutex); +} + +int +OFPlainRecursiveMutexTryLock(OFPlainRecursiveMutex *rmutex) { - return of_mutex_lock(rmutex); + return OFPlainMutexTryLock(rmutex); } int -of_rmutex_trylock(of_rmutex_t *rmutex) +OFPlainRecursiveMutexUnlock(OFPlainRecursiveMutex *rmutex) { - return of_mutex_trylock(rmutex); + return OFPlainMutexUnlock(rmutex); } int -of_rmutex_unlock(of_rmutex_t *rmutex) -{ - return of_mutex_unlock(rmutex); -} - -int -of_rmutex_free(of_rmutex_t *rmutex) -{ - return of_mutex_free(rmutex); +OFPlainRecursiveMutexFree(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexFree(rmutex); } #else int -of_rmutex_new(of_rmutex_t *rmutex) +OFPlainRecursiveMutexNew(OFPlainRecursiveMutex *rmutex) { int error; - if ((error = of_mutex_new(&rmutex->mutex)) != 0) + if ((error = OFPlainMutexNew(&rmutex->mutex)) != 0) return error; if ((error = OFTLSKeyNew(&rmutex->count)) != 0) return error; return 0; } int -of_rmutex_lock(of_rmutex_t *rmutex) +OFPlainRecursiveMutexLock(OFPlainRecursiveMutex *rmutex) +{ + uintptr_t count = (uintptr_t)OFTLSKeyGet(rmutex->count); + int error; + + if (count > 0) { + if ((error = OFTLSKeySet(rmutex->count, + (void *)(count + 1))) != 0) + return error; + + return 0; + } + + if ((error = OFPlainMutexLock(&rmutex->mutex)) != 0) + return error; + + if ((error = OFTLSKeySet(rmutex->count, (void *)1)) != 0) { + OFPlainMutexUnlock(&rmutex->mutex); + return error; + } + + return 0; +} + +int +OFPlainRecursiveMutexTryLock(OFPlainRecursiveMutex *rmutex) { uintptr_t count = (uintptr_t)OFTLSKeyGet(rmutex->count); int error; if (count > 0) { @@ -120,48 +145,23 @@ return error; return 0; } - if ((error = of_mutex_lock(&rmutex->mutex)) != 0) + if ((error = OFPlainMutexTryLock(&rmutex->mutex)) != 0) return error; if ((error = OFTLSKeySet(rmutex->count, (void *)1)) != 0) { - of_mutex_unlock(&rmutex->mutex); + OFPlainMutexUnlock(&rmutex->mutex); return error; } return 0; } int -of_rmutex_trylock(of_rmutex_t *rmutex) -{ - uintptr_t count = (uintptr_t)OFTLSKeyGet(rmutex->count); - int error; - - if (count > 0) { - if ((error = OFTLSKeySet(rmutex->count, - (void *)(count + 1))) != 0) - return error; - - return 0; - } - - if ((error = of_mutex_trylock(&rmutex->mutex)) != 0) - return error; - - if ((error = OFTLSKeySet(rmutex->count, (void *)1)) != 0) { - of_mutex_unlock(&rmutex->mutex); - return error; - } - - return 0; -} - -int -of_rmutex_unlock(of_rmutex_t *rmutex) +OFPlainRecursiveMutexUnlock(OFPlainRecursiveMutex *rmutex) { uintptr_t count = (uintptr_t)OFTLSKeyGet(rmutex->count); int error; if (count > 1) { @@ -173,25 +173,25 @@ } if ((error = OFTLSKeySet(rmutex->count, (void *)0)) != 0) return error; - if ((error = of_mutex_unlock(&rmutex->mutex)) != 0) + if ((error = OFPlainMutexUnlock(&rmutex->mutex)) != 0) return error; return 0; } int -of_rmutex_free(of_rmutex_t *rmutex) +OFPlainRecursiveMutexFree(OFPlainRecursiveMutex *rmutex) { int error; - if ((error = of_mutex_free(&rmutex->mutex)) != 0) + if ((error = OFPlainMutexFree(&rmutex->mutex)) != 0) return error; if ((error = OFTLSKeyFree(rmutex->count)) != 0) return error; return 0; } #endif Index: src/platform/windows/condition.m ================================================================== --- src/platform/windows/condition.m +++ src/platform/windows/condition.m @@ -65,25 +65,25 @@ return 0; } int -of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) +of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) { int error; DWORD status; - if ((error = of_mutex_unlock(mutex)) != 0) + if ((error = OFPlainMutexUnlock(mutex)) != 0) return error; of_atomic_int_inc(&condition->count); status = WaitForSingleObject(condition->event, INFINITE); of_atomic_int_dec(&condition->count); switch (status) { case WAIT_OBJECT_0: - return of_mutex_lock(mutex); + return OFPlainMutexLock(mutex); case WAIT_FAILED: switch (GetLastError()) { case ERROR_INVALID_HANDLE: return EINVAL; default: @@ -93,26 +93,26 @@ OF_ENSURE(0); } } int -of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, +of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { int error; DWORD status; - if ((error = of_mutex_unlock(mutex)) != 0) + if ((error = OFPlainMutexUnlock(mutex)) != 0) return error; of_atomic_int_inc(&condition->count); status = WaitForSingleObject(condition->event, timeout * 1000); of_atomic_int_dec(&condition->count); switch (status) { case WAIT_OBJECT_0: - return of_mutex_lock(mutex); + return OFPlainMutexLock(mutex); case WAIT_TIMEOUT: return ETIMEDOUT; case WAIT_FAILED: switch (GetLastError()) { case ERROR_INVALID_HANDLE: Index: src/platform/windows/mutex.m ================================================================== --- src/platform/windows/mutex.m +++ src/platform/windows/mutex.m @@ -20,74 +20,74 @@ #import "mutex.h" #include int -of_mutex_new(of_mutex_t *mutex) +OFPlainMutexNew(OFPlainMutex *mutex) { InitializeCriticalSection(mutex); return 0; } int -of_mutex_lock(of_mutex_t *mutex) +OFPlainMutexLock(OFPlainMutex *mutex) { EnterCriticalSection(mutex); return 0; } int -of_mutex_trylock(of_mutex_t *mutex) +OFPlainMutexTryLock(OFPlainMutex *mutex) { if (!TryEnterCriticalSection(mutex)) return EBUSY; return 0; } int -of_mutex_unlock(of_mutex_t *mutex) +OFPlainMutexUnlock(OFPlainMutex *mutex) { LeaveCriticalSection(mutex); return 0; } int -of_mutex_free(of_mutex_t *mutex) +OFPlainMutexFree(OFPlainMutex *mutex) { DeleteCriticalSection(mutex); return 0; } int -of_rmutex_new(of_rmutex_t *rmutex) -{ - return of_mutex_new(rmutex); -} - -int -of_rmutex_lock(of_rmutex_t *rmutex) -{ - return of_mutex_lock(rmutex); -} - -int -of_rmutex_trylock(of_rmutex_t *rmutex) -{ - return of_mutex_trylock(rmutex); -} - -int -of_rmutex_unlock(of_rmutex_t *rmutex) -{ - return of_mutex_unlock(rmutex); -} - -int -of_rmutex_free(of_rmutex_t *rmutex) -{ - return of_mutex_free(rmutex); +OFPlainRecursiveMutexNew(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexNew(rmutex); +} + +int +OFPlainRecursiveMutexLock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexLock(rmutex); +} + +int +OFPlainRecursiveMutexTryLock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexTryLock(rmutex); +} + +int +OFPlainRecursiveMutexUnlock(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexUnlock(rmutex); +} + +int +OFPlainRecursiveMutexFree(OFPlainRecursiveMutex *rmutex) +{ + return OFPlainMutexFree(rmutex); } Index: src/runtime/synchronized.m ================================================================== --- src/runtime/synchronized.m +++ src/runtime/synchronized.m @@ -22,22 +22,22 @@ #import "private.h" #ifdef OF_HAVE_THREADS # import "mutex.h" -static struct lock_s { - id object; - int count; - of_rmutex_t rmutex; - struct lock_s *next; +static struct lock { + id object; + int count; + OFPlainRecursiveMutex rmutex; + struct lock *next; } *locks = NULL; -static of_mutex_t mutex; +static OFPlainMutex mutex; OF_CONSTRUCTOR() { - if (of_mutex_new(&mutex) != 0) + if (OFPlainMutexNew(&mutex) != 0) OBJC_ERROR("Failed to create mutex!"); } #endif int @@ -45,48 +45,48 @@ { if (object == nil) return 0; #ifdef OF_HAVE_THREADS - struct lock_s *lock; + struct lock *lock; - if (of_mutex_lock(&mutex) != 0) + if (OFPlainMutexLock(&mutex) != 0) OBJC_ERROR("Failed to lock mutex!"); /* Look if we already have a lock */ for (lock = locks; lock != NULL; lock = lock->next) { if (lock->object != object) continue; lock->count++; - if (of_mutex_unlock(&mutex) != 0) + if (OFPlainMutexUnlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); - if (of_rmutex_lock(&lock->rmutex) != 0) + if (OFPlainRecursiveMutexLock(&lock->rmutex) != 0) OBJC_ERROR("Failed to lock mutex!"); return 0; } /* Create a new lock */ if ((lock = malloc(sizeof(*lock))) == NULL) OBJC_ERROR("Failed to allocate memory for mutex!"); - if (of_rmutex_new(&lock->rmutex) != 0) + if (OFPlainRecursiveMutexNew(&lock->rmutex) != 0) OBJC_ERROR("Failed to create mutex!"); lock->object = object; lock->count = 1; lock->next = locks; locks = lock; - if (of_mutex_unlock(&mutex) != 0) + if (OFPlainMutexUnlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); - if (of_rmutex_lock(&lock->rmutex) != 0) + if (OFPlainRecursiveMutexLock(&lock->rmutex) != 0) OBJC_ERROR("Failed to lock mutex!"); #endif return 0; } @@ -96,26 +96,26 @@ { if (object == nil) return 0; #ifdef OF_HAVE_THREADS - struct lock_s *lock, *last = NULL; + struct lock *lock, *last = NULL; - if (of_mutex_lock(&mutex) != 0) + if (OFPlainMutexLock(&mutex) != 0) OBJC_ERROR("Failed to lock mutex!"); for (lock = locks; lock != NULL; lock = lock->next) { if (lock->object != object) { last = lock; continue; } - if (of_rmutex_unlock(&lock->rmutex) != 0) + if (OFPlainRecursiveMutexUnlock(&lock->rmutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); if (--lock->count == 0) { - if (of_rmutex_free(&lock->rmutex) != 0) + if (OFPlainRecursiveMutexFree(&lock->rmutex) != 0) OBJC_ERROR("Failed to destroy mutex!"); if (last != NULL) last->next = lock->next; if (locks == lock) @@ -122,11 +122,11 @@ locks = lock->next; free(lock); } - if (of_mutex_unlock(&mutex) != 0) + if (OFPlainMutexUnlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); return 0; } Index: src/runtime/threading.m ================================================================== --- src/runtime/threading.m +++ src/runtime/threading.m @@ -21,30 +21,30 @@ #import "ObjFWRT.h" #import "private.h" #import "mutex.h" #import "once.h" -static of_rmutex_t globalMutex; +static OFPlainRecursiveMutex globalMutex; static void init(void) { - if (of_rmutex_new(&globalMutex) != 0) + if (OFPlainRecursiveMutexNew(&globalMutex) != 0) OBJC_ERROR("Failed to create global mutex!"); } void objc_global_mutex_lock(void) { static OFOnceControl onceControl = OFOnceControlInitValue; OFOnce(&onceControl, init); - if (of_rmutex_lock(&globalMutex) != 0) + if (OFPlainRecursiveMutexLock(&globalMutex) != 0) OBJC_ERROR("Failed to lock global mutex!"); } void objc_global_mutex_unlock(void) { - if (of_rmutex_unlock(&globalMutex) != 0) + if (OFPlainRecursiveMutexUnlock(&globalMutex) != 0) OBJC_ERROR("Failed to unlock global mutex!"); }