2010-11-16  Ross Johnson <ross.johnson at homemail.com.au>



	* ChangeLog: Add this entry ;-)

	Restore entries from 2007 through 2009 that went missing

	at the last update.



2010-06-19  Ross Johnson <ross.johnson at homemail.com.au>



	* ptw32_MCS_lock.c (ptw32_mcs_node_substitute): Fix variable

	names to avoid using C++ keyword ("new").

	* implement.h (ptw32_mcs_node_substitute): Likewise.

	* pthread_barrier_wait.c: Fix signed/unsigned comparison warning.



2010-06-18  Ramiro Polla  <ramiro.polla at gmail.com >



	* autostatic.c: New file; call pthread_win32_process_*()

	libary init/cleanup routines automatically on application start

	when statically linked.

	* pthread.c (autostatic.c): Included.

	* pthread.h (declspec): Remove import/export defines if compiler

	is MINGW.

	* sched.h (declspec): Likewise.

	* semaphore.h (declspec): Likewise.

	* need_errno.h (declspec): Likewise.

	* Makefile (autostatic.obj): Add for small static builds.

	* GNUmakefile (autostatic.o): Likewise.

	* NEWS (Version 2.9.0): Add changes.

	* README.NONPORTABLE (pthread_win32_process_*): Update

	description.



2010-06-15  Ramiro Polla  <ramiro.polla at gmail.com >



	* Makefile: Remove linkage with the winsock library by default.

	* GNUmakefile: Likewise.

	* pthread_getspecific.c: Likewise by removing calls to WSA

	functions.

	* config.h (RETAIN_WSALASTERROR): Can be defined if necessary.



2010-01-26  Ross Johnson <ross.johnson at homemail.com.au>



	* ptw32_MCS_lock.c (ptw32_mcs_node_substitute): New routine

	to allow relocating the lock owners thread-local node to somewhere

	else, e.g. to global space so that another thread can release the

	lock. Used in pthread_barrier_wait.

	(ptw32_mcs_lock_try_acquire): New routine.

	* pthread_barrier_init: Only one semaphore is used now.

	* pthread_barrier_wait: Added an MCS guard lock with the last thread

	to leave the barrier releasing the lock. This removes a deadlock bug

	observed when there are greater than barrier-count threads

	attempting to cross.

	* pthread_barrier_destroy: Added an MCS guard lock.

        

2009-03-03  Stephan O'Farrill <stephan dot ofarrill at gmail dot com>



	* pthread_attr_getschedpolicy.c: Add "const" to function parameter

	in accordance with SUSv3 (POSIX).

	* pthread_attr_getinheritsched.c: Likewise.

	* pthread_mutexattr_gettype.c: Likewise.



2008-06-06  Robert Kindred  <RKindred at SwRI dot edu>



	* ptw32_throw.c (ptw32_throw): Remove possible reference to NULL

	pointer. (At the same time made the switch block conditionally

	included only if exitCode is needed - RPJ.)

	* pthread_testcancel.c (pthread_testcancel): Remove duplicate and

	misplaced pthread_mutex_unlock().



2008-02-21  Sebastian Gottschalk  <seppig_relay at gmx dot de>



	* pthread_attr_getdetachstate.c (pthread_attr_getdetachstate):

	Remove potential and superfluous null pointer assignment.



2007-11-22  Ivan Pizhenko  <ivanp4 at ua dot fm>



	* pthread.h (gmtime_r): gmtime returns 0 if tm represents a time

	prior to 1/1/1970. Notice this to prevent raising an exception.

	* pthread.h (localtime_r): Likewise for localtime.



2007-07-14  Marcel Ruff  <mr at marcelruff dot info>



	* errno.c (_errno): Fix test for pthread_self() success.

	* need_errno.h: Remove unintentional line wrap from #if line.



2007-07-14  Mike Romanchuk  <mromanchuk at empirix dot com>



	* pthread.h (timespec): Fix tv_sec type.



2007-01-07  Sinan Kaya <sinan.kaya at siemens dot com>



	* need_errno.h: Fix declaration of _errno - the local version of

	_errno() is used, e.g. by WinCE.



2007-01-06  Ross Johnson <ross.johnson at homemail dot com dot au>



	* ptw32_semwait.c: Add check for invalid sem_t after acquiring the

	sem_t state guard mutex and before affecting changes to sema state.

                

2007-01-06  Marcel Ruff <mr at marcelruff dot info>



	* error.c: Fix reference to pthread handle exitStatus member for

	builds that use NEED_ERRNO (i.e. WINCE).

	* context.h: Add support for ARM processor (WinCE).

	* mutex.c (process.h): Exclude for WINCE.

	* create.c: Likewise.

	* exit.c: Likewise.

	* implement.h: Likewise.

	* pthread_detach.c (signal.h): Exclude for WINCE.

	* pthread_join.c: Likewise.

	* pthread_kill.c: Likewise.

	* pthread_rwlock_init.c (errno.h): Remove - included by pthread.h.

	* pthread_rwlock_destroy.c: Likewise.

	* pthread_rwlock_rdlock.c: Likewise.

	* pthread_rwlock_timedrdlock.c: Likewise.

	* pthread_rwlock_timedwrlock.c: Likewise.

	* pthread_rwlock_tryrdlock.c: Likewise.

	* pthread_rwlock_trywrlock.c: likewise.

	* pthread_rwlock_unlock.c: Likewise.

	* pthread_rwlock_wrlock.c: Likewise.

	* pthread_rwlockattr_destroy.c: Likewise.

	* pthread_rwlockattr_getpshared.c: Likewise.

	* pthread_rwlockattr_init.c: Likewise.

	* pthread_rwlockattr_setpshared.c: Likewise.



2007-01-06  Romano Paolo Tenca <rotenca at telvia dot it>



	* pthread_cond_destroy.c: Replace sem_wait() with non-cancelable

	ptw32_semwait() since pthread_cond_destroy() is not a cancelation

	point.

	* implement.h (ptw32_spinlock_check_need_init): Add prototype.

	* ptw32_MCS_lock.c: Reverse order of includes.



2007-01-06  Eric Berge <eric dot berge at quantum dot com>



	* pthread_cond_destroy.c: Add LeaveCriticalSection before returning

	after errors.



2007-01-04  Ross Johnson <ross.johnson at homemail dot com dot au>



	* ptw32_InterlockedCompareExchange.c: Conditionally skip for

	Win64 as not required.

	* pthread_win32_attach_detach_np.c (pthread_win32_process_attach_np):

	Test for InterlockedCompareExchange is not required for Win64.

	* context.h: New file. Included by pthread_cancel.h and any tests

	that need it (e.g. context1.c).

	* pthread_cancel.c: Architecture-dependent context macros moved

	to context.h.



2007-01-04  Kip Streithorst <KSTREITH at ball dot com>



	* implement.h (PTW32_INTERLOCKED_COMPARE_EXCHANGE): Add Win64

	support.



2006-12-20  Ross Johnson <ross.johnson at homemail.com.au>



	* sem_destroy.c: Fix the race involving invalidation of the sema;

	fix incorrect return of EBUSY resulting from the mutex trylock

	on the private mutex guard.

	* sem_wait.c: Add check for invalid sem_t after acquiring the

	sem_t state guard mutex and before affecting changes to sema state.

	* sem_trywait.c: Likewise.

	* sem_timedwait.c: Likewise.

	* sem_getvalue.c: Likewise.

	* sem_post.c: Similar.

	* sem_post_multiple.c: Likewise.

	* sem_init.c: Set max Win32 semaphore count to SEM_VALUE_MAX (was

	_POSIX_SEM_VALUE_MAX, which is a lower value - the minimum).



	* pthread_win32_attach_detach_np.c (pthread_win32_process_attach_np):

	Load COREDLL.DLL under WINCE to check existence of

	InterlockedCompareExchange() routine. This used to be done to test

	for TryEnterCriticalSection() but was removed when this was no

	longer needed.



2006-01-25  Prashant Thakre <prashant.thakre at gmail.com>



	* pthread_cancel.c: Added _M_IA64 register context support.



2005-05-13  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread_kill.c (pthread_kill): Remove check for Win32 thread

	priority (to confirm HANDLE validity). Useless since thread HANDLEs

	a not recycle-unique.



2005-05-30  Vladimir Kliatchko  <vladimir at kliatchko.com>



	* pthread_once.c: Re-implement using an MCS queue-based lock. The form

	of pthread_once is as proposed by Alexander Terekhov (see entry of

	2005-03-13). The MCS lock implementation does not require a unique

	'name' to identify the lock between threads. Attempts to get the Event

	or Semaphore based versions of pthread_once to a satisfactory level

	of robustness have thus far failed. The last problem (avoiding races

	involving non recycle-unique Win32 HANDLEs) was giving everyone

	grey hair trying to solve it.



	* ptw32_MCS_lock.c: New MCS queue-based lock implementation. These

	locks are efficient: they have very low overhead in the uncontended case;

	are efficient in contention and minimise cache-coherence updates in

	managing the user level FIFO queue; do not require an ABI change in the

	library.



2005-05-27  Alexander Gottwald <alexander.gottwald at s1999.tu-chemnitz.de>



	* pthread.h: Some things, like HANDLE, were only defined if

	PTW32_LEVEL was >= 3. They should always be defined.



2005-05-25  Vladimir Kliatchko  <vladimir at kliatchko.com>



	* pthread_once.c: Eliminate all priority operations and other

	complexity by replacing the event with a semaphore. The advantage

	of the change is the ability to release just one waiter if the

	init_routine thread is cancelled yet still release all waiters when

	done. Simplify once_control state checks to improve efficiency

	further.



2005-05-24  Mikael Magnusson  <mikaelmagnusson at glocalnet.net>



	* GNUmakefile: Patched to allow cross-compile with mingw32 on Linux.

	It uses macros instead of referencing dlltool, gcc and g++ directly;

	added a call to ranlib. For example the GC static library can be

	built with:

	make CC=i586-mingw32msvc-gcc RC=i586-mingw32msvc-windres \

	RANLIB=i586-mingw32msvc-ranlib clean GC-static



2005-05-13  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread_win32_attach_detach_np.c (pthread_win32_thread_detach_np):

	Move on-exit-only stuff from ptw32_threadDestroy() to here.

	* ptw32_threadDestroy.c: It's purpose is now only to reclaim thread

	resources for detached threads, or via pthread_join() or

	pthread_detach() on joinable threads.

	* ptw32_threadStart.c: Calling user destruct routines has moved to

	pthread_win32_thread_detach_np(); call pthread_win32_thread_detach_np()

	directly if statically linking, otherwise do so via dllMain; store

	thread return value in thread struct for all cases, including

	cancellation and exception exits; thread abnormal exits	go via

	pthread_win32_thread_detach_np.

	* pthread_join.c (pthread_join): Don't try to get return code from

	Win32 thread - always get it from he thread struct.

	* pthread_detach.c (pthread_detach): reduce extent of the thread

	existence check since we now don't care if the Win32 thread HANDLE has

	been closed; reclaim thread resources if the thread has exited already.

	* ptw32_throw.c (ptw32_throw): For Win32 threads that are not implicit,

	only Call thread cleanup if statically linking, otherwise leave it to

	dllMain.

	* sem_post.c (_POSIX_SEM_VALUE_MAX): Change to SEM_VALUE_MAX.

	* sem_post_multiple.c: Likewise.

	* sem_init.c: Likewise.



2005-05-10  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread_join.c (pthread_join): Add missing check for thread ID

	reference count in thread existence test; reduce extent of the

	existence test since we don't care if the Win32 thread HANDLE has

	been closed.



2005-05-09  Ross Johnson  <ross at callisto.canberra.edu.au>



	* ptw32_callUserDestroyRoutines.c: Run destructor process (i.e.

	loop over all keys calling destructors) up to

	PTHREAD_DESTRUCTOR_ITERATIONS times if TSD value isn't NULL yet;

	modify assoc management.

	* pthread_key_delete.c: Modify assoc management.

	* ptw32_tkAssocDestroy.c: Fix error in assoc removal from chains.

	* pthread.h

	(_POSIX_THREAD_DESTRUCTOR_ITERATIONS): Define to value specified by

	POSIX.

	(_POSIX_THREAD_KEYS_MAX): Define to value specified by POSIX.

	(PTHREAD_KEYS_MAX): Redefine [upward] to minimum required by POSIX.

	(SEM_NSEMS_MAX): Define to implementation value.

	(SEM_VALUE_MAX): Define to implementation value.

	(_POSIX_SEM_NSEMS_MAX): Redefine to value specified by POSIX.

	(_POSIX_SEM_VALUE_MAX): Redefine to value specified by POSIX.



2005-05-06  Ross Johnson  <ross at callisto.canberra.edu.au>



	* signal.c (sigwait): Add a cancellation point to this otherwise

	no-op.

	* sem_init.c (sem_init): Check for and return ERANGE error.

	* sem_post.c (sem_post): Likewise.

	* sem_post_multiple.c (sem_post_multiple): Likewise.

	* manual (directory): Added; see ChangeLog inside.



2005-05-02  Ross Johnson  <ross at callisto.canberra.edu.au>



	* implement.h (struct pthread_key_t_): Change threadsLock to keyLock

	so as not to be confused with the per thread lock 'threadlock';

	change all references to it.

	* implement.h (struct ThreadKeyAssoc): Remove lock; add prevKey

	and prevThread pointers; re-implemented all routines that use this

	struct. The effect of this is to save one handle per association,

	which could potentially equal the number of keys multiplied by the

	number of threads, accumulating over time - and to free the

	association memory as soon as it is no longer referenced by either

	the key or the thread. Previously, the handle and memory were

	released only after BOTH key and thread no longer referenced the

	association. That is, often no association resources were released

	until the process itself exited. In addition, at least one race

	condition has been removed - where two threads could attempt to

	release the association resources simultaneously - one via

	ptw32_callUserDestroyRoutines and the other via

	pthread_key_delete.

	- thanks to Richard Hughes at Aculab for discovering the problem.

	* pthread_key_create.c: See above.

	* pthread_key_delete.c: See above.

	* pthread_setspecific.c: See above.

	* ptw32_callUserDestroyRoutines.c: See above.

	* ptw32_tkAssocCreate.c: See above.

	* ptw32_tkAssocDestroy.c: See above.



2005-04-27  Ross Johnson  <ross at callisto.canberra.edu.au>



	* sem_wait.c (ptw32_sem_wait_cleanup): after cancellation re-attempt

	to acquire the semaphore to avoid a race with a late sem_post.

	* sem_timedwait.c: Modify comments.



2005-04-25  Ross Johnson  <ross at callisto.canberra.edu.au>



	* ptw32_relmillisecs.c: New module; converts future abstime to 

	milliseconds relative to 'now'.

	* pthread_mutex_timedlock.c: Use new ptw32_relmillisecs routine in

	place of internal code; remove the NEED_SEM code - this routine is now

	implemented for builds that define NEED_SEM (WinCE etc)

	* sem_timedwait.c: Likewise; after timeout or cancellation,

	re-attempt to acquire the semaphore in case one has been posted since

	the timeout/cancel occurred. Thanks to Stefan Mueller.

	* Makefile: Add ptw32_relmillisecs.c module; remove

	ptw32_{in,de}crease_semaphore.c modules.

	* GNUmakefile: Likewise.

	* Bmakefile: Likewise.



	* sem_init.c: Re-write the NEED_SEM code to be consistent with the

	non-NEED_SEM code, but retaining use of an event in place of the w32 sema

	for w32 systems that don't include semaphores (WinCE);

	the NEED_SEM versions of semaphores has been broken for a long time but is

	now fixed and supports all of the same routines as the non-NEED_SEM case.

	* sem_destroy.c: Likewise.

	* sem_wait.c: Likewise.

	* sem_post.c: Likewise.

	* sem_post_multple.c: Likewise.

	* implement.h: Likewise.

	* sem_timedwait.c: Likewise; this routine is now

	implemented for builds that define NEED_SEM (WinCE etc).

	* sem_trywait.c: Likewise.

	* sem_getvalue.c: Likewise.



	* pthread_once.c: Yet more changes, reverting closer to Gottlob Frege's

	first design, but retaining cancellation, priority boosting, and adding

	preservation of W32 error codes to make pthread_once transparent to

	GetLastError.



2005-04-11  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread_once.c (pthread_once): Added priority boosting to

	solve starvation problem after once_routine cancellation.

	See notes in file.



2005-04-06  Kevin Lussier <Kevin at codegreennetworks.com>



	* Makefile: Added debug targets for all versions of the library.



2005-04-01  Ross Johnson  <ross at callisto.canberra.edu.au>



	* GNUmakefile: Add target to build libpthreadGC1.a as a static link

	library.

	* Makefile: Likewise for pthreadGC1.lib.



2005-04-01  Kevin Lussier <Kevin at codegreennetworks.com>



	* sem_timedwait.c (sem_timedwait): Increase size of temp variables to

	avoid int overflows for large timeout values.

	* implement.h (int64_t): Include or define.



2005-03-31   Dimitar Panayotov <develop at mail.bg>^M



	* pthread.h: Fix conditional defines for static linking.

	* sched.h: Liekwise.

	* semaphore.h: Likewise.

	* dll.c (PTW32_STATIC_LIB): Module is conditionally included

	in the build.



2005-03-16  Ross Johnson  <ross at callisto.canberra.edu.au>^M



	* pthread_setcancelstate.c: Undo the last change.



2005-03-16  Ross Johnson  <ross at callisto.canberra.edu.au>^M



	* pthread_setcancelstate.c: Don't check for an async cancel event

	if the library is using alertable async cancel..



2005-03-14  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread_once.c (pthread_once): Downgrade interlocked operations to simple

	memory operations where these are protected by the critical section; edit

	comments.



2005-03-13  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_once.c (pthread_once): Completely redesigned; a change was

	required to the ABI (pthread_once_t_), and resulting in a version

	compatibility index increment.



	NOTES:

	The design (based on pseudo code contributed by Gottlob Frege) avoids

	creating a kernel object if there is no contention. See URL for details:-

	http://sources.redhat.com/ml/pthreads-win32/2005/msg00029.html

	This uses late initialisation similar to the technique already used for

	pthreads-win32 mutexes and semaphores (from Alexander Terekhov).



	The subsequent cancelation cleanup additions (by rpj) could not be implemented

	without sacrificing some of the efficiency in Gottlob's design. In particular,

	although each once_control uses it's own event to block on, a global CS is

	required to manage it - since the event must be either re-usable or

	re-creatable under cancelation. This is not needed in the non-cancelable

	design because it is able to mark the event as closed (forever).



	When uncontested, a CS operation is equivalent to an Interlocked operation

	in speed. So, in the final design with cancelability, an uncontested

	once_control operation involves a minimum of five interlocked operations

	(including the LeaveCS operation).

	

	ALTERNATIVES:

	An alternative design from Alexander Terekhov proposed using a named mutex,

	as sketched below:-



	  if (!once_control) { // May be in TLS

	    named_mutex::guard guard(&once_control2);

	      if (!once_control2) {

	         <init>

	         once_control2 = true;

	      }

	    once_control = true;

	  }

	

	A more detailed description of this can be found here:-

	http://groups.yahoo.com/group/boost/message/15442



	[Although the definition of a suitable PTHREAD_ONCE_INIT precludes use of the

	TLS located flag, this is not critical.]

	

	There are three primary concerns though:-

	1) The [named] mutex is 'created' even in the uncontended case.

	2) A system wide unique name must be generated.

	3) Win32 mutexes are VERY slow even in the uncontended 	case. An uncontested

	Win32 mutex lock operation can be 50 (or more) times slower than an

	uncontested EnterCS operation.



	Ultimately, the named mutex trick is making use of the global locks maintained

	by the kernel.



	* pthread.h (pthread_once_t_): One flag and an event HANDLE added.

	(PTHREAD_ONCE_INIT): Additional values included.



2005-03-08  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_once.c (pthread_once): Redesigned to elliminate potential

	starvation problem.

	- reported by Gottlob Frege  <gottlobfrege at gmail.com>



	* ptw32_threadDestroy.c (ptw32_threadDestroy): Implicit threads were

	not closing their Win32 thread duplicate handle.

	- reported by Dmitrii Semii <bogolt at gmail.com>



2005-01-25  Ralf Kubis  <RKubis at mc.com>



	* Attempted acquisition of recursive mutex was causing waiting

	threads to not be woken when the mutex is released.



	* GNUmakefile (GCE): Generate correct version resource comments.



2005-01-01  Konstantin Voronkov  <beowinkle at yahoo.com>



	* pthread_mutex_lock.c (pthread_mutex_lock): The new atomic exchange

	mutex algorithm is known to allow a thread to steal the lock off

	FIFO waiting threads. The next waiting FIFO thread gets a spurious

	wake-up and must attempt to re-acquire the lock. The woken thread

	was setting itself as the mutex's owner before the re-acquisition.



2004-11-22  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_cond_wait.c (ptw32_cond_wait_cleanup): Undo change

	from 2004-11-02.

	* Makefile (DLL_VER): Added for DLL naming suffix - see README.

	* GNUmakefile (DLL_VER): Likewise.

	* Wmakefile (DLL_VER): Likewise.

	* Bmakefile (DLL_VER): Likewise.

	* pthread.dsw (version.rc): Added to MSVS workspace.



2004-11-20  Boudewijn Dekker  <b.dekker at ellipsis.nl>



	* pthread_getspecific.c (pthread_getspecific): Check for

	invalid (NULL) key argument.



2004-11-19  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* config.h (PTW32_THREAD_ID_REUSE_INCREMENT): Added to allow

	building the library for either unique thread IDs like Solaris

	or non-unique thread IDs like Linux; allows application developers

	to override the library's default insensitivity to some apps

	that may not be strictly POSIX compliant.

	* version.rc: New resource module to encode version information

	within the DLL.

	* pthread.h: Added PTW32_VERSION* defines and grouped sections

	required by resource compiler together; bulk of file is skipped

	if RC_INVOKED. Defined some error numbers and other names for

	Borland compiler.



2004-11-02  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_cond_wait.c (ptw32_cond_wait_cleanup): Lock CV mutex at

	start of cleanup handler rather than at the end.

	* implement.h (PTW32_THREAD_REUSE_EMPTY): Renamed from *_BOTTOM.

	(ptw32_threadReuseBottom): New global variable.

	* global.c (ptw32_threadReuseBottom): Declare new variable.

	* ptw32_reuse.c (ptw32_reuse): Change reuse LIFO stack to LILO queue

	to more evenly distribute use of reusable thread IDs; use renamed

	PTW32_THREAD_REUSE_EMPTY.

	* ptw32_processTerminate.c (ptw2_processTerminate): Use renamed

	PTW32_THREAD_REUSE_EMPTY.



2004-10-31  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* implement.h (PThreadState): Add new state value

	'PThreadStateCancelPending'.

	* pthread_testcancel.c (pthread_testcancel): Use new thread

	'PThreadStateCancelPending' state as short cut to avoid entering

	kernel space via WaitForSingleObject() call. This was obviated

	by user space sema acquisition in sem_wait() and sem_timedwait(),

	which are also cancelation points. A call to pthread_testcancel()

	was required, which introduced a kernel call, effectively nullifying

	any gains made by the user space sem acquisition checks.

	* pthread_cancel.c (pthread_cancel): Set new thread

	'PThreadStateCancelPending' state.



2004-10-29  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* implement.h (pthread_t): Renamed to ptw32_thread_t; struct contains

	all thread state.

	* pthread.h (ptw32_handle_t): New general purpose struct to serve

	as a handle for various reusable object IDs - currently only used

	by pthread_t; contains a pointer to ptw32_thread_t (thread state)

	and a general purpose uint for use as a reuse counter or flags etc.

	(pthread_t): typedef'ed to ptw32_handle_t; the uint is the reuse

	counter that allows the library to maintain unique POSIX thread IDs.

	When the pthread struct reuse stack was introduced, threads would

	often acquire an identical ID to a previously destroyed thread. The

	same was true for the pre-reuse stack library, by virtue of pthread_t

	being the address of the thread struct. The new pthread_t retains

	the reuse stack but provides virtually unique thread IDs.

	* sem_wait.c (ptw32_sem_wait_cleanup): New routine used for

	cancelation cleanup.

	* sem_timedwait.c (ptw32_sem_timedwait_cleanup): Likewise.



2004-10-22  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* sem_init.c (sem_init): Introduce a 'lock' element in order to

	replace the interlocked operations with conventional serialisation.

	This is needed in order to be able to atomically modify the sema

	value and perform Win32 sema release operations. Win32 semaphores are

	used instead of events in order to support efficient multiple posting.

	If the whole modify/release isn't atomic, a race between

	sem_timedwait() and sem_post() could result in a release when there is

	no waiting semaphore, which would cause too many threads to proceed.

	* sem_wait.c (sem_wait): Use new 'lock'element.

	* sem_timedwait.c (sem_timedwait): Likewise.

	* sem_trywait.c (sem_trywait): Likewise.

	* sem_post.c (sem_post): Likewise.

	* sem_post_multiple.c (sem_post_multiple): Likewise.

	* sem_getvalue.c (sem_getvalue): Likewise.

	* ptw32_semwait.c (ptw32_semwait): Likewise.

	* sem_destroy.c (sem_destroy): Likewise; also tightened the conditions

	for semaphore destruction; in particular, a semaphore will not be

	destroyed if it has waiters.

	* sem_timedwait.c (sem_timedwait): Added cancel cleanup handler to

	restore sema value when cancelled.

	* sem_wait.c (sem_wait): Likewise.



2004-10-21  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_mutex_unlock.c (pthread_mutex_unlock): Must use PulseEvent()

	rather than SetEvent() to reset the event if there are no waiters.



2004-10-19  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* sem_init.c (sem_init): New semaphore model based on the same idea

	as mutexes, i.e. user space interlocked check to avoid 

	unnecessarily entering kernel space. Wraps the Win32 semaphore and

	keeps it's own counter. Although the motivation to do this has existed

	for a long time, credit goes to Alexander Terekhov for providing

	the logic. I have deviated slightly from AT's logic to add the waiters

	count, which has made the code more complicated by adding cancelation

	cleanup. This also appears to have broken the VCE (C++ EH) version of

	the library (the same problem as previously reported - see BUGS #2),

	only apparently not fixable using the usual workaround, nor by turning

	all optimisation off. The GCE version works fine, so it is presumed to

	be a bug in MSVC++ 6.0. The cancelation exception is thrown and caught

	correctly, but the cleanup class destructor is never called. The failing

	test is tests\semaphore4.c.

	* sem_wait.c (sem_wait): Implemented user space check model.

	* sem_post.c (sem_post): Likewise.

	* sem_trywait.c (sem_trywait): Likewise.

	* sem_timedwait.c (sem_timedwait): Likewise.

	* sem_post_multiple.c (sem_post_multiple): Likewise.

	* sem_getvalue.c (sem_getvalue): Likewise.

	* ptw32_semwait.c (ptw32_semwait): Likewise.

	* implement.h (sem_t_): Add counter element.



2004-10-15  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* implement.h (pthread_mutex_t_): Use an event in place of

	the POSIX semaphore.

	* pthread_mutex_init.c: Create the event; remove semaphore init.

	* pthread_mutex_destroy.c: Delete the event.

	* pthread_mutex_lock.c: Replace the semaphore wait with the event wait.

	* pthread_mutex_trylock.c: Likewise.

	* pthread_mutex_timedlock.c: Likewise.

	* pthread_mutex_unlock.c: Set the event.

	

2004-10-14  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_mutex_lock.c (pthread_mutex_lock): New algorithm using

	Terekhov's xchg based variation of Drepper's cmpxchg model.

	Theoretically, xchg uses fewer clock cycles than cmpxchg (using IA-32

	as a reference), however, in my opinion bus locking dominates the

	equation on smp systems, so the model with the least number of bus

	lock operations in the execution path should win, which is Terekhov's

	variant. On IA-32 uni-processor systems, it's faster to use the

	CMPXCHG instruction without locking the bus than to use the XCHG

	instruction, which always locks the bus. This makes the two variants

	equal for the non-contended lock (fast lane) execution path on up

	IA-32. Testing shows that the xchg variant is faster on up IA-32 as

	well if the test forces higher lock contention frequency, even though

	kernel calls should be dominating the times (on up IA-32, both

	variants used CMPXCHG instructions and neither locked the bus).

	* pthread_mutex_timedlock.c pthread_mutex_timedlock(): Similarly.

	* pthread_mutex_trylock.c (pthread_mutex_trylock): Similarly.

	* pthread_mutex_unlock.c (pthread_mutex_unlock): Similarly.

	* ptw32_InterlockedCompareExchange.c (ptw32_InterlockExchange): New

	function.

	(PTW32_INTERLOCKED_EXCHANGE): Sets up macro to use inlined

	ptw32_InterlockedExchange.

	* implement.h (PTW32_INTERLOCKED_EXCHANGE): Set default to

	InterlockedExchange().

	* Makefile: Building using /Ob2 so that asm sections within inline

	functions are inlined.



2004-10-08  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_mutex_destroy.c (pthread_mutex_destroy): Critical Section

	element is no longer required.

	* pthread_mutex_init.c (pthread_mutex_init): Likewise.

	* pthread_mutex_lock.c (pthread_mutex_lock): New algorithm following

	Drepper's paper at http://people.redhat.com/drepper/futex.pdf, but

	using the existing semaphore in place of the futex described in the

	paper. Idea suggested by Alexander Terekhov - see:

	http://sources.redhat.com/ml/pthreads-win32/2003/msg00108.html

	* pthread_mutex_timedlock.c pthread_mutex_timedlock(): Similarly.

	* pthread_mutex_trylock.c (pthread_mutex_trylock): Similarly.

	* pthread_mutex_unlock.c (pthread_mutex_unlock): Similarly.

	* pthread_barrier_wait.c (pthread_barrier_wait): Use inlined version

	of InterlockedCompareExchange() if possible - determined at

	build-time.

	* pthread_spin_destroy.c pthread_spin_destroy(): Likewise.

	* pthread_spin_lock.c pthread_spin_lock():Likewise.

	* pthread_spin_trylock.c (pthread_spin_trylock):Likewise.

	* pthread_spin_unlock.c (pthread_spin_unlock):Likewise.

	* ptw32_InterlockedCompareExchange.c: Sets up macro for inlined use.

	* implement.h (pthread_mutex_t_): Remove Critical Section element.

	(PTW32_INTERLOCKED_COMPARE_EXCHANGE): Set to default non-inlined

	version of InterlockedCompareExchange().

	* private.c: Include ptw32_InterlockedCompareExchange.c first for

	inlining.

	* GNUmakefile: Add commandline option to use inlined

	InterlockedCompareExchange().

	* Makefile: Likewise.



2004-09-27  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_mutex_lock.c (pthread_mutex_lock): Separate

	PTHREAD_MUTEX_NORMAL logic since we do not need to keep or check some

	state required by other mutex types; do not check mutex pointer arg

	for validity - leave this to the system since we are only checking

	for NULL pointers. This should improve speed of NORMAL mutexes and

	marginally improve speed of other type.

	* pthread_mutex_trylock.c (pthread_mutex_trylock): Likewise.

	* pthread_mutex_unlock.c (pthread_mutex_unlock): Likewise; also avoid

	entering the critical section for the no-waiters case, with approx.

	30% reduction in lock/unlock overhead for this case.

	* pthread_mutex_timedlock.c (pthread_mutex_timedlock): Likewise; also

	no longer keeps mutex if post-timeout second attempt succeeds - this

	will assist applications that wish to impose strict lock deadlines,

	rather than simply to escape from frozen locks.



2004-09-09  Tristan Savatier  <tristan at mpegtv.com>

	* pthread.h (struct pthread_once_t_): Qualify the 'done' element

	as 'volatile'.

	* pthread_once.c: Concerned about possible race condition,

	specifically on MPU systems re concurrent access to multibyte types.

	[Maintainer's note: the race condition is harmless on SPU systems

	and only a problem on MPU systems if concurrent access results in an

	exception (presumably generated by a hardware interrupt). There are

	other instances of similar harmless race conditions that have not

	been identified as issues.]



2004-09-09  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread.h: Declare additional types as volatile.



2004-08-27  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_barrier_wait.c (pthread_barrier_wait): Remove excessive code

	by substituting the internal non-cancelable version of sem_wait

	(ptw32_semwait).



2004-08-25  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_join.c (pthread_join): Rewrite and re-order the conditional

	tests in an attempt to improve efficiency and remove a race

	condition.



2004-08-23  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* create.c (pthread_create): Don't create a thread if the thread

	id pointer location (first arg) is inaccessible. A memory

	protection fault will result if the thread id arg isn't an accessible

	location. This is consistent with GNU/Linux but different to

	Solaris or MKS (and possibly others), which accept NULL as meaning

	'don't return the created thread's ID'. Applications that run

	using pthreads-win32 will run on all other POSIX threads

	implementations, at least w.r.t. this feature.



	It was decided not to copy the Solaris et al behaviour because,

	although it would have simplified some application porting (but only

	from Solaris to Windows), the feature is not technically necessary,

	and the alternative segfault behaviour helps avoid buggy application

	code.



2004-07-01  Anuj Goyal  <anuj.goyal at gmail.com>



	* builddmc.bat: New; Windows bat file to build the library.

	* config.h (__DMC__): Support for Digital Mars compiler.

	* create.c (__DMC__): Likewise.

	* pthread_exit.c (__DMC__): Likewise.

	* pthread_join.c (__DMC__): Likewise.

	* ptw32_threadDestroy.c (__DMC__): Likewise.

	* ptw32_threadStart.c (__DMC__): Likewise.

	* ptw32_throw.c (__DMC__): Likewise.



2004-06-29  Anuj Goyal  <anuj.goyal at gmail.com>



	* pthread.h (__DMC__): Initial support for Digital Mars compiler.



2004-06-29  Will Bryant  <will.bryant at ecosm.com>



	* README.Borland: New; description of Borland changes.

	* Bmakefile: New makefile for the Borland make utility.

	* ptw32_InterlockedCompareExchange.c:

	Add Borland compatible asm code.



2004-06-26  Jason Bard  <BardJA at Npt.NUWC.Navy.Mil>



	* pthread.h (HAVE_STRUCT_TIMESPEC): If undefined, define it

	to avoid timespec struct redefined errors elsewhere in an

	application.



2004-06-21  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread.h (PTHREAD_RECURSIVE_MUTEX_INITIALIZER): Mutex

	initialiser added for compatibility with Linux threads and

	others; currently not included in SUSV3.

	* pthread.h (PTHREAD_ERRORCHECK_MUTEX_INITIALIZER): Likewise.

	* pthread.h (PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP): Likewise.

	* pthread.h (PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP): Likewise.



	* ptw32_mutex_check_need_init.c (ptw32_mutex_check_need_init): 

	Add new initialisers.



	* pthread_mutex_lock.c (pthread_mutex_lock): Check for new

	initialisers.

	* pthread_mutex_trylock.c (pthread_mutex_trylock): Likewise.

	* pthread_mutex_timedlock.c (pthread_mutex_timedlock): Likewise.

	* pthread_mutex_unlock.c (pthread_mutex_unlock): Likewise.

	* pthread_mutex_destroy.c (pthread_mutex_destroy): Likewise.



2004-05-20  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* README.NONPORTABLE: Document pthread_win32_test_features_np().

	* FAQ: Update various answers.



2004-05-19  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* Makefile: Don't define _WIN32_WINNT on compiler command line.

	* GNUmakefile: Likewise.



2004-05-16  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_cancel.c (pthread_cancel): Adapted to use auto-detected

	QueueUserAPCEx features at run-time.

	(ptw32_RegisterCancelation): Drop in replacement for QueueUserAPCEx()

	if it can't be used. Provides older style non-preemptive async

	cancelation.

	* pthread_win32_attach_detach_np.c (pthread_win32_attach_np):

	Auto-detect quserex.dll and the availability of alertdrv.sys;

	initialise and close on process attach/detach.

	* global.c (ptw32_register_cancelation): Pointer to either

	QueueUserAPCEx() or ptw32_RegisterCancelation() depending on

	availability. QueueUserAPCEx makes pre-emptive async cancelation

	possible.

	* implement.h: Add definitions and prototypes related to QueueUserAPC.



2004-05-16  Panagiotis E. Hadjidoukas <peh at hpclab.ceid.upatras.gr>



	* QueueUserAPCEx (separate contributed package): Provides preemptive

	APC feature.

	* pthread_cancel.c (pthread_cancel): Initial integration of

	QueueUserAPCEx into pthreads-win32 to provide true pre-emptive

	async cancelation of threads, including blocked threads.



2004-05-06  Makoto Kato  <raven at oldskool.jp>



	* pthread.h (DWORD_PTR): Define typedef for older MSVC.

	* pthread_cancel.c (AMD64): Add architecture specific Context register.

	* ptw32_getprocessors.c: Use correct types (DWORD_PTR) for mask

	variables.



2004-04-06  P. van Bruggen  <pietvb at newbridges.nl>



	* ptw32_threadDestroy.c: Destroy threadLock mutex to

	close a memory leak.



2004-02-13  Gustav Hallberg  <gustav at virtutech.com>



	* pthread_equal.c: Remove redundant equality logic.



2003-12-10  Philippe Di Cristo  <philipped at voicebox.com>



	* sem_timedwait.c (sem_timedwait): Fix timeout calculations.



2003-10-20  Alexander Terekhov  <TEREKHOV at de.ibm.com>



	* pthread_mutex_timedlock.c (ptw32_semwait): Move to individual module.

	* ptw32_semwait.c: New module.

	* pthread_cond_wait.c (ptw32_cond_wait_cleanup): Replace cancelable

	sem_wait() call with non-cancelable ptw32_semwait() call.

	* pthread.c (private.c): Re-order for inlining. GNU C warned that

	function ptw32_semwait() was defined 'inline' after it was called.

	* pthread_cond_signal.c (ptw32_cond_unblock): Likewise.

	* pthread_delay_np.c: Disable Watcom warning with comment.

	* *.c (process.h): Remove include from .c files. This is conditionally

	included by the common project include files.



2003-10-20  James Ewing  <james.ewing at sveasoft.com>



	* ptw32_getprocessors.c: Some Win32 environments don't have

	GetProcessAffinityMask(), so always return CPU count = 1 for them.

	* config.h (NEED_PROCESSOR_AFFINITY_MASK): Define for WinCE.

	

2003-10-15  Ross Johnson  <ross at callisto.canberra.edu.au>



	* Re-indented all .c files using default GNU style to remove assorted

	editor ugliness (used GNU indent utility in default style).



2003-10-15  Alex Blanco  <Alex.Blanco at motorola.com>



	* sem_init.c (sem_init): Would call CreateSemaphore even if the sema

	struct calloc failed; was not freeing calloced memory if either

	CreateSemaphore or CreateEvent failed.



2003-10-14  Ross Johnson  <ross at callisto.canberra.edu.au>



	* pthread.h: Add Watcom compiler compatibility. Esssentially just add

	the cdecl attribute to all exposed function prototypes so that Watcom

	generates function call code compatible with non-Watcom built libraries.

	By default, Watcom uses registers to pass function args if possible rather

	than pushing to stack.

	* semaphore.h: Likewise.

	* sched.h: Likewise.

	* pthread_cond_wait.c (ptw32_cond_wait_cleanup): Define with cdecl attribute

	for Watcom compatibility. This routine is called via pthread_cleanup_push so

	it had to match function arg definition.

	* Wmakefile: New makefile for Watcom builds.



2003-09-14  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_setschedparam.c (pthread_setschedparam): Attempt to map

	all priority levels between max and min (as returned by

	sched_get_priority_min/max) to reasonable Win32 priority levels - i.e.

	levels between THREAD_PRIORITY_LOWEST/IDLE to THREAD_PRIORITY_LOWEST and

	between THREAD_PRIORITY_HIGHEST/TIME_CRITICAL to THREAD_PRIORITY_HIGHEST

	while others remain unchanged; record specified thread priority level

	for return by pthread_getschedparam.



	Note that, previously, specified levels not matching Win32 priority levels

	would silently leave the current thread priority unaltered.



	* pthread_getschedparam.c (pthread_getschedparam): Return the priority

	level specified by the latest pthread_setschedparam or pthread_create rather

	than the actual running thread priority as returned by GetThreadPriority - as

	required by POSIX. I.e. temporary or adjusted actual priority levels are not

	returned by this routine.



	* pthread_create.c (pthread_create): For priority levels specified via

	pthread attributes, attempt to map all priority levels between max and

	min (as returned by sched_get_priority_min/max) to reasonable Win32

	priority levels; record priority level given via attributes, or

	inherited from parent thread, for later return by pthread_getschedparam.



	* ptw32_new.c (ptw32_new): Initialise pthread_t_ sched_priority element.



	* pthread_self.c (pthread_self): Set newly created implicit POSIX thread

	sched_priority to Win32 thread's current actual priority. Temporarily

	altered priorities can't be avoided in this case.



	* implement.h (struct pthread_t_): Add new sched_priority element.



2003-09-12  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* sched_get_priority_min.c (sched_get_priority_min): On error should return -1

	with errno set.

	* sched_get_priority_max.c (sched_get_priority_max): Likewise.



2003-09-03  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* w32_cancelableWait.c (ptw32_cancelable_wait): Allow cancelation

	of implicit POSIX threads as well.



2003-09-02  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_win32_attach_detach_np.c (pthread_win32_thread_detach_np):

	Add comment.



	* pthread_exit.c (pthread_exit): Fix to recycle the POSIX thread handle in

	addition to calling user TSD destructors. Move the implicit POSIX thread exit

	handling to ptw32_throw to centralise the logic.



	* ptw32_throw.c (ptw32_throw): Implicit POSIX threads have no point

	to jump or throw to, so cleanup and exit the thread here in this case. For

	processes using the C runtime, the exit code will be set to the POSIX

	reason for the throw (i.e. PTHREAD_CANCEL or the value given to pthread_exit).

	Note that pthread_exit() already had similar logic, which has been moved to

	here.



	* ptw32_threadDestroy.c (ptw32_threadDestroy): Don't close the Win32 handle

	of implicit POSIX threads - expect this to be done by Win32?



2003-09-01  Ross Johnson  <rpj at callisto.canberra.edu.au>



	* pthread_self.c (pthread_self): The newly aquired pthread_t must be

	assigned to the reuse stack, not freed, if the routine fails somehow.



2003-08-13  Ross Johnson  <rpj at ise.canberra.edu.au>



	* pthread_getschedparam.c (pthread_getschedparam): An invalid thread ID

	parameter was returning an incorrect error value; now uses a more exhaustive

	check for validity.



	* pthread_setschedparam.c (pthread_setschedparam): Likewise.



	* pthread_join.c (pthread_join): Now uses a more exhaustive

	check for validity.



	* pthread_detach.c (pthread_detach): Likewise.



	* pthread_cancel.c (pthread_cancel): Likewise.



	* ptw32_threadDestroy.c (ptw32_threadDestroy): pthread_t structs are

	never freed - push them onto a stack for reuse.



	* ptw32_new.c (ptw32_new): Check for reusable pthread_t before dynamically

	allocating new memory for the struct.



	* pthread_kill.c (pthread_kill): New file; new routine; takes only a zero

	signal arg so that applications can check the thread arg for validity; checks

	that the underlying Win32 thread HANDLE is valid.



	* pthread.h (pthread_kill): Add prototype.



	* ptw32_reuse.c (ptw32_threadReusePop): New file; new routine; pop a

	pthread_t off the reuse stack. pthread_t_ structs that have been destroyed, i.e.

	have exited detached or have been joined, are cleaned up and put onto a reuse

	stack. Consequently, thread IDs are no longer freed once calloced. The library

	will attempt to get a struct off this stack before asking the system to alloc

	new memory when creating threads. The stack is guarded by a global mutex.

	(ptw32_threadReusePush): New routine; push a pthread_t onto the reuse stack.



	* implement.h (ptw32_threadReusePush): Add new prototype.

	(ptw32_threadReusePop): Likewise.

	(pthread_t): Add new element.



	* ptw32_processTerminate.c (ptw32_processTerminate): Delete the thread

	reuse lock; free all thread ID structs on the thread reuse stack.



	* ptw32_processInitialize.c (ptw32_processInitialize): Initialise the

	thread reuse lock.



2003-07-19  Ross Johnson  <rpj at ise.canberra.edu.au>



	* GNUmakefile: modified to work under MsysDTK environment.

	* pthread_spin_lock.c (pthread_spin_lock): Check for NULL arg.

	* pthread_spin_unlock.c (pthread_spin_unlock): Likewise.

	* pthread_spin_trylock.c (pthread_spin_trylock): Likewise;

	fix incorrect pointer value if lock is dynamically initialised by

	this function.

	* sem_init.c (sem_init): Initialise sem_t value to quell compiler warning.

	* sem_destroy.c (sem_destroy): Likewise.

	* ptw32_threadStart.c (non-MSVC code sections): Include <exception> rather

	than old-style <new.h>; fix all std:: namespace entities such as

	std::terminate_handler instances and associated methods.

	* ptw32_callUserDestroyRoutines.c (non-MSVC code sections): Likewise.



2003-06-24  Piet van Bruggen  <pietvb at newbridges.nl>



	* pthread_spin_destroy.c (pthread_spin_destroy): Was not freeing the

	spinlock struct.



2003-06-22  Nicolas Barry  <boozai at yahoo.com>



	* pthread_mutex_destroy.c (pthread_mutex_destroy): When called

	with a recursive mutex that was locked by the current thread, the

	function was failing with a success return code.



2003-05-15  Steven Reddie  <Steven.Reddie at ca.com>



	* pthread_win32_attach_detach_np.c (pthread_win32_process_detach_np):

	NULLify ptw32_selfThreadKey after the thread is destroyed, otherwise

	destructors calling pthreads routines might resurrect it again, creating

	memory leaks. Call the underlying Win32 Tls routine directly rather than

	pthread_setspecific().

	(pthread_win32_thread_detach_np): Likewise.



2003-05-14  Viv  <vcotirlea at hotmail.com>



	* pthread.dsp: Change /MT compile flag to /MD.



2003-03-04  Alexander Terekhov  <TEREKHOV at de.ibm.com>



	* pthread_mutex_timedlock.c (pthread_mutex_timedlock): Fix failure to

	set ownership of mutex on second grab after abstime timeout.

	- bug reported by Robert Strycek <strycek at posam.sk>



2002-12-17  Thomas Pfaff  <tpfaff at gmx.net>



	* pthread_mutex_lock.c (ptw32_semwait): New static routine to provide

	a non-cancelable sem_wait() function. This is consistent with the

	way that pthread_mutex_timedlock.c does it.

	(pthread_mutex_lock): Use ptw32_semwait() instead of sem_wait().



2002-12-11  Thomas Pfaff  <tpfaff at gmx.net>



	* pthread_mutex_trylock.c: Should return EBUSY rather than EDEADLK.

	* pthread_mutex_destroy.c: Remove redundant ownership test (the

	trylock call does this for us); do not destroy a recursively locked

	mutex.



2002-09-20  Michael Johnson  <michaelj at maine.rr.com>



	* pthread_cond_destroy.c (pthread_cond_destroy): 

	When two different threads exist, and one is attempting to

	destroy a condition variable while the other is attempting to

	initialize a condition variable that was created with

	PTHREAD_COND_INITIALIZER, a deadlock can occur. Shrink

	the ptw32_cond_list_lock critical section to fix it.



2002-07-31  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* ptw32_threadStart.c (ptw32_threadStart): Thread cancelLock

	destruction moved to ptw32_threadDestroy().



	* ptw32_threadDestroy.c (ptw32_threadDestroy):  Destroy

	the thread's cancelLock. Moved here from ptw32_threadStart.c

	to cleanup implicit threads as well.



2002-07-30  Alexander Terekhov  <TEREKHOV at de.ibm.com>



	* pthread_cond_wait.c (ptw32_cond_wait_cleanup): 

	Remove code designed to avoid/prevent spurious wakeup

	problems. It is believed that the sem_timedwait() call

	is consuming a CV signal that it shouldn't and this is

	breaking the avoidance logic.



2002-07-30  Ross Johnson  <rpj at ise.canberra.edu.au>



	* sem_timedwait.c (sem_timedwait): Tighten checks for

	unreasonable abstime values - that would result in

	unexpected timeout values.



	* w32_CancelableWait.c (ptw32_cancelable_wait):

	Tighten up return value checking and add comments.





2002-06-08  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* sem_getvalue.c (sem_getvalue): Now returns a value for the

	NEED_SEM version (i.e. earlier versions of WinCE).





2002-06-04  Rob Fanner  <rfanner at stonethree.com>



	* sem_getvalue.c (sem_getvalue): The Johnson M. Hart

	approach didn't work - we are forced to take an

	intrusive approach. We try to decrement the sema

	and then immediately release it again to get the

	value. There is a small probability that this may

	block other threads, but only momentarily.



2002-06-03  Ross Johnson  <rpj at ise.canberra.edu.au>



	* sem_init.c (sem_init): Initialise Win32 semaphores

	to _POSIX_SEM_VALUE_MAX (which this implementation

	defines in pthread.h) so that sem_getvalue() can use

	the trick described in the comments in sem_getvalue().

	* pthread.h (_POSIX_SEM_VALUE_MAX): Defined.

	(_POSIX_SEM_NSEMS_MAX): Defined - not used but may be

	useful for source code portability.



2002-06-03  Rob Fanner  <rfanner at stonethree.com>



	* sem_getvalue.c (sem_getvalue): Did not work on NT.

	Use approach suggested by Johnson M. Hart in his book

	"Win32 System Programming".



2002-02-28  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* errno.c: Compiler directive was incorrectly including code.

	* pthread.h: Conditionally added some #defines from config.h

	needed when not building the library. e.g. NEED_ERRNO, NEED_SEM.

	(PTW32_DLLPORT): Now only defined if _DLL defined.

	(_errno): Compiler directive was incorrectly including prototype.

	* sched.h: Conditionally added some #defines from config.h

	needed when not building the library.

	* semaphore.h: Replace an instance of NEED_SEM that should

	have been NEED_ERRNO. This change currently has nil effect.



	* GNUmakefile: Correct some recent changes.



	* Makefile: Add rule to generate pre-processor output.



2002-02-23  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* pthread_rwlock_timedrdlock.c: New - untested.

	* pthread_rwlock_timedwrlock.c: New - untested.

	

	* Testsuite passed (except known MSVC++ problems)



	* pthread_cond_destroy.c: Expand the time change

	critical section to solve deadlock problem.



	* pthread.c: Add all remaining C modules.

	* pthread.h: Use dllexport/dllimport attributes on functions

	to avoid using pthread.def.

	* sched.h: Likewise.

	* semaphore.h: Likewise.

	* GNUmakefile: Add new targets for single translation

	unit build to maximise inlining potential; generate

	pthread.def automatically.

	* Makefile: Likewise, but no longer uses pthread.def.



2002-02-20  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* pthread_cond_destroy.c (pthread_cond_destroy):

	Enter the time change critical section earlier.



2002-02-17  Ross Johnson  <rpj at setup1.ise.canberra.edu.au



	* Testsuite passed.



	* pthread_timechange_handler_np.c: New; following

	a suggestion from Alexander Terekhov that CVs should

	be broadcast so that they all re-evaluate their

	condition variables and reset a new timeout if

	required, whenever an application receives a

	WM_TIMECHANGE message. This message indicates that

	the system time has been changed. Therefore, CVs

	waiting for a timeout set as an abs_time will possibly

	not wake up at the expected time. Some applications

	may not be tolerant of this.

	* pthread_cond_init.c: Add CV to linked list.

	* pthread_cond_destroy.c: Remove CV from linked list.

	* global.c (ptw32_cond_list_head): New variable.

	(ptw32_cond_list_tail): New variable.

	(ptw32_cond_list_cs): New critical section.

	* ptw32_processInitialize (ptw32_cond_list_cs): Initialize.

	* ptw32_processTerminate (ptw32_cond_list_cs): Delete.





	* Reduce executable size.

	  -----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* spin.c: Split file into function segments.

	* ptw32_spinlock_check_need_init.c: Separated routine from spin.c.

	* pthread_spin_init.c: Likewise.

	* pthread_spin_destroy.c: Likewise.

	* pthread_spin_lock.c: Likewise.

	* pthread_spin_unlock.c: Likewise.

	* pthread_spin_trylock.c: Likewise.



	* sync.c: Split file into function segments.

	* pthread_detach.c: Separated routine from sync.c.

	* pthread_join.c: Likewise.



	* tsd.c: Split file into function segments.

	* pthread_key_create.c: Separated routine from tsd.c.

	* pthread_key_delete.c: Likewise.

	* pthread_setspecific.c: Likewise.

	* pthread_getspecific.c: Likewise.



	* sched.c: Split file into function segments.

	* pthread_attr_setschedpolicy.c: Separated routine from sched.c.

	* pthread_attr_getschedpolicy.c: Likewise.

	* pthread_attr_setschedparam.c: Likewise.

	* pthread_attr_getschedparam.c: Likewise.

	* pthread_attr_setinheritsched.c: Likewise.

	* pthread_attr_getinheritsched.c: Likewise.

	* pthread_setschedparam.c: Likewise.

	* pthread_getschedparam.c: Likewise.

	* sched_get_priority_max.c: Likewise.

	* sched_get_priority_min.c: Likewise.

	* sched_setscheduler.c: Likewise.

	* sched_getscheduler.c: Likewise.

	* sched_yield.c: Likewise.





2002-02-16  Ross Johnson  <rpj at setup1.ise.canberra.edu.au



	Reduce executable size.

	-----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* mutex.c: Split file into function segments.

	* pthread_mutexattr_destroy.c: Separated routine from mutex.c

	* pthread_mutexattr_getpshared.c: Likewise.

	* pthread_mutexattr_gettype.c: Likewise.

	* pthread_mutexattr_init.c: Likewise.

	* pthread_mutexattr_setpshared.c: Likewise.

	* pthread_mutexattr_settype.c: Likewise.

	* ptw32_mutex_check_need_init.c: Likewise.

	* pthread_mutex_destroy.c: Likewise.

	* pthread_mutex_init.c: Likewise.

	* pthread_mutex_lock.c: Likewise.

	* pthread_mutex_timedlock.c: Likewise.

	* pthread_mutex_trylock.c: Likewise.

	* pthread_mutex_unlock.c: Likewise.

	

	* private.c: Split file into function segments.

	* ptw32_InterlockedCompareExchange.c: Separated routine from private.c

	* ptw32_callUserDestroyRoutines.c: Likewise.

	* ptw32_getprocessors.c: Likewise.

	* ptw32_processInitialize.c: Likewise.

	* ptw32_processTerminate.c: Likewise.

	* ptw32_threadDestroy.c: Likewise.

	* ptw32_threadStart.c: Likewise.

	* ptw32_throw.c: Likewise.

	* ptw32_timespec.c: Likewise.

	* ptw32_tkAssocCreate.c: Likewise.

	* ptw32_tkAssocDestroy.c: Likewise.



	* rwlock.c: Split file into function segments.

	* pthread_rwlockattr_destroy.c: Separated routine from rwlock.c

	* pthread_rwlockattr_getpshared.c: Likewise.

	* pthread_rwlockattr_init.c: Likewise.

	* pthread_rwlockattr_setpshared.c: Likewise.

	* ptw32_rwlock_check_need_init.c: Likewise.

	* pthread_rwlock_destroy.c: Likewise.

	* pthread_rwlock_init.c: Likewise.

	* pthread_rwlock_rdlock.c: Likewise.

	* pthread_rwlock_tryrdlock.c: Likewise.

	* pthread_rwlock_trywrlock.c: Likewise.

	* pthread_rwlock_unlock.c: Likewise.

	* pthread_rwlock_wrlock.c: Likewise.



2002-02-10  Ross Johnson  <rpj at setup1.ise.canberra.edu.au



	Reduce executable size.

	-----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* nonportable.c: Split file into function segments.

	* np_delay.c: Separated routine from nonportable.c

	* np_getw32threadhandle.c: Likewise.

	* np_mutexattr_setkind.c: Likewise.

	* np_mutexattr_getkind.c: Likewise.

	* np_num_processors.c: Likewise.

	* np_win32_attach_detach.c: Likewise.



	* misc.c: Split file into function segments.

	* pthread_equal.c: Separated routine from nonportable.c.

	* pthread_getconcurrency.c: Likewise.

	* pthread_once.c: Likewise.

	* pthread_self.c: Likewise.

	* pthread_setconcurrency.c: Likewise.

	* ptw32_calloc.c: Likewise.

	* ptw32_new.c: Likewise.

	* w32_CancelableWait.c: Likewise.

	

2002-02-09  Ross Johnson  <rpj at setup1.ise.canberra.edu.au



	Reduce executable size.

	-----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* condvar.c: Split file into function segments.

	* pthread_condattr_destroy.c: Separated routine from condvar.c.

	* pthread_condattr_getpshared.c: Likewise.

	* pthread_condattr_init.c: Likewise.

	* pthread_condattr_setpshared.c: Likewise.

	* ptw32_cond_check_need_init.c: Likewise.

	* pthread_cond_destroy.c: Likewise.

	* pthread_cond_init.c: Likewise.

	* pthread_cond_signal.c: Likewise.

	* pthread_cond_wait.c: Likewise.

	

2002-02-07  Alexander Terekhov<TEREKHOV at de.ibm.com>



	* nonportable.c (pthread_delay_np): Make a true

	cancelation point. Deferred cancels will interrupt the

	wait.



2002-02-07  Ross Johnson  <rpj at setup1.ise.canberra.edu.au



	* misc.c (ptw32_new): Add creation of cancelEvent so that

	implicit POSIX threads (Win32 threads with a POSIX face)

	are cancelable; mainly so that pthread_delay_np doesn't fail

	if called from the main thread.

	* create.c (pthread_create): Remove creation of cancelEvent

	from here; now in ptw32_new().



	Reduce executable size.

	-----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* barrier.c: All routines are now in separate compilation units;

	This file is used to congregate the separate modules for

	potential inline optimisation and backward build compatibility.

	* cancel.c: Likewise.

	* pthread_barrierattr_destroy.c: Separated routine from cancel.c.

	* pthread_barrierattr_getpshared.c: Likewise.

	* pthread_barrierattr_init.c: Likewise.

	* pthread_barrierattr_setpshared.c: Likewise.

	* pthread_barrier_destroy.c: Likewise.

	* pthread_barrier_init.c: Likewise.

	* pthread_barrier_wait.c: Likewise.

	* pthread_cancel.c: Likewise.

	* pthread_setcancelstate.c: Likewise.

	* pthread_setcanceltype.c: Likewise.

	* pthread_testcancel.c: Likewise.



2002-02-04  Max Woodbury <mtew at cds.duke.edu>



	Reduced name space pollution.

	-----------------------------

	When the appropriate symbols are defined, the headers

	will restrict the definitions of new names. In particular,

	it must be possible to NOT include the <windows.h>

	header and related definitions with some combination

	of symbol definitions. Secondly, it should be possible

	that additional definitions should be limited to POSIX 

	compliant symbols by the definition of appropriate symbols.



	* pthread.h: POSIX conditionals.

	* sched.h: POSIX conditionals.

	* semaphore.h: POSIX conditionals.



	* semaphore.c: Included <limits.h>.

	(sem_init): Changed magic 0x7FFFFFFFL to INT_MAX.

	(sem_getvalue): Trial version.



	Reduce executable size.

	-----------------------

	When linking with the static library, only those

	routines actually called, either directly or indirectly

	should be included.



	[Gcc has the -ffunction-segments option to do this but MSVC

	doesn't have this feature as far as I can determine. Other

	compilers are undetermined as well. - rpj]



	* semaphore.c: All routines are now in separate compilation units;

	This file is used to congregate the separate modules for

	potential inline optimisation and backward build compatibility.

	* sem_close.c: Separated routine from semaphore.c.

	* ptw32_decrease_semaphore.c: Likewise.

	* sem_destroy.c: Likewise.

	* sem_getvalue.c: Likewise.

	* ptw32_increase_semaphore.c: Likewise.

	* sem_init.c: Likewise.

	* sem_open.c: Likewise.

	* sem_post.c: Likewise.

	* sem_post_multiple.c: Likewise.

	* sem_timedwait.c: Likewise.

	* sem_trywait.c: Likewise.

	* sem_unlink.c: Likewise.

	* sem_wait.c: Likewise.



2002-02-04  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	The following extends the idea above to the rest of pthreads-win32 - rpj

	

	* attr.c: All routines are now in separate compilation units;

	This file is used to congregate the separate modules for

	potential inline optimisation and backward build compatibility.

	* pthread_attr_destroy.c: Separated routine from attr.c.

	* pthread_attr_getdetachstate.c: Likewise.

	* pthread_attr_getscope.c: Likewise.

	* pthread_attr_getstackaddr.c: Likewise.

	* pthread_attr_getstacksize.c: Likewise.

	* pthread_attr_init.c: Likewise.

	* pthread_attr_is_attr.c: Likewise.

	* pthread_attr_setdetachstate.c: Likewise.

	* pthread_attr_setscope.c: Likewise.

	* pthread_attr_setstackaddr.c: Likewise.

	* pthread_attr_setstacksize.c: Likewise.



	* pthread.c: Agregation of agregate modules for super-inlineability.



2002-02-02  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* cancel.c: Rearranged some code and introduced checks

	to disable cancelation at the start of a thread's cancelation

	run to prevent double cancelation. The main problem

	arises if a thread is canceling and then receives a subsequent

	async cancel request.

	* private.c: Likewise.

	* condvar.c: Place pragmas around cleanup_push/pop to turn

	off inline optimisation (/Obn where n>0 - MSVC only). Various

	optimisation switches in MSVC turn this on, which interferes with

	the way that cleanup handlers are run in C++ EH and SEH

	code. Application code compiled with inline optimisation must

	also wrap cleanup_push/pop blocks with the pragmas, e.g.

	  #pragma inline_depth(0)

	  pthread_cleanup_push(...)

	    ...

	  pthread_cleanup_pop(...)

	  #pragma inline_depth(8)

	* rwlock.c: Likewise.

	* mutex.c: Remove attempts to inline some functions.

	* signal.c: Modify misleading comment.



2002-02-01  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* semaphore.c (sem_trywait): Fix missing errno return

	for systems that define NEED_SEM (e.g. early WinCE).

	* mutex.c (pthread_mutex_timedlock): Return ENOTSUP

	for systems that define NEED_SEM since they don't

	have sem_trywait().



2002-01-27  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* mutex.c (pthread_mutex_timedlock): New function suggested by

	Alexander Terekhov. The logic required to implement this

	properly came from Alexander, with some collaboration

	with Thomas Pfaff.

	(pthread_mutex_unlock): Wrap the waiters check and sema

	post in a critical section to prevent a race with

	pthread_mutex_timedlock.

	(ptw32_timed_semwait): New function;

	returns a special result if the absolute timeout parameter

	represents a time already passed when called; used by

	pthread_mutex_timedwait(). Have deliberately not reused

	the name "ptw32_sem_timedwait" because they are not the same

	routine.

	* condvar.c (ptw32_cond_timedwait): Use the new sem_timedwait()

	instead of ptw32_sem_timedwait(), which now has a different

	function. See previous.

	* implement.h: Remove prototype for ptw32_sem_timedwait.

	See next.

	(pthread_mutex_t_): Add critical section element for access

	to lock_idx during mutex post-timeout processing.

	* semaphore.h (sem_timedwait): See next.

	* semaphore.c (sem_timedwait): See next.

	* private.c (ptw32_sem_timedwait): Move to semaphore.c

	and rename as sem_timedwait().



2002-01-18  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* sync.c (pthread_join): Was getting the exit code from the

	calling thread rather than the joined thread if

	defined(__MINGW32__) && !defined(__MSVCRT__).



2002-01-15  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h: Unless the build explicitly defines __CLEANUP_SEH,

	__CLEANUP_CXX, or __CLEANUP_C, then the build defaults to

	__CLEANUP_C style cleanup. This style uses setjmp/longjmp

	in the cancelation and thread exit implementations and therefore

	won't do stack unwinding if linked to applications that have it

	(e.g. C++ apps). This is currently consistent with most/all

	commercial Unix POSIX threads implementations.



	* spin.c (pthread_spin_init): Edit renamed function call.

	* nonportable.c (pthread_num_processors_np): New.

	(pthread_getprocessors_np): Renamed to ptw32_getprocessors

	and moved to private.c.

	* private.c (pthread_getprocessors): Moved here from

	nonportable.c.

	* pthread.def (pthread_getprocessors_np): Removed

	from export list.



	* rwlock.c (pthread_rwlockattr_init): New.

	(pthread_rwlockattr_destroy): New.

	(pthread_rwlockattr_getpshared): New.

	(pthread_rwlockattr_setpshared): New.



2002-01-14  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* attr.c (pthread_attr_setscope): Fix struct pointer

	indirection error introduced 2002-01-04.

	(pthread_attr_getscope): Likewise.



2002-01-12  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.dsp (SOURCE): Add missing source files.



2002-01-08  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* mutex.c (pthread_mutex_trylock): use

	ptw32_interlocked_compare_exchange function pointer

	rather than ptw32_InterlockedCompareExchange() directly

	to retain portability to non-iX86 processors,

	e.g. WinCE etc. The pointer will point to the native

	OS version of InterlockedCompareExchange() if the

	OS supports it (see ChangeLog entry of 2001-10-17).



2002-01-07  Thomas Pfaff <tpfaff at gmx.net>, Alexander Terekhov <TEREKHOV at de.ibm.com>



	* mutex.c (pthread_mutex_init): Remove critical

	section calls.

	(pthread_mutex_destroy): Likewise.

	(pthread_mutex_unlock): Likewise.

	(pthread_mutex_trylock): Likewise; uses

	ptw32_InterlockedCompareExchange() to avoid need for

	critical section; library is no longer i386 compatible;

	recursive mutexes now increment the lock count rather

	than return EBUSY; errorcheck mutexes return EDEADLCK

	rather than EBUSY. This behaviour is consistent with the

	Solaris pthreads implementation.

	* implement.h (pthread_mutex_t_): Remove critical

	section element - no longer needed.

	



2002-01-04  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* attr.c (pthread_attr_setscope): Add more error

	checking and actually store the scope value even

	though it's not really necessary.

	(pthread_attr_getscope): Return stored value.

	* implement.h (pthread_attr_t_): Add new scope element.

	* ANNOUNCE: Fix out of date comment next to

	pthread_attr_setscope in conformance section.



2001-12-21  Alexander Terekhov <TEREKHOV at de.ibm.com>



	* mutex.c (pthread_mutex_lock): Decrementing lock_idx was

	not thread-safe.

	(pthread_mutex_trylock): Likewise.



2001-10-26  prionx@juno.com



	* semaphore.c (sem_init): Fix typo and missing bracket

	in conditionally compiled code. Only older versions of

	WinCE require this code, hence it doesn't normally get

	tested; somehow when sem_t reverted to an opaque struct

	the calloc NULL check was left in the conditionally included

	section.

	(sem_destroy): Likewise, the calloced sem_t wasn't being freed.



2001-10-25  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* GNUmakefile (libwsock32): Add to linker flags for

	WSAGetLastError() and WSASetLastError().

	* Makefile (wsock32.lib): Likewise.

	* create.c: Minor mostly inert changes.

	* implement.h (PTW32_MAX): Move into here and renamed

	from sched.h.

	(PTW32_MIN): Likewise.

	* GNUmakefile (TEST_ICE): Define if testing internal

	implementation of InterlockedCompareExchange.

	* Makefile (TEST_ICE): Likewise.

	* private.c (TEST_ICE): Likewise.

	

2001-10-24  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* attr.c (pthread_attr_setstacksize): Quell warning

	from LCC by conditionally compiling the stacksize

	validity check. LCC correctly warns that the condition

	(stacksize < PTHREAD_STACK_MIN) is suspicious

	because STACK_MIN is 0 and stacksize is of type

	size_t (or unsigned int).



2001-10-17  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Move _LONG and _LPLONG defines into

	implement.h; rename to PTW32_INTERLOCKED_LONG and

	PTW32_INTERLOCKED_LPLONG respectively.

	* spin.c: Likewise; ptw32_interlocked_compare_exchange used

	in place of InterlockedCompareExchange directly.

	* global.c (ptw32_interlocked_compare_exchange): Add

	prototype for this new routine pointer to be used when

	InterlockedCompareExchange isn't supported by Windows.

	* nonportable.c (pthread_win32_process_attach_np): Check for

	support of InterlockedCompareExchange in kernel32 and assign its

	address to ptw32_interlocked_compare_exchange if it exists, or

	our own ix86 specific implementation ptw32_InterlockedCompareExchange.

	*private.c (ptw32_InterlockedCompareExchange): An

	implementation of InterlockedCompareExchange() which is

	specific to ix86; written directly in assembler for either

	MSVC or GNU C; needed because Windows 95 doesn't support

	InterlockedCompareExchange().



	* sched.c (sched_get_priority_min): Extend to return

	THREAD_PRIORITY_IDLE.

	(sched_get_priority_max): Extend to return

	THREAD_PRIORITY_CRITICAL.



2001-10-15  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* spin.c (pthread_spin_lock): PTHREAD_SPINLOCK_INITIALIZER

	was causing a program fault.

	(pthread_spin_init): Could have alloced memory

	without freeing under some error conditions.



	* mutex.c (pthread_mutex_init): Move memory

	allocation of mutex struct after checking for

	PROCESS_SHARED.



2001-10-12  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* spin.c (pthread_spin_unlock): Was not returning

	EPERM if the spinlock was not locked, for multi CPU

	machines.



2001-10-08  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* spin.c (pthread_spin_trylock): Was not returning

	EBUSY for multi CPU machines.



2001-08-24  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* condvar.c (pthread_cond_destroy): Remove cv element

	that is no longer used.

	* implement.h: Likewise.



2001-08-23  Alexander Terekhov <TEREKHOV at de.ibm.com>



	* condvar.c (pthread_cond_destroy): fix bug with

	respect to deadlock in the case of concurrent

	_destroy/_unblock; a condition variable can be destroyed

	immediately after all the threads that are blocked on

	it are awakened.



2001-08-23  Phil Frisbie, Jr. <phil at hawksoft.com>



	* tsd.c (pthread_getspecific): Preserve the last

	winsock error [from WSAGetLastError()].



2001-07-18  Scott McCaskill <scott at magruder.org>



	* mutex.c (pthread_mutexattr_init): Return ENOMEM

	immediately and don't dereference the NULL pointer

	if calloc fails.

	(pthread_mutexattr_getpshared): Don't dereference

	a pointer that is possibly NULL.

	* barrier.c (pthread_barrierattr_init): Likewise

	(pthread_barrierattr_getpshared): Don't dereference

	a pointer that is possibly NULL.

	* condvar.c (pthread_condattr_getpshared): Don't dereference

	a pointer that is possibly NULL.



2001-07-15  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* rwlock.c (pthread_rwlock_wrlock): Is allowed to be

	a cancelation point; re-enable deferred cancelability

	around the CV call.



2001-07-10  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Still more revamping. The exclusive access

	mutex isn't really needed so it has been removed and replaced

	by an InterlockedDecrement(). nSerial has been removed.

	iStep is now dual-purpose. The process shared attribute

	is now stored in the barrier struct.

	* implement.h (pthread_barrier_t_): Lost some/gained one

	elements.

	* private.c (ptw32_threadStart): Removed some comments.



2001-07-10  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Revamped to fix the race condition. Two alternating

	semaphores are used instead of the PulseEvent. Also improved

	overall throughput by returning PTHREAD_BARRIER_SERIAL_THREAD

	to the first waking thread.

	* implement.h (pthread_barrier_t_): Revamped.



2001-07-09  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Fix several bugs in all routines. Now passes

	tests/barrier5.c which is fairly rigorous. There is still

	a non-optimal work-around for a race condition between

	the barrier breeched event signal and event wait. Basically

	the last (signalling) thread to hit the barrier yields

	to allow any other threads, which may have lost the race,

	to complete.



2001-07-07  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Changed synchronisation mechanism to a

	Win32 manual reset Event and use PulseEvent to signal

	waiting threads. If the implementation continued to use

	a semaphore it would require a second semaphore and

	some management to use them alternately as barriers. A

	single semaphore allows threads to cascade from one barrier

	through the next, leaving some threads blocked at the first.

	* implement.h (pthread_barrier_t_): As per above.

	* general: Made a number of other routines inlinable.



2001-07-07  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* spin.c: Revamped and working; included static initialiser.

	Now beta level.

	* barrier.c: Likewise.

	* condvar.c: Macro constant change; inline auto init routine.

	* mutex.c: Likewise.

	* rwlock.c: Likewise.

	* private.c: Add support for spinlock initialiser.

	* global.c: Likewise.

	* implement.h: Likewise.

	* pthread.h (PTHREAD_SPINLOCK_INITIALIZER): Fix typo.



2001-07-05  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* barrier.c: Remove static initialisation - irrelevent

	for this object.

	* pthread.h (PTHREAD_BARRIER_INITIALIZER): Removed.

	* rwlock.c (pthread_rwlock_wrlock): This routine is

	not a cancelation point - disable deferred

	cancelation around call to pthread_cond_wait().



2001-07-05  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* spin.c: New module implementing spin locks.

	* barrier.c: New module implementing barriers.

	* pthread.h (_POSIX_SPIN_LOCKS): defined.

	(_POSIX_BARRIERS): Defined.

	(pthread_spin_*): Defined.

	(pthread_barrier*): Defined.

	(PTHREAD_BARRIER_SERIAL_THREAD): Defined.

	* implement.h (pthread_spinlock_t_): Defined.

	(pthread_barrier_t_): Defined.

	(pthread_barrierattr_t_): Defined.



	* mutex.c (pthread_mutex_lock): Return with the error

	if an auto-initialiser initialisation fails.



	* nonportable.c (pthread_getprocessors_np): New; gets the

	number of available processors for the current process.



2001-07-03  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* pthread.h (_POSIX_READER_WRITER_LOCKS): Define it

	if not already defined.



2001-07-01  Alexander Terekhov <TEREKHOV at de.ibm.com>



	* condvar.c: Fixed lost signal bug reported by Timur Aydin

	(taydin@snet.net).

	[RPJ (me) didn't translate the original algorithm

	correctly.]

	* semaphore.c: Added sem_post_multiple; this is a useful

	routine, but it doesn't appear to be standard. For now it's

	not an exported function.

	

2001-06-25  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* create.c (pthread_create): Add priority inheritance

	attributes.

	* mutex.c (pthread_mutex_lock): Remove some overhead for

	PTHREAD_MUTEX_NORMAL mutex types. Specifically, avoid

	calling pthread_self() and pthread_equal() to check/set

	the mutex owner. Introduce a new pseudo owner for this

	type. Test results suggest increases in speed of up to

	90% for non-blocking locks.

	This is the default type of mutex used internally by other

	synchronising objects, ie. condition variables and

	read-write locks. The test rwlock7.c shows about a

	30-35% speed increase over snapshot 2001-06-06. The

	price of this is that the application developer

	must ensure correct behaviour, or explicitly set the

	mutex to a safer type such as PTHREAD_MUTEX_ERRORCHECK.

	For example, PTHREAD_MUTEX_NORMAL (or PTHREAD_MUTEX_DEFAULT)

	type mutexes will not return an error if a thread which is not

	the owner calls pthread_mutex_unlock. The call will succeed

	in unlocking the mutex if it is currently locked, but a

	subsequent unlock by the true owner will then fail with EPERM.

	This is however consistent with some other implementations.

	(pthread_mutex_unlock): Likewise.

	(pthread_mutex_trylock): Likewise.

	(pthread_mutex_destroy): Likewise.

	* attr.c (pthread_attr_init): PTHREAD_EXPLICIT_SCHED is the

	default inheritance attribute; THREAD_PRIORITY_NORMAL is

	the default priority for new threads.

	* sched.c (pthread_attr_setschedpolicy): Added routine.

	(pthread_attr_getschedpolicy): Added routine.

	(pthread_attr_setinheritsched): Added routine.

	(pthread_attr_getinheritsched): Added routine.

	* pthread.h (sched_rr_set_interval): Added as a macro;

	returns -1 with errno set to ENOSYS.



2001-06-23  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	*sched.c (pthread_attr_setschedparam): Add priority range

	check.

	(sched_setscheduler): New function; checks for a valid

	pid and policy; checks for permission to set information

	in the target process; expects pid to be a Win32 process ID,

	not a process handle; the only scheduler policy allowed is

	SCHED_OTHER.

	(sched_getscheduler): Likewise, but checks for permission

	to query.

	* pthread.h (SCHED_*): Moved to sched.h as defined in the

	POSIX standard.

	* sched.h (SCHED_*): Moved from pthread.h.

	(pid_t): Defined if necessary.

	(sched_setscheduler): Defined.

	(sched_getscheduler): Defined.

	* pthread.def (sched_setscheduler): Exported.

	(sched_getscheduler): Likewise.



2001-06-23  Ralf Brese <Ralf.Brese at pdb4.siemens.de>



	* create.c (pthread_create): Set thread priority from

	thread attributes.



2001-06-18  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* Made organisational-only changes to UWIN additions.

	* dll.c (dllMain): Moved UWIN process attach code

	to pthread_win32_process_attach_np(); moved

	instance of pthread_count to global.c.

	* global.c (pthread_count): Moved from dll.c.

	* nonportable.c (pthread_win32_process_attach_np):

	Moved _UWIN code to here from dll.c.

	* implement.h (pthread_count): Define extern int.

	* create.c (pthread_count): Remove extern int.

	* private.c (pthread_count): Likewise.

	* exit.c (pthread_count): Likewise.



2001-06-18  David Korn <dgk at research.att.com>



	* dll.c: Added changes necessary to work with UWIN.

	* create.c: Likewise.

	* pthread.h: Likewise.

	* misc.c: Likewise.

	* exit.c: Likewise.

	* private.c: Likewise.

	* implement.h: Likewise.

	There is some room at the start of struct pthread_t_

	to implement the signal semantics in UWIN's posix.dll

	although this is not yet complete.

	* Nmakefile: Compatible with UWIN's Nmake utility.

	* Nmakefile.tests: Likewise - for running the tests.



2001-06-08  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* semaphore.h (sem_t): Fixed for compile and test.

	* implement.h (sem_t_): Likewise.

	* semaphore.c: Likewise.

	* private.c (ptw32_sem_timedwait): Updated to use new

	opaque sem_t.



2001-06-06  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* semaphore.h (sem_t): Is now an opaque pointer;

	moved actual definition to implement.h.

	* implement.h (sem_t_): Move here from semaphore.h;

	was the definition of sem_t.

	* semaphore.c: Wherever necessary, changed use of sem

	from that of a pointer to a pointer-pointer; added

	extra checks for a valid sem_t; NULL sem_t when

	it is destroyed; added extra checks when creating

	and destroying sem_t elements in the NEED_SEM

	code branches; changed from using a pthread_mutex_t

	((*sem)->mutex) to CRITICAL_SECTION ((*sem)->sem_lock_cs)

	in NEED_SEM branches for access serialisation.



2001-06-06  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* mutex.c (pthread_mutexattr_init): Remove 

	ptw32_mutex_default_kind.

	

2001-06-05  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* nonportable.c (pthread_mutex_setdefaultkind_np):

	Remove - should not have been included in the first place.

	(pthread_mutex_getdefaultkind_np): Likewise.

	* global.c (ptw32_mutex_default_kind): Likewise.

	* mutex.c (pthread_mutex_init): Remove use of

	ptw32_mutex_default_kind.

	* pthread.h (pthread_mutex_setdefaultkind_np): Likewise.

	(pthread_mutex_getdefaultkind_np): Likewise.

	* pthread.def (pthread_mutexattr_setkind_np): Added.

	(pthread_mutexattr_getkind_np): Likewise.



	* README: Many changes that should have gone in before

	the last snapshot.

	* README.NONPORTABLE: New - referred to by ANNOUNCE

	but never created; documents the non-portable routines

	included in the library - moved from README with new

	routines added.

	* ANNOUNCE (pthread_mutexattr_setkind_np): Added to

	compliance list.

	(pthread_mutexattr_getkind_np): Likewise.



2001-06-04  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* condvar.c: Add original description of the algorithm as

	developed by Terekhov and Thomas, plus reference to

	README.CV.



2001-06-03  Alexander Terekhov <TEREKHOV at de.ibm.com>, Louis Thomas <lthomas at arbitrade.com>



	* condvar.c (pthread_cond_init): Completely revamped.

	(pthread_cond_destroy): Likewise.

	(ptw32_cond_wait_cleanup): Likewise.

	(ptw32_cond_timedwait): Likewise.

	(ptw32_cond_unblock): New general signaling routine.

	(pthread_cond_signal): Now calls ptw32_cond_unblock.

	(pthread_cond_broadcast): Likewise.

	* implement.h (pthread_cond_t_): Revamped.

	* README.CV: New; explanation of the above changes.



2001-05-30  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* pthread.h (rand_r): Fake using _seed argument to quell

	compiler warning (compiler should optimise this away later).



	* GNUmakefile (OPT): Leave symbolic information out of the library

	and increase optimisation level - for smaller faster prebuilt

	dlls.

	

2001-05-29  Milan Gardian <Milan.Gardian at LEIBINGER.com>



	* Makefile: fix typo.

	* pthreads.h: Fix problems with stdcall/cdecl conventions, in particular

	remove the need for PT_STDCALL everywhere; remove warning supression.

	* (errno): Fix the longstanding "inconsistent dll linkage" problem

	with errno; now also works with /MD debugging libs - 

	warnings emerged when compiling pthreads library with /MD (or /MDd)

	compiler switch, instead of /MT (or /MTd) (i.e. when compiling pthreads

	using Multithreaded DLL CRT instead of Multithreaded statically linked

	CRT).

	* create.c (pthread_create): Likewise; fix typo.

	* private.c (ptw32_threadStart): Eliminate use of terminate() which doesn't

	throw exceptions.

	* Remove unnecessary #includes from a number of modules -

	[I had to #include malloc.h in implement.h for gcc - rpj].



2001-05-29  Thomas Pfaff <tpfaff at gmx.net>



	* pthread.h (PTHREAD_MUTEX_DEFAULT): New; equivalent to

	PTHREAD_MUTEX_DEFAULT_NP.

	* (PTHREAD_MUTEX_NORMAL): Similarly.

	* (PTHREAD_MUTEX_ERRORCHECK): Similarly.

	* (PTHREAD_MUTEX_RECURSIVE): Similarly.

	* (pthread_mutex_setdefaultkind_np): New; Linux compatibility stub

	for pthread_mutexattr_settype.

	* (pthread_mutexattr_getkind_np): New; Linux compatibility stub

	for pthread_mutexattr_gettype.

	* mutex.c (pthread_mutexattr_settype): New; allow

	the following types of mutex:

	  PTHREAD_MUTEX_DEFAULT_NP

	  PTHREAD_MUTEX_NORMAL_NP

	  PTHREAD_MUTEX_ERRORCHECK_NP

	  PTHREAD_MUTEX_RECURSIVE_NP

	* Note that PTHREAD_MUTEX_DEFAULT is equivalent to

	PTHREAD_MUTEX_NORMAL - ie. mutexes should no longer

	be recursive by default, and a thread will deadlock if it

	tries to relock a mutex it already owns. This is inline with

	other pthreads implementations.

	* (pthread_mutex_lock): Process the lock request

	according to the mutex type.

	* (pthread_mutex_init): Eliminate use of Win32 mutexes as the

	basis of POSIX mutexes - instead, a combination of one critical section

	and one semaphore are used in conjunction with Win32 Interlocked* routines.

	* (pthread_mutex_destroy): Likewise.

	* (pthread_mutex_lock): Likewise.

	* (pthread_mutex_trylock): Likewise.

	* (pthread_mutex_unlock): Likewise.

	* Use longjmp/setjmp to implement cancelation when building the library

	using a C compiler which doesn't support exceptions, e.g. gcc -x c (note

	that gcc -x c++ uses exceptions).

	* Also fixed some of the same typos and eliminated PT_STDCALL as

	Milan Gardian's patches above.



2001-02-07  Alexander Terekhov <TEREKHOV at de.ibm.com>



	* rwlock.c: Revamped.

	* implement.h (pthread_rwlock_t_): Redefined.

	This implementation does not have reader/writer starvation problem.

	Rwlock attempts to behave more like a normal mutex with

	races and scheduling policy determining who is more important;

	It also supports recursive locking,

	has less synchronization overhead (no broadcasts at all,

	readers are not blocked on any condition variable) and seem to

	be faster than the current implementation [W98 appears to be

	approximately 15 percent faster at least - on top of speed increase

	from Thomas Pfaff's changes to mutex.c - rpj].



2000-12-29  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* Makefile: Back-out "for" loops which don't work.



	* GNUmakefile: Remove the fake.a target; add the "realclean"

	target; don't remove built libs under the "clean" target.



	* config.h: Add a guard against multiple inclusion.



	* semaphore.h: Add some defines from config.h to make

	semaphore.h independent of config.h when building apps.



	* pthread.h (_errno): Back-out previous fix until we know how to

	fix it properly.



	* implement.h (lockCount): Add missing element to pthread_mutex_t_.



	* sync.c (pthread_join): Spelling fix in comment.



	* private.c (ptw32_threadStart): Reset original termination

	function (C++).

	(ptw32_threadStart): Cleanup detached threads early in case

	the library is statically linked.

	(ptw32_callUserDestroyRoutines): Remove [SEH] __try block from

	destructor call so that unhandled exceptions will be passed through

	to the 	system; call terminate() from [C++] try block for the same

	reason.



	* tsd.c (pthread_getspecific): Add comment.



	* mutex.c (pthread_mutex_init): Initialise new elements in

	pthread_mutex_t.

	(pthread_mutex_unlock): Invert "pthread_equal()" test.



2000-12-28  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* semaphore.c (mode_t): Use ifndef HAVE_MODE_T to include definition.



	* config.h.in (HAVE_MODE_T): Added.

	(_UWIN): Start adding defines for the UWIN package.



	* private.c (ptw32_threadStart): Unhandled exceptions are

	now passed through to the system to deal with. This is consistent

	with normal Windows behaviour. C++ applications may use

	set_terminate() to override the default behaviour which is

	to call ptw32_terminate(). Ptw32_terminate() cleans up some

	POSIX thread stuff before calling the system default function

	which calls abort(). The users termination function should conform

	to standard C++ semantics which is to not return. It should

	exit the thread (call pthread_exit()) or exit the application.

	* private.c (ptw32_terminate): Added as the default set_terminate()

	function. It calls the system default function after cleaning up

	some POSIX thread stuff.



	* implement.h (ptw32_try_enter_critical_section): Move

	declaration.

	* global.c (ptw32_try_enter_critical_section): Moved

	from dll.c.

	* dll.c: Move process and thread attach/detach code into

	functions in nonportable.c.

	* nonportable.c (pthread_win32_process_attach_np): Process

	attach code from dll.c is now available to static linked

	applications.

	* nonportable.c (pthread_win32_process_detach_np): Likewise.

	* nonportable.c (pthread_win32_thread_attach_np): Likewise.

	* nonportable.c (pthread_win32_thread_detach_np): Likewise.



	* pthread.h: Add new non-portable prototypes for static

	linked applications.



	* GNUmakefile (OPT): Increase optimisation flag and remove

	debug info flag.



	* pthread.def: Add new non-portable exports for static

	linked applications.



2000-12-11  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* FAQ: Update Answer 6 re getting a fully working

	Mingw32 built library.



2000-10-10  Steven Reddie <smr at essemer.com.au>

 

        * misc.c (pthread_self): Restore Win32 "last error"

        cleared by TlsGetValue() call in

        pthread_getspecific()

 

2000-09-20  Arthur Kantor <akantor at bexusa.com>

 

        * mutex.c (pthread_mutex_lock): Record the owner

        of the mutex. This requires also keeping count of

        recursive locks ourselves rather than leaving it

        to Win32 since we need to know when to NULL the

        thread owner when the mutex is unlocked.

        (pthread_mutex_trylock): Likewise.

        (pthread_mutex_unlock): Check that the calling

        thread owns the mutex, decrement the recursive

        lock count, and NULL the owner if zero. Return

        EPERM if the mutex is owned by another thread.

        * implement.h (pthread_mutex_t_): Add ownerThread

        and lockCount members.



2000-09-13  Jef Gearhart <jgearhart at tpssys.com>



	* mutex.c (pthread_mutex_init): Call

	TryEnterCriticalSection through the pointer

	rather than directly so that the dll can load

	on Windows versions that can't resolve the

	function, eg. Windows 95



2000-09-09  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h (ctime_r): Fix arg.



2000-09-08  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* GNUmakefile(_WIN32_WINNT=0x400): Define in CFLAGS;

	doesn't seem to be needed though.



	* cancel.c (pthread_cancel): Must get "self" through

	calling pthread_self() which will ensure a POSIX thread

	struct is built for non-POSIX threads; return an error

	if this fails

	- Ollie Leahy <ollie at mpt.ie>

	(pthread_setcancelstate): Likewise.

	(pthread_setcanceltype): Likewise.

	* misc.c (ptw32_cancelable_wait): Likewise.



	* private.c (ptw32_tkAssocCreate): Remove unused #if 0

	wrapped code.



	* pthread.h (ptw32_get_exception_services_code):

	Needed to be forward declared unconditionally.



2000-09-06  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* cancel.c (pthread_cancel): If called from the main

	thread "self" would be NULL; get "self" via pthread_self()

	instead of directly from TLS so that an implicit

	pthread object is created.



	* misc.c (pthread_equal): Strengthen test for NULLs.



2000-09-02  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* condvar.c (ptw32_cond_wait_cleanup): Ensure that all

	waking threads check if they are the last, and notify

	the broadcaster if so - even if an error occurs in the

	waiter.



	* semaphore.c (_decrease_semaphore): Should be

	a call to ptw32_decrease_semaphore.

	(_increase_semaphore): Should be a call to

	ptw32_increase_semaphore.



	* misc.c (ptw32_cancelable_wait): Renamed from

	CancelableWait.

	* rwlock.c (_rwlock_check*): Renamed to

	ptw32_rwlock_check*.

	* mutex.c (_mutex_check*): Renamed to ptw32_mutex_check*.

	* condvar.c (cond_timed*): Renamed to ptw32_cond_timed*.

	(_cond_check*): Renamed to ptw32_cond_check*.

	(cond_wait_cleanup*): Rename to ptw32_cond_wait_cleanup*.

	(ptw32_cond_timedwait): Add comments.



2000-08-22  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* private.c (ptw32_throw): Fix exception test;

	move exceptionInformation declaration.



	* tsd.c (pthread_key_create): newkey wrongly declared.



	* pthread.h: Fix comment block.



2000-08-18  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* mutex.c (pthread_mutex_destroy): Check that the mutex isn't

	held; invalidate the mutex as early as possible to avoid

	contention; not perfect - FIXME!



	* rwlock.c (pthread_rwlock_init): Remove redundant assignment

	to "rw".

	(pthread_rwlock_destroy): Invalidate the rwlock before

	freeing up any of it's resources - to avoid contention.



	* private.c (ptw32_tkAssocCreate): Change assoc->lock

	to use a dynamically initialised mutex - only consumes

	a W32 mutex or critical section when first used,

	not before.



	* mutex.c (pthread_mutex_init): Remove redundant assignment

	to "mx".

	(pthread_mutexattr_destroy): Set attribute to NULL

	before freeing it's memory - to avoid contention.



	* implement.h (PTW32_EPS_CANCEL/PTW32_EPS_EXIT):

	Must be defined for all compilers - used as generic

	exception selectors by ptw32_throw().



	* Several: Fix typos from scripted edit session

	yesterday.



	* nonportable.c (pthread_mutexattr_setforcecs_np):

	Moved this function from mutex.c.

	(pthread_getw32threadhandle_np): New function to

	return the win32 thread handle that the POSIX

	thread is using.

	* mutex.c (pthread_mutexattr_setforcecs_np):

	Moved to new file "nonportable.c".



	* pthread.h (PTW32_BUILD): Only	redefine __except

	and catch compiler keywords if we aren't building

	the library (ie. PTW32_BUILD is not defined) - 

	this is safer than defining and then undefining

	if not building the library.

	* implement.h: Remove __except and catch undefines.

	* Makefile (CFLAGS): Define PTW32_BUILD.

	* GNUmakefile (CFLAGS): Define PTW32_BUILD.



	* All appropriate: Change Pthread_exception* to

	ptw32_exception* to be consistent with internal

	identifier naming.



	* private.c (ptw32_throw): New function to provide

	a generic exception throw for all internal

	exceptions and EH schemes.

	(ptw32_threadStart): pthread_exit() value is now

	returned via the thread structure exitStatus

	element.

	* exit.c (pthread_exit): pthread_exit() value is now

	returned via the thread structure exitStatus

	element.

	* cancel.c (ptw32_cancel_self): Now uses ptw32_throw.

	(pthread_setcancelstate): Ditto.

	(pthread_setcanceltype): Ditto.

	(pthread_testcancel): Ditto.

	(pthread_cancel): Ditto.

	* misc.c (CancelableWait): Ditto.

	* exit.c (pthread_exit): Ditto.

	* All applicable: Change PTW32_ prefix to

	PTW32_ prefix to remove leading underscores

	from private library identifiers.



2000-08-17  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* All applicable: Change _pthread_ prefix to

	ptw32_ prefix to remove leading underscores

	from private library identifiers (single

	and double leading underscores are reserved in the

	ANSI C standard for compiler implementations).



	* tsd.c (pthread_create_key): Initialise temporary

	key before returning it's address to avoid race

	conditions.



2000-08-13  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* errno.c: Add _MD precompile condition; thus far

	had no effect when using /MD compile option but I

	thnk it should be there.



	* exit.c: Add __cplusplus to various #if lines;

	was compiling SEH code even when VC++ had

	C++ compile options.



	* private.c: ditto.



	* create.c (pthread_create): Add PT_STDCALL macro to

	function pointer arg in _beginthread().



	* pthread.h: PT_STDCALL really does need to be defined

	in both this and impliment.h; don't set it to __cdecl

	- this macro is only used to extend function pointer

	casting for functions that will be passed as parameters.

	(~PThreadCleanup): add cast and group expression.

	(_errno): Add _MD compile conditional.

	(PtW32NoCatchWarn): Change pragma message.



	* implement.h: Move and change PT_STDCALL define.



	* need_errno.h: Add _MD to compilation conditional.



	* GNUmakefile: Substantial rewrite for new naming

	convention; set for nil optimisation (turn it up

	when we have a working library build; add target

	"fake.a" to build a libpthreadw32.a from the VC++

	built DLL pthreadVCE.dll.



	* pthread.def (LIBRARY): Don't specify in the .def

	file - it is specified on the linker command line

	since we now use the same .def file for variously

	named .dlls.



	* Makefile: Substantial rewrite for new naming

	convention; default nmake target only issues a

	help message; run nmake with specific target

	corresponding to the EH scheme being used.



	* README: Update information; add naming convention

	explanation.



	* ANNOUNCE: Update information.



2000-08-12  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h: Add compile-time message when using

	MSC_VER compiler and C++ EH to warn application

	programmers to use PtW32Catch instead of catch(...)

	if they want cancelation and pthread_exit to work.



	* implement.h: Remove #include <semaphore.h>; we

	use our own local semaphore.h.



2000-08-10  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* cleanup.c (pthread_pop_cleanup): Remove _pthread

	prefix from __except and catch keywords; implement.h

	now simply undefines ptw32__except and

	ptw32_catch if defined; VC++ was not textually

	substituting ptw32_catch etc back to catch as

	it was redefined; the reason for using the prefixed

	version was to make it clear that it was not using

	the pthread.h redefined catch keyword.



	* private.c (ptw32_threadStart): Ditto.

	(ptw32_callUserDestroyRoutines): Ditto.



	* implement.h (ptw32__except): Remove #define.

	(ptw32_catch): Remove #define.



	* GNUmakefile (pthread.a): New target to build

	libpthread32.a from pthread.dll using dlltool.



	* buildlib.bat: Duplicate cl commands with args to

	build C++ EH version of pthread.dll; use of .bat

	files is redundant now that nmake compatible

	Makefile is included; used as a kludge only now.



	* Makefile: Localise some macros and fix up the clean:

	target to extend it and work properly.



	* CONTRIBUTORS: Add contributors.



	* ANNOUNCE: Updated.



	* README: Updated.



2000-08-06  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h: Remove #warning - VC++ doesn't accept it.



2000-08-05  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h (PtW32CatchAll): Add macro. When compiling

	applications using VC++ with C++ EH rather than SEH

	'PtW32CatchAll' must be used in place of any 'catch( ... )'

	if the application wants pthread cancelation or

	pthread_exit() to work.



2000-08-03  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* pthread.h: Add a base class ptw32_exception for

	library internal exceptions and change the "catch"

	re-define macro to use it.



2000-08-02  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* GNUmakefile (CFLAGS): Add -mthreads.

	Add new targets to generate cpp and asm output.



	* sync.c (pthread_join): Remove dead code.



2000-07-25  Tristan Savatier <tristan at mpegtv.com>



	* sched.c (sched_get_priority_max): Handle different WinCE and

	Win32 priority values together.

	(sched_get_priority_min): Ditto.



2000-07-25  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* create.c (pthread_create): Force new threads to wait until

	pthread_create has the new thread's handle; we also retain

	a local copy of the handle for internal use until

	pthread_create returns.



	* private.c (ptw32_threadStart): Initialise ei[].

	(ptw32_threadStart): When beginthread is used to start the

	thread, force waiting until the creator thread had the 

	thread handle.



	* cancel.c (ptw32_cancel_thread): Include context switch

	code for defined(_X86_) environments in addition to _M_IX86.



	* rwlock.c (pthread_rwlock_destroy): Assignment changed

	to avoid compiler warning.



	* private.c (ptw32_get_exception_services_code): Cast

	NULL return value to avoid compiler warning.



	* cleanup.c (pthread_pop_cleanup): Initialise "cleanup" variable

	to avoid compiler warnings.



	* misc.c (ptw32_new): Change "new" variable to "t" to avoid

	confusion with the C++ keyword of the same name.



	* condvar.c (cond_wait_cleanup): Initialise lastWaiter variable.

	(cond_timedwait): Remove unused local variables. to avoid

	compiler warnings.



	* dll.c (dllMain): Remove 2000-07-21 change - problem

	appears to be in pthread_create().



2000-07-22  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* tsd.c (pthread_key_create): If a destructor was given

	and the pthread_mutex_init failed, then would try to

	reference a NULL pointer (*key); eliminate this section of

	code by using a dynamically initialised mutex

	(PTHREAD_MUTEX_INITIALIZER).



	* tsd.c (pthread_setspecific): Return an error if

	unable to set the value; simplify cryptic conditional.



	* tsd.c (pthread_key_delete): Locking threadsLock relied

	on mutex_lock returning an error if the key has no destructor.

	ThreadsLock is only initialised if the key has a destructor.

	Making this mutex a static could reduce the number of mutexes

	used by an application since it is actually created only at

	first use and it's often destroyed soon after.

	

2000-07-22  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* FAQ: Added Q5 and Q6.



2000-07-21  David Baggett <dmb at itasoftware.com>



	* dll.c: Include resource leakage work-around. This is a

	partial FIXME which doesn't stop all leakage. The real

	problem needs to be found and fixed.



2000-07-21  Ross Johnson  <rpj at setup1.ise.canberra.edu.au>



	* create.c (pthread_create): Set threadH to 0 (zero)

	everywhere. Some assignments were using NULL. Maybe

	it should be NULL everywhere - need to check. (I know

	they are nearly always the same thing - but not by

	definition.)



	* misc.c (pthread_self): Try to catch NULL thread handles

	at the point where they might be generated, even though

	they should always be valid at this point.



	* tsd.c (pthread_setspecific): return an error value if

	pthread_self() returns NULL.



	* sync.c (pthread_join): return an error value if

	pthread_self() returns NULL.



	* signal.c (pthread_sigmask): return an error value if

	pthread_self() returns NULL.



2000-03-02  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* attr.c (pthread_attr_init): Set default stacksize to zero (0)

	rather than PTHREAD_STACK_MIN even though these are now the same.



	* pthread.h (PTHREAD_STACK_MIN): Lowered to 0.



2000-01-28  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* mutex.c (pthread_mutex_init): Free mutex if it has been alloced;

	if critical sections can be used instead of Win32 mutexes, test

	that the critical section works and return an error if not.



2000-01-07  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* cleanup.c (pthread_pop_cleanup): Include SEH code only if MSC is not

	compiling as C++.

	(pthread_push_cleanup): Include SEH code only if MSC is not

	compiling as C++.



	* pthread.h: Include SEH code only if MSC is not

	compiling as C++.



	* implement.h: Include SEH code only if MSC is not

	compiling as C++.



	* cancel.c (ptw32_cancel_thread): Add _M_IX86 check.

	(pthread_testcancel): Include SEH code only if MSC is not

	compiling as C++.

	(ptw32_cancel_self): Include SEH code only if MSC is not

	compiling as C++.



2000-01-06  Erik Hensema <erik.hensema at group2000.nl>



	* Makefile: Remove inconsistencies in 'cl' args



2000-01-04  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* private.c (ptw32_get_exception_services_code): New; returns

	value of EXCEPTION_PTW32_SERVICES.

	(ptw32_processInitialize): Remove initialisation of

	ptw32_exception_services which is no longer needed.



	* pthread.h (ptw32_exception_services): Remove extern.

	(ptw32_get_exception_services_code): Add function prototype;

	use this to return EXCEPTION_PTW32_SERVICES value instead of

	using the ptw32_exception_services variable which I had

	trouble exporting through pthread.def.



	* global.c (ptw32_exception_services): Remove declaration.



1999-11-22  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* implement.h: Forward declare ptw32_new();



	* misc.c (ptw32_new): New; alloc and initialise a new pthread_t.

	(pthread_self): New thread struct is generated 	by new routine

	ptw32_new().



	* create.c (pthread_create): New thread struct is generated

	by new routine ptw32_new().



1999-11-21  Ross Johnson  <rpj at special.ise.canberra.edu.au>



	* global.c (ptw32_exception_services): Declare new variable. 



	* private.c (ptw32_threadStart): Destroy thread's

	cancelLock mutex; make 'catch' and '__except' usageimmune to

	redfinitions in pthread.h.

	(ptw32_processInitialize): Init new constant ptw32_exception_services.



	* create.c (pthread_create): Initialise thread's cancelLock

	mutex.



	* cleanup.c (pthread_pop_cleanup): Make 'catch' and '__except'

	usage immune to redfinition s in pthread.h.



	* private.c: Ditto.



	* pthread.h (catch): Redefine 'catch' so that C++ applications

	won't catch our internal exceptions.

	(__except): ditto for __except.



	* implement.h (ptw32_catch): Define internal version

	of 'catch' because 'catch' is redefined by pthread.h.

	(__except): ditto for __except.

	(struct pthread_t_): Add cancelLock mutex for async cancel

	safety.



1999-11-21  Jason Nye <jnye at nbnet.nb.ca>, Erik Hensema <erik.hensema at group2000.nl>



	* cancel.c (ptw32_cancel_self): New; part of the async

	cancellation implementation.

	(ptw32_cancel_thread): Ditto; this function is X86

	processor specific.

	(pthread_setcancelstate): Add check for pending async

	cancel request and cancel the calling thread if

	required; add async-cancel safety lock.

	(pthread_setcanceltype): Ditto.



1999-11-13  Erik Hensema <erik.hensema at group2000.nl>



	* configure.in (AC_OUTPUT): Put generated output into GNUmakefile

	rather than Makefile. Makefile will become the MSC nmake compatible

	version



1999-11-13  John Bossom (John.Bossom@cognos.com>



	* misc.c (pthread_self): Add a note about GetCurrentThread

	returning a pseudo-handle



1999-11-10  Todd Owen <towen at lucidcalm.dropbear.id.au>



	* dll.c (dllMain): Free kernel32 ASAP.

	If TryEnterCriticalSection is not being used, then free

	the kernel32.dll handle now, rather than leaving it until

	DLL_PROCESS_DETACH.



	Note: this is not a pedantic exercise in freeing unused

	resources!  It is a work-around for a bug in Windows 95

	(see microsoft knowledge base article, Q187684) which

	does Bad Things when FreeLibrary is called within

	the DLL_PROCESS_DETACH code, in certain situations.

	Since w95 just happens to be a platform which does not

	provide TryEnterCriticalSection, the bug will be

	effortlessly avoided.



1999-11-10  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c (pthread_join): Make it a deferred cancelation point.



	* misc.c (pthread_self): Explicitly initialise implicitly

	created thread state to default values.



1999-11-05  Tristan Savatier <tristan at mpegtv.com>



	* pthread.h (winsock.h): Include unconditionally.

	(ETIMEDOUT): Change fallback value to that defined by winsock.h.

	

	* general: Patched for portability to WinCE. The details are

	described in the file WinCE-PORT. Follow the instructions

	in README.WinCE to make the appropriate changes in config.h.



1999-10-30  Erik Hensema <erik.hensema at group2000.nl>



	* create.c (pthread_create): Explicitly initialise thread state to

	default values.



	* cancel.c (pthread_setcancelstate): Check for NULL 'oldstate'

	for compatibility with Solaris pthreads;

	(pthread_setcanceltype): ditto:



1999-10-23  Erik Hensema <erik.hensema at group2000.nl>



	* pthread.h (ctime_r): Fix incorrect argument "_tm"



1999-10-21  Aurelio Medina <aureliom at crt.com>



	* pthread.h (_POSIX_THREADS): Only define it if it isn't

	already defined. Projects may need to define this on

	the CC command line under Win32 as it doesn't have unistd.h



1999-10-17  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* rwlock.c (pthread_rwlock_destroy): Add cast to remove compile

	warning.



	* condvar.c (pthread_cond_broadcast): Only release semaphores

	if there are waiting threads.



1999-10-15  Lorin Hochstein <lmh at xiphos.ca>, Peter Slacik <Peter.Slacik at tatramed.sk>



	* condvar.c (cond_wait_cleanup): New static cleanup handler for

	cond_timedwait;

	(cond_timedwait): pthread_cleanup_push args changed;

	canceling a thread while it's in pthread_cond_wait

	will now decrement the waiters count and cleanup if it's the

	last waiter.



1999-10-15  Graham Dumpleton <Graham.Dumpleton at ra.pad.otc.telstra.com.au>



	* condvar.c (cond_wait_cleanup): the last waiter will now reset the CV's

	wasBroadcast flag



Thu Sep 16 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* rwlock.c (pthread_rwlock_destroy): Add serialisation.

	(_rwlock_check_need_init): Check for detroyed rwlock.

	* rwlock.c: Check return codes from _rwlock_check_need_init();

	modify comments; serialise access to rwlock objects during

	operations; rename rw_mutex to rw_lock.

	* implement.h: Rename rw_mutex to rw_lock.

	* mutex.c (pthread_mutex_destroy): Add serialisation.

	(_mutex_check_need_init): Check for detroyed mutex.

	* condvar.c (pthread_cond_destroy): Add serialisation.

	(_cond_check_need_init): Check for detroyed condvar.

	* mutex.c: Modify comments.

	* condvar.c: Modify comments.



1999-08-10  Aurelio Medina  <aureliom at crt.com>



	* implement.h (pthread_rwlock_t_): Add.

	* pthread.h (pthread_rwlock_t): Add.

	(PTHREAD_RWLOCK_INITIALIZER): Add.

	Add rwlock function prototypes.

	* rwlock.c: New module.

	* pthread.def: Add new rwlock functions.

	* private.c (ptw32_processInitialize): initialise

	ptw32_rwlock_test_init_lock critical section.

	* global.c (ptw32_rwlock_test_init_lock): Add.



	* mutex.c (pthread_mutex_destroy): Don't free mutex memory

	if mutex is PTHREAD_MUTEX_INITIALIZER and has not been

	initialised yet.



1999-08-08 Milan Gardian <mg at tatramed.sk>



	* mutex.c (pthread_mutex_destroy): Free mutex memory.



1999-08-22  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* exit.c (pthread_exit): Fix reference to potentially

	uninitialised pointer.



1999-08-21  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_threadStart): Apply fix of 1999-08-19

	this time to C++ and non-trapped C versions. Ommitted to

	do this the first time through.



1999-08-19  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_threadStart): Return exit status from

	the application thread startup routine.

	- Milan Gardian <mg at tatramed.sk>



1999-08-18  John Bossom <john.Bossom at cognos.com>



	* exit.c (pthread_exit): Put status into pthread_t->exitStatus

	* private.c (ptw32_threadStart): Set pthread->exitStatus

	on exit of try{} block.

	* sync.c (pthread_join): use pthread_exitStatus value if the

	thread exit doesn't return a value (for Mingw32 CRTDLL

	which uses endthread instead of _endthreadex).



Tue Aug 17 20:17:58 CDT 1999  Mumit Khan  <khan at xraylith.wisc.edu>



        * create.c (pthread_create): Add CRTDLL suppport.

        * exit.c (pthread_exit): Likewise.

        * private.c (ptw32_threadStart): Likewise.

        (ptw32_threadDestroy): Likewise.

        * sync.c (pthread_join): Likewise.

        * tests/join1.c (main): Warn about partial support for CRTDLL.



Tue Aug 17 20:00:08 1999  Mumit Khan  <khan at xraylith.wisc.edu>



        * Makefile.in (LD): Delete entry point.

        * acconfig.h (STDCALL): Delete unused macro.

        * configure.in: Remove test for STDCALL.

        * config.h.in: Regenerate.

        * errno.c (_errno): Fix self type.

        * pthread.h (PT_STDCALL): Move from here to

        * implement.h (PT_STDCALL): here.

        (ptw32_threadStart): Fix prototype.

        * private.c (ptw32_threadStart): Likewise.



1999-08-14  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* exit.c (pthread_exit): Don't call pthread_self() but

	get thread handle directly from TSD for efficiency.

	

1999-08-12  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_threadStart): ei[] only declared if _MSC_VER.



	* exit.c (pthread_exit): Check for implicitly created threads

	to avoid raising an unhandled exception.

	

1999-07-12  Peter Slacik <Peter.Slacik at tatramed.sk>



	* condvar.c (pthread_cond_destroy): Add critical section.

	(cond_timedwait): Add critical section; check for timeout

	waiting on semaphore.

	(pthread_cond_broadcast): Add critical section.



1999-07-09  Lorin Hochstein <lmh at xiphos.ca>, John Bossom <John.Bossom at Cognos.COM>



	The problem was that cleanup handlers were not executed when

	pthread_exit() was called.



	* implement.h (pthread_t_): Add exceptionInformation element for

	C++ per-thread exception information.

	(general): Define and rename exceptions.



1999-07-09  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (CancelableWait):  PTW32_EPS_CANCEL (SEH) and

	ptw32_exception_cancel (C++) used to identify the exception.



	* cancel.c (pthread_testcancel): PTW32_EPS_CANCEL (SEH) and

	ptw32_exception_cancel (C++) used to identify the exception.



	* exit.c (pthread_exit): throw/raise an exception to return to

	ptw32_threadStart() to exit the thread. PTW32_EPS_EXIT (SEH)

	and ptw32_exception_exit (C++) used to identify the exception.



	* private.c (ptw32_threadStart): Add pthread_exit exception trap;

	clean up and exit the thread directly rather than via pthread_exit().



Sun May 30 00:25:02 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* semaphore.h (mode_t): Conditionally typedef it.



Fri May 28 13:33:05 1999  Mark E. Armstrong <avail at pacbell.net>



	* condvar.c (pthread_cond_broadcast): Fix possible memory fault

	

Thu May 27 13:08:46 1999  Peter Slacik <Peter.Slacik at tatramed.sk>



	* condvar.c (pthread_cond_broadcast): Fix logic bug



Thu May 27 13:08:46 1999  Bossom, John <John.Bossom at Cognos.COM>



	* condvar.c (pthread_cond_broadcast): optimise sem_post loop



Fri May 14 12:13:18 1999  Mike Russo <miker at eai.com>



	* attr.c (pthread_attr_setdetachstate): Fix logic bug



Sat May  8 09:42:30 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.def (sem_open): Add.

	(sem_close): Add.

	(sem_unlink): Add.

	(sem_getvalue): Add.



	* FAQ (Question 3): Add.



Thu Apr  8 01:16:23 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* semaphore.c (sem_open): New function; returns an error (ENOSYS).

	(sem_close): ditto.

	(sem_unlink): ditto.

	(sem_getvalue): ditto.



	* semaphore.h (_POSIX_SEMAPHORES): define.

	

Wed Apr  7 14:09:52 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* errno.c (_REENTRANT || _MT): Invert condition.



	* pthread.h (_errno): Conditionally include prototype.



Wed Apr  7 09:37:00 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* *.c (comments): Remove individual attributions - these are

	documented sufficiently elsewhere.



	* implement.h (pthread.h): Remove extraneous include.



Sun Apr  4 11:05:57 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sched.c (sched.h): Include.



	* sched.h: New file for POSIX 1b scheduling.



	* pthread.h: Move opaque structures to implement.h; move sched_*

	prototypes out and into sched.h.



	* implement.h: Add opaque structures from pthread.h.



	* sched.c (sched_yield): New function.



	* condvar.c (ptw32_sem_*): Rename to sem_*; except for

	ptw32_sem_timedwait which is an private function.



Sat Apr  3 23:28:00 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* Makefile.in (OBJS): Add errno.o.



Fri Apr  2 11:08:50 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h (ptw32_sem_*): Remove prototypes now defined in

	semaphore.h.



	* pthread.h (sempahore.h): Include.



	* semaphore.h: New file for POSIX 1b semaphores.



	* semaphore.c (ptw32_sem_timedwait): Moved to private.c.



	* pthread.h (ptw32_sem_t): Change to sem_t. 



	* private.c (ptw32_sem_timedwait): Moved from semaphore.c;

	set errno on error.



	* pthread.h (pthread_t_): Add per-thread errno element.



Fri Apr  2 11:08:50 1999  John Bossom <jebossom at cognos.com>



	* semaphore.c (ptw32_sem_*): Change to sem_*; these functions

	will be exported from the library; set errno on error.



	* errno.c (_errno): New file. New function.



Fri Mar 26 14:11:45 1999  Tor Lillqvist <tml at iki.fi>



	* semaphore.c (ptw32_sem_timedwait): Check for negative

	milliseconds.



Wed Mar 24 11:32:07 1999  John Bossom <jebossom at cognos.com>



	* misc.c (CancelableWait): Initialise exceptionInformation[2].

	(pthread_self): Get a real Win32 thread handle for implicit threads.



	* cancel.c (pthread_testcancel): Initialise exceptionInformation[2].



	* implement.h (SE_INFORMATION): Fix values.



	* private.c (ptw32_threadDestroy): Close the thread handle.



Fri Mar 19 12:57:27 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cancel.c (comments): Update and cleanup.



Fri Mar 19 09:12:59 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_threadStart): status returns PTHREAD_CANCELED.



	* pthread.h (PTHREAD_CANCELED): defined.



Tue Mar 16  1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* all: Add GNU LGPL and Copyright and Warranty.

	

Mon Mar 15 00:20:13 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (pthread_cond_init): fix possible uninitialised use

	of cv.



Sun Mar 14 21:01:59 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (pthread_cond_destroy): don't do full cleanup if

	static initialised cv has never been used.

	(cond_timedwait): check result of auto-initialisation.



Thu Mar 11 09:01:48 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (pthread_mutex_t): revert to (pthread_mutex_t *);

	define a value to serve as PTHREAD_MUTEX_INITIALIZER.

	(pthread_mutex_t_): remove staticinit and valid elements.

	(pthread_cond_t): revert to (pthread_cond_t_ *);

	define a value to serve as PTHREAD_COND_INITIALIZER.

	(pthread_cond_t_): remove staticinit and valid elements.



	* mutex.c (pthread_mutex_t args): adjust indirection of references.

	(all functions): check for PTHREAD_MUTEX_INITIALIZER value;

	check for NULL (invalid).



	* condvar.c (pthread_cond_t args): adjust indirection of references.

	(all functions): check for PTHREAD_COND_INITIALIZER value;

	check for NULL (invalid).



Wed Mar 10 17:18:12 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (CancelableWait): Undo changes from Mar 8 and 7.



Mon Mar  8 11:18:59 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (CancelableWait): Ensure cancelEvent handle is the lowest

	indexed element in the handles array. Enhance test for abandoned

	objects.



	* pthread.h (PTHREAD_MUTEX_INITIALIZER): Trailing elements not

	initialised are set to zero by the compiler. This avoids the

	problem of initialising the opaque critical section element in it.

	(PTHREAD_COND_INITIALIZER): Ditto.



	* semaphore.c (ptw32_sem_timedwait): Check sem == NULL earlier.



Sun Mar  7 12:31:14 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (pthread_cond_init): set semaphore initial value

	to 0, not 1. cond_timedwait was returning signaled immediately.



	* misc.c (CancelableWait): Place the cancel event handle first

	in the handle table for WaitForMultipleObjects. This ensures that

	the cancel event is recognised and acted apon if both objects

	happen to be signaled together.



	* private.c (ptw32_cond_test_init_lock): Initialise and destroy.



	* implement.h (ptw32_cond_test_init_lock): Add extern.



	* global.c (ptw32_cond_test_init_lock): Add declaration. 



	* condvar.c (pthread_cond_destroy): check for valid initialised CV;

	flag destroyed CVs as invalid.

	(pthread_cond_init): pthread_cond_t is no longer just a pointer.

	This is because PTHREAD_COND_INITIALIZER needs state info to reside

	in pthread_cond_t so that it can initialise on first use. Will work on

	making pthread_cond_t (and other objects like it) opaque again, if

	possible, later.

	(cond_timedwait): add check for statically initialisation of

	CV; initialise on first use.

	(pthread_cond_signal): check for valid CV.

	(pthread_cond_broadcast): check for valid CV.

	(_cond_check_need_init): Add.



	* pthread.h (PTHREAD_COND_INITIALIZER): Fix.

	(pthread_cond_t): no longer a pointer to pthread_cond_t_.

	(pthread_cond_t_): add 'staticinit' and 'valid' elements.



Sat Mar 6 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Undate comments.



Sun Feb 21 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (PTHREAD_MUTEX_INITIALIZER): missing braces around

	cs element initialiser.



1999-02-21  Ben Elliston  <bje at cygnus.com>



	* pthread.h (pthread_exit): The return type of this function is

	void, not int.



	* exit.c (pthread_exit): Do not return 0.



Sat Feb 20 16:03:30 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* dll.c (DLLMain): Expand TryEnterCriticalSection support test.



	* mutex.c (pthread_mutex_trylock): The check for

	ptw32_try_enter_critical_section == NULL should have been

	removed long ago.



Fri Feb 19 16:03:30 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c (pthread_join): Fix pthread_equal() test.



	* mutex.c (pthread_mutex_trylock): Check mutex != NULL before

	using it.



Thu Feb 18 16:17:30 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (pthread_equal): Fix inverted result.



	* Makefile.in: Use libpthread32.a as the name of the DLL export

	library instead of pthread.lib.



	* condvar.c (pthread_cond_init): cv could have been used unitialised;

	initialise.



	* create.c (pthread_create): parms could have been used unitialised;

	initialise.



	* pthread.h (struct pthread_once_t_): Remove redefinition.



Sat Feb 13 03:03:30 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (struct pthread_once_t_): Replaced.



	* misc.c (pthread_once): Replace with John Bossom's version;

	has lighter weight serialisation; fixes problem of not holding

	competing threads until after the init_routine completes.



Thu Feb 11 13:34:14 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (CancelableWait): Change C++ exception throw.



	* sync.c (pthread_join): Change FIXME comment - issue resolved.



Wed Feb 10 12:49:11 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* configure: Various temporary changes.

	- Kevin Ruland <Kevin.Ruland at anheuser-busch.com>



	* README: Update.



	* pthread.def (pthread_attr_getstackaddr): uncomment

	(pthread_attr_setstackaddr): uncomment



Fri Feb  5 13:42:30 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* semaphore.c: Comment format changes.



Thu Feb  4 10:07:28 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* global.c: Remove ptw32_exception instantiation.



	* cancel.c (pthread_testcancel): Change C++ exception throw.



	* implement.h: Remove extern declaration.



Wed Feb  3 13:04:44 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c: Rename ptw32_*_cleanup() to pthread_*_cleanup().



	* pthread.def: Ditto.

	

	* pthread.h: Ditto.



	* pthread.def (pthread_cleanup_push): Remove from export list;

	the function is defined as a macro under all compilers.

	(pthread_cleanup_pop): Ditto.



	* pthread.h: Remove #if defined().



Wed Feb  3 10:13:48 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c (pthread_join): Check for NULL value_ptr arg;

	check for detached threads.



Tue Feb  2 18:07:43 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* implement.h: Add #include <pthread.h>.

	Change sem_t to ptw32_sem_t.



Tue Feb  2 18:07:43 1999  Kevin Ruland <Kevin.Ruland at anheuser-busch.com>



	* signal.c (pthread_sigmask): Add and modify casts.

	Reverse LHS/RHS bitwise assignments.



	* pthread.h: Remove #include <semaphore.h>.

	(PTW32_ATTR_VALID): Add cast.

	(struct pthread_t_): Add sigmask element.



	* dll.c: Add "extern C" for DLLMain.

	(DllMain): Add cast.



	* create.c (pthread_create): Set sigmask in thread.



	* condvar.c: Remove #include. Change sem_* to ptw32_sem_*.



	* attr.c: Changed #include.



	* Makefile.in: Additional targets and changes to build the library

	as a DLL.



Fri Jan 29 11:56:28 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* Makefile.in (OBJS): Add semaphore.o to list.



	* semaphore.c (ptw32_sem_timedwait): Move from private.c.

	Rename sem_* to ptw32_sem_*.



	* pthread.h (pthread_cond_t): Change type of sem_t.

	_POSIX_SEMAPHORES no longer defined.



	* semaphore.h: Contents moved to implement.h.

	Removed from source tree.



	* implement.h: Add semaphore function prototypes and rename all

	functions to prepend 'ptw32_'. They are

	now private to the pthreads-win32 implementation.



	* private.c: Change #warning.

	Move ptw32_sem_timedwait() to semaphore.c.



	* cleanup.c: Change #warning.



	* misc.c: Remove #include <errno.h>



	* pthread.def: Cleanup CVS merge conflicts.



	* global.c: Ditto.



	* ChangeLog: Ditto.



	* cleanup.c: Ditto.



Sun Jan 24 01:34:52 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* semaphore.c (sem_wait): Remove second arg to 

	pthreadCancelableWait() call.



Sat Jan 23 17:36:40 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.def: Add new functions to export list.



	* pthread.h (PTHREAD_MUTEX_AUTO_CS_NP): New.

	(PTHREAD_MUTEX_FORCE_CS_NP): New.



	* README: Updated.



Fri Jan 22 14:31:59 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* Makefile.in (CFLAGS): Remove -fhandle-exceptions. Not needed

	with egcs. Add -g for debugging.



	* create.c (pthread_create): Replace __stdcall with PT_STDCALL

	macro. This is a hack and must be fixed.



	* misc.c (CancelableWait): Remove redundant statement.



	* mutex.c (pthread_mutexattr_init): Cast calloc return value.



	* misc.c (CancelableWait): Add cast.

	(pthread_self): Add cast.



	* exit.c (pthread_exit): Add cast.



	* condvar.c (pthread_condattr_init): Cast calloc return value.



	* cleanup.c: Reorganise conditional compilation.



	* attr.c (pthread_attr_init): Remove unused 'result'.

	Cast malloc return value.



	* private.c (ptw32_callUserDestroyRoutines): Redo conditional

	compilation.



	* misc.c (CancelableWait): C++ version uses 'throw'.



	* cancel.c (pthread_testcancel): Ditto.



	* implement.h (class ptw32_exception): Define for C++.



	* pthread.h: Fix C, C++, and Win32 SEH condition compilation

	mayhem around pthread_cleanup_* defines. C++ version now uses John

	Bossom's cleanup handlers.

	(pthread_attr_t): Make 'valid' unsigned.

	Define '_timeb' as 'timeb' for Ming32.

	Define PT_STDCALL as nothing for Mingw32. May be temporary.



	* cancel.c (pthread_testcancel): Cast return value.



Wed Jan 20 09:31:28 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (pthread_mutexattr_t): Changed to a pointer.



	* mutex.c (pthread_mutex_init): Conditionally create Win32 mutex

	- from John Bossom's implementation.

	(pthread_mutex_destroy): Conditionally close Win32 mutex

	- from John Bossom's implementation.

	(pthread_mutexattr_init): Replaced by John Bossom's version.

	(pthread_mutexattr_destroy): Ditto.

	(pthread_mutexattr_getpshared): New function from John Bossom's

	implementation.

	(pthread_mutexattr_setpshared): New function from John Bossom's

	implementation.



Tue Jan 19 18:27:42 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* pthread.h (pthreadCancelableTimedWait): New prototype.

	(pthreadCancelableWait): Remove second argument.



	* misc.c (CancelableWait): New static function is 

	pthreadCancelableWait() renamed.

	(pthreadCancelableWait): Now just calls CancelableWait() with

	INFINITE timeout.

	(pthreadCancelableTimedWait): Just calls CancelableWait()

	with passed in timeout.



Tue Jan 19 18:27:42 1999  Scott Lightner <scott at curriculum.com>



	* private.c (ptw32_sem_timedwait): 'abstime' arg really is

	absolute time. Calculate relative time to wait from current

	time before passing timeout to new routine 

	pthreadCancelableTimedWait().



Tue Jan 19 10:27:39 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (pthread_mutexattr_setforcecs_np): New prototype.

	

	* mutex.c (pthread_mutexattr_init): Init 'pshared' and 'forcecs'

	attributes to 0.

	(pthread_mutexattr_setforcecs_np): New function (not portable).



	* pthread.h (pthread_mutex_t): 

	Add 'mutex' element. Set to NULL in PTHREAD_MUTEX_INITIALIZER.

	The pthread_mutex_*() routines will try to optimise performance

	by choosing either mutexes or critical sections as the basis

	for pthread mutexes for each indevidual mutex.

	(pthread_mutexattr_t_): Add 'forcecs' element.

	Some applications may choose to force use of critical sections

	if they know that:-

	     the mutex is PROCESS_PRIVATE and, 

	         either the OS supports TryEnterCriticalSection() or

	         pthread_mutex_trylock() will never be called on the mutex.

	This attribute will be setable via a non-portable routine.



	Note: We don't yet support PROCESS_SHARED mutexes, so the

	implementation as it stands will default to Win32 mutexes only if

	the OS doesn't support TryEnterCriticalSection. On Win9x, and early

	versions of NT 'forcecs' will need to be set in order to get

	critical section based mutexes.



Sun Jan 17 12:01:26 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (PTHREAD_MUTEX_INITIALIZER): Init new 'staticinit'

	value to '1' and existing 'valid' value to '1'.



	* global.c (ptw32_mutex_test_init_lock): Add.



	* implement.h (ptw32_mutex_test_init_lock.): Add extern.



	* private.c (ptw32_processInitialize): Init critical section for

	global lock used by _mutex_check_need_init().

	(ptw32_processTerminate): Ditto (:s/Init/Destroy/).



	* dll.c (dllMain): Move call to FreeLibrary() so that it is only

	called once when the process detaches.



	* mutex.c (_mutex_check_need_init): New static function to test

	and init PTHREAD_MUTEX_INITIALIZER mutexes. Provides serialised

	access to the internal state of the uninitialised static mutex. 

	Called from pthread_mutex_trylock() and pthread_mutex_lock() which

	do a quick unguarded test to check if _mutex_check_need_init()

	needs to be called. This is safe as the test is conservative

 	and is repeated inside the guarded section of 

	_mutex_check_need_init(). Thus in all calls except the first

	calls to lock static mutexes, the additional overhead to lock any

	mutex is a single memory fetch and test for zero.



	* pthread.h (pthread_mutex_t_): Add 'staticinit' member. Mutexes

	initialised by PTHREAD_MUTEX_INITIALIZER aren't really initialised

	until the first attempt to lock it. Using the 'valid'

	flag (which flags the mutex as destroyed or not) to record this

	information would be messy. It is possible for a statically

	initialised mutex such as this to be destroyed before ever being

	used.



	* mutex.c (pthread_mutex_trylock): Call _mutex_check_need_init()

	to test/init PTHREAD_MUTEX_INITIALIZER mutexes.

	(pthread_mutex_lock): Ditto.

	(pthread_mutex_unlock): Add check to ensure we don't try to unlock

	an unitialised static mutex.

	(pthread_mutex_destroy): Add check to ensure we don't try to delete

	a critical section that we never created. Allows us to destroy

	a static mutex that has never been locked (and hence initialised).

	(pthread_mutex_init): Set 'staticinit' flag to 0 for the new mutex.



Sun Jan 17 12:01:26 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_sem_timedwait): Move from semaphore.c.



	* semaphore.c : Remove redundant #includes.

	(ptw32_sem_timedwait): Move to private.c.

	(sem_wait): Add missing abstime arg to pthreadCancelableWait() call.



Fri Jan 15 23:38:05 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (cond_timedwait): Remove comment.



Fri Jan 15 15:41:28 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* pthread.h: Add new 'abstime' arg to pthreadCancelableWait()

	prototype.



	* condvar.c (cond_timedwait): New generalised function called by

	both pthread_cond_wait() and pthread_cond_timedwait(). This is

	essentially pthread_cond_wait() renamed and modified to add the

	'abstime' arg and call the new ptw32_sem_timedwait() instead of

	sem_wait().

	(pthread_cond_wait): Now just calls the internal static

	function cond_timedwait() with an INFINITE wait.

	(pthread_cond_timedwait): Now implemented. Calls the internal

	static function cond_timedwait().



	* implement.h (ptw32_sem_timedwait): New internal function

	prototype.



	* misc.c (pthreadCancelableWait): Added new 'abstime' argument

	to allow shorter than INFINITE wait.



	* semaphore.c (ptw32_sem_timedwait): New function for internal

	use.  This is essentially sem_wait() modified to add the

        'abstime' arg and call the modified (see above)

        pthreadCancelableWait().



Thu Jan 14 14:27:13 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c: Correct _cplusplus to __cplusplus wherever used.



	* Makefile.in: Add CC=g++ and add -fhandle-exceptions to CFLAGS.

	The derived Makefile will compile all units of the package as C++

	so that those which include try/catch exception handling should work

	properly. The package should compile ok if CC=gcc, however, exception

	handling will not be included and thus thread cancellation, for

 	example, will not work.



	* cleanup.c (ptw32_pop_cleanup): Add #warning to compile this

 	file as C++ if using a cygwin32 environment. Perhaps the whole package

	should be compiled using g++ under cygwin.



	* private.c (ptw32_threadStart): Change #error directive

	into #warning and bracket for __CYGWIN__ and derivative compilers.



Wed Jan 13 09:34:52 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* build.bat: Delete old binaries before compiling/linking.



Tue Jan 12 09:58:38 1999  Tor Lillqvist <tml at iki.fi>



	* dll.c: The Microsoft compiler pragmas probably are more

	appropriately protected by _MSC_VER than by _WIN32.



	* pthread.h: Define ETIMEDOUT. This should be returned by

	pthread_cond_timedwait which is not implemented yet as of

	snapshot-1999-01-04-1305. It was implemented in the older version.

	The Microsoft compiler pragmas probably are more appropriately

	protected by _MSC_VER than by _WIN32.



	* pthread.def: pthread_mutex_destroy was missing from the def file



	* condvar.c (pthread_cond_broadcast): Ensure we only wait on threads

	if there were any waiting on the condition.

	I think pthread_cond_broadcast should do the WaitForSingleObject

	only if cv->waiters > 0? Otherwise it seems to hang, at least in the

	testg thread program from glib.



Tue Jan 12 09:58:38 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (pthread_cond_timedwait): Fix function description

	comments.



	* semaphore.c (sem_post): Correct typo in comment.



Mon Jan 11 20:33:19 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h: Re-arrange conditional compile of pthread_cleanup-*

	macros.



	* cleanup.c (ptw32_push_cleanup): Provide conditional 

	compile of cleanup->prev.



1999-01-11  Tor Lillqvist <tml at iki.fi>



	* condvar.c (pthread_cond_init): Invert logic when testing the

	return value from calloc().



Sat Jan  9 14:32:08 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Compile-time switch for CYGWIN derived environments

	to use CreateThread instead of _beginthreadex. Ditto for ExitThread.

	Patch provided by Anders Norlander  <anorland at hem2.passagen.se>.



Tue Jan  5 16:33:04 1999  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c (ptw32_pop_cleanup): Add C++ version of __try/__except

	block. Move trailing "}" out of #ifdef _WIN32 block left there by

	(rpj's) mistake.



	* private.c: Remove #include <errno.h> which is included by pthread.h.



1998-12-11  Ben Elliston  <bje at toilet.to.cygnus.com>



	* README: Update info about subscribing to the mailing list.



Mon Jan  4 11:23:40 1999  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* all: No code changes, just cleanup.

	- remove #if 0 /* Pre Bossom */ enclosed code.

	- Remove some redundant #includes.

	* pthread.h: Update implemented/unimplemented routines list.

	* Tag the bossom merge branch getting ready to merge back to main

	trunk.



Tue Dec 29 13:11:16 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Move the following struct definitions to pthread.h:

	pthread_t_, pthread_attr_t_, pthread_mutex_t_, pthread_mutex_t_,

	pthread_mutexattr_t_, pthread_key_t_, pthread_cond_t_,

	pthread_condattr_t_, pthread_once_t_.



	* pthread.h: Add "_" prefix to pthread_push_cleanup and 

	pthread_pop_cleanup internal routines, and associated struct and

	typedefs.



	* buildlib.bat: Add compile command for semaphore.c



	* pthread.def: Comment out pthread_atfork routine name. 

	Now unimplemented.



	* tsd.c (pthread_setspecific): Rename tkAssocCreate to

	ptw32_tkAssocCreate.

	(pthread_key_delete): Rename tkAssocDestroy to

	ptw32_tkAssocDestroy.



	* sync.c (pthread_join): Rename threadDestroy to ptw32_threadDestroy



	* sched.c (is_attr): attr is now **attr (was *attr), so add extra

	NULL pointer test.

	(pthread_attr_setschedparam): Increase redirection for attr which is

	now a **.

	(pthread_attr_getschedparam): Ditto.

	(pthread_setschedparam): Change thread validation and rename "thread"

 	Win32 thread Handle element name to match John Bossom's version.

	(pthread_getschedparam): Ditto.



	* private.c (ptw32_threadDestroy): Rename call to

	callUserDestroyRoutines() as ptw32_callUserDestroyRoutines()



	* misc.c: Add #include "implement.h".



	* dll.c: Remove defined(KLUDGE) wrapped code.



	* fork.c: Remove redefinition of ENOMEM.

	Remove pthread_atfork() and fork() with #if 0/#endif.



	* create.c (pthread_create): Rename threadStart and threadDestroy calls

	to ptw32_threadStart and ptw32_threadDestroy.



	* implement.h: Rename "detachedstate" to "detachstate".



	* attr.c: Rename "detachedstate" to "detachstate".



Mon Dec 28 09:54:39 1998  John Bossom



	* semaphore.c: Initial version.

	* semaphore.h: Initial version.



Mon Dec 28 09:54:39 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.h (pthread_attr_t_): Change to *pthread_attr_t.



Mon Dec 28 09:54:39 1998  John Bossom, Ben Elliston



	* attr.c (pthread_attr_setstacksize): Merge with John's version.

	(pthread_attr_getstacksize): Merge with John's version.

	(pthread_attr_setstackaddr): Merge with John's version.

	(pthread_attr_getstackaddr): Merge with John's version.

	(pthread_attr_init): Merge with John's version.

	(pthread_attr_destroy): Merge with John's version.

	(pthread_attr_getdetachstate): Merge with John's version.

	(pthread_attr_setdetachstate): Merge with John's version.

	(is_attr): attr is now **attr (was *attr), so add extra NULL pointer

	test.



Mon Dec 28 09:54:39 1998  Ross Johnson



	* implement.h (pthread_attr_t_): Add and rename elements in JEB's

	version to correspond to original, so that it can be used with

	original attr routines.



	* pthread.h: Add #endif at end which was truncated in merging.



Sun Dec 20 14:51:58 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* misc.c (pthreadCancelableWait): New function by John Bossom. Non-standard

	but provides a hook that can be used to implement cancellation points in

	applications that use this library.



	* pthread.h (pthread_cleanup_pop): C++ (non-WIN32) version uses

	try/catch to emulate John Bossom's WIN32 __try/__finally behaviour.

	In the WIN32 version __finally block, add a test for AbnormalTermination otherwise

	cleanup is only run if the cleanup_pop execute arg is non-zero. Cancellation

	should cause the cleanup to run irrespective of the execute arg.



	* condvar.c (pthread_condattr_init): Replaced by John Bossom's version.

	(pthread_condattr_destroy): Replaced by John Bossom's version.

	(pthread_condattr_getpshared): Replaced by John Bossom's version.

	(pthread_condattr_setpshared): Replaced by John Bossom's version.

	(pthread_cond_init): Replaced by John Bossom's version.

	Fix comment (refered to mutex rather than condition variable).

	(pthread_cond_destroy): Replaced by John Bossom's version.

	(pthread_cond_wait): Replaced by John Bossom's version.

	(pthread_cond_timedwait): Replaced by John Bossom's version.

	(pthread_cond_signal): Replaced by John Bossom's version.

	(pthread_cond_broadcast): Replaced by John Bossom's version.



Thu Dec 17 19:10:46 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* tsd.c (pthread_key_create): Replaced by John Bossom's version.

	(pthread_key_delete): Replaced by John Bossom's version.

	(pthread_setspecific): Replaced by John Bossom's version.

	(pthread_getspecific): Replaced by John Bossom's version.



Mon Dec  7 09:44:40 1998  John Bossom



	* cancel.c (pthread_setcancelstate): Replaced.

	(pthread_setcanceltype): Replaced.

	(pthread_testcancel): Replaced.

	(pthread_cancel): Replaced.

	

	* exit.c (pthread_exit): Replaced.



	* misc.c (pthread_self): Replaced.

	(pthread_equal): Replaced.



	* sync.c (pthread_detach): Replaced.

	(pthread_join): Replaced.



	* create.c (pthread_create): Replaced.



	* private.c (ptw32_processInitialize): New.

	(ptw32_processTerminate): New.

	(ptw32_threadStart): New.

 	(ptw32_threadDestroy): New.

	(ptw32_cleanupStack): New.

	(ptw32_tkAssocCreate): New.

	(ptw32_tkAssocDestroy): New.

	(ptw32_callUserDestroyRoutines): New.



	* implement.h: Added non-API structures and declarations.



	* dll.c (PthreadsEntryPoint): Cast return value of GetProcAddress

	to resolve compile warning from MSVC.



	* dll.c (DLLmain): Replaced.

	* dll.c (PthreadsEntryPoint):

	Re-applied Anders Norlander's patch:-

	Initialize ptw32_try_enter_critical_section at startup

	and release kernel32 handle when DLL is being unloaded.



Sun Dec  6 21:54:35 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* buildlib.bat: Fix args to CL when building the .DLL



	* cleanup.c (ptw32_destructor_run_all): Fix TSD key management.

	This is a tidy-up before TSD and Thread management is completely

	replaced by John Bossom's code.



	* tsd.c (pthread_key_create): Fix TSD key management.



	* global.c (ptw32_key_virgin_next): Initialise.



	* build.bat: New DOS script to compile and link a pthreads app

	using Microsoft's CL compiler linker.

	* buildlib.bat: New DOS script to compile all the object files

	and create pthread.lib and pthread.dll using Microsoft's CL

	compiler linker.



1998-12-05  Anders Norlander  <anorland at hem2.passagen.se>



	* implement.h (ptw32_try_enter_critical_section): New extern

	* dll.c (ptw32_try_enter_critical_section): New pointer to

	TryEnterCriticalSection if it exists; otherwise NULL.

	* dll.c (PthreadsEntryPoint):

	Initialize ptw32_try_enter_critical_section at startup

	and release kernel32 handle when DLL is being unloaded.

	* mutex.c (pthread_mutex_trylock): Replaced check for NT with

	a check if ptw32_try_enter_critical_section is valid

	pointer to a function. Call ptw32_try_enter_critical_section

	instead of TryEnterCriticalSection to avoid errors on Win95.



Thu Dec 3 13:32:00 1998  Ross Johnson  <rpj at ise.canberra.edu.au>



	* README: Correct cygwin32 compatibility statement.



Sun Nov 15 21:24:06 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* cleanup.c (ptw32_destructor_run_all): Declare missing void * arg.

	Fixup CVS merge conflicts.



1998-10-30  Ben Elliston  <bje at cygnus.com>



	* condvar.c (cond_wait): Fix semantic error. Test for equality

	instead of making an assignment.



Fri Oct 30 15:15:50 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c (ptw32_handler_push): Fixed bug appending new

	handler to list reported by Peter Slacik

	<Peter.Slacik at leibinger.freinet.de>.

	(new_thread): Rename poorly named local variable to

	"new_handler".



Sat Oct 24 18:34:59 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* global.c: Add TSD key management array and index declarations.



	* implement.h: Ditto for externs.



Fri Oct 23 00:08:09 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h (PTW32_TSD_KEY_REUSE): Add enum.



	* private.c (ptw32_delete_thread): Add call to

	ptw32_destructor_run_all() to clean up the threads keys.



	* cleanup.c (ptw32_destructor_run_all): Check for no more dirty

	keys to run destructors on. Assume that the destructor call always

	succeeds and set the key value to NULL.



Thu Oct 22 21:44:44 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* tsd.c (pthread_setspecific): Add key management code.

	(pthread_key_create): Ditto.

	(pthread_key_delete): Ditto.



	* implement.h (struct ptw32_tsd_key): Add status member.



	* tsd.c: Add description of pthread_key_delete() from the

	standard as a comment.



Fri Oct 16 17:38:47 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c (ptw32_destructor_run_all): Fix and improve

	stepping through the key table.



Thu Oct 15 14:05:01 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* private.c (ptw32_new_thread): Remove init of destructorstack.

	No longer an element of pthread_t.



	* tsd.c (pthread_setspecific): Fix type declaration and cast.

	(pthread_getspecific): Ditto.

	(pthread_getspecific): Change error return value to NULL if key

	is not in use.



Thu Oct 15 11:53:21 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* global.c (ptw32_tsd_key_table): Fix declaration.



	* implement.h(ptw32_TSD_keys_TlsIndex): Add missing extern.

	(ptw32_tsd_mutex): Ditto.



	* create.c (ptw32_start_call): Fix "keys" array declaration.

	Add comment.



	* tsd.c (pthread_setspecific): Fix type declaration and cast.

	(pthread_getspecific): Ditto.



	* cleanup.c (ptw32_destructor_run_all): Declare missing loop

	counter.



Wed Oct 14 21:09:24 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_new_thread): Increment ptw32_threads_count.

	(ptw32_delete_thread): Decrement ptw32_threads_count.

	Remove some comments.



	* exit.c (ptw32_exit): : Fix two pthread_mutex_lock() calls that

 	should have been pthread_mutex_unlock() calls.

	(ptw32_vacuum): Remove call to ptw32_destructor_pop_all().



	* create.c (pthread_create): Fix two pthread_mutex_lock() calls that

 	should have been pthread_mutex_unlock() calls.



	* global.c (ptw32_tsd_mutex): Add mutex for TSD operations.



	* tsd.c (pthread_key_create): Add critical section.

	(pthread_setspecific): Ditto.

	(pthread_getspecific): Ditto.

	(pthread_key_delete): Ditto.



	* sync.c (pthread_join): Fix two pthread_mutex_lock() calls that

 	should have been pthread_mutex_unlock() calls.



Mon Oct 12 00:00:44 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h (ptw32_tsd_key_table): New.



	* create.c (ptw32_start_call): Initialise per-thread TSD keys

	to NULL.



	* misc.c (pthread_once): Correct typo in comment.



	* implement.h (ptw32_destructor_push): Remove.

	(ptw32_destructor_pop): Remove.

	(ptw32_destructor_run_all): Rename from ptw32_destructor_pop_all.

	(PTW32_TSD_KEY_DELETED): Add enum.

	(PTW32_TSD_KEY_INUSE): Add enum.



	* cleanup.c (ptw32_destructor_push): Remove.

	(ptw32_destructor_pop): Remove.

	(ptw32_destructor_run_all): Totally revamped TSD.



	* dll.c (ptw32_TSD_keys_TlsIndex): Initialise.



	* tsd.c (pthread_setspecific): Totally revamped TSD.

	(pthread_getspecific): Ditto.

	(pthread_create): Ditto.

	(pthread_delete): Ditto.



Sun Oct 11 22:44:55 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* global.c (ptw32_tsd_key_table): Add new global.



	* implement.h (ptw32_tsd_key_t and struct ptw32_tsd_key):

	Add.

	(struct _pthread): Remove destructorstack.



	* cleanup.c (ptw32_destructor_run_all): Rename from

 	ptw32_destructor_pop_all. The key destructor stack was made

 	global rather than per-thread. No longer removes destructor nodes

	from the stack. Comments updated.



1998-10-06  Ben Elliston  <bje at cygnus.com>



	* condvar.c (cond_wait): Use POSIX, not Win32 mutex calls.

	(pthread_cond_broadcast): Likewise.

	(pthread_cond_signal): Likewise.



1998-10-05  Ben Elliston  <bje at cygnus.com>



	* pthread.def: Update. Some functions aren't available yet, others

	are macros in <pthread.h>.



	* tests/join.c: Remove; useless.



Mon Oct  5 14:25:08 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* pthread.def: New file for building the DLL.



1998-10-05  Ben Elliston  <bje at cygnus.com>



	* misc.c (pthread_equal): Correct inverted logic bug.

	(pthread_once): Use the POSIX mutex primitives, not Win32. Remove

	irrelevant FIXME comment.



	* global.c (PTHREAD_MUTEX_INITIALIZER): Move to pthread.h.



	* pthread.h (PTHREAD_MUTEX_INITIALIZER): Define.

	(pthread_mutex_t): Reimplement as a struct containing a valid

	flag. If the flag is ever down upon entry to a mutex operation,

	we call pthread_mutex_create() to initialise the object. This

	fixes the problem of how to handle statically initialised objects

	that can't call InitializeCriticalSection() due to their context.

	(PTHREAD_ONCE_INIT): Define.



	* mutex.c (pthread_mutex_init): Set valid flag.

	(pthread_mutex_destroy): Clear valid flag.

	(pthread_mutex_lock): Check and handle the valid flag.

	(pthread_mutex_unlock): Likewise.

	(pthread_mutex_trylock): Likewise.



	* tests/mutex3.c: New file; test for the static initialisation

	macro. Passes.



	* tests/create1.c: New file; test pthread_create(). Passes.

	

	* tests/equal.c: Poor test; remove.

	

	* tests/equal1.c New file; test pthread_equal(). Passes.



	* tests/once1.c: New file; test for pthread_once(). Passes.



	* tests/self.c: Remove; rename to self1.c.



	* tests/self1.c: This is the old self.c.



	* tests/self2.c: New file. Test pthread_self() with a single

	thread. Passes.



	* tests/self3.c: New file. Test pthread_self() with a couple of

	threads to ensure their thread IDs differ. Passes.

	

1998-10-04  Ben Elliston  <bje at cygnus.com>



	* tests/mutex2.c: Test pthread_mutex_trylock(). Passes.



	* tests/mutex1.c: New basic test for mutex functions (it passes).

	(main): Eliminate warning.



	* configure.in: Test for __stdcall, not _stdcall. Typo.



	* configure: Regenerate.



	* attr.c (pthread_attr_setstackaddr): Remove FIXME comment. Win32

	does know about ENOSYS after all.

	(pthread_attr_setstackaddr): Likewise.



1998-10-03  Ben Elliston  <bje at cygnus.com>



	* configure.in: Test for the `_stdcall' keyword.  Define `STDCALL'

	to `_stdcall' if we have it, null otherwise.



	* configure: Regenerate.



	* acconfig.h (STDCALL): New define.



	* config.h.in: Regenerate.



	* create.c (ptw32_start_call): Add STDCALL prefix.

	

	* mutex.c (pthread_mutex_init): Correct function signature.



	* attr.c (pthread_attr_init): Only zero out the `sigmask' member

	if we have the sigset_t type.



	* pthread.h: No need to include <unistd.h>.  It doesn't even exist

	on Win32! Again, an artifact of cross-compilation.	

	(pthread_sigmask): Only provide if we have the sigset_t type.



	* process.h: Remove. This was a stand-in before we started doing

	native compilation under Win32.



	* pthread.h (pthread_mutex_init): Make `attr' argument const.



1998-10-02  Ben Elliston  <bje at cygnus.com>



	* COPYING: Remove.



	* COPYING.LIB: Add. This library is under the LGPL.



1998-09-13  Ben Elliston  <bje at cygnus.com>



	* configure.in: Test for required system features.



	* configure: Generate. 



	* acconfig.h: New file.



	* config.h.in: Generate.



	* Makefile.in: Renamed from Makefile.



	* COPYING: Import from a recent GNU package.



	* config.guess: Likewise.



	* config.sub: Likewise.



	* install-sh: Likewise.



	* config.h: Remove.  



	* Makefile: Likewise.



1998-09-12  Ben Elliston  <bje at cygnus.com>



	* windows.h: No longer needed; remove.



	* windows.c: Likewise.



Sat Sep 12 20:09:24 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* windows.h: Remove error number definitions. These are in <errno.h>

	

	* tsd.c: Add comment explaining rationale for not building

	POSIX TSD on top of Win32 TLS.



1998-09-12  Ben Elliston  <bje at cygnus.com>



	* {most}.c: Include <errno.h> to get POSIX error values.



	* signal.c (pthread_sigmask): Only provide if HAVE_SIGSET_T is

	defined.

 

	* config.h: #undef features, don't #define them.  This will be

	generated by autoconf very soon.

	

1998-08-11  Ben Elliston  <bje at cygnus.com>



	* Makefile (LIB): Define.

	(clean): Define target.

	(all): Build a library not just the object files.



	* pthread.h: Provide a definition for struct timespec if we don't

	already have one.



	* windows.c (TlsGetValue): Bug fix.

	

Thu Aug  6 15:19:22 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* misc.c (pthread_once): Fix arg 1 of EnterCriticalSection()

 	and LeaveCriticalSection() calls to pass address-of lock.



	* fork.c (pthread_atfork): Typecast (void (*)(void *)) funcptr

	in each ptw32_handler_push() call.



	* exit.c (ptw32_exit): Fix attr arg in 

	pthread_attr_getdetachstate() call.



	* private.c (ptw32_new_thread): Typecast (HANDLE) NULL.

	(ptw32_delete_thread): Ditto.



	* implement.h: (PTW32_MAX_THREADS): Add define. This keeps

	changing in an attempt to make thread administration data types

	opaque and cleanup DLL startup.



	* dll.c (PthreadsEntryPoint): 

	(ptw32_virgins): Remove malloc() and free() calls.

	(ptw32_reuse): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* global.c (_POSIX_THREAD_THREADS_MAX): Initialise with 

	PTW32_MAX_THREADS.

	(ptw32_virgins): Ditto.

	(ptw32_reuse): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* create.c (pthread_create): Typecast (HANDLE) NULL.

	Typecast (unsigned (*)(void *)) start_routine.



	* condvar.c (pthread_cond_init): Add address-of operator & to

	arg 1 of pthread_mutex_init() call.

	(pthread_cond_destroy): Add address-of operator & to

	arg 1 of pthread_mutex_destroy() call. 



	* cleanup.c (ptw32_destructor_pop_all): Add (int) cast to 

	pthread_getspecific() arg.

	(ptw32_destructor_pop): Add (void *) cast to "if" conditional.

	(ptw32_destructor_push): Add (void *) cast to

	ptw32_handler_push() "key" arg.

	(malloc.h): Add include.



	* implement.h (ptw32_destructor_pop): Add prototype.



	* tsd.c (implement.h): Add include.



	* sync.c (pthread_join): Remove target_thread_mutex and it's

	initialisation. Rename getdetachedstate to getdetachstate.

	Remove unused variable "exitcode".

	(pthread_detach): Remove target_thread_mutex and it's

	initialisation. Rename getdetachedstate to getdetachstate.

	Rename setdetachedstate to setdetachstate.



	* signal.c (pthread_sigmask): Rename SIG_SET to SIG_SETMASK.

	Cast "set" to (long *) in assignment to passify compiler warning.

	Add address-of operator & to thread->attr.sigmask in memcpy() call

	and assignment.

	(pthread_sigmask): Add address-of operator & to thread->attr.sigmask

	in memcpy() call and assignment.



	* windows.h (THREAD_PRIORITY_ERROR_RETURN): Add.

	(THREAD_PRIORITY_LOWEST): Add.

	(THREAD_PRIORITY_HIGHEST): Add.



	* sched.c (is_attr): Add function.

	(implement.h): Add include.

	(pthread_setschedparam): Rename all instances of "sched_policy"

	to "sched_priority".

	(pthread_getschedparam): Ditto.



Tue Aug  4 16:57:58 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* private.c (ptw32_delete_thread): Fix typo. Add missing ';'.



	* global.c (ptw32_virgins): Change types from pointer to 

	array pointer.

	(ptw32_reuse): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* implement.h(ptw32_virgins): Change types from pointer to 

	array pointer.

	(ptw32_reuse): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* private.c (ptw32_delete_thread): Fix "entry" should be "thread".



	* misc.c (pthread_self): Add extern for ptw32_threadID_TlsIndex.



	* global.c: Add comment.



	* misc.c (pthread_once): Fix member -> dereferences.

	Change ptw32_once_flag to once_control->flag in "if" test.



Tue Aug  4 00:09:30 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h(ptw32_virgins): Add extern.

	(ptw32_virgin_next): Ditto.

	(ptw32_reuse): Ditto.

	(ptw32_reuse_top): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* global.c (ptw32_virgins): Changed from array to pointer.

	Storage allocation for the array moved into dll.c.

	(ptw32_reuse): Ditto.

	(ptw32_win32handle_map): Ditto.

	(ptw32_threads_mutex_table): Ditto.



	* dll.c (PthreadsEntryPoint): Set up thread admin storage when

	DLL is loaded.



	* fork.c (pthread_atfork): Fix function pointer arg to all

	ptw32_handler_push() calls. Change "arg" arg to NULL in child push.



	* exit.c: Add windows.h and process.h includes.

	(ptw32_exit): Add local detachstate declaration.

	(ptw32_exit): Fix incorrect name for pthread_attr_getdetachstate().



	* pthread.h (_POSIX_THREAD_ATTR_STACKSIZE): Move from global.c

	(_POSIX_THREAD_ATTR_STACKADDR): Ditto.



	* create.c (pthread_create): Fix #if should be #ifdef.

	(ptw32_start_call): Remove usused variables.



	* process.h: Create.



	* windows.h: Move _beginthreadex and _endthreadex into

	process.h



Mon Aug  3 21:19:57 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* condvar.c (pthread_cond_init): Add NULL attr to

	pthread_mutex_init() call - default attributes will be used.

	(cond_wait): Fix typo.

	(cond_wait): Fix typo - cv was ev.

	(pthread_cond_broadcast): Fix two identical typos.



	* cleanup.c (ptw32_destructor_pop_all): Remove _ prefix from

	PTHREAD_DESTRUCTOR_ITERATIONS.



	* pthread.h: Move _POSIX_* values into posix.h



	* pthread.h: Fix typo in pthread_mutex_init() prototype.



	* attr.c (pthread_attr_init): Fix error in priority member init.



	* windows.h (THREAD_PRIORITY_NORMAL): Add.



	* pthread.h (sched_param): Add missing ';' to struct definition. 



	* attr.c (pthread_attr_init): Remove obsolete pthread_attr_t

	member initialisation - cancelstate, canceltype, cancel_pending.

	(is_attr): Make arg "attr" a const.



	* implement.h (PTW32_HANDLER_POP_LIFO): Remove definition.

	(PTW32_HANDLER_POP_FIFO): Ditto.

	(PTW32_VALID): Add missing newline escape (\).

	(ptw32_handler_node): Make element "next" a pointer.



1998-08-02  Ben Elliston  <bje at cygnus.com>



	* windows.h: Remove duplicate TlsSetValue() prototype.  Add 

	TlsGetValue() prototype.

	(FALSE): Define.

	(TRUE): Likewise.

	Add forgotten errno values.  Guard against multiple #includes.



	* windows.c: New file.  Implement stubs for Win32 functions.



	* Makefile (SRCS): Remove.  Not explicitly needed.

	(CFLAGS): Add -Wall for all warnings with GCC.



Sun Aug  2 19:03:42 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* config.h: Create. This is a temporary stand-in for autoconf yet

	to be done.

 	(HAVE_SIGNAL_H): Add.



	* pthread.h: Minor rearrangement for temporary config.h.



Fri Jul 31 14:00:29 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* cleanup.c (ptw32_destructor_pop): Implement. Removes

	destructors associated with a key without executing them.

	(ptw32_destructor_pop_all): Add FIXME comment.



	* tsd.c (pthread_key_delete): Add call to ptw32_destructor_pop().



Fri Jul 31 00:05:45 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* tsd.c (pthread_key_create): Update to properly associate

	the destructor routine with the key.

	(pthread_key_delete): Add FIXME comment.



	* exit.c (ptw32_vacuum): Add call to

	ptw32_destructor_pop_all().



	* implement.h (ptw32_handler_pop_all): Add prototype.

	(ptw32_destructor_pop_all): Ditto.



	* cleanup.c (ptw32_destructor_push): Implement. This is just a

	call to ptw32_handler_push().

	(ptw32_destructor_pop_all): Implement. This is significantly

	different to ptw32_handler_pop_all().



	* Makefile (SRCS): Create. Preliminary.



	* windows.h: Create. Contains Win32 definitions for compile

	testing. This is just a standin for the real one.



	* pthread.h (SIG_UNBLOCK): Fix typo. Was SIG_BLOCK.

	(windows.h): Add include. Required for CRITICAL_SECTION.

	(pthread_cond_t): Move enum declaration outside of struct

	definition.

	(unistd.h): Add include - may be temporary.



	* condvar.c (windows.h): Add include.



	* implement.h (PTW32_THIS): Remove - no longer required.

	(PTW32_STACK): Use pthread_self() instead of PTW32_THIS.



Thu Jul 30 23:12:45 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Remove ptw32_find_entry() prototype.



	* private.c: Extend comments.

	Remove ptw32_find_entry() - no longer needed.



	* create.c (ptw32_start_call): Add call to TlsSetValue() to

	store the thread ID.



	* dll.c (PthreadsEntryPoint): Implement. This is called

	whenever a process loads the DLL. Used to initialise thread

	local storage.



	* implement.h: Add ptw32_threadID_TlsIndex.

	Add ()s around PTW32_VALID expression.



	* misc.c (pthread_self): Re-implement using Win32 TLS to store

	the threads own ID.



Wed Jul 29 11:39:03 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c: Corrections in comments.

	(ptw32_new_thread): Alter "if" flow to be more natural.



	* cleanup.c (ptw32_handler_push): Same as below.



	* create.c (pthread_create): Same as below.



	* private.c (ptw32_new_thread): Rename "new" to "new_thread".

	Since when has a C programmer been required to know C++?



Tue Jul 28 14:04:29 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* implement.h: Add PTW32_VALID macro.



	* sync.c (pthread_join): Modify to use the new thread

	type and ptw32_delete_thread(). Rename "target" to "thread".

	Remove extra local variable "target".

	(pthread_detach): Ditto.



	* signal.c (pthread_sigmask): Move init of "us" out of inner block.

	Fix instance of "this" should have been "us". Rename "us" to "thread".



	* sched.c (pthread_setschedparam): Modify to use the new thread

	type.

	(pthread_getschedparam): Ditto.



	* private.c (ptw32_find_thread): Fix return type and arg.



	* implement.h: Remove PTW32_YES and PTW32_NO.

	(ptw32_new_thread): Add prototype.

	(ptw32_find_thread): Ditto.

	(ptw32_delete_thread): Ditto.

	(ptw32_new_thread_entry): Remove prototype.

	(ptw32_find_thread_entry): Ditto.

	(ptw32_delete_thread_entry): Ditto.

	(  PTW32_NEW, PTW32_INUSE, PTW32_EXITED, PTW32_REUSE):

	Add.





	* create.c (pthread_create): Minor rename "us" to "new" (I need

	these cues but it doesn't stop me coming out with some major bugs

	at times).

	Load start_routine and arg into the thread so the wrapper can

	call it.



	* exit.c (pthread_exit): Fix pthread_this should be pthread_self.



	* cancel.c (pthread_setcancelstate): Change

 	ptw32_threads_thread_t * to pthread_t and init with

 	pthread_this().

	(pthread_setcanceltype): Ditto.



	* exit.c (ptw32_exit): Add new pthread_t arg.

	Rename ptw32_delete_thread_entry to ptw32_delete_thread.

	Rename "us" to "thread".

	(pthread_exit): Call ptw32_exit with added thread arg.



	* create.c (ptw32_start_call): Insert missing ")".

	Add "us" arg to ptw32_exit() call.

	(pthread_create): Modify to use new thread allocation scheme.



	* private.c: Added detailed explanation of the new thread

	allocation scheme.

	(ptw32_new_thread): Totally rewritten to use

	new thread allocation scheme.

	(ptw32_delete_thread): Ditto.

	(ptw32_find_thread): Obsolete.



Mon Jul 27 17:46:37 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* create.c (pthread_create): Start of rewrite. Not completed yet.



	* private.c (ptw32_new_thread_entry): Start of rewrite. Not

	complete.



	* implement.h (ptw32_threads_thread): Rename, remove thread

	member, add win32handle and ptstatus members.

	(ptw32_t): Add.



	* pthread.h: pthread_t is no longer mapped directly to a Win32

	HANDLE type. This is so we can let the Win32 thread terminate and

	reuse the HANDLE while pthreads holds it's own thread ID until

	the last waiting join exits.



Mon Jul 27 00:20:37 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_delete_thread_entry): Destroy the thread

 	entry attribute object before deleting the thread entry itself.



	* attr.c (pthread_attr_init): Initialise cancel_pending = FALSE.

	(pthread_attr_setdetachstate): Rename "detached" to "detachedstate".

	(pthread_attr_getdetachstate): Ditto.



	* exit.c (ptw32_exit): Fix incorrect check for detachedstate.



	* implement.h (ptw32_call_t): Remove env member. 



Sun Jul 26 13:06:12 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h (ptw32_new_thread_entry): Fix prototype.

	(ptw32_find_thread_entry): Ditto.

	(ptw32_delete_thread_entry): Ditto.

	(ptw32_exit): Add prototype.



	* exit.c (ptw32_exit): New function. Called from pthread_exit()

	and ptw32_start_call() to exit the thread. It allows an extra

	argument which is the return code passed to _endthreadex().

	(ptw32_exit): Move thread entry delete call from ptw32_vacuum()

	into here. Add more explanation of thread entry deletion.

	(ptw32_exit): Clarify comment.



	* create.c (ptw32_start_call): Change pthread_exit() call to

	ptw32_exit() call.



	* exit.c (ptw32_vacuum): Add thread entry deletion code

	moved from ptw32_start_call(). See next item.

	(pthread_exit): Remove longjmp(). Add mutex lock around thread table

	manipulation code. This routine now calls _enthreadex().



	* create.c (ptw32_start_call): Remove setjmp() call and move

	cleanup code out. Call pthread_exit(NULL) to terminate the thread.



1998-07-26  Ben Elliston  <bje at cygnus.com>



	* tsd.c (pthread_getspecific): Update comments.



	* mutex.c (pthread_mutexattr_setpshared): Not supported; remove.

	(pthread_mutexattr_getpshared): Likewise.



	* pthread.h (pthread_mutexattr_setpshared): Remove prototype.

	(pthread_mutexattr_getpshared): Likewise.



Sun Jul 26 00:09:59 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c: Rename all instances of ptw32_count_mutex to

	ptw32_table_mutex.



	* implement.h: Rename ptw32_count_mutex to

	ptw32_table_mutex.



	* global.c: Rename ptw32_count_mutex to

	ptw32_table_mutex.



	* create.c (pthread_create): Add critical sections.

	(ptw32_start_call): Rename ptw32_count_mutex to

	ptw32_table_mutex.



	* cancel.c (pthread_setcancelstate): Fix indirection bug and rename

	"this" to "us".



	* signal.c (pthread_sigmask): Rename "this" to "us" and fix some

	minor syntax errors. Declare "us" and initialise it.



	* sync.c (pthread_detach): Rename "this" to "target".



	* pthread.h: Converting PTHREAD_* defines to alias the (const int)

	values in global.c.



	* global.c: Started converting PTHREAD_* defines to (const int) as

 	a part of making the eventual pthreads DLL binary compatible

 	through version changes.



	* condvar.c (cond_wait): Add cancelation point. This applies the

	point to both pthread_cond_wait() and pthread_cond_timedwait().



	* exit.c (pthread_exit): Rename "this" to "us".



	* implement.h: Add comment.



	* sync.c (pthread_join): I've satisfied myself that pthread_detach()

	does set the detached attribute in the thread entry attributes

	to PTHREAD_CREATE_DETACHED. "if" conditions were changed to test

	that attribute instead of a separate flag.



	* create.c (pthread_create): Rename "this" to "us".

	(pthread_create): cancelstate and canceltype are not attributes

	so the copy to thread entry attribute storage was removed.

	Only the thread itself can change it's cancelstate or canceltype,

	ie. the thread must exist already.



	* private.c (ptw32_delete_thread_entry): Mutex locks removed.

	Mutexes must be applied at the caller level.

	(ptw32_new_thread_entry): Ditto.

	(ptw32_new_thread_entry): Init cancelstate, canceltype, and

	cancel_pending to default values.

	(ptw32_new_thread_entry): Rename "this" to "new".

	(ptw32_find_thread_entry): Rename "this" to "entry".

	(ptw32_delete_thread_entry): Rename "thread_entry" to "entry".



	* create.c (ptw32_start_call): Mutexes changed to

	ptw32_count_mutex. All access to the threads table entries is

	under the one mutex. Otherwise chaos reigns.



Sat Jul 25 23:16:51 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h (ptw32_threads_thread): Move cancelstate and

 	canceltype members out of pthread_attr_t into here.



	* fork.c (fork): Add comment.



1998-07-25  Ben Elliston  <bje at cygnus.com>



	* fork.c (fork): Autoconfiscate.



Sat Jul 25 00:00:13 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* create.c (ptw32_start_call): Set thread priority.  Ensure our

 	thread entry is removed from the thread table but only if

 	pthread_detach() was called and there are no waiting joins.

	(pthread_create): Set detach flag in thread entry if the 

	thread is created PTHREAD_CREATE_DETACHED.



	* pthread.h (pthread_attr_t): Rename member "detachedstate".



	* attr.c (pthread_attr_init): Rename attr members.



	* exit.c (pthread_exit): Fix indirection mistake.



	* implement.h (PTW32_THREADS_TABLE_INDEX): Add.



	* exit.c (ptw32_vacuum): Fix incorrect args to

	ptw32_handler_pop_all() calls.

	Make thread entry removal conditional.



	* sync.c (pthread_join): Add multiple join and async detach handling.



	* implement.h (PTW32_THREADS_TABLE_INDEX): Add.



	* global.c (ptw32_threads_mutex_table): Add.



	* implement.h (ptw32_once_flag): Remove.

	(ptw32_once_lock): Ditto.

	(ptw32_threads_mutex_table): Add.



	* global.c (ptw32_once_flag): Remove.

	(ptw32_once_lock): Ditto.



	* sync.c (pthread_join): Fix tests involving new return value

	from ptw32_find_thread_entry().

	(pthread_detach): Ditto.



	* private.c (ptw32_find_thread_entry): Failure return code

	changed from -1 to NULL.



Fri Jul 24 23:09:33 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* create.c (pthread_create): Change . to -> in sigmask memcpy() args.



	* pthread.h: (pthread_cancel): Add function prototype.

	(pthread_testcancel): Ditto.



1998-07-24  Ben Elliston  <bje at cygnus.com>



	* pthread.h (pthread_condattr_t): Rename dummy structure member.

	(pthread_mutexattr_t): Likewise.



Fri Jul 24 21:13:55 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* cancel.c (pthread_cancel): Implement.

	(pthread_testcancel): Implement.



	* exit.c (pthread_exit): Add comment explaining the longjmp().



	* implement.h (ptw32_threads_thread_t): New member cancelthread.

	(PTW32_YES): Define.

	(PTW32_NO): Define.

	(RND_SIZEOF): Remove.



	* create.c (pthread_create): Rename cancelability to cancelstate.



	* pthread.h (pthread_attr_t): Rename cancelability to cancelstate.

	(PTHREAD_CANCELED): Define.



1998-07-24  Ben Elliston  <bje at cygnus.com>



	* pthread.h (SIG_BLOCK): Define if not already defined.

	(SIG_UNBLOCK): Likewise.

	(SIG_SETMASK): Likewise.

	(pthread_attr_t): Add signal mask member.

	(pthread_sigmask): Add function prototype.



	* signal.c (pthread_sigmask): Implement.



	* create.c: #include <string.h> to get a prototype for memcpy().

	(pthread_create): New threads inherit their creator's signal

	mask.  Copy the signal mask to the new thread structure if we know

	about signals.

	

Fri Jul 24 16:33:17 1998  Ross Johnson  <rpj at swan.canberra.edu.au>



	* fork.c (pthread_atfork): Add all the necessary push calls.

	Local implementation semantics:

	If we get an ENOMEM at any time then ALL handlers

	(including those from previous pthread_atfork() calls) will be

	popped off each of the three atfork stacks before we return.

	(fork): Add all the necessary pop calls. Add the thread cancellation

	and join calls to the child fork.

	Add #includes.



	* implement.h: (ptw32_handler_push): Fix return type and stack arg

	type in prototype.

	(ptw32_handler_pop): Fix stack arg type in prototype.

	(ptw32_handler_pop_all): Fix stack arg type in prototype.



	* cleanup.c (ptw32_handler_push): Change return type to int and

	return ENOMEM if malloc() fails.



	* sync.c (pthread_detach): Use equality test, not assignment.



	* create.c (ptw32_start_call): Add call to Win32 CloseHandle()

	if thread is detached.



1998-07-24  Ben Elliston  <bje at cygnus.com>



	* sync.c (pthread_detach): Close the Win32 thread handle to

	emulate detached (or daemon) threads.



Fri Jul 24 03:00:25 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c (pthread_join): Save valueptr arg in joinvalueptr for

	pthread_exit() to use.



	* private.c (ptw32_new_thread_entry): Initialise joinvalueptr to

	NULL.



	* create.c (ptw32_start_call): Rewrite to facilitate joins.

	pthread_exit() will do a longjmp() back to here. Does appropriate

	cleanup and exit/return from the thread.

	(pthread_create): _beginthreadex() now passes a pointer to our

	thread table entry instead of just the call member of that entry.



	* implement.h (ptw32_threads_thread): New member 

	void ** joinvalueptr.

	(ptw32_call_t): New member jmpbuf env.



	* exit.c (pthread_exit): Major rewrite to handle joins and handing

	value pointer to joining thread. Uses longjmp() back to 

	ptw32_start_call().



	* create.c (pthread_create): Ensure values of new attribute members

	are copied to the thread attribute object.



	* attr.c (pthread_attr_destroy):  Fix merge conflicts.

	(pthread_attr_getdetachstate):  Fix merge conflicts.

	(pthread_attr_setdetachstate):  Fix merge conflicts.



	* pthread.h:  Fix merge conflicts.



	* sync.c (pthread_join): Fix merge conflicts.



Fri Jul 24 00:21:21 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* sync.c (pthread_join): Add check for valid and joinable

	thread.

	(pthread_detach): Implement. After checking for a valid and joinable

	thread, it's still a no-op.



	* private.c (ptw32_find_thread_entry): Bug prevented returning

	an error value in some cases.



	* attr.c (pthread_attr_setdetachedstate): Implement.

	(pthread_attr_getdetachedstate): Implement.



	* implement.h: Move more hidden definitions into here from

	pthread.h.



1998-07-24  Ben Elliston  <bje at cygnus.com>



	* pthread.h (PTHREAD_CREATE_JOINABLE): Define.

	(PTHREAD_CREATE_DETACHED): Likewise.

	(pthread_attr_t): Add new structure member `detached'.

	(pthread_attr_getdetachstate): Add function prototype.

	(pthread_attr_setdetachstate): Likewise.



	* sync.c (pthread_join): Return if the target thread is detached.



	* attr.c (pthread_attr_init): Initialise cancelability and

	canceltype structure members.

	(pthread_attr_getdetachstate): Implement.

	(pthread_attr_setdetachstate): Likewise.



	* implement.h (PTW32_CANCEL_DEFAULTS): Remove.  Bit fields

	proved to be too cumbersome.  Set the defaults in attr.c using the

	public PTHREAD_CANCEL_* constants.



	* cancel.c: New file.



	* pthread.h (sched_param): Define this type.

	(pthread_attr_getschedparam): Add function prototype.

	(pthread_attr_setschedparam): Likewise.

	(pthread_setcancelstate): Likewise.

	(pthread_setcanceltype): Likewise.

	(sched_get_priority_min): Likewise.

	(sched_get_priority_max): Likewise.

	(pthread_mutexattr_setprotocol): Remove; not supported.

	(pthread_mutexattr_getprotocol): Likewise.

	(pthread_mutexattr_setprioceiling): Likewise.

	(pthread_mutexattr_getprioceiling): Likewise.

	(pthread_attr_t): Add canceltype member.  Update comments.

	(SCHED_OTHER): Define this scheduling policy constant.

	(SCHED_FIFO): Likewise.

	(SCHED_RR): Likewise.

	(SCHED_MIN): Define the lowest possible value for this constant.

	(SCHED_MAX): Likewise, the maximum possible value.

	(PTHREAD_CANCEL_ASYNCHRONOUS): Redefine.

	(PTHREAD_CANCEL_DEFERRED): Likewise.

	

	* sched.c: New file.

	(pthread_setschedparam): Implement.

	(pthread_getschedparam): Implement.

	(sched_get_priority_max): Validate policy argument.

	(sched_get_priority_min): Likewise.



	* mutex.c (pthread_mutexattr_setprotocol): Remove; not supported.

	(pthread_mutexattr_getprotocol): Likewise.

	(pthread_mutexattr_setprioceiling): Likewise.

	(pthread_mutexattr_getprioceiling): Likewise.



Fri Jul 24 00:21:21 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* create.c (pthread_create): Arg to ptw32_new_thread_entry()

	changed. See next entry. Move mutex locks out. Changes made yesterday

	and today allow us to start the new thread running rather than

	temporarily suspended.



	* private.c (ptw32_new_thread_entry): ptw32_thread_table

	was changed back to a table of thread structures rather than pointers.

	As such we're trading storage for increaded speed. This routine

	was modified to work with the new table. Mutex lock put in around

	global data accesses.

	(ptw32_find_thread_entry): Ditto

	(ptw32_delete_thread_entry): Ditto



Thu Jul 23 23:25:30 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* global.c: New. Global data objects declared here. These moved from

	pthread.h.



	* pthread.h: Move implementation hidden definitions into

	implement.h.



	* implement.h: Move implementation hidden definitions from

	pthread.h. Add constants to index into the different handler stacks.



	* cleanup.c (ptw32_handler_push): Simplify args. Restructure.

	(ptw32_handler_pop): Simplify args. Restructure.

	(ptw32_handler_pop_all): Simplify args. Restructure.



Wed Jul 22 00:16:22 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* attr.c, implement.h, pthread.h, ChangeLog: Resolve CVS merge

	conflicts.



	* private.c (ptw32_find_thread_entry): Changes to return type

	to support leaner ptw32_threads_table[] which now only stores

	ptw32_thread_thread_t *.

	(ptw32_new_thread_entry): Internal changes.

	(ptw32_delete_thread_entry): Internal changes to avoid contention.

 	Calling routines changed accordingly.



	* pthread.h: Modified cleanup macros to use new generic push and pop.

	Added destructor and atfork stacks to ptw32_threads_thread_t.



	* cleanup.c (ptw32_handler_push, ptw32_handler_pop,

	ptw32_handler_pop_all): Renamed cleanup push and pop routines

	and made generic to handle destructors and atfork handlers as

	well.



	* create.c (ptw32_start_call): New function is a wrapper for

	all new threads. It allows us to do some cleanup when the thread

	returns, ie. that is otherwise only done if the thread is cancelled.



	* exit.c (ptw32_vacuum): New function contains code from 

	pthread_exit() that we need in the new ptw32_start_call()

	as well.



	* implement.h: Various additions and minor changes.



	* pthread.h: Various additions and minor changes.

	Change cleanup handler macros to use generic handler push and pop

	functions.



	* attr.c: Minor mods to all functions.

	(is_attr): Implemented missing function.



	* create.c (pthread_create): More clean up.



	* private.c (ptw32_find_thread_entry): Implement.

	(ptw32_delete_thread_entry): Implement.

	(ptw32_new_thread_entry): Implement.

	These functions manipulate the implementations internal thread

	table and are part of general code cleanup and modularisation.

	They replace ptw32_getthreadindex() which was removed.



	* exit.c (pthread_exit): Changed to use the new code above.



	* pthread.h: Add cancelability constants. Update comments.



1998-07-22  Ben Elliston  <bje at cygnus.com>



	* attr.c (pthread_setstacksize): Update test of attr argument.

	(pthread_getstacksize): Likewise.

	(pthread_setstackaddr): Likewise.

	(pthread_getstackaddr): Likewise.

	(pthread_attr_init): No need to allocate any storage.

	(pthread_attr_destroy): No need to free any storage.



	* mutex.c (is_attr): Not likely to be needed; remove.

	(remove_attr): Likewise.

	(insert_attr): Likewise.



	* implement.h (ptw32_mutexattr_t): Moved to a public definition

	in pthread.h.  There was little gain in hiding these details.

	(ptw32_condattr_t): Likewise.

	(ptw32_attr_t): Likewise.



	* pthread.h (pthread_atfork): Add function prototype.

	(pthread_attr_t): Moved here from implement.h.



	* fork.c (pthread_atfork): Preliminary implementation.

	(ptw32_fork): Likewise.



Wed Jul 22 00:16:22 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* cleanup.c (ptw32_cleanup_push): Implement.

	(ptw32_cleanup_pop): Implement.

	(ptw32_do_cancellation): Implement.

	These are private to the implementation. The real cleanup functions

	are macros. See below.



	* pthread.h (pthread_cleanup_push): Implement as a macro.

	(pthread_cleanup_pop): Implement as a macro.

	Because these are macros which start and end a block, the POSIX scoping

	requirement is observed. See the comment in the file.



	* exit.c (pthread_exit): Refine the code.



	* create.c (pthread_create): Code cleanup.



	* implement.h (RND_SIZEOF): Add RND_SIZEOF(T) to round sizeof(T)

	up to multiple of DWORD.

	Add function prototypes.



	* private.c (ptw32_getthreadindex): "*thread" should have been 

	"thread". Detect empty slot fail condition.



1998-07-20  Ben Elliston  <bje at cygnus.com>



	* misc.c (pthread_once): Implement.  Don't use a per-application

	flag and mutex--make `pthread_once_t' contain these elements in

	their structure.  The earlier version had incorrect semantics.

	

	* pthread.h (ptw32_once_flag): Add new variable.  Remove.

	(ptw32_once_lock): Add new mutex lock to ensure integrity of

	access to ptw32_once_flag.  Remove.

	(pthread_once): Add function prototype.

	(pthread_once_t): Define this type.

	

Mon Jul 20 02:31:05 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* private.c (ptw32_getthreadindex): Implement.



	* pthread.h: Add application static data dependent on

	_PTHREADS_BUILD_DLL define. This is needed to avoid allocating

	non-sharable static data within the pthread DLL.



	* implement.h: Add ptw32_cleanup_stack_t, ptw32_cleanup_node_t

	and PTW32_HASH_INDEX.



	* exit.c (pthread_exit): Begin work on cleanup and de-allocate

	thread-private storage.



	* create.c (pthread_create): Add thread to thread table.

	Keep a thread-private copy of the attributes with default values

	filled in when necessary. Same for the cleanup stack. Make 

	pthread_create C run-time library friendly by using _beginthreadex()

	instead of CreateThread(). Fix error returns.



Sun Jul 19 16:26:23 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Rename pthreads_thread_count to ptw32_threads_count.

	Create ptw32_threads_thread_t struct to keep thread specific data.



	* create.c: Rename pthreads_thread_count to ptw32_threads_count.

	(pthread_create): Handle errors from CreateThread().



1998-07-19  Ben Elliston  <bje at cygnus.com>



	* condvar.c (pthread_cond_wait): Generalise.  Moved from here ..

	(cond_wait): To here.

	(pthread_cond_timedwait): Implement; use generalised cond_wait().



	* pthread.h (pthread_key_t): Define this type.

	(pthread_key_create): Add function prototype.

	(pthread_setspecific): Likewise.

	(pthread_getspecific): Likwise.

	(pthread_key_delete): Likewise.



	* tsd.c (pthread_key_create): Implement.

	(pthread_setspecific): Likewise.

	(pthread_getspecific): Likewise.

	(pthread_key_delete): Likewise.



	* mutex.c (pthread_mutex_trylock): Return ENOSYS if this function

	is called on a Win32 platform which is not Windows NT.



1998-07-18  Ben Elliston  <bje at cygnus.com>



	* condvar.c (pthread_condattr_init): Do not attempt to malloc any

	storage; none is needed now that condattr_t is an empty struct.

	(pthread_condattr_destory): Likewise; do not free storage.

	(pthread_condattr_setpshared): No longer supported; return ENOSYS.

	(pthread_condattr_getpshared): Likewise.

	(pthread_cond_init): Implement with help from Douglas Schmidt.

	Remember to initialise the cv's internal mutex.

	(pthread_cond_wait): Likewise.

	(pthread_cond_signal): Likewise.

	(pthread_cond_broadcast): Likewise.

	(pthread_cond_timedwait): Preliminary implementation, but I need

	to see some API documentation for `WaitForMultipleObject'.

	(pthread_destory): Implement.



	* pthread.h (pthread_cond_init): Add function protoype.

	(pthread_cond_broadcast): Likewise.

	(pthread_cond_signal): Likewise.

	(pthread_cond_timedwait): Likewise.

	(pthread_cond_wait): Likewise.

	(pthread_cond_destroy): Likewise.

	(pthread_cond_t): Define this type.  Fix for u_int.  Do not assume

	that the mutex contained withing the pthread_cond_t structure will

	be a critical section.  Use our new POSIX type!



	* implement.h (ptw32_condattr_t): Remove shared attribute.



1998-07-17  Ben Elliston  <bje at cygnus.com>



	* pthread.h (PTHREADS_PROCESS_PRIVATE): Remove.

	(PTHREAD_PROCESS_SHARED): Likewise.  No support for mutexes shared

	across processes for now.

	(pthread_mutex_t): Use a Win32 CRITICAL_SECTION type for better

	performance.

	

	* implement.h (ptw32_mutexattr_t): Remove shared attribute.

	

	* mutex.c (pthread_mutexattr_setpshared): This optional function

	is no longer supported, since we want to implement POSIX mutex

	variables using the much more efficient Win32 critical section

	primitives.  Critical section objects in Win32 cannot be shared

	between processes.

	(pthread_mutexattr_getpshared): Likewise.

	(pthread_mutexattr_init): No need to malloc any storage; the

	attributes structure is now empty.

	(pthread_mutexattr_destroy): This is now a nop.

	(pthread_mutex_init): Use InitializeCriticalSection().

	(pthread_mutex_destroy): Use DeleteCriticalSection().

	(pthread_mutex_lock): Use EnterCriticalSection().

	(pthread_mutex_trylock): Use TryEnterCriticalSection().  This is

	not supported by Windows 9x, but trylock is a hack anyway, IMHO.

	(pthread_mutex_unlock): Use LeaveCriticalSection().



1998-07-14  Ben Elliston  <bje at cygnus.com>



	* attr.c (pthread_attr_setstacksize): Implement.

	(pthread_attr_getstacksize): Likewise.

	(pthread_attr_setstackaddr): Likewise.

	(pthread_attr_getstackaddr): Likewise.

	(pthread_attr_init): Likewise.

	(pthread_attr_destroy): Likewise.

	

	* condvar.c (pthread_condattr_init): Add `_cond' to function name.



	* mutex.c (pthread_mutex_lock): Add `_mutex' to function name.

	(pthread_mutex_trylock): Likewise.

	(pthread_mutex_unlock): Likewise.



	* pthread.h (pthread_condattr_setpshared): Fix typo.

	(pthread_attr_init): Add function prototype.

	(pthread_attr_destroy): Likewise.

	(pthread_attr_setstacksize): Likewise.

	(pthread_attr_getstacksize): Likewise.

	(pthread_attr_setstackaddr): Likewise.

	(pthread_attr_getstackaddr): Likewise.

	

Mon Jul 13 01:09:55 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Wrap in #ifndef _IMPLEMENT_H



	* create.c (pthread_create): Map stacksize attr to Win32.



	* mutex.c: Include implement.h



1998-07-13  Ben Elliston  <bje at cygnus.com>



	* condvar.c (pthread_condattr_init): Implement.

	(pthread_condattr_destroy): Likewise.

	(pthread_condattr_setpshared): Likewise.

	(pthread_condattr_getpshared): Likewise.

	

	* implement.h (PTHREAD_THREADS_MAX): Remove trailing semicolon.

	(PTHREAD_STACK_MIN): Specify; needs confirming.

	(ptw32_attr_t): Define this type.

	(ptw32_condattr_t): Likewise.



	* pthread.h (pthread_mutex_t): Define this type.

	(pthread_condattr_t): Likewise.

	(pthread_mutex_destroy): Add function prototype.

	(pthread_lock): Likewise.

	(pthread_trylock): Likewise.

	(pthread_unlock): Likewise.

	(pthread_condattr_init): Likewise.

	(pthread_condattr_destroy): Likewise.

	(pthread_condattr_setpshared): Likewise.

	(pthread_condattr_getpshared): Likewise.



	* mutex.c (pthread_mutex_init): Implement.

	(pthread_mutex_destroy): Likewise.

	(pthread_lock): Likewise.

	(pthread_trylock): Likewise.

	(pthread_unlock): Likewise.



1998-07-12  Ben Elliston  <bje at cygnus.com>



	* implement.h (ptw32_mutexattr_t): Define this implementation

	internal type.  Application programmers only see a mutex attribute

	object as a void pointer.



	* pthread.h (pthread_mutexattr_t): Define this type.

	(pthread_mutexattr_init): Add function prototype.

	(pthread_mutexattr_destroy): Likewise.

	(pthread_mutexattr_setpshared): Likewise.

	(pthread_mutexattr_getpshared): Likewise.

	(pthread_mutexattr_setprotocol): Likewise.

	(pthread_mutexattr_getprotocol): Likewise.

	(pthread_mutexattr_setprioceiling): Likewise.

	(pthread_mutexattr_getprioceiling): Likewise.

	(PTHREAD_PROCESS_PRIVATE): Define.

	(PTHREAD_PROCESS_SHARED): Define.



	* mutex.c (pthread_mutexattr_init): Implement.

	(pthread_mutexattr_destroy): Implement.

	(pthread_mutexattr_setprotocol): Implement.

	(pthread_mutexattr_getprotocol): Likewise.

	(pthread_mutexattr_setprioceiling): Likewise.

	(pthread_mutexattr_getprioceiling): Likewise.

	(pthread_mutexattr_setpshared): Likewise.

	(pthread_mutexattr_getpshared): Likewise.

	(insert_attr): New function; very preliminary implementation!

	(is_attr): Likewise.

	(remove_attr): Likewise.

	

Sat Jul 11 14:48:54 1998  Ross Johnson  <rpj at ixobrychus.canberra.edu.au>



	* implement.h: Preliminary implementation specific defines.



	* create.c (pthread_create): Preliminary implementation.



1998-07-11  Ben Elliston  <bje at cygnus.com>



	* sync.c (pthread_join): Implement.



	* misc.c (pthread_equal): Likewise.

	

	* pthread.h (pthread_join): Add function prototype.

	(pthread_equal): Likewise.

	

1998-07-10  Ben Elliston  <bje at cygnus.com>



	* misc.c (pthread_self): Implement.



	* exit.c (pthread_exit): Implement.



	* pthread.h (pthread_exit): Add function prototype.

	(pthread_self): Likewise.

	(pthread_t): Define this type.



1998-07-09  Ben Elliston  <bje at cygnus.com>



	* create.c (pthread_create): A dummy stub right now.



	* pthread.h (pthread_create): Add function prototype.