@@ -26,146 +26,145 @@
 
 #import "macros.h"
 
 #if defined(OF_HAVE_PTHREADS)
 # include <pthread.h>
-typedef pthread_mutex_t of_mutex_t;
+typedef pthread_mutex_t OFPlainMutex;
 #elif defined(OF_WINDOWS)
 # include <windows.h>
-typedef CRITICAL_SECTION of_mutex_t;
+typedef CRITICAL_SECTION OFPlainMutex;
 #elif defined(OF_AMIGAOS)
 # include <exec/semaphores.h>
-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
+# import "OFAtomic.h"
+typedef volatile int OFSpinlock;
 #elif defined(OF_HAVE_PTHREAD_SPINLOCKS)
-typedef pthread_spinlock_t of_spinlock_t;
+typedef pthread_spinlock_t OFSpinlock;
 #else
-typedef of_mutex_t of_spinlock_t;
+typedef OFPlainMutex OFSpinlock;
 #endif
 
 #ifdef OF_HAVE_SCHED_YIELD
 # include <sched.h>
 #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"
+# import "OFTLSKey.h"
 typedef struct {
-	of_mutex_t mutex;
-	of_tlskey_t count;
-} of_rmutex_t;
+	OFPlainMutex mutex;
+	OFTLSKey count;
+} 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. */
 
 static OF_INLINE void
-of_thread_yield(void)
+OFYieldThread(void)
 {
 #if defined(OF_HAVE_SCHED_YIELD)
 	sched_yield();
 #elif defined(OF_WINDOWS)
 	Sleep(0);
 #endif
 }
 
 static OF_INLINE int
-of_spinlock_new(of_spinlock_t *spinlock)
+OFSpinlockNew(OFSpinlock *spinlock)
 {
 #if defined(OF_HAVE_ATOMIC_OPS)
 	*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)
+OFSpinlockTryLock(OFSpinlock *spinlock)
 {
 #if defined(OF_HAVE_ATOMIC_OPS)
-	if (of_atomic_int_cmpswap(spinlock, 0, 1)) {
-		of_memory_barrier_acquire();
+	if (OFAtomicIntCompareAndSwap(spinlock, 0, 1)) {
+		OFAcquireMemoryBarrier();
 		return 0;
 	}
 
 	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)
+OFSpinlockLock(OFSpinlock *spinlock)
 {
 #if defined(OF_HAVE_ATOMIC_OPS)
 	size_t i;
 
-	for (i = 0; i < OF_SPINCOUNT; i++)
-		if (of_spinlock_trylock(spinlock) == 0)
+	for (i = 0; i < 10; i++)
+		if (OFSpinlockTryLock(spinlock) == 0)
 			return 0;
 
-	while (of_spinlock_trylock(spinlock) == EBUSY)
-		of_thread_yield();
+	while (OFSpinlockTryLock(spinlock) == EBUSY)
+		OFYieldThread();
 
 	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)
+OFSpinlockUnlock(OFSpinlock *spinlock)
 {
 #if defined(OF_HAVE_ATOMIC_OPS)
-	bool ret = of_atomic_int_cmpswap(spinlock, 1, 0);
+	bool ret = OFAtomicIntCompareAndSwap(spinlock, 1, 0);
 
-	of_memory_barrier_release();
+	OFReleaseMemoryBarrier();
 
 	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)
+OFSpinlockFree(OFSpinlock *spinlock)
 {
 #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
 }