diff -urp src.old/winsup/cygwin/pthread.cc src/winsup/cygwin/pthread.cc --- src.old/winsup/cygwin/pthread.cc 2003-02-28 11:33:10.000000000 +0100 +++ src/winsup/cygwin/pthread.cc 2003-02-28 12:20:51.000000000 +0100 @@ -36,107 +36,6 @@ pthread_atfork (void (*prepare)(void), v return pthread::atfork (prepare, parent, child); } -int -pthread_attr_init (pthread_attr_t * attr) -{ - return __pthread_attr_init (attr); -} - -int -pthread_attr_destroy (pthread_attr_t * attr) -{ - return __pthread_attr_destroy (attr); -} - -int -pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate) -{ - return __pthread_attr_setdetachstate (attr, detachstate); -} - -int -pthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate) -{ - return __pthread_attr_getdetachstate (attr, detachstate); -} - - -int -pthread_attr_setstacksize (pthread_attr_t * attr, size_t size) -{ - return __pthread_attr_setstacksize (attr, size); -} - -int -pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size) -{ - return __pthread_attr_getstacksize (attr, size); -} - -int -pthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched) -{ - return __pthread_attr_setinheritsched (attr, inheritsched); -} - -int -pthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched) -{ - return __pthread_attr_getinheritsched (attr, inheritsched); -} - -int -pthread_attr_setschedparam (pthread_attr_t * attr, - const struct sched_param *param) -{ - return __pthread_attr_setschedparam (attr, param); -} - -int -pthread_attr_getschedparam (const pthread_attr_t * attr, - struct sched_param *param) -{ - return __pthread_attr_getschedparam (attr, param); -} - -int -pthread_attr_setschedpolicy (pthread_attr_t * attr, int policy) -{ - return __pthread_attr_setschedpolicy (attr, policy); -} - -int -pthread_attr_getschedpolicy (const pthread_attr_t * attr, int *policy) -{ - return __pthread_attr_getschedpolicy (attr, policy); -} - -int -pthread_attr_setscope (pthread_attr_t * attr, int contentionscope) -{ - return __pthread_attr_setscope (attr, contentionscope); -} - -int -pthread_attr_getscope (const pthread_attr_t * attr, int *contentionscope) -{ - return __pthread_attr_getscope (attr, contentionscope); -} - -#ifdef _POSIX_THREAD_ATTR_STACKADDR -int -pthread_attr_setstackaddr (pthread_attr_t * attr, void *stackaddr) -{ - return __pthread_attr_setstackaddr (attr, stackaddr); -} - -int -pthread_attr_getstackaddr (const pthread_attr_t * attr, void **stackaddr) -{ - return __pthread_attr_getstackaddr (attr, stackaddr); -} -#endif - /* Thread Exit */ void pthread_exit (void *value_ptr) @@ -179,44 +78,6 @@ pthread_getsequence_np (pthread_t * thre return (*thread)->getsequence_np (); } -/* Thread SpecificData */ -int -pthread_key_create (pthread_key_t * key, void (*destructor) (void *)) -{ - return __pthread_key_create (key, destructor); -} - -int -pthread_key_delete (pthread_key_t key) -{ - return __pthread_key_delete (key); -} - -int -pthread_setspecific (pthread_key_t key, const void *value) -{ - return __pthread_setspecific (key, value); -} - -void * -pthread_getspecific (pthread_key_t key) -{ - return (void *) __pthread_getspecific (key); -} - -/* Thread signal */ -int -pthread_kill (pthread_t thread, int sig) -{ - return __pthread_kill (thread, sig); -} - -int -pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set) -{ - return __pthread_sigmask (operation, set, old_set); -} - /* ID */ pthread_t pthread_self () @@ -224,12 +85,6 @@ pthread_t pthread_self () return pthread::self (); } -int -pthread_equal (pthread_t t1, pthread_t t2) -{ - return __pthread_equal (&t1, &t2); -} - /* Mutexes */ int pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr) @@ -237,257 +92,20 @@ pthread_mutex_init (pthread_mutex_t * mu return pthread_mutex::init (mutex, attr); } -int -pthread_mutex_lock (pthread_mutex_t * mutex) -{ - return __pthread_mutex_lock (mutex); -} - -int -pthread_mutex_trylock (pthread_mutex_t * mutex) -{ - return __pthread_mutex_trylock (mutex); -} - -int -pthread_mutex_unlock (pthread_mutex_t * mutex) -{ - return __pthread_mutex_unlock (mutex); -} - -int -pthread_mutex_destroy (pthread_mutex_t * mutex) -{ - return __pthread_mutex_destroy (mutex); -} - -int -pthread_mutex_setprioceiling (pthread_mutex_t * mutex, - int prioceiling, int *old_ceiling) -{ - return __pthread_mutex_setprioceiling (mutex, prioceiling, old_ceiling); -} - -int -pthread_mutex_getprioceiling (const pthread_mutex_t * mutex, int *prioceiling) -{ - return __pthread_mutex_getprioceiling (mutex, prioceiling); -} - - - -int -pthread_mutexattr_destroy (pthread_mutexattr_t * attr) -{ - return __pthread_mutexattr_destroy (attr); -} - -int -pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * attr, - int *prioceiling) -{ - return __pthread_mutexattr_getprioceiling (attr, prioceiling); -} - -int -pthread_mutexattr_getprotocol (const pthread_mutexattr_t * attr, - int *protocol) -{ - return __pthread_mutexattr_getprotocol (attr, protocol); -} - -int -pthread_mutexattr_getpshared (const pthread_mutexattr_t * attr, int *pshared) -{ - return __pthread_mutexattr_getpshared (attr, pshared); -} - -int -pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *type) -{ - return __pthread_mutexattr_gettype (attr, type); -} - -int -pthread_mutexattr_init (pthread_mutexattr_t * attr) -{ - return __pthread_mutexattr_init (attr); -} - -int -pthread_mutexattr_setprioceiling (pthread_mutexattr_t * attr, int prioceiling) -{ - return __pthread_mutexattr_setprioceiling (attr, prioceiling); -} - -int -pthread_mutexattr_setprotocol (pthread_mutexattr_t * attr, int protocol) -{ - return __pthread_mutexattr_setprotocol (attr, protocol); -} - -int -pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, int pshared) -{ - return __pthread_mutexattr_setpshared (attr, pshared); -} - -int -pthread_mutexattr_settype (pthread_mutexattr_t * attr, int type) -{ - return __pthread_mutexattr_settype (attr, type); -} - /* Synchronisation */ - -int -pthread_cond_destroy (pthread_cond_t * cond) -{ - return __pthread_cond_destroy (cond); -} - int pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr) { return pthread_cond::init (cond, attr); } -int -pthread_cond_signal (pthread_cond_t * cond) -{ - return __pthread_cond_signal (cond); -} - -int -pthread_cond_broadcast (pthread_cond_t * cond) -{ - return __pthread_cond_broadcast (cond); -} - -int -pthread_condattr_init (pthread_condattr_t * condattr) -{ - return __pthread_condattr_init (condattr); -} - -int -pthread_condattr_destroy (pthread_condattr_t * condattr) -{ - return __pthread_condattr_destroy (condattr); -} - -int -pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared) -{ - return __pthread_condattr_getpshared (attr, pshared); -} - -int -pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared) -{ - return __pthread_condattr_setpshared (attr, pshared); -} - /* RW Locks */ int -pthread_rwlock_destroy (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_destroy (rwlock); -} - -int pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) { return pthread_rwlock::init (rwlock, attr); } -int -pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_rdlock (rwlock); -} - -int -pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_tryrdlock (rwlock); -} - -int -pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_wrlock (rwlock); -} - -int -pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_trywrlock (rwlock); -} - -int -pthread_rwlock_unlock (pthread_rwlock_t *rwlock) -{ - return __pthread_rwlock_unlock (rwlock); -} - -int -pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr) -{ - return __pthread_rwlockattr_init (rwlockattr); -} - -int -pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, - int *pshared) -{ - return __pthread_rwlockattr_getpshared (attr, pshared); -} - -int -pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared) -{ - return __pthread_rwlockattr_setpshared (attr, pshared); -} - -int -pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr) -{ - return __pthread_rwlockattr_destroy (rwlockattr); -} - -/* Scheduling */ - -int -pthread_getconcurrency (void) -{ - return __pthread_getconcurrency (); -} - -int -pthread_setconcurrency (int new_level) -{ - return __pthread_setconcurrency (new_level); -} - - - - -int -pthread_getschedparam (pthread_t thread, int *policy, - struct sched_param *param) -{ - return __pthread_getschedparam (thread, policy, param); -} - -int -pthread_setschedparam (pthread_t thread, int policy, - const struct sched_param *param) -{ - return __pthread_setschedparam (thread, policy, param); -} - - /* Cancelability */ int diff -urp src.old/winsup/cygwin/thread.cc src/winsup/cygwin/thread.cc --- src.old/winsup/cygwin/thread.cc 2003-02-28 10:54:17.000000000 +0100 +++ src/winsup/cygwin/thread.cc 2003-02-28 12:55:42.000000000 +0100 @@ -373,7 +373,7 @@ pthread::exit (void *value_ptr) mutex.Lock (); // cleanup if thread is in detached state and not joined - if (__pthread_equal (&joiner, &thread)) + if (pthread_equal (joiner, thread)) delete this; else { @@ -404,7 +404,7 @@ pthread::cancel (void) return 0; } - else if (__pthread_equal (&thread, &self)) + else if (pthread_equal (thread, self)) { mutex.UnLock (); cancel_self (); @@ -1495,7 +1495,7 @@ pthread_mutex::canBeUnlocked (pthread_mu /* * Check if the mutex is owned by the current thread and can be unlocked */ - return (__pthread_equal (&(*mutex)->owner, &self)) && 1 == (*mutex)->recursion_counter; + return (pthread_equal ((*mutex)->owner, self)) && 1 == (*mutex)->recursion_counter; } List pthread_mutex::mutexes; @@ -1557,7 +1557,7 @@ pthread_mutex::_Lock (pthread_t self) if (1 == InterlockedIncrement ((long *)&lock_counter)) SetOwner (self); - else if (PTHREAD_MUTEX_NORMAL != type && __pthread_equal (&owner, &self)) + else if (PTHREAD_MUTEX_NORMAL != type && pthread_equal (owner, self)) { InterlockedDecrement ((long *) &lock_counter); if (PTHREAD_MUTEX_RECURSIVE == type) @@ -1581,7 +1581,7 @@ pthread_mutex::_TryLock (pthread_t self) if (0 == InterlockedCompareExchange ((long *)&lock_counter, 1, 0 )) SetOwner (self); - else if (PTHREAD_MUTEX_RECURSIVE == type && __pthread_equal (&owner, &self)) + else if (PTHREAD_MUTEX_RECURSIVE == type && pthread_equal (owner, self)) result = LockRecursive (); else result = EBUSY; @@ -1592,7 +1592,7 @@ pthread_mutex::_TryLock (pthread_t self) int pthread_mutex::_UnLock (pthread_t self) { - if (!__pthread_equal (&owner, &self)) + if (!pthread_equal (owner, self)) return EPERM; if (0 == --recursion_counter) @@ -2027,8 +2027,8 @@ pthread::atfork (void (*prepare)(void), return 0; } -int -__pthread_attr_init (pthread_attr_t *attr) +extern "C" int +pthread_attr_init (pthread_attr_t *attr) { if (check_valid_pointer (attr)) return EINVAL; @@ -2042,8 +2042,8 @@ __pthread_attr_init (pthread_attr_t *att return 0; } -int -__pthread_attr_getinheritsched (const pthread_attr_t *attr, +extern "C" int +pthread_attr_getinheritsched (const pthread_attr_t *attr, int *inheritsched) { if (!pthread_attr::isGoodObject (attr)) @@ -2052,8 +2052,8 @@ __pthread_attr_getinheritsched (const pt return 0; } -int -__pthread_attr_getschedparam (const pthread_attr_t *attr, +extern "C" int +pthread_attr_getschedparam (const pthread_attr_t *attr, struct sched_param *param) { if (!pthread_attr::isGoodObject (attr)) @@ -2065,8 +2065,8 @@ __pthread_attr_getschedparam (const pthr /* From a pure code point of view, this should call a helper in sched.cc, to allow for someone adding scheduler policy changes to win32 in the future. However that's extremely unlikely, so short and sweet will do us */ -int -__pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy) +extern "C" int +pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2075,8 +2075,8 @@ __pthread_attr_getschedpolicy (const pth } -int -__pthread_attr_getscope (const pthread_attr_t *attr, int *contentionscope) +extern "C" int +pthread_attr_getscope (const pthread_attr_t *attr, int *contentionscope) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2084,8 +2084,8 @@ __pthread_attr_getscope (const pthread_a return 0; } -int -__pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate) +extern "C" int +pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2095,8 +2095,8 @@ __pthread_attr_setdetachstate (pthread_a return 0; } -int -__pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate) +extern "C" int +pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2104,8 +2104,8 @@ __pthread_attr_getdetachstate (const pth return 0; } -int -__pthread_attr_setinheritsched (pthread_attr_t *attr, int inheritsched) +extern "C" int +pthread_attr_setinheritsched (pthread_attr_t *attr, int inheritsched) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2116,8 +2116,8 @@ __pthread_attr_setinheritsched (pthread_ return 0; } -int -__pthread_attr_setschedparam (pthread_attr_t *attr, +extern "C" int +pthread_attr_setschedparam (pthread_attr_t *attr, const struct sched_param *param) { if (!pthread_attr::isGoodObject (attr)) @@ -2129,8 +2129,8 @@ __pthread_attr_setschedparam (pthread_at } /* See __pthread_attr_getschedpolicy for some notes */ -int -__pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy) +extern "C" int +pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2139,8 +2139,8 @@ __pthread_attr_setschedpolicy (pthread_a return 0; } -int -__pthread_attr_setscope (pthread_attr_t *attr, int contentionscope) +extern "C" int +pthread_attr_setscope (pthread_attr_t *attr, int contentionscope) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2155,8 +2155,8 @@ __pthread_attr_setscope (pthread_attr_t return 0; } -int -__pthread_attr_setstacksize (pthread_attr_t *attr, size_t size) +extern "C" int +pthread_attr_setstacksize (pthread_attr_t *attr, size_t size) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2164,8 +2164,8 @@ __pthread_attr_setstacksize (pthread_att return 0; } -int -__pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *size) +extern "C" int +pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *size) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2173,8 +2173,8 @@ __pthread_attr_getstacksize (const pthre return 0; } -int -__pthread_attr_destroy (pthread_attr_t *attr) +extern "C" int +pthread_attr_destroy (pthread_attr_t *attr) { if (!pthread_attr::isGoodObject (attr)) return EINVAL; @@ -2200,7 +2200,7 @@ pthread::join (pthread_t *thread, void * if (!isGoodObject (thread)) return ESRCH; - if (__pthread_equal (thread,&joiner)) + if (pthread_equal (*thread,joiner)) return EDEADLK; (*thread)->mutex.Lock (); @@ -2302,15 +2302,15 @@ pthread::resume (pthread_t *thread) /* provided for source level compatability. See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html */ -int -__pthread_getconcurrency (void) +extern "C" int +pthread_getconcurrency (void) { return MT_INTERFACE->concurrency; } /* keep this in sync with sched.cc */ -int -__pthread_getschedparam (pthread_t thread, int *policy, +extern "C" int +pthread_getschedparam (pthread_t thread, int *policy, struct sched_param *param) { if (!pthread::isGoodObject (&thread)) @@ -2323,8 +2323,8 @@ __pthread_getschedparam (pthread_t threa } /* Thread SpecificData */ -int -__pthread_key_create (pthread_key_t *key, void (*destructor) (void *)) +extern "C" int +pthread_key_create (pthread_key_t *key, void (*destructor) (void *)) { /* The opengroup docs don't define if we should check this or not, but creation is relatively rare. */ @@ -2342,8 +2342,8 @@ __pthread_key_create (pthread_key_t *key return 0; } -int -__pthread_key_delete (pthread_key_t key) +extern "C" int +pthread_key_delete (pthread_key_t key) { if (!pthread_key::isGoodObject (&key)) return EINVAL; @@ -2355,8 +2355,8 @@ __pthread_key_delete (pthread_key_t key) /* provided for source level compatability. See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html */ -int -__pthread_setconcurrency (int new_level) +extern "C" int +pthread_setconcurrency (int new_level) { if (new_level < 0) return EINVAL; @@ -2365,8 +2365,8 @@ __pthread_setconcurrency (int new_level) } /* keep syncronised with sched.cc */ -int -__pthread_setschedparam (pthread_t thread, int policy, +extern "C" int +pthread_setschedparam (pthread_t thread, int policy, const struct sched_param *param) { if (!pthread::isGoodObject (&thread)) @@ -2383,8 +2383,8 @@ __pthread_setschedparam (pthread_t threa } -int -__pthread_setspecific (pthread_key_t key, const void *value) +extern "C" int +pthread_setspecific (pthread_key_t key, const void *value) { if (!pthread_key::isGoodObject (&key)) return EINVAL; @@ -2392,8 +2392,8 @@ __pthread_setspecific (pthread_key_t key return 0; } -void * -__pthread_getspecific (pthread_key_t key) +extern "C" void * +pthread_getspecific (pthread_key_t key) { if (!pthread_key::isGoodObject (&key)) return NULL; @@ -2436,8 +2436,8 @@ pthread_cond::isGoodInitializerOrBadObje return true; } -int -__pthread_cond_destroy (pthread_cond_t *cond) +extern "C" int +pthread_cond_destroy (pthread_cond_t *cond) { if (pthread_cond::isGoodInitializer (cond)) return 0; @@ -2480,8 +2480,8 @@ pthread_cond::init (pthread_cond_t *cond return 0; } -int -__pthread_cond_broadcast (pthread_cond_t *cond) +extern "C" int +pthread_cond_broadcast (pthread_cond_t *cond) { if (pthread_cond::isGoodInitializer (cond)) return 0; @@ -2493,8 +2493,8 @@ __pthread_cond_broadcast (pthread_cond_t return 0; } -int -__pthread_cond_signal (pthread_cond_t *cond) +extern "C" int +pthread_cond_signal (pthread_cond_t *cond) { if (pthread_cond::isGoodInitializer (cond)) return 0; @@ -2551,8 +2551,8 @@ pthread_cond_wait (pthread_cond_t *cond, return __pthread_cond_dowait (cond, mutex, INFINITE); } -int -__pthread_condattr_init (pthread_condattr_t *condattr) +extern "C" int +pthread_condattr_init (pthread_condattr_t *condattr) { if (check_valid_pointer (condattr)) return EINVAL; @@ -2566,8 +2566,8 @@ __pthread_condattr_init (pthread_condatt return 0; } -int -__pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared) +extern "C" int +pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared) { if (!pthread_condattr::isGoodObject (attr)) return EINVAL; @@ -2575,8 +2575,8 @@ __pthread_condattr_getpshared (const pth return 0; } -int -__pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared) +extern "C" int +pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared) { if (!pthread_condattr::isGoodObject (attr)) return EINVAL; @@ -2589,8 +2589,8 @@ __pthread_condattr_setpshared (pthread_c return 0; } -int -__pthread_condattr_destroy (pthread_condattr_t *condattr) +extern "C" int +pthread_condattr_destroy (pthread_condattr_t *condattr) { if (!pthread_condattr::isGoodObject (condattr)) return EINVAL; @@ -2633,8 +2633,8 @@ pthread_rwlock::isGoodInitializerOrBadOb return true; } -int -__pthread_rwlock_destroy (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_destroy (pthread_rwlock_t *rwlock) { if (pthread_rwlock::isGoodInitializer (rwlock)) return 0; @@ -2677,8 +2677,8 @@ pthread_rwlock::init (pthread_rwlock_t * return 0; } -int -__pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) { pthread_testcancel (); @@ -2690,8 +2690,8 @@ __pthread_rwlock_rdlock (pthread_rwlock_ return (*rwlock)->RdLock (); } -int -__pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) { if (pthread_rwlock::isGoodInitializer (rwlock)) pthread_rwlock::init (rwlock, NULL); @@ -2701,8 +2701,8 @@ __pthread_rwlock_tryrdlock (pthread_rwlo return (*rwlock)->TryRdLock (); } -int -__pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) { pthread_testcancel (); @@ -2714,8 +2714,8 @@ __pthread_rwlock_wrlock (pthread_rwlock_ return (*rwlock)->WrLock (); } -int -__pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) { if (pthread_rwlock::isGoodInitializer (rwlock)) pthread_rwlock::init (rwlock, NULL); @@ -2725,8 +2725,8 @@ __pthread_rwlock_trywrlock (pthread_rwlo return (*rwlock)->TryWrLock (); } -int -__pthread_rwlock_unlock (pthread_rwlock_t *rwlock) +extern "C" int +pthread_rwlock_unlock (pthread_rwlock_t *rwlock) { if (pthread_rwlock::isGoodInitializer (rwlock)) return 0; @@ -2736,8 +2736,8 @@ __pthread_rwlock_unlock (pthread_rwlock_ return (*rwlock)->UnLock (); } -int -__pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr) +extern "C" int +pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr) { if (check_valid_pointer (rwlockattr)) return EINVAL; @@ -2751,8 +2751,8 @@ __pthread_rwlockattr_init (pthread_rwloc return 0; } -int -__pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared) +extern "C" int +pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared) { if (!pthread_rwlockattr::isGoodObject (attr)) return EINVAL; @@ -2760,8 +2760,8 @@ __pthread_rwlockattr_getpshared (const p return 0; } -int -__pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared) +extern "C" int +pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared) { if (!pthread_rwlockattr::isGoodObject (attr)) return EINVAL; @@ -2774,8 +2774,8 @@ __pthread_rwlockattr_setpshared (pthread return 0; } -int -__pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr) +extern "C" int +pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr) { if (!pthread_rwlockattr::isGoodObject (rwlockattr)) return EINVAL; @@ -2785,8 +2785,8 @@ __pthread_rwlockattr_destroy (pthread_rw } /* Thread signal */ -int -__pthread_kill (pthread_t thread, int sig) +extern "C" int +pthread_kill (pthread_t thread, int sig) { // lock myself, for the use of thread2signal // two different kills might clash: FIXME @@ -2803,8 +2803,8 @@ __pthread_kill (pthread_t thread, int si return rval; } -int -__pthread_sigmask (int operation, const sigset_t *set, sigset_t *old_set) +extern "C" int +pthread_sigmask (int operation, const sigset_t *set, sigset_t *old_set) { pthread *thread = pthread::self (); @@ -2824,9 +2824,9 @@ __pthread_sigmask (int operation, const /* ID */ int -__pthread_equal (pthread_t *t1, pthread_t *t2) +pthread_equal (pthread_t t1, pthread_t t2) { - return (*t1 == *t2); + return t1 == t2; } /* Mutexes */ @@ -2866,8 +2866,8 @@ pthread_mutex::init (pthread_mutex_t *mu return 0; } -int -__pthread_mutex_getprioceiling (const pthread_mutex_t *mutex, +extern "C" int +pthread_mutex_getprioceiling (const pthread_mutex_t *mutex, int *prioceiling) { pthread_mutex_t *themutex = (pthread_mutex_t *) mutex; @@ -2886,7 +2886,7 @@ __pthread_mutex_getprioceiling (const pt } int -__pthread_mutex_lock (pthread_mutex_t *mutex) +pthread_mutex_lock (pthread_mutex_t *mutex) { pthread_mutex_t *themutex = mutex; /* This could be simplified via isGoodInitializerOrObject @@ -2913,8 +2913,8 @@ __pthread_mutex_lock (pthread_mutex_t *m return (*themutex)->Lock (); } -int -__pthread_mutex_trylock (pthread_mutex_t *mutex) +extern "C" int +pthread_mutex_trylock (pthread_mutex_t *mutex) { pthread_mutex_t *themutex = mutex; if (pthread_mutex::isGoodInitializer (mutex)) @@ -2924,8 +2924,8 @@ __pthread_mutex_trylock (pthread_mutex_t return (*themutex)->TryLock (); } -int -__pthread_mutex_unlock (pthread_mutex_t *mutex) +extern "C" int +pthread_mutex_unlock (pthread_mutex_t *mutex) { if (pthread_mutex::isGoodInitializer (mutex)) pthread_mutex::init (mutex, NULL); @@ -2934,8 +2934,8 @@ __pthread_mutex_unlock (pthread_mutex_t return (*mutex)->UnLock (); } -int -__pthread_mutex_destroy (pthread_mutex_t *mutex) +extern "C" int +pthread_mutex_destroy (pthread_mutex_t *mutex) { int rv; @@ -2952,8 +2952,8 @@ __pthread_mutex_destroy (pthread_mutex_t return 0; } -int -__pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling, +extern "C" int +pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling, int *old_ceiling) { pthread_mutex_t *themutex = mutex; @@ -2966,8 +2966,8 @@ __pthread_mutex_setprioceiling (pthread_ /* Win32 doesn't support mutex priorities - see __pthread_mutex_getprioceiling for more detail */ -int -__pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr, +extern "C" int +pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr, int *protocol) { if (!pthread_mutexattr::isGoodObject (attr)) @@ -2975,8 +2975,8 @@ __pthread_mutexattr_getprotocol (const p return ENOSYS; } -int -__pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr, +extern "C" int +pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr, int *pshared) { if (!pthread_mutexattr::isGoodObject (attr)) @@ -2985,8 +2985,8 @@ __pthread_mutexattr_getpshared (const pt return 0; } -int -__pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type) +extern "C" int +pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type) { if (!pthread_mutexattr::isGoodObject (attr)) return EINVAL; @@ -2995,8 +2995,8 @@ __pthread_mutexattr_gettype (const pthre } /* FIXME: write and test process shared mutex's. */ -int -__pthread_mutexattr_init (pthread_mutexattr_t *attr) +extern "C" int +pthread_mutexattr_init (pthread_mutexattr_t *attr) { if (pthread_mutexattr::isGoodObject (attr)) return EBUSY; @@ -3011,8 +3011,8 @@ __pthread_mutexattr_init (pthread_mutexa return 0; } -int -__pthread_mutexattr_destroy (pthread_mutexattr_t *attr) +extern "C" int +pthread_mutexattr_destroy (pthread_mutexattr_t *attr) { if (!pthread_mutexattr::isGoodObject (attr)) return EINVAL; @@ -3023,8 +3023,8 @@ __pthread_mutexattr_destroy (pthread_mut /* Win32 doesn't support mutex priorities */ -int -__pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol) +extern "C" int +pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol) { if (!pthread_mutexattr::isGoodObject (attr)) return EINVAL; @@ -3032,8 +3032,8 @@ __pthread_mutexattr_setprotocol (pthread } /* Win32 doesn't support mutex priorities */ -int -__pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attr, +extern "C" int +pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attr, int prioceiling) { if (!pthread_mutexattr::isGoodObject (attr)) @@ -3041,8 +3041,8 @@ __pthread_mutexattr_setprioceiling (pthr return ENOSYS; } -int -__pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *attr, +extern "C" int +pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *attr, int *prioceiling) { if (!pthread_mutexattr::isGoodObject (attr)) @@ -3050,8 +3050,8 @@ __pthread_mutexattr_getprioceiling (cons return ENOSYS; } -int -__pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared) +extern "C" int +pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared) { if (!pthread_mutexattr::isGoodObject (attr)) return EINVAL; @@ -3064,9 +3064,9 @@ __pthread_mutexattr_setpshared (pthread_ return 0; } -/* see __pthread_mutex_gettype */ -int -__pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type) +/* see pthread_mutex_gettype */ +extern "C" int +pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type) { if (!pthread_mutexattr::isGoodObject (attr)) return EINVAL; diff -urp src.old/winsup/cygwin/thread.h src/winsup/cygwin/thread.h --- src.old/winsup/cygwin/thread.h 2003-02-28 11:34:23.000000000 +0100 +++ src/winsup/cygwin/thread.h 2003-02-28 12:20:50.000000000 +0100 @@ -670,97 +670,6 @@ public: #define MT_INTERFACE user_data->threadinterface -extern "C" -{ -int __pthread_attr_init (pthread_attr_t * attr); -int __pthread_attr_destroy (pthread_attr_t * attr); -int __pthread_attr_setdetachstate (pthread_attr_t *, int); -int __pthread_attr_getdetachstate (const pthread_attr_t *, int *); -int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size); -int __pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size); - -int __pthread_attr_getinheritsched (const pthread_attr_t *, int *); -int __pthread_attr_getschedparam (const pthread_attr_t *, - struct sched_param *); -int __pthread_attr_getschedpolicy (const pthread_attr_t *, int *); -int __pthread_attr_getscope (const pthread_attr_t *, int *); -int __pthread_attr_getstackaddr (const pthread_attr_t *, void **); -int __pthread_attr_setinheritsched (pthread_attr_t *, int); -int __pthread_attr_setschedparam (pthread_attr_t *, - const struct sched_param *); -int __pthread_attr_setschedpolicy (pthread_attr_t *, int); -int __pthread_attr_setscope (pthread_attr_t *, int); -int __pthread_attr_setstackaddr (pthread_attr_t *, void *); - -/* Thread SpecificData */ -int __pthread_key_create (pthread_key_t * key, void (*destructor) (void *)); -int __pthread_key_delete (pthread_key_t key); -int __pthread_setspecific (pthread_key_t key, const void *value); -void *__pthread_getspecific (pthread_key_t key); - -/* Thead synchroniation */ -int __pthread_cond_destroy (pthread_cond_t * cond); -int __pthread_cond_signal (pthread_cond_t * cond); -int __pthread_cond_broadcast (pthread_cond_t * cond); -int __pthread_condattr_init (pthread_condattr_t * condattr); -int __pthread_condattr_destroy (pthread_condattr_t * condattr); -int __pthread_condattr_getpshared (const pthread_condattr_t * attr, - int *pshared); -int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared); - -/* RW locks */ -int __pthread_rwlock_destroy (pthread_rwlock_t *rwlock); -int __pthread_rwlock_rdlock (pthread_rwlock_t *rwlock); -int __pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock); -int __pthread_rwlock_wrlock (pthread_rwlock_t *rwlock); -int __pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock); -int __pthread_rwlock_unlock (pthread_rwlock_t *rwlock); -int __pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr); -int __pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, - int *pshared); -int __pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared); -int __pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr); - -/* Thread signal */ -int __pthread_kill (pthread_t thread, int sig); -int __pthread_sigmask (int operation, const sigset_t * set, - sigset_t * old_set); - -/* ID */ -int __pthread_equal (pthread_t * t1, pthread_t * t2); - -/* Mutexes */ -int __pthread_mutex_lock (pthread_mutex_t *); -int __pthread_mutex_trylock (pthread_mutex_t *); -int __pthread_mutex_unlock (pthread_mutex_t *); -int __pthread_mutex_destroy (pthread_mutex_t *); -int __pthread_mutex_setprioceiling (pthread_mutex_t * mutex, - int prioceiling, int *old_ceiling); -int __pthread_mutex_getprioceiling (const pthread_mutex_t * mutex, - int *prioceiling); - - -int __pthread_mutexattr_destroy (pthread_mutexattr_t *); -int __pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *, int *); -int __pthread_mutexattr_getprotocol (const pthread_mutexattr_t *, int *); -int __pthread_mutexattr_getpshared (const pthread_mutexattr_t *, int *); -int __pthread_mutexattr_gettype (const pthread_mutexattr_t *, int *); -int __pthread_mutexattr_init (pthread_mutexattr_t *); -int __pthread_mutexattr_setprioceiling (pthread_mutexattr_t *, int); -int __pthread_mutexattr_setprotocol (pthread_mutexattr_t *, int); -int __pthread_mutexattr_setpshared (pthread_mutexattr_t *, int); -int __pthread_mutexattr_settype (pthread_mutexattr_t *, int); - - -/* Scheduling */ -int __pthread_getconcurrency (void); -int __pthread_setconcurrency (int new_level); -int __pthread_getschedparam (pthread_t thread, int *policy, - struct sched_param *param); -int __pthread_setschedparam (pthread_t thread, int policy, - const struct sched_param *param); - -}; #endif // MT_SAFE #endif // _CYGNUS_THREADS_