* sched.cc: New file. Implement sched*.

* include/sched.h: New file.  User land includes for sched*.
* Makefile.in: Add sched.o
* cygwin.din: Add exports for sched*.

winsup/cygwin/ChangeLog

@@ -1,3 +1,10 @@
+2001-03-21 Robert Collins <rbtcollins@hotmail.com>
+
+	* sched.cc: New file.  Implement sched*.
+	* include/sched.h: New file.  User land includes for sched*.
+	* Makefile.in: Add sched.o
+	* cygwin.din: Add exports for sched*.
+
 Tue Mar 20 14:48:46 2001  Christopher Faylor <cgf@cygnus.com>
 
 	* dtable.cc: Guard against new winsock.h/winsock2.h warnings when

winsup/cygwin/Makefile.in

@@ -121,13 +121,12 @@ DLL_OFILES:=assert.o autoload.o cygheap.o dcrt0.o debug.o delqueue.o dir.o \
 	fhandler_serial.o fhandler_socket.o fhandler_tape.o \
 	fhandler_termios.o fhandler_tty.o fhandler_windows.o fhandler_zero.o \
 	fork.o glob.o grp.o heap.o init.o ioctl.o localtime.o malloc.o \
-	miscfuncs.o mmap.o \
+	miscfuncs.o mmap.o net.o ntea.o passwd.o path.o pinfo.o pipe.o poll.o \
-	net.o ntea.o passwd.o path.o pinfo.o pipe.o poll.o pthread.o regexp.o \
+	pthread.o regexp.o regerror.o regsub.o registry.o resource.o scandir.o \
-	regerror.o regsub.o registry.o resource.o scandir.o security.o select.o \
+	sched.o security.o select.o shared.o shortcut.o signal.o sigproc.o \
-	shared.o \
+	smallprint.o spawn.o strace.o strsep.o sync.o syscalls.o sysconf.o \
-	shortcut.o signal.o sigproc.o smallprint.o spawn.o strace.o strsep.o \
+	syslog.o termios.o thread.o times.o tty.o uinfo.o uname.o wait.o \
-	sync.o syscalls.o sysconf.o syslog.o termios.o thread.o times.o tty.o \
+	window.o \
-	uinfo.o uname.o wait.o window.o \
 	$(EXTRA_DLL_OFILES) $(EXTRA_OFILES) $(MT_SAFE_OBJECTS)
 
 GMON_OFILES:= gmon.o mcount.o profil.o

winsup/cygwin/include/pthread.h

@@ -21,7 +21,6 @@ extern "C"
 {
 #endif
 
-#define TFD(n) void*(*n)(void*)
 
 /* Defines. (These are correctly defined here as per
    http://www.opengroup.org/onlinepubs/7908799/xsh/pthread.h.html */
@@ -32,40 +31,36 @@ extern "C"
 
 #define PTHREAD_PROCESS_PRIVATE 0
 #define PTHREAD_PROCESS_SHARED  1
+#define PTHREAD_DESTRUCTOR_ITERATIONS 1
+/* Tls has 64 items for pre win2000 - and we don't want to use them all :]
+ * Before committing discuss this with the list
+ */
+#define PTHREAD_KEYS_MAX 32
+#define PTHREAD_CREATE_DETACHED 1
+/* the default : joinable */
+#define PTHREAD_CREATE_JOINABLE 0
 
-typedef int pthread_t;
-typedef int pthread_mutex_t;
-typedef int sem_t;
 
-typedef struct pthread_key
+/* these shouldn't be defined here but in sys/types.
-  {
+ * defining in sys/types mught also allow us to override them for the internal functions
-  }
+ * more easily (internal sys/types vs external sys/type - dev thoughts on this? 
-pthread_key_t;
+ */
+  typedef void *pthread_t;
+  typedef void *pthread_mutex_t;
 
-typedef struct pthread_attr
+  typedef void *pthread_key_t;
-  {
+  typedef void *pthread_attr_t;
-    size_t stacksize;
+  typedef void *pthread_mutexattr_t;
-  }
+  typedef void *pthread_condattr_t;
-pthread_attr_t;
+  typedef void *pthread_cond_t;
-
-typedef struct pthread_mutexattr
-  {
-  }
-pthread_mutexattr_t;
-
-typedef struct pthread_condattr
-  {
-    int shared;
-    int valid;
-  }
-pthread_condattr_t;
-
-typedef int pthread_cond_t;
 
 /*  ThreadCreation */
-int pthread_create (pthread_t * thread, const pthread_attr_t * attr, TFD (function), void *arg);
+  int pthread_create (pthread_t * thread, const pthread_attr_t * attr,
+		      void *(*)(void *), void *arg);
   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 (pthread_attr_t * attr, size_t * size);
 
@@ -88,36 +83,31 @@ int pthread_detach (pthread_t thread);
   int pthread_join (pthread_t thread, void **value_ptr);
 
 /* Thread Exit */
-int pthread_exit (void *value_ptr);
+  void pthread_exit (void *value_ptr);
 
 /* Thread SpecificData */
-int pthread_key_create (pthread_key_t * key);
+  int pthread_key_create (pthread_key_t *, void (*)(void *));
   int pthread_key_delete (pthread_key_t * key);
-int pthread_setspecific (pthread_key_t * key, const void *value);
+  int pthread_setspecific (pthread_key_t key, const void *value);
-void *pthread_getspecific (pthread_key_t * key);
+  void *pthread_getspecific (pthread_key_t key);
 
-/* Thread signal */
+/* Thread signal (should be in signal.h) */
   int pthread_kill (pthread_t * thread, int sig);
-int pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set);
+  int pthread_sigmask (int operation, const sigset_t * set,
+		       sigset_t * old_set);
 
 /*  ID */
   pthread_t pthread_self ();
   int pthread_equal (pthread_t t1, pthread_t t2);
 
 /* Mutexes  */
-int pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t *);
+  int pthread_mutex_init (pthread_mutex_t * mutex,
+			  const pthread_mutexattr_t *);
   int pthread_mutex_lock (pthread_mutex_t * mutext);
   int pthread_mutex_trylock (pthread_mutex_t * mutext);
   int pthread_mutex_unlock (pthread_mutex_t * mutext);
   int pthread_mutex_destroy (pthread_mutex_t * mutext);
 
-/* Solaris Semaphores */
-int sem_init (sem_t * sem, int pshared, unsigned int value);
-int sem_destroy (sem_t * sem);
-int sem_wait (sem_t * sem);
-int sem_trywait (sem_t * sem);
-int sem_post (sem_t * sem);
-
 #ifdef __cplusplus
 }
 #endif

winsup/cygwin/pinfo.h

@@ -116,13 +116,13 @@ public:
     return thread2signal ? thread2signal->win32_obj_id : hMainThread;
   }
 
-  inline void setthread2signal (void *thr) {thread2signal = (ThreadItem *) thr;}
+  inline void setthread2signal (void *thr) {thread2signal = (pthread *) thr;}
 
 private:
   struct sigaction sigs[NSIG];
   sigset_t sig_mask;		/* one set for everything to ignore. */
   LONG _sigtodo[NSIG + __SIGOFFSET];
-  ThreadItem *thread2signal;  // NULL means means thread any other means a pthread
+  pthread *thread2signal;  // NULL means means thread any other means a pthread
 };
 
 class pinfo

winsup/cygwin/pthread.cc

@@ -13,34 +13,45 @@
 #include "winsup.h"
 #include "thread.h"
 
-extern "C" {
+extern "C"
+{
 /*  ThreadCreation */
   int
-pthread_create (pthread_t * thread, const pthread_attr_t * attr, void *(*start_routine) (void *), void *arg)
+    pthread_create (pthread_t * thread, const pthread_attr_t * attr,
+		    void *(*start_routine) (void *), void *arg)
   {
     return __pthread_create (thread, attr, start_routine, arg);
   }
 
-int
+  int pthread_attr_init (pthread_attr_t * attr)
-pthread_attr_init (pthread_attr_t * attr)
   {
     return __pthread_attr_init (attr);
   }
 
-int
+  int pthread_attr_destroy (pthread_attr_t * attr)
-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_setstacksize (pthread_attr_t * attr, size_t size)
+    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
+  int pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
-pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
   {
     return __pthread_attr_getstacksize (attr, size);
   }
@@ -52,70 +63,59 @@ pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
  */
 
 /* Thread Exit */
-int
+  void pthread_exit (void *value_ptr)
-pthread_exit (void * value_ptr)
   {
     return __pthread_exit (value_ptr);
   }
 
-int
+  int pthread_join (pthread_t thread, void **return_val)
-pthread_join (pthread_t thread, void **return_val)
   {
     return __pthread_join (&thread, (void **) return_val);
   }
 
-int
+  int pthread_detach (pthread_t thread)
-pthread_detach (pthread_t thread)
   {
     return __pthread_detach (&thread);
   }
 
-int
+  int pthread_suspend (pthread_t thread)
-pthread_suspend (pthread_t thread)
   {
     return __pthread_suspend (&thread);
   }
 
-int
+  int pthread_continue (pthread_t thread)
-pthread_continue (pthread_t thread)
   {
     return __pthread_continue (&thread);
   }
 
-unsigned long
+  unsigned long pthread_getsequence_np (pthread_t * thread)
-pthread_getsequence_np (pthread_t * thread)
   {
     return __pthread_getsequence_np (thread);
   }
 
 /* Thread SpecificData */
-int
+  int pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
-pthread_key_create (pthread_key_t * key)
   {
-  return __pthread_key_create (key);
+    return __pthread_key_create (key, destructor);
   }
 
-int
+  int pthread_key_delete (pthread_key_t * key)
-pthread_key_delete (pthread_key_t * key)
   {
     return __pthread_key_delete (key);
   }
 
-int
+  int pthread_setspecific (pthread_key_t key, const void *value)
-pthread_setspecific (pthread_key_t * key, const void *value)
   {
     return __pthread_setspecific (key, value);
   }
 
-void *
+  void *pthread_getspecific (pthread_key_t key)
-pthread_getspecific (pthread_key_t * key)
   {
     return (void *) __pthread_getspecific (key);
   }
 
 /* Thread signal */
-int
+  int pthread_kill (pthread_t * thread, int sig)
-pthread_kill (pthread_t * thread, int sig)
   {
     return __pthread_kill (thread, sig);
   }
@@ -128,53 +128,47 @@ pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
 
 /*  ID */
 
-pthread_t
+  pthread_t pthread_self ()
-pthread_self ()
   {
     return __pthread_self ();
   }
 
-int
+  int pthread_equal (pthread_t t1, pthread_t t2)
-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)
+    pthread_mutex_init (pthread_mutex_t * mutex,
+			const pthread_mutexattr_t * attr)
   {
     return __pthread_mutex_init (mutex, attr);
   }
 
-int
+  int pthread_mutex_lock (pthread_mutex_t * mutex)
-pthread_mutex_lock (pthread_mutex_t * mutex)
   {
     return __pthread_mutex_lock (mutex);
   }
 
-int
+  int pthread_mutex_trylock (pthread_mutex_t * mutex)
-pthread_mutex_trylock (pthread_mutex_t * mutex)
   {
     return __pthread_mutex_trylock (mutex);
   }
 
-int
+  int pthread_mutex_unlock (pthread_mutex_t * mutex)
-pthread_mutex_unlock (pthread_mutex_t * mutex)
   {
     return __pthread_mutex_unlock (mutex);
   }
 
-int
+  int pthread_mutex_destroy (pthread_mutex_t * mutex)
-pthread_mutex_destroy (pthread_mutex_t * mutex)
   {
     return __pthread_mutex_destroy (mutex);
   }
 
 /* Synchronisation */
 
-int
+  int pthread_cond_destroy (pthread_cond_t * cond)
-pthread_cond_destroy (pthread_cond_t *cond)
   {
     return __pthread_cond_destroy (cond);
   }
@@ -185,82 +179,73 @@ pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr)
     return __pthread_cond_init (cond, attr);
   }
 
-int
+  int pthread_cond_signal (pthread_cond_t * cond)
-pthread_cond_signal (pthread_cond_t *cond)
   {
     return __pthread_cond_signal (cond);
   }
 
-int
+  int pthread_cond_broadcast (pthread_cond_t * cond)
-pthread_cond_broadcast (pthread_cond_t *cond)
   {
     return __pthread_cond_broadcast (cond);
   }
 
   int
     pthread_cond_timedwait (pthread_cond_t * cond,
-	 pthread_mutex_t *mutex, const struct timespec *abstime)
+			    pthread_mutex_t * mutex,
+			    const struct timespec *abstime)
   {
     return __pthread_cond_timedwait (cond, mutex, abstime);
   }
 
-int
+  int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
-pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
   {
     return __pthread_cond_wait (cond, mutex);
   }
 
-int
+  int pthread_condattr_init (pthread_condattr_t * condattr)
-pthread_condattr_init (pthread_condattr_t *condattr)
   {
     return __pthread_condattr_init (condattr);
   }
 
-int
+  int pthread_condattr_destroy (pthread_condattr_t * condattr)
-pthread_condattr_destroy (pthread_condattr_t *condattr)
   {
     return __pthread_condattr_destroy (condattr);
   }
 
   int
-pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
+    pthread_condattr_getpshared (const pthread_condattr_t * attr,
+				 int *pshared)
   {
     return __pthread_condattr_getpshared (attr, pshared);
   }
 
-int
+  int pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
-pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
   {
     return __pthread_condattr_setpshared (attr, pshared);
   }
 
 /* Semaphores */
-int
+  int sem_init (sem_t * sem, int pshared, unsigned int value)
-sem_init (sem_t * sem, int pshared, unsigned int value)
   {
     return __sem_init (sem, pshared, value);
   }
 
-int
+  int sem_destroy (sem_t * sem)
-sem_destroy (sem_t * sem)
   {
     return __sem_destroy (sem);
   }
 
-int
+  int sem_wait (sem_t * sem)
-sem_wait (sem_t * sem)
   {
     return __sem_wait (sem);
   }
 
-int
+  int sem_trywait (sem_t * sem)
-sem_trywait (sem_t * sem)
   {
     return __sem_trywait (sem);
   }
 
-int
+  int sem_post (sem_t * sem)
-sem_post (sem_t * sem)
   {
     return __sem_post (sem);
   }

winsup/cygwin/thread.h

@@ -1,8 +1,10 @@
 /* thread.h: Locking and threading module definitions
 
    Copyright 1998, 1999, 2000 Cygnus Solutions.
+   Copyright 2001 Red Hat, Inc.
 
    Written by Marco Fuykschot <marco@ddi.nl>
+   Major update 2001 Robert Collins <rbtcollins@hotmail.com>
    
 This file is part of Cygwin.
 
@@ -17,10 +19,6 @@ details. */
 #define LOCK_MEMORY_LIST 2
 #define LOCK_MMAP_LIST   3
 #define LOCK_DLL_LIST    4
-#define LOCK_THREAD_LIST 5
-#define LOCK_MUTEX_LIST  6
-#define LOCK_SEM_LIST    7
-#define LOCK_COND_LIST   8
 
 #define WRITE_LOCK 1
 #define READ_LOCK  2
@@ -41,13 +39,29 @@ extern "C"
 
 #else
 
-#include <pthread.h>
+//#include <pthread.h>
+/* FIXME: these are defined in pthread.h, but pthread.h defines symbols it shouldn't -
+ * all the types.
+ */
+#define PTHREAD_PROCESS_PRIVATE 0
+#define PTHREAD_PROCESS_SHARED  1
+#define PTHREAD_DESTRUCTOR_ITERATIONS 1
+/* Tls has 64 items for pre win2000 - and we don't want to use them all :]
+ * Before committing discuss this with the list
+ */
+#define PTHREAD_KEYS_MAX 32
+#define PTHREAD_CREATE_DETACHED 1
+/* the default : joinable */
+#define PTHREAD_CREATE_JOINABLE 0
+
+#include <signal.h>
 #include <pwd.h>
 #include <grp.h>
 #define _NOMNTENT_FUNCS
 #include <mntent.h>
 
-extern "C" {
+extern "C"
+{
 
   struct _winsup_t
   {
@@ -111,7 +125,8 @@ struct __reent_t
   _reent *_reent_clib ();
   _winsup_t *_reent_winsup ();
   void SetResourceLock (int, int, const char *) __attribute__ ((regparm (3)));
-void ReleaseResourceLock (int, int, const char *) __attribute__ ((regparm(3)));
+  void ReleaseResourceLock (int, int, const char *)
+    __attribute__ ((regparm (3)));
 
 #ifdef _CYG_THREAD_FAILSAFE
   void AssertResourceOwner (int, int);
@@ -126,7 +141,9 @@ class pinfo;
 class ResourceLocks
 {
 public:
-  ResourceLocks () {};
+  ResourceLocks ()
+  {
+  };
   LPCRITICAL_SECTION Lock (int);
   void Init ();
   void Delete ();
@@ -139,120 +156,171 @@ public:
   bool inited;
 };
 
+#define PTHREAD_MAGIC 0xdf0df045
+#define PTHREAD_MUTEX_MAGIC PTHREAD_MAGIC+1
+#define PTHREAD_KEY_MAGIC PTHREAD_MAGIC+2
+#define PTHREAD_ATTR_MAGIC PTHREAD_MAGIC+3
+#define PTHREAD_MUTEXATTR_MAGIC PTHREAD_MAGIC+4
+#define PTHREAD_COND_MAGIC PTHREAD_MAGIC+5
+#define PTHREAD_CONDATTR_MAGIC PTHREAD_MAGIC+6
+#define SEM_MAGIC PTHREAD_MAGIC+7
 
-#define MT_MAX_ITEMS 128
+class verifyable_object
+{
+public:
+  long magic;
 
-// thread classes\lists
+    verifyable_object (long);
+   ~verifyable_object ();
+};
 
-class MTitem
+int verifyable_object_isvalid (verifyable_object *, long);
+
+class pthread_attr:public verifyable_object
+{
+public:
+  int joinable;
+  size_t stacksize;
+
+    pthread_attr ();
+   ~pthread_attr ();
+};
+
+class pthread:public verifyable_object
 {
 public:
   HANDLE win32_obj_id;
-  UINT return_value;
+  class pthread_attr attr;
-  bool used;
+  void *(*function) (void *);
-  char joinable;       // for thread only
-  bool HandleOke () {return win32_obj_id;}
-  virtual void Destroy ();
-  virtual int Id () {return (int) win32_obj_id;}
-};
-
-class ThreadItem: public MTitem
-{
-public:
-  pthread_attr_t attr;
-  TFD (function);
   void *arg;
   void *return_ptr;
   bool suspended;
-  DWORD thread_id;
+  int joinable;
-  DWORD GetThreadId () {return thread_id;}
+  DWORD GetThreadId ()
+  {
+    return thread_id;
+  }
+  void setThreadIdtoCurrent ()
+  {
+    thread_id = GetCurrentThreadId ();
+  }
 
   /* signal handling */
   struct sigaction *sigs;
   sigset_t *sigmask;
   LONG *sigtodo;
+  void create (void *(*)(void *), pthread_attr *, void *);
+
+    pthread ();
+   ~pthread ();
+
+private:
+    DWORD thread_id;
+
 };
 
-class MutexItem: public MTitem
+class pthread_mutexattr:public verifyable_object
 {
 public:
+
+  pthread_mutexattr ();
+  ~pthread_mutexattr ();
+};
+
+class pthread_mutex:public verifyable_object
+{
+public:
+  HANDLE win32_obj_id;
+  LONG condwaits;
+
   int Lock ();
   int TryLock ();
   int UnLock ();
+
+    pthread_mutex (pthread_mutexattr *);
+   ~pthread_mutex ();
 };
 
-class SemaphoreItem: public MTitem
+class pthread_key:public verifyable_object
+{
+public:
+
+  DWORD dwTlsIndex;
+  int set (const void *);
+  void *get ();
+
+    pthread_key ();
+   ~pthread_key ();
+};
+
+class pthread_condattr:public verifyable_object
 {
 public:
   int shared;
-  int Wait ();
+
-  int Post ();
+    pthread_condattr ();
-  int TryWait ();
+   ~pthread_condattr ();
 };
 
-class CondItem: public MTitem
+class pthread_cond:public verifyable_object
 {
 public:
   int shared;
   LONG waiting;
-  MutexItem *mutexitem;
+  pthread_mutex *mutex;
-  int Wait ();
+  HANDLE win32_obj_id;
   int TimedWait (DWORD dwMilliseconds);
-  int BroadCast ();
+  void BroadCast ();
-  int Signal ();
+  void Signal ();
+
+    pthread_cond (pthread_condattr *);
+   ~pthread_cond ();
 };
 
-typedef struct
+/* shouldn't be here */
+class semaphore:public verifyable_object
 {
-  MTitem *items[MT_MAX_ITEMS];
+public:
-  int index;
+  HANDLE win32_obj_id;
-} MTList;
+  int shared;
+  void Wait ();
+  void Post ();
+  int TryWait ();
+
+    semaphore (int, unsigned int);
+   ~semaphore ();
+};
+
+typedef class pthread *pthread_t;
+typedef class pthread_mutex *pthread_mutex_t;
+/* sem routines belong in semaphore.cc */
+typedef class semaphore *sem_t;
+
+typedef class pthread_key *pthread_key_t;
+typedef class pthread_attr *pthread_attr_t;
+typedef class pthread_mutexattr *pthread_mutexattr_t;
+typedef class pthread_condattr *pthread_condattr_t;
+typedef class pthread_cond *pthread_cond_t;
 
 class MTinterface
 {
 public:
   // General
   DWORD reent_index;
-  DWORD thread_key;
+  DWORD thread_self_dwTlsIndex;
+  /* we may get 0 for the Tls index.. grrr */
+  int indexallocated;
 
   // Used for main thread data, and sigproc thread
   struct __reent_t reents;
   struct _winsup_t winsup_reent;
-  ThreadItem mainthread;
+  pthread mainthread;
 
   void Init (int);
 
-  void ReleaseItem (MTitem *);
+    MTinterface ():reent_index (0), indexallocated (0)
-
+  {
-  // Thread functions
+  }
-  ThreadItem *CreateThread (pthread_t *, TFD (func), void *, pthread_attr_t);
-  ThreadItem *GetCallingThread ();
-  ThreadItem *GetThread (pthread_t *);
-
-  // Mutex functions
-  MutexItem *CreateMutex (pthread_mutex_t *);
-  MutexItem *GetMutex (pthread_mutex_t *);
-
-  // Semaphore functions
-  SemaphoreItem *CreateSemaphore (sem_t *, int, int);
-  SemaphoreItem *GetSemaphore (sem_t * t);
-
-  // Condition functions
-  CondItem *CreateCond (pthread_cond_t *, const pthread_condattr_t *);
-  CondItem *GetCond (pthread_cond_t *);
-
-private:
-  // General Administration
-  MTitem * Find (void *, int (*compare) (void *, void *), int &, MTList *);
-  MTitem *GetItem (int, MTList *);
-  MTitem *SetItem (int, MTitem *, MTList *);
-  int Find (MTitem &, MTList *);
-  int FindNextUnused (MTList *);
-
-  MTList threadlist;
-  MTList mutexlist;
-  MTList semalist;
-  MTList condlist;
 };
 
 
@@ -262,9 +330,12 @@ extern "C"
   void *thread_init_wrapper (void *);
 
 /*  ThreadCreation */
-int __pthread_create (pthread_t * thread, const pthread_attr_t * attr, TFD (start_routine), void *arg);
+  int __pthread_create (pthread_t * thread, const pthread_attr_t * attr,
+			void *(*start_routine) (void *), void *arg);
   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 (pthread_attr_t * attr, size_t * size);
 /*
@@ -273,7 +344,7 @@ __pthread_attr_getstackaddr(...);
 */
 
 /* Thread Exit */
-int __pthread_exit (void *value_ptr);
+  void __pthread_exit (void *value_ptr);
   int __pthread_join (pthread_t * thread, void **return_val);
   int __pthread_detach (pthread_t * thread);
 
@@ -285,26 +356,31 @@ int __pthread_continue(pthread_t *thread);
   unsigned long __pthread_getsequence_np (pthread_t * thread);
 
 /* Thread SpecificData */
-int __pthread_key_create (pthread_key_t * key);
+  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);
+  int __pthread_setspecific (pthread_key_t key, const void *value);
-void *__pthread_getspecific (pthread_key_t * key);
+  void *__pthread_getspecific (pthread_key_t key);
 
 /* Thead synchroniation */
   int __pthread_cond_destroy (pthread_cond_t * cond);
-int __pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
+  int __pthread_cond_init (pthread_cond_t * cond,
+			   const pthread_condattr_t * attr);
   int __pthread_cond_signal (pthread_cond_t * cond);
   int __pthread_cond_broadcast (pthread_cond_t * cond);
-int __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
+  int __pthread_cond_timedwait (pthread_cond_t * cond,
+				pthread_mutex_t * mutex,
+				const struct timespec *abstime);
   int __pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);
   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_getpshared (const pthread_condattr_t * attr,
+				     int *pshared);
   int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared);
 
 /* Thread signal */
   int __pthread_kill (pthread_t * thread, int sig);
-int __pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set);
+  int __pthread_sigmask (int operation, const sigset_t * set,
+			 sigset_t * old_set);
 
 /*  ID */
   pthread_t __pthread_self ();