From cdd43d43c9be3914bfeca4b1548885b9b44dcabb Mon Sep 17 00:00:00 2001 From: Ryan Lortie Date: Sun, 2 Oct 2011 20:24:18 -0400 Subject: [PATCH] locks: rename a bunch of parameters --- glib/gthread-posix.c | 84 ++++++++++++++++++++++++++-------------------------- glib/gthread.h | 16 +++++----- 2 files changed, 50 insertions(+), 50 deletions(-) diff --git a/glib/gthread-posix.c b/glib/gthread-posix.c index 3670d4f..c9ccaa1 100644 --- a/glib/gthread-posix.c +++ b/glib/gthread-posix.c @@ -255,16 +255,16 @@ g_rec_mutex_impl_free (pthread_mutex_t *mutex) } static pthread_mutex_t * -g_rec_mutex_get_impl (GRecMutex *mutex) +g_rec_mutex_get_impl (GRecMutex *rec_mutex) { - pthread_mutex_t *impl = mutex->impl; + pthread_mutex_t *impl = rec_mutex->impl; - if G_UNLIKELY (mutex->impl == NULL) + if G_UNLIKELY (rec_mutex->impl == NULL) { impl = g_rec_mutex_impl_new (); - if (!g_atomic_pointer_compare_and_exchange (&mutex->impl, NULL, impl)) + if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->impl, NULL, impl)) g_rec_mutex_impl_free (impl); - impl = mutex->impl; + impl = rec_mutex->impl; } return impl; @@ -395,7 +395,7 @@ g_rec_mutex_trylock (GRecMutex *rec_mutex) /** * g_rw_lock_init: - * @lock: an uninitialized #GRWLock + * @rw_lock: an uninitialized #GRWLock * * Initializes a #GRWLock so that it can be used. * @@ -425,14 +425,14 @@ g_rec_mutex_trylock (GRecMutex *rec_mutex) * Since: 2.32 */ void -g_rw_lock_init (GRWLock *lock) +g_rw_lock_init (GRWLock *rw_lock) { - pthread_rwlock_init (&lock->impl, NULL); + pthread_rwlock_init (&rw_lock->impl, NULL); } /** * g_rw_lock_clear: - * @lock: an initialized #GRWLock + * @rw_lock: an initialized #GRWLock * * Frees the resources allocated to a lock with g_rw_lock_init(). * @@ -442,43 +442,43 @@ g_rw_lock_init (GRWLock *lock) * Sine: 2.32 */ void -g_rw_lock_clear (GRWLock *lock) +g_rw_lock_clear (GRWLock *rw_lock) { - pthread_rwlock_destroy (&lock->impl); + pthread_rwlock_destroy (&rw_lock->impl); } /** * g_rw_lock_writer_lock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Obtain a write lock on @lock. If any thread already holds - * a read or write lock on @lock, the current thread will block - * until all other threads have dropped their locks on @lock. + * Obtain a write lock on @rw_lock. If any thread already holds + * a read or write lock on @rw_lock, the current thread will block + * until all other threads have dropped their locks on @rw_lock. * * Since: 2.32 */ void -g_rw_lock_writer_lock (GRWLock *lock) +g_rw_lock_writer_lock (GRWLock *rw_lock) { - pthread_rwlock_wrlock (&lock->impl); + pthread_rwlock_wrlock (&rw_lock->impl); } /** * g_rw_lock_writer_trylock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Tries to obtain a write lock on @lock. If any other thread holds - * a read or write lock on @lock, it immediately returns %FALSE. - * Otherwise it locks @lock and returns %TRUE. + * Tries to obtain a write lock on @rw_lock. If any other thread holds + * a read or write lock on @rw_lock, it immediately returns %FALSE. + * Otherwise it locks @rw_lock and returns %TRUE. * - * Returns: %TRUE if @lock could be locked + * Returns: %TRUE if @rw_lock could be locked * * Since: 2.32 */ gboolean -g_rw_lock_writer_trylock (GRWLock *lock) +g_rw_lock_writer_trylock (GRWLock *rw_lock) { - if (pthread_rwlock_trywrlock (&lock->impl) != 0) + if (pthread_rwlock_trywrlock (&rw_lock->impl) != 0) return FALSE; return TRUE; @@ -486,9 +486,9 @@ g_rw_lock_writer_trylock (GRWLock *lock) /** * g_rw_lock_writer_unlock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Release a write lock on @lock. + * Release a write lock on @rw_lock. * * Calling g_rw_lock_writer_unlock() on a lock that is not held * by the current thread leads to undefined behaviour. @@ -496,17 +496,17 @@ g_rw_lock_writer_trylock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_writer_unlock (GRWLock *lock) +g_rw_lock_writer_unlock (GRWLock *rw_lock) { - pthread_rwlock_unlock (&lock->impl); + pthread_rwlock_unlock (&rw_lock->impl); } /** * g_rw_lock_reader_lock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Obtain a read lock on @lock. If another thread currently holds - * the write lock on @lock or blocks waiting for it, the current + * Obtain a read lock on @rw_lock. If another thread currently holds + * the write lock on @rw_lock or blocks waiting for it, the current * thread will block. Read locks can be taken recursively. * * It is implementation-defined how many threads are allowed to @@ -515,27 +515,27 @@ g_rw_lock_writer_unlock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_reader_lock (GRWLock *lock) +g_rw_lock_reader_lock (GRWLock *rw_lock) { - pthread_rwlock_rdlock (&lock->impl); + pthread_rwlock_rdlock (&rw_lock->impl); } /** * g_rw_lock_reader_trylock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Tries to obtain a read lock on @lock and returns %TRUE if + * Tries to obtain a read lock on @rw_lock and returns %TRUE if * the read lock was successfully obtained. Otherwise it * returns %FALSE. * - * Returns: %TRUE if @lock could be locked + * Returns: %TRUE if @rw_lock could be locked * * Since: 2.32 */ gboolean -g_rw_lock_reader_trylock (GRWLock *lock) +g_rw_lock_reader_trylock (GRWLock *rw_lock) { - if (pthread_rwlock_tryrdlock (&lock->impl) != 0) + if (pthread_rwlock_tryrdlock (&rw_lock->impl) != 0) return FALSE; return TRUE; @@ -543,9 +543,9 @@ g_rw_lock_reader_trylock (GRWLock *lock) /** * g_rw_lock_reader_unlock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Release a read lock on @lock. + * Release a read lock on @rw_lock. * * Calling g_rw_lock_reader_unlock() on a lock that is not held * by the current thread leads to undefined behaviour. @@ -553,9 +553,9 @@ g_rw_lock_reader_trylock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_reader_unlock (GRWLock *lock) +g_rw_lock_reader_unlock (GRWLock *rw_lock) { - pthread_rwlock_unlock (&lock->impl); + pthread_rwlock_unlock (&rw_lock->impl); } /* {{{1 GCond */ diff --git a/glib/gthread.h b/glib/gthread.h index 67106e5..c481c0e 100644 --- a/glib/gthread.h +++ b/glib/gthread.h @@ -251,14 +251,14 @@ void g_mutex_lock (GMutex void g_mutex_unlock (GMutex *mutex); gboolean g_mutex_trylock (GMutex *mutex); -void g_rw_lock_init (GRWLock *lock); -void g_rw_lock_clear (GRWLock *lock); -void g_rw_lock_writer_lock (GRWLock *lock); -gboolean g_rw_lock_writer_trylock (GRWLock *lock); -void g_rw_lock_writer_unlock (GRWLock *lock); -void g_rw_lock_reader_lock (GRWLock *lock); -gboolean g_rw_lock_reader_trylock (GRWLock *lock); -void g_rw_lock_reader_unlock (GRWLock *lock); +void g_rw_lock_init (GRWLock *rw_lock); +void g_rw_lock_clear (GRWLock *rw_lock); +void g_rw_lock_writer_lock (GRWLock *rw_lock); +gboolean g_rw_lock_writer_trylock (GRWLock *rw_lock); +void g_rw_lock_writer_unlock (GRWLock *rw_lock); +void g_rw_lock_reader_lock (GRWLock *rw_lock); +gboolean g_rw_lock_reader_trylock (GRWLock *rw_lock); +void g_rw_lock_reader_unlock (GRWLock *rw_lock); void g_rec_mutex_init (GRecMutex *rec_mutex); void g_rec_mutex_clear (GRecMutex *rec_mutex); -- 2.7.4