Cleanup: Fix various coding style issues in src/untrusted/pthread

src/untrusted/pthread/nc_mutex.c

 /*
  * Copyright (c) 2011 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Native Client mutex implementation
  */
 
@@ skipping 18 matching lines @@
 
   if (nc_token_acquire(&mutex->token)) {
     /* Mutex_type was set by pthread_mutex_init */
     rv = nc_thread_mutex_init(mutex);
     nc_token_release(&mutex->token);
   }
 
   return rv;
 }
 
-int pthread_mutex_init (pthread_mutex_t *mutex,
-                        const pthread_mutexattr_t *mutex_attr) {
+int pthread_mutex_init(pthread_mutex_t *mutex,
+                       const pthread_mutexattr_t *mutex_attr) {
   int retval;
   nc_token_init(&mutex->token, 1);
   if (mutex_attr != NULL) {
     mutex->mutex_type = mutex_attr->kind;
   } else {
     mutex->mutex_type = PTHREAD_MUTEX_FAST_NP;
   }
   retval = nc_thread_mutex_init(mutex);
   nc_token_release(&mutex->token);
   return retval;
 }
 
-int pthread_mutex_destroy (pthread_mutex_t *mutex) {
+int pthread_mutex_destroy(pthread_mutex_t *mutex) {
   int retval;
   pthread_mutex_validate(mutex);
   if (NACL_PTHREAD_ILLEGAL_THREAD_ID != mutex->owner_thread_id) {
     /* the mutex is still locked - cannot destroy */
     return EBUSY;
   }
   retval = __nc_irt_mutex.mutex_destroy(mutex->mutex_handle);
   mutex->mutex_handle = NC_INVALID_HANDLE;
   mutex->owner_thread_id = NACL_PTHREAD_ILLEGAL_THREAD_ID;
   mutex->recursion_counter = 0;
@@ skipping 34 matching lines @@
   if (rv) {
     return rv;
   }
 
   mutex->owner_thread_id = pthread_self();
   mutex->recursion_counter = 1;
 
   return 0;
 }
 
-int pthread_mutex_trylock (pthread_mutex_t *mutex) {
+int pthread_mutex_trylock(pthread_mutex_t *mutex) {
   return nc_thread_mutex_lock(mutex, 1);
 }
 
-int pthread_mutex_lock (pthread_mutex_t *mutex) {
+int pthread_mutex_lock(pthread_mutex_t *mutex) {
   return nc_thread_mutex_lock(mutex, 0);
 }
 
-int pthread_mutex_unlock (pthread_mutex_t *mutex) {
+int pthread_mutex_unlock(pthread_mutex_t *mutex) {
   pthread_mutex_validate(mutex);
   if (mutex->mutex_type != PTHREAD_MUTEX_FAST_NP) {
     if ((PTHREAD_MUTEX_RECURSIVE_NP == mutex->mutex_type) &&
         (0 != (--mutex->recursion_counter))) {
       /*
        * We assume that this thread owns the lock
        * (no verification for recursive locks),
        * so just decrement the counter, this thread is still the owner
        */
       return 0;
     }
     if ((PTHREAD_MUTEX_ERRORCHECK_NP == mutex->mutex_type) &&
         (pthread_self() != mutex->owner_thread_id)) {
       /* error - releasing a mutex that's free or owned by another thread */
       return EPERM;
     }
   }
   mutex->owner_thread_id = NACL_PTHREAD_ILLEGAL_THREAD_ID;
   mutex->recursion_counter = 0;
   return __nc_irt_mutex.mutex_unlock(mutex->mutex_handle);
 }
 
 /*
  * NOTE(sehr): pthread_once needs to be defined in the same module as contains
  * the mutex definitions, so that it overrides the weak symbol in the libstdc++
  * library.  Otherwise we get calls through address zero.
  */
-int pthread_once(pthread_once_t* __once_control,
-                  void (*__init_routine) (void)) {
+int pthread_once(pthread_once_t *__once_control,

[Roland McGrath, 2012/12/04 00:04:20]

It's also a style violation (or should be) that this is using __name for local
variables.

[Mark Seaborn, 2012/12/05 05:10:57]

Done.

+                 void (*__init_routine)(void)) {
 /*
  * NOTE(gregoryd): calling pthread_once from __init_routine providing the same
  * __once_control argument is an error and will cause a deadlock
  */
-  volatile AtomicInt32* pdone = &__once_control->done;
+  volatile AtomicInt32 *pdone = &__once_control->done;
   if (*pdone == 0) {
     /* not done yet */
     pthread_mutex_lock(&__once_control->lock);
     if (*pdone == 0) {
       /* still not done - but this time we own the lock */
       (*__init_routine)();
 
       /* GCC intrinsic; see:
        * http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html.
        * The x86-{32,64} compilers generate inline code.  The ARM
@@ skipping 28 matching lines @@
     return -1;
   }
   return 0;
 }
 
 int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr,
                               int *kind) {
   *kind = attr->kind;
   return 0;
 }