Remove trailing whitespaces in *.c.

git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@1905414 13f79535-47bb-0310-9956-ffa450edef68

14 files changed, 125 insertions, 125 deletions

diff --git a/locks/beos/proc_mutex.c b/locks/beos/proc_mutex.c
index 35a5e8f10..47789a1e2 100644
--- a/locks/beos/proc_mutex.c
+++ b/locks/beos/proc_mutex.c
@@ -17,7 +17,7 @@
 /*Read/Write locking implementation based on the MultiLock code from
  * Stephen Beaulieu <hippo@be.com>
  */
- 
+
 #include "apr_arch_proc_mutex.h"
 #include "apr_strings.h"
 #include "apr_portable.h"
@@ -28,7 +28,7 @@ static apr_status_t _proc_mutex_cleanup(void * data)
     if (lock->LockCount != 0) {
         /* we're still locked... */
         while (atomic_add(&lock->LockCount , -1) > 1){
-            /* OK we had more than one person waiting on the lock so 
+            /* OK we had more than one person waiting on the lock so
              * the sem is also locked. Release it until we have no more
              * locks left.
              */
@@ -37,7 +37,7 @@ static apr_status_t _proc_mutex_cleanup(void * data)
     }
     delete_sem(lock->Lock);
     return APR_SUCCESS;
-}    
+}
 
 APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                 const char *fname,
@@ -46,7 +46,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
 {
     apr_proc_mutex_t *new;
     apr_status_t stat = APR_SUCCESS;
-  
+
     if (mech != APR_LOCK_DEFAULT && mech != APR_LOCK_DEFAULT_TIMED) {
         return APR_ENOTIMPL;
     }
@@ -55,13 +55,13 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
     if (new == NULL){
         return APR_ENOMEM;
     }
-    
+
     if ((stat = create_sem(0, "APR_Lock")) < B_NO_ERROR) {
         _proc_mutex_cleanup(new);
         return stat;
     }
     new->LockCount = 0;
-    new->Lock = stat;  
+    new->Lock = stat;
     new->pool  = pool;
 
     apr_pool_cleanup_register(new->pool, (void *)new, _proc_mutex_cleanup,
@@ -77,11 +77,11 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
 {
     return APR_SUCCESS;
 }
-    
+
 APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
 {
     int32 stat;
-    
+
     if (atomic_add(&mutex->LockCount, 1) > 0) {
         if ((stat = acquire_sem(mutex->Lock)) < B_NO_ERROR) {
             atomic_add(&mutex->LockCount, -1);
@@ -135,7 +135,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_timedlock(apr_proc_mutex_t *mutex,
 APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
 {
     int32 stat;
-    
+
     if (atomic_add(&mutex->LockCount, -1) > 1) {
         if ((stat = release_sem(mutex->Lock)) < B_NO_ERROR) {
             atomic_add(&mutex->LockCount, 1);
@@ -187,7 +187,7 @@ APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
 
 /* Implement OS-specific accessors defined in apr_portable.h */
 
-APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex,
                                                    apr_proc_mutex_t *pmutex,
                                                    apr_lockmech_e *mech)
 {
diff --git a/locks/beos/thread_cond.c b/locks/beos/thread_cond.c
index a0978c008..33b77cf71 100644
--- a/locks/beos/thread_cond.c
+++ b/locks/beos/thread_cond.c
@@ -36,16 +36,16 @@ static struct waiter_t *make_waiter(apr_pool_t *pool)
                        apr_palloc(pool, sizeof(struct waiter_t));
     if (w == NULL)
         return NULL;
-      
+
     w->sem  = create_sem(0, "apr conditional waiter");
     if (w->sem < 0)
         return NULL;
 
     APR_RING_ELEM_INIT(w, link);
-    
+
     return w;
 }
-  
+
 APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
                                                  apr_pool_t *pool)
 {
@@ -60,12 +60,12 @@ APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
 
     if ((rv = create_sem(1, "apr conditional lock")) < B_OK)
         return rv;
-    
+
     new_cond->lock = rv;
     new_cond->pool = pool;
     APR_RING_INIT(&new_cond->alist, waiter_t, link);
     APR_RING_INIT(&new_cond->flist, waiter_t, link);
-        
+
     for (i=0;i < 10 ;i++) {
         struct waiter_t *nw = make_waiter(pool);
         APR_RING_INSERT_TAIL(&new_cond->flist, nw, waiter_t, link);
@@ -87,8 +87,8 @@ static apr_status_t do_wait(apr_thread_cond_t *cond, apr_thread_mutex_t *mutex,
     thread_id cth = find_thread(NULL);
     apr_status_t rv;
     int flags = B_RELATIVE_TIMEOUT;
-    
-    /* We must be the owner of the mutex or we can't do this... */    
+
+    /* We must be the owner of the mutex or we can't do this... */
     if (mutex->owner != cth) {
         /* What should we return??? */
         return APR_EINVAL;
@@ -99,31 +99,31 @@ static apr_status_t do_wait(apr_thread_cond_t *cond, apr_thread_mutex_t *mutex,
     if (wait)
         APR_RING_REMOVE(wait, link);
     else
-        wait = make_waiter(cond->pool);   
+        wait = make_waiter(cond->pool);
     APR_RING_INSERT_TAIL(&cond->alist, wait, waiter_t, link);
     cond->condlock = mutex;
     release_sem(cond->lock);
-       
+
     apr_thread_mutex_unlock(cond->condlock);
 
     if (timeout == 0)
         flags = 0;
-        
+
     rv = acquire_sem_etc(wait->sem, 1, flags, timeout);
 
     apr_thread_mutex_lock(cond->condlock);
-    
+
     if (rv != B_OK) {
         if (rv == B_TIMED_OUT)
             return APR_TIMEUP;
-        return rv;       
+        return rv;
     }
 
     acquire_sem(cond->lock);
     APR_RING_REMOVE(wait, link);
     APR_RING_INSERT_TAIL(&cond->flist, wait, waiter_t, link);
     release_sem(cond->lock);
-    
+
     return APR_SUCCESS;
 }
 
@@ -144,7 +144,7 @@ APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
 {
     struct waiter_t *wake;
 
-    acquire_sem(cond->lock);    
+    acquire_sem(cond->lock);
     if (!APR_RING_EMPTY(&cond->alist, waiter_t, link)) {
         wake = APR_RING_FIRST(&cond->alist);
         APR_RING_REMOVE(wake, link);
@@ -152,14 +152,14 @@ APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
         APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link);
     }
     release_sem(cond->lock);
-    
+
     return APR_SUCCESS;
 }
 
 APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
 {
     struct waiter_t *wake;
-    
+
     acquire_sem(cond->lock);
     while (! APR_RING_EMPTY(&cond->alist, waiter_t, link)) {
         wake = APR_RING_FIRST(&cond->alist);
@@ -168,7 +168,7 @@ APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
         APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link);
     }
     release_sem(cond->lock);
-    
+
     return APR_SUCCESS;
 }
 
diff --git a/locks/beos/thread_mutex.c b/locks/beos/thread_mutex.c
index e4099d882..2cc1c6cc6 100644
--- a/locks/beos/thread_mutex.c
+++ b/locks/beos/thread_mutex.c
@@ -17,7 +17,7 @@
 /*Read/Write locking implementation based on the MultiLock code from
  * Stephen Beaulieu <hippo@be.com>
  */
- 
+
 #include "apr_arch_thread_mutex.h"
 #include "apr_strings.h"
 #include "apr_portable.h"
@@ -28,7 +28,7 @@ static apr_status_t _thread_mutex_cleanup(void * data)
     if (lock->LockCount != 0) {
         /* we're still locked... */
         while (atomic_add(&lock->LockCount , -1) > 1){
-            /* OK we had more than one person waiting on the lock so 
+            /* OK we had more than one person waiting on the lock so
              * the sem is also locked. Release it until we have no more
              * locks left.
              */
@@ -37,7 +37,7 @@ static apr_status_t _thread_mutex_cleanup(void * data)
     }
     delete_sem(lock->Lock);
     return APR_SUCCESS;
-}    
+}
 
 APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
                                                   unsigned int flags,
@@ -45,21 +45,21 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
 {
     apr_thread_mutex_t *new_m;
     apr_status_t stat = APR_SUCCESS;
-  
+
     new_m = (apr_thread_mutex_t *)apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
     if (new_m == NULL){
         return APR_ENOMEM;
     }
-    
+
     if ((stat = create_sem(0, "APR_Lock")) < B_NO_ERROR) {
         _thread_mutex_cleanup(new_m);
         return stat;
     }
     new_m->LockCount = 0;
-    new_m->Lock = stat;  
+    new_m->Lock = stat;
     new_m->pool  = pool;
 
-    /* Optimal default is APR_THREAD_MUTEX_UNNESTED, 
+    /* Optimal default is APR_THREAD_MUTEX_UNNESTED,
      * no additional checks required for either flag.
      */
     new_m->nested = flags & APR_THREAD_MUTEX_NESTED;
@@ -78,19 +78,19 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create_np(apr_thread_mutex_t **mutex,
                                                    apr_pool_t *pool)
 {
     return APR_ENOTIMPL;
-}       
+}
 #endif
-  
+
 APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
 {
     int32 stat;
     thread_id me = find_thread(NULL);
-    
+
     if (mutex->nested && mutex->owner == me) {
         mutex->owner_ref++;
         return APR_SUCCESS;
     }
-    
+
     if (atomic_add(&mutex->LockCount, 1) > 0) {
         if ((stat = acquire_sem(mutex->Lock)) < B_NO_ERROR) {
             /* Oh dear, acquire_sem failed!!  */
@@ -101,7 +101,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
 
     mutex->owner = me;
     mutex->owner_ref = 1;
-    
+
     return APR_SUCCESS;
 }
 
@@ -109,12 +109,12 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
 {
     int32 stat;
     thread_id me = find_thread(NULL);
-    
+
     if (mutex->nested && mutex->owner == me) {
         mutex->owner_ref++;
         return APR_SUCCESS;
     }
-    
+
     if (atomic_add(&mutex->LockCount, 1) > 0) {
         if ((stat = acquire_sem_etc(mutex->Lock, 1, 0, 0)) < B_NO_ERROR) {
             atomic_add(&mutex->LockCount, -1);
@@ -127,7 +127,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
 
     mutex->owner = me;
     mutex->owner_ref = 1;
-    
+
     return APR_SUCCESS;
 }
 
@@ -136,12 +136,12 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_timedlock(apr_thread_mutex_t *mutex,
 {
     int32 stat;
     thread_id me = find_thread(NULL);
-    
+
     if (mutex->nested && mutex->owner == me) {
         mutex->owner_ref++;
         return APR_SUCCESS;
     }
-    
+
     if (atomic_add(&mutex->LockCount, 1) > 0) {
         if (timeout <= 0) {
             stat = B_TIMED_OUT;
@@ -161,20 +161,20 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_timedlock(apr_thread_mutex_t *mutex,
 
     mutex->owner = me;
     mutex->owner_ref = 1;
-    
+
     return APR_SUCCESS;
 }
 
 APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
 {
     int32 stat;
-        
+
     if (mutex->nested && mutex->owner == find_thread(NULL)) {
         mutex->owner_ref--;
         if (mutex->owner_ref > 0)
             return APR_SUCCESS;
     }
-    
+
     if (atomic_add(&mutex->LockCount, -1) > 1) {
         if ((stat = release_sem(mutex->Lock)) < B_NO_ERROR) {
             atomic_add(&mutex->LockCount, 1);
diff --git a/locks/beos/thread_rwlock.c b/locks/beos/thread_rwlock.c
index a540b4455..363455a7a 100644
--- a/locks/beos/thread_rwlock.c
+++ b/locks/beos/thread_rwlock.c
@@ -17,7 +17,7 @@
 /*Read/Write locking implementation based on the MultiLock code from
  * Stephen Beaulieu <hippo@be.com>
  */
- 
+
 #include "apr_arch_thread_rwlock.h"
 #include "apr_strings.h"
 #include "apr_portable.h"
@@ -43,23 +43,23 @@ static apr_status_t _thread_rw_cleanup(void * data)
             release_sem (mutex->Lock);
     	}
     }
-    
+
     delete_sem(mutex->Read);
     delete_sem(mutex->Write);
     delete_sem(mutex->Lock);
     return APR_SUCCESS;
-}    
+}
 
 APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
                                                    apr_pool_t *pool)
 {
     apr_thread_rwlock_t *new;
-  
+
     new = (apr_thread_rwlock_t *)apr_pcalloc(pool, sizeof(apr_thread_rwlock_t));
     if (new == NULL){
         return APR_ENOMEM;
     }
-    
+
     new->pool  = pool;
     /* we need to make 3 locks... */
     new->ReadCount = 0;
@@ -68,7 +68,7 @@ APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
     new->Read  = create_sem(0, "APR_ReadLock");
     new->Write = create_sem(0, "APR_WriteLock");
     new->Lock  = create_sem(0, "APR_Lock");
-    
+
     if (new->Lock < 0 || new->Read < 0 || new->Write < 0) {
         _thread_rw_cleanup(new);
         return -1;
@@ -132,7 +132,7 @@ APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
                 rwlock->writer = find_thread(NULL);
         }
     }
-    
+
     return rv;
 }
 
diff --git a/locks/netware/proc_mutex.c b/locks/netware/proc_mutex.c
index 287011b06..999ad3549 100644
--- a/locks/netware/proc_mutex.c
+++ b/locks/netware/proc_mutex.c
@@ -40,8 +40,8 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
     new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool, sizeof(apr_proc_mutex_t));
     if (new_mutex == NULL) {
         return APR_ENOMEM;
-    }     
-    
+    }
+
     new_mutex->pool = pool;
     ret = apr_thread_mutex_create(&(new_mutex->mutex), flags, pool);
 
@@ -57,7 +57,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
 {
     return APR_SUCCESS;
 }
-    
+
 APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
 {
     if (mutex)
@@ -125,7 +125,7 @@ APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
 
 /* Implement OS-specific accessors defined in apr_portable.h */
 
-APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex,
                                                    apr_proc_mutex_t *pmutex,
                                                    apr_lockmech_e *mech)
 {
diff --git a/locks/netware/thread_cond.c b/locks/netware/thread_cond.c
index 432b0d290..51934a53a 100644
--- a/locks/netware/thread_cond.c
+++ b/locks/netware/thread_cond.c
@@ -28,9 +28,9 @@ static apr_status_t thread_cond_cleanup(void *data)
 {
     apr_thread_cond_t *cond = (apr_thread_cond_t *)data;
 
-    NXCondFree(cond->cond);        
+    NXCondFree(cond->cond);
     return APR_SUCCESS;
-} 
+}
 
 APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
                                                  apr_pool_t *pool)
@@ -38,18 +38,18 @@ APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
     apr_thread_cond_t *new_cond = NULL;
 
     new_cond = (apr_thread_cond_t *)apr_pcalloc(pool, sizeof(apr_thread_cond_t));
-	
+
 	if(new_cond ==NULL) {
         return APR_ENOMEM;
-    }     
+    }
     new_cond->pool = pool;
 
     new_cond->cond = NXCondAlloc(NULL);
-    
+
     if(new_cond->cond == NULL)
         return APR_ENOMEM;
 
-    apr_pool_cleanup_register(new_cond->pool, new_cond, 
+    apr_pool_cleanup_register(new_cond->pool, new_cond,
                                 (void*)thread_cond_cleanup,
                                 apr_pool_cleanup_null);
    *cond = new_cond;
diff --git a/locks/netware/thread_mutex.c b/locks/netware/thread_mutex.c
index 435abebba..9698b1f98 100644
--- a/locks/netware/thread_mutex.c
+++ b/locks/netware/thread_mutex.c
@@ -26,7 +26,7 @@ static apr_status_t thread_mutex_cleanup(void *data)
 {
     apr_thread_mutex_t *mutex = (apr_thread_mutex_t *)data;
 
-    NXMutexFree(mutex->mutex);        
+    NXMutexFree(mutex->mutex);
     return APR_SUCCESS;
 }
 
@@ -45,23 +45,23 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
 
     if (new_mutex == NULL) {
         return APR_ENOMEM;
-    }     
+    }
     new_mutex->pool = pool;
 
     new_mutex->mutex = NXMutexAlloc(NX_MUTEX_RECURSIVE, 0, NULL);
-    
+
     if(new_mutex->mutex == NULL)
         return APR_ENOMEM;
 
     if (flags & APR_THREAD_MUTEX_TIMED) {
         apr_status_t rv = apr_thread_cond_create(&new_mutex->cond, pool);
         if (rv != APR_SUCCESS) {
-            NXMutexFree(new_mutex->mutex);        
+            NXMutexFree(new_mutex->mutex);
             return rv;
         }
     }
 
-    apr_pool_cleanup_register(new_mutex->pool, new_mutex, 
+    apr_pool_cleanup_register(new_mutex->pool, new_mutex,
                                 (void*)thread_mutex_cleanup,
                                 apr_pool_cleanup_null);
    *mutex = new_mutex;
diff --git a/locks/netware/thread_rwlock.c b/locks/netware/thread_rwlock.c
index f971aefd4..010b9de6f 100644
--- a/locks/netware/thread_rwlock.c
+++ b/locks/netware/thread_rwlock.c
@@ -27,13 +27,13 @@ static apr_status_t thread_rwlock_cleanup(void *data)
 
     NXRwLockFree (rwlock->rwlock);
     return APR_SUCCESS;
-} 
+}
 
 APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
                                                    apr_pool_t *pool)
 {
     apr_thread_rwlock_t *new_rwlock = NULL;
-   
+
     NXHierarchy_t hierarchy = 1;   /* for libc NKS NXRwLockAlloc */
     NXLockInfo_t *info;            /* for libc NKS NXRwLockAlloc */
 
@@ -41,9 +41,9 @@ APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
 
     if(new_rwlock ==NULL) {
         return APR_ENOMEM;
-    }     
+    }
     new_rwlock->pool = pool;
-    
+
     info = (NXLockInfo_t *)apr_pcalloc(pool, sizeof(NXLockInfo_t));
     new_rwlock->rwlock = NXRwLockAlloc(hierarchy, info);
     if(new_rwlock->rwlock == NULL)
diff --git a/locks/os2/proc_mutex.c b/locks/os2/proc_mutex.c
index a86c208b3..0dde9a06f 100644
--- a/locks/os2/proc_mutex.c
+++ b/locks/os2/proc_mutex.c
@@ -165,7 +165,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_timedlock(apr_proc_mutex_t *mutex,
                                                apr_interval_time_t timeout)
 {
     ULONG rc;
-    
+
     if (timeout <= 0) {
         rc = DosRequestMutexSem(mutex->hMutex, SEM_IMMEDIATE_RETURN);
     }
@@ -234,7 +234,7 @@ APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
 
 /* Implement OS-specific accessors defined in apr_portable.h */
 
-APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex,
                                                    apr_proc_mutex_t *pmutex,
                                                    apr_lockmech_e *mech)
 {
diff --git a/locks/unix/proc_mutex.c b/locks/unix/proc_mutex.c
index ef3676152..22a79d4b7 100644
--- a/locks/unix/proc_mutex.c
+++ b/locks/unix/proc_mutex.c
@@ -38,7 +38,7 @@ static apr_status_t proc_mutex_no_child_init(apr_proc_mutex_t **mutex,
 {
     return APR_SUCCESS;
 }
-#endif    
+#endif
 
 #if APR_HAS_POSIXSEM_SERIALIZE || APR_HAS_PROC_PTHREAD_SERIALIZE
 static apr_status_t proc_mutex_no_perms_set(apr_proc_mutex_t *mutex,
@@ -48,7 +48,7 @@ static apr_status_t proc_mutex_no_perms_set(apr_proc_mutex_t *mutex,
 {
     return APR_ENOTIMPL;
 }
-#endif    
+#endif
 
 #if APR_HAS_FCNTL_SERIALIZE \
     || APR_HAS_FLOCK_SERIALIZE \
@@ -98,13 +98,13 @@ static apr_status_t proc_mutex_spinsleep_timedacquire(apr_proc_mutex_t *mutex,
 static apr_status_t proc_mutex_posix_cleanup(void *mutex_)
 {
     apr_proc_mutex_t *mutex = mutex_;
-    
+
     if (sem_close(mutex->os.psem_interproc) < 0) {
         return errno;
     }
 
     return APR_SUCCESS;
-}    
+}
 
 static apr_status_t proc_mutex_posix_create(apr_proc_mutex_t *new_mutex,
                                             const char *fname)
@@ -113,7 +113,7 @@ static apr_status_t proc_mutex_posix_create(apr_proc_mutex_t *new_mutex,
     #define APR_POSIXSEM_NAME_MIN 13
     sem_t *psem;
     char semname[APR_MD5_DIGESTSIZE * 2 + 2];
-    
+
     /*
      * This bogusness is to follow what appears to be the
      * lowest common denominator in Posix semaphore naming:
@@ -179,7 +179,7 @@ static apr_status_t proc_mutex_posix_create(apr_proc_mutex_t *new_mutex,
     new_mutex->os.psem_interproc = psem;
     new_mutex->fname = apr_pstrdup(new_mutex->pool, semname);
     apr_pool_cleanup_register(new_mutex->pool, (void *)new_mutex,
-                              apr_proc_mutex_cleanup, 
+                              apr_proc_mutex_cleanup,
                               apr_pool_cleanup_null);
     return APR_SUCCESS;
 }
@@ -230,7 +230,7 @@ static apr_status_t proc_mutex_posix_timedacquire(apr_proc_mutex_t *mutex,
         timeout += apr_time_now();
         abstime.tv_sec = apr_time_sec(timeout);
         abstime.tv_nsec = apr_time_usec(timeout) * 1000; /* nanoseconds */
-        
+
         do {
             rc = sem_timedwait(mutex->os.psem_interproc, &abstime);
         } while (rc < 0 && errno == EINTR);
@@ -305,20 +305,20 @@ static apr_status_t proc_mutex_sysv_cleanup(void *mutex_)
 {
     apr_proc_mutex_t *mutex=mutex_;
     union semun ick;
-    
+
     if (mutex->os.crossproc != -1) {
         ick.val = 0;
         semctl(mutex->os.crossproc, 0, IPC_RMID, ick);
     }
     return APR_SUCCESS;
-}    
+}
 
 static apr_status_t proc_mutex_sysv_create(apr_proc_mutex_t *new_mutex,
                                            const char *fname)
 {
     union semun ick;
     apr_status_t rv;
-    
+
     new_mutex->os.crossproc = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
     if (new_mutex->os.crossproc == -1) {
         rv = errno;
@@ -334,7 +334,7 @@ static apr_status_t proc_mutex_sysv_create(apr_proc_mutex_t *new_mutex,
     }
     new_mutex->curr_locked = 0;
     apr_pool_cleanup_register(new_mutex->pool,
-                              (void *)new_mutex, apr_proc_mutex_cleanup, 
+                              (void *)new_mutex, apr_proc_mutex_cleanup,
                               apr_pool_cleanup_null);
     return APR_SUCCESS;
 }
@@ -588,7 +588,7 @@ static apr_status_t proc_mutex_pthread_create(apr_proc_mutex_t *new_mutex,
 
     new_mutex->os.pthread_interproc = mmap(NULL, sizeof(proc_pthread_mutex_t),
                                            PROT_READ | PROT_WRITE, MAP_SHARED,
-                                           fd, 0); 
+                                           fd, 0);
     if (new_mutex->os.pthread_interproc == MAP_FAILED) {
         new_mutex->os.pthread_interproc = NULL;
         rv = errno;
@@ -665,18 +665,18 @@ static apr_status_t proc_mutex_pthread_create(apr_proc_mutex_t *new_mutex,
 
     apr_pool_cleanup_register(new_mutex->pool,
                               (void *)new_mutex,
-                              apr_proc_mutex_cleanup, 
+                              apr_proc_mutex_cleanup,
                               apr_pool_cleanup_null);
     return APR_SUCCESS;
 }
 
 static apr_status_t proc_mutex_pthread_child_init(apr_proc_mutex_t **mutex,
-                                                  apr_pool_t *pool, 
+                                                  apr_pool_t *pool,
                                                   const char *fname)
 {
     (*mutex)->curr_locked = 0;
     if (proc_pthread_mutex_inc(*mutex)) {
-        apr_pool_cleanup_register(pool, *mutex, proc_pthread_mutex_unref, 
+        apr_pool_cleanup_register(pool, *mutex, proc_pthread_mutex_unref,
                                   apr_pool_cleanup_null);
     }
     return APR_SUCCESS;
@@ -690,7 +690,7 @@ static apr_status_t proc_mutex_pthread_acquire_ex(apr_proc_mutex_t *mutex,
 #if APR_USE_PROC_PTHREAD_MUTEX_COND
     if (proc_pthread_mutex_is_cond(mutex)) {
         if ((rv = pthread_mutex_lock(&proc_pthread_mutex(mutex)))) {
-#ifdef HAVE_ZOS_PTHREADS 
+#ifdef HAVE_ZOS_PTHREADS
             rv = errno;
 #endif
 #if defined(HAVE_PTHREAD_MUTEX_ROBUST) || defined(HAVE_PTHREAD_MUTEX_ROBUST_NP)
@@ -800,7 +800,7 @@ static apr_status_t proc_mutex_pthread_acquire_ex(apr_proc_mutex_t *mutex,
 
             rv = pthread_mutex_timedlock(&proc_pthread_mutex(mutex), &abstime);
             if (rv) {
-#ifdef HAVE_ZOS_PTHREADS 
+#ifdef HAVE_ZOS_PTHREADS
                 rv = errno;
 #endif
                 if (rv == ETIMEDOUT) {
@@ -856,7 +856,7 @@ static apr_status_t proc_mutex_pthread_release(apr_proc_mutex_t *mutex)
 #if APR_USE_PROC_PTHREAD_MUTEX_COND
     if (proc_pthread_mutex_is_cond(mutex)) {
         if ((rv = pthread_mutex_lock(&proc_pthread_mutex(mutex)))) {
-#ifdef HAVE_ZOS_PTHREADS 
+#ifdef HAVE_ZOS_PTHREADS
             rv = errno;
 #endif
 #if defined(HAVE_PTHREAD_MUTEX_ROBUST) || defined(HAVE_PTHREAD_MUTEX_ROBUST_NP)
@@ -940,7 +940,7 @@ static apr_status_t proc_mutex_pthread_cond_create(apr_proc_mutex_t *new_mutex,
         rv = errno;
 #endif
         apr_pool_cleanup_run(new_mutex->pool, new_mutex,
-                             apr_proc_mutex_cleanup); 
+                             apr_proc_mutex_cleanup);
         return rv;
     }
     if ((rv = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED))) {
@@ -949,7 +949,7 @@ static apr_status_t proc_mutex_pthread_cond_create(apr_proc_mutex_t *new_mutex,
 #endif
         pthread_condattr_destroy(&cattr);
         apr_pool_cleanup_run(new_mutex->pool, new_mutex,
-                             apr_proc_mutex_cleanup); 
+                             apr_proc_mutex_cleanup);
         return rv;
     }
     if ((rv = pthread_cond_init(&proc_pthread_mutex_cond(new_mutex),
@@ -959,7 +959,7 @@ static apr_status_t proc_mutex_pthread_cond_create(apr_proc_mutex_t *new_mutex,
 #endif
         pthread_condattr_destroy(&cattr);
         apr_pool_cleanup_run(new_mutex->pool, new_mutex,
-                             apr_proc_mutex_cleanup); 
+                             apr_proc_mutex_cleanup);
         return rv;
     }
     pthread_condattr_destroy(&cattr);
@@ -1019,7 +1019,7 @@ static apr_status_t proc_mutex_fcntl_cleanup(void *mutex_)
         if (status != APR_SUCCESS)
             return status;
     }
-        
+
     if (mutex->interproc) {
         status = apr_file_close(mutex->interproc);
     }
@@ -1030,13 +1030,13 @@ static apr_status_t proc_mutex_fcntl_cleanup(void *mutex_)
         status = errno;
     }
     return status;
-}    
+}
 
 static apr_status_t proc_mutex_fcntl_create(apr_proc_mutex_t *new_mutex,
                                             const char *fname)
 {
     int rv;
- 
+
     if (fname) {
         new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
         rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
@@ -1050,7 +1050,7 @@ static apr_status_t proc_mutex_fcntl_create(apr_proc_mutex_t *new_mutex,
                              APR_FOPEN_CREATE | APR_FOPEN_WRITE | APR_FOPEN_EXCL,
                              new_mutex->pool);
     }
- 
+
     if (rv != APR_SUCCESS) {
         return rv;
     }
@@ -1061,9 +1061,9 @@ static apr_status_t proc_mutex_fcntl_create(apr_proc_mutex_t *new_mutex,
     unlink(new_mutex->fname);
     apr_pool_cleanup_register(new_mutex->pool,
                               (void*)new_mutex,
-                              apr_proc_mutex_cleanup, 
+                              apr_proc_mutex_cleanup,
                               apr_pool_cleanup_null);
-    return APR_SUCCESS; 
+    return APR_SUCCESS;
 }
 
 static apr_status_t proc_mutex_fcntl_acquire(apr_proc_mutex_t *mutex)
@@ -1179,13 +1179,13 @@ static apr_status_t proc_mutex_flock_cleanup(void *mutex_)
         unlink(mutex->fname);
     }
     return status;
-}    
+}
 
 static apr_status_t proc_mutex_flock_create(apr_proc_mutex_t *new_mutex,
                                             const char *fname)
 {
     int rv;
- 
+
     if (fname) {
         new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
         rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
@@ -1199,7 +1199,7 @@ static apr_status_t proc_mutex_flock_create(apr_proc_mutex_t *new_mutex,
                              APR_FOPEN_CREATE | APR_FOPEN_WRITE | APR_FOPEN_EXCL,
                              new_mutex->pool);
     }
- 
+
     if (rv != APR_SUCCESS) {
         proc_mutex_flock_cleanup(new_mutex);
         return rv;
@@ -1260,7 +1260,7 @@ static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)
 }
 
 static apr_status_t proc_mutex_flock_child_init(apr_proc_mutex_t **mutex,
-                                                apr_pool_t *pool, 
+                                                apr_pool_t *pool,
                                                 const char *fname)
 {
     apr_proc_mutex_t *new_mutex;
@@ -1521,7 +1521,7 @@ APR_DECLARE(const char *) apr_proc_mutex_defname(void)
 
     return apr_proc_mutex_name(&mutex);
 }
-   
+
 static apr_status_t proc_mutex_create(apr_proc_mutex_t *new_mutex, apr_lockmech_e mech, const char *fname)
 {
     apr_status_t rv;
@@ -1626,7 +1626,7 @@ APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
 
 /* Implement OS-specific accessors defined in apr_portable.h */
 
-APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex,
                                                    apr_proc_mutex_t *pmutex,
                                                    apr_lockmech_e *mech)
 {
@@ -1668,7 +1668,7 @@ APR_DECLARE(apr_status_t) apr_os_proc_mutex_put_ex(apr_proc_mutex_t **pmutex,
 #endif
 
     if (rv == APR_SUCCESS && register_cleanup) {
-        apr_pool_cleanup_register(pool, *pmutex, apr_proc_mutex_cleanup, 
+        apr_pool_cleanup_register(pool, *pmutex, apr_proc_mutex_cleanup,
                                   apr_pool_cleanup_null);
     }
     return rv;
diff --git a/locks/unix/thread_cond.c b/locks/unix/thread_cond.c
index 3c8e3170a..5a31a1f03 100644
--- a/locks/unix/thread_cond.c
+++ b/locks/unix/thread_cond.c
@@ -33,7 +33,7 @@ static apr_status_t thread_cond_cleanup(void *data)
     }
 #endif
     return rv;
-} 
+}
 
 APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
                                                  apr_pool_t *pool)
diff --git a/locks/unix/thread_mutex.c b/locks/unix/thread_mutex.c
index 9cd643bec..10cb7bab6 100644
--- a/locks/unix/thread_mutex.c
+++ b/locks/unix/thread_mutex.c
@@ -32,7 +32,7 @@ static apr_status_t thread_mutex_cleanup(void *data)
     }
 #endif
     return rv;
-} 
+}
 
 APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
                                                   unsigned int flags,
@@ -40,7 +40,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
 {
     apr_thread_mutex_t *new_mutex;
     apr_status_t rv;
-    
+
 #ifndef HAVE_PTHREAD_MUTEX_RECURSIVE
     if (flags & APR_THREAD_MUTEX_NESTED) {
         return APR_ENOTIMPL;
@@ -53,18 +53,18 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
 #ifdef HAVE_PTHREAD_MUTEX_RECURSIVE
     if (flags & APR_THREAD_MUTEX_NESTED) {
         pthread_mutexattr_t mattr;
-        
+
         rv = pthread_mutexattr_init(&mattr);
         if (rv) return rv;
-        
+
         rv = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
         if (rv) {
             pthread_mutexattr_destroy(&mattr);
             return rv;
         }
-         
+
         rv = pthread_mutex_init(&new_mutex->mutex, &mattr);
-        
+
         pthread_mutexattr_destroy(&mattr);
     } else
 #endif
@@ -74,7 +74,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
 
         rv = pthread_mutexattr_init(&mattr);
         if (rv) return rv;
-        
+
         rv = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK);
         if (rv) {
             pthread_mutexattr_destroy(&mattr);
@@ -351,7 +351,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
     if (rv == APR_SUCCESS) {
         rv = rv2;
     }
-    
+
     return rv;
 }
 
diff --git a/locks/unix/thread_rwlock.c b/locks/unix/thread_rwlock.c
index 0f8b7a79f..91e39f72c 100644
--- a/locks/unix/thread_rwlock.c
+++ b/locks/unix/thread_rwlock.c
@@ -35,7 +35,7 @@ static apr_status_t thread_rwlock_cleanup(void *data)
     }
 #endif
     return stat;
-} 
+}
 
 APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
                                                    apr_pool_t *pool)
diff --git a/locks/win32/proc_mutex.c b/locks/win32/proc_mutex.c
index 79236237b..2cf994d94 100644
--- a/locks/win32/proc_mutex.c
+++ b/locks/win32/proc_mutex.c
@@ -67,7 +67,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
     (*mutex)->pool = pool;
     (*mutex)->handle = hMutex;
     (*mutex)->fname = fname;
-    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+    apr_pool_cleanup_register((*mutex)->pool, *mutex,
                               proc_mutex_cleanup, apr_pool_cleanup_null);
     return APR_SUCCESS;
 }
@@ -99,11 +99,11 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
     (*mutex)->pool = pool;
     (*mutex)->handle = hMutex;
     (*mutex)->fname = fname;
-    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+    apr_pool_cleanup_register((*mutex)->pool, *mutex,
                               proc_mutex_cleanup, apr_pool_cleanup_null);
     return APR_SUCCESS;
 }
-    
+
 APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
 {
     DWORD rv;
@@ -124,7 +124,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
 
     if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
         return APR_SUCCESS;
-    } 
+    }
     else if (rv == WAIT_TIMEOUT) {
         return APR_EBUSY;
     }
@@ -143,7 +143,7 @@ APR_DECLARE(apr_status_t) apr_proc_mutex_timedlock(apr_proc_mutex_t *mutex,
     }
     if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
         return APR_SUCCESS;
-    } 
+    }
     return apr_get_os_error();
 }
 
@@ -197,7 +197,7 @@ APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
 
 /* Implement OS-specific accessors defined in apr_portable.h */
 
-APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex,
                                                    apr_proc_mutex_t *pmutex,
                                                    apr_lockmech_e *mech)
 {