Game Programming - All in One (3rd Edition)/game_prog_all_in_one_3rd_ed.iso/pthread/docs/ChangeLog

Text File | 2003-09-14 | 147.1 KB | 4,093 lines

2003-09-14  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * w32_cancelableWait.c (ptw32_cancelable_wait): Allow cancelation
    of implicit POSIX threads as well.

2003-09-02  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

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

2003-06-22  Nicolas Barry  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

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

2003-03-04  Alexander Terekhov  <[e-mail]>

    * 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 <[e-mail]>

2002-12-17  Thomas Pfaff  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * pthread_cond_destroy.c (pthread_cond_destroy):
    Enter the time change critical section earlier.

2002-02-17  Ross Johnson  <[e-mail]

    * 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  <[e-mail]

    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  <[e-mail]

    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  <[e-mail]

    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<[e-mail]>

    * nonportable.c (pthread_delay_np): Make a true
    cancelation point. Deferred cancels will interrupt the
    wait.

2002-02-07  Ross Johnson  <[e-mail]

    * 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 <[e-mail]>

    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  <[e-mail]>

    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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * attr.c (pthread_attr_setscope): Fix struct pointer
    indirection error introduced 2002-01-04.
    (pthread_attr_getscope): Likewise.

2002-01-12  Ross Johnson  <[e-mail]>

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

2002-01-08  Ross Johnson  <[e-mail]>

    * 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 <[e-mail]>, Alexander Terekhov <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * mutex.c (pthread_mutex_lock): Decrementing lock_idx was
    not thread-safe.
    (pthread_mutex_trylock): Likewise.

2001-10-26  [e-mail]

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * spin.c (pthread_spin_unlock): Was not returning
    EPERM if the spinlock was not locked, for multi CPU
    machines.

2001-10-08  Ross Johnson  <[e-mail]>

    * spin.c (pthread_spin_trylock): Was not returning
    EBUSY for multi CPU machines.

2001-08-24  Ross Johnson  <[e-mail]>

    * condvar.c (pthread_cond_destroy): Remove cv element
    that is no longer used.
    * implement.h: Likewise.

2001-08-23  Alexander Terekhov <[e-mail]>

    * 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. <[e-mail]>

    * tsd.c (pthread_getspecific): Preserve the last
    winsock error [from WSAGetLastError()].

2001-07-18  Scott McCaskill <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * pthread.h (_POSIX_READER_WRITER_LOCKS): Define it
    if not already defined.

2001-07-01  Alexander Terekhov <[e-mail]>

    * condvar.c: Fixed lost signal bug reported by Timur Aydin
    ([e-mail]).
    [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  <[e-mail]>

    * 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  <[e-mail]>

    *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 <[e-mail]>

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

2001-06-18  Ross Johnson  <[e-mail]>

    * 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 <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * mutex.c (pthread_mutexattr_init): Remove
    ptw32_mutex_default_kind.

2001-06-05  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * condvar.c: Add original description of the algorithm as
    developed by Terekhov and Thomas, plus reference to
    README.CV.

2001-06-03  Alexander Terekhov <[e-mail]>, Louis Thomas <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * FAQ: Update Answer 6 re getting a fully working
    Mingw32 built library.

2000-10-10  Steven Reddie <[e-mail]>

        * misc.c (pthread_self): Restore Win32 "last error"
        cleared by TlsGetValue() call in
        pthread_getspecific()

2000-09-20  Arthur Kantor <[e-mail]>

        * 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 <[e-mail]>

    * 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  <[e-mail]>

    * pthread.h (ctime_r): Fix arg.

2000-09-08  Ross Johnson  <[e-mail]>

    * 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 <[e-mail]>
    (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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

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

2000-08-05  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * sched.c (sched_get_priority_max): Handle different WinCE and
    Win32 priority values together.
    (sched_get_priority_min): Ditto.

2000-07-25  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * FAQ: Added Q5 and Q6.

2000-07-21  David Baggett <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * Makefile: Remove inconsistencies in 'cl' args

2000-01-04  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>, Erik Hensema <[e-mail]>

    * 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 <[e-mail]>

    * 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 ([e-mail]>

    * misc.c (pthread_self): Add a note about GetCurrentThread
    returning a pseudo-handle

1999-11-10  Todd Owen <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>

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

1999-10-21  Aurelio Medina <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>, Peter Slacik <[e-mail]>

    * 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 <[e-mail]>

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

Thu Sep 16 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * mutex.c (pthread_mutex_destroy): Free mutex memory.

1999-08-22  Ross Johnson  <[e-mail]>

    * exit.c (pthread_exit): Fix reference to potentially
    uninitialised pointer.

1999-08-21  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * private.c (ptw32_threadStart): Return exit status from
    the application thread startup routine.
    - Milan Gardian <[e-mail]>

1999-08-18  John Bossom <[e-mail]>

    * 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  <[e-mail]>

        * 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  <[e-mail]>

        * 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  <[e-mail]>

    * exit.c (pthread_exit): Don't call pthread_self() but
    get thread handle directly from TSD for efficiency.

1999-08-12  Ross Johnson  <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>, John Bossom <[e-mail]>

    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  <[e-mail]>

    * 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  <[e-mail]>

    * semaphore.h (mode_t): Conditionally typedef it.

Fri May 28 13:33:05 1999  Mark E. Armstrong <[e-mail]>

    * condvar.c (pthread_cond_broadcast): Fix possible memory fault

Thu May 27 13:08:46 1999  Peter Slacik <[e-mail]>

    * condvar.c (pthread_cond_broadcast): Fix logic bug

Thu May 27 13:08:46 1999  Bossom, John <[e-mail]>

    * condvar.c (pthread_cond_broadcast): optimise sem_post loop

Fri May 14 12:13:18 1999  Mike Russo <[e-mail]>

    * attr.c (pthread_attr_setdetachstate): Fix logic bug

Sat May  8 09:42:30 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * errno.c (_REENTRANT || _MT): Invert condition.

    * pthread.h (_errno): Conditionally include prototype.

Wed Apr  7 09:37:00 1999  Ross Johnson  <[e-mail]>

    * *.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  <[e-mail]>

    * 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  <[e-mail]>

    * Makefile.in (OBJS): Add errno.o.

Fri Apr  2 11:08:50 1999  Ross Johnson  <[e-mail]>

    * 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 <[e-mail]>

    * 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 <[e-mail]>

    * semaphore.c (ptw32_sem_timedwait): Check for negative
    milliseconds.

Wed Mar 24 11:32:07 1999  John Bossom <[e-mail]>

    * 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  <[e-mail]>

    * cancel.c (comments): Update and cleanup.

Fri Mar 19 09:12:59 1999  Ross Johnson  <[e-mail]>

    * private.c (ptw32_threadStart): status returns PTHREAD_CANCELED.

    * pthread.h (PTHREAD_CANCELED): defined.

Tue Mar 16  1999  Ross Johnson  <[e-mail]>

    * all: Add GNU LGPL and Copyright and Warranty.

Mon Mar 15 00:20:13 1999  Ross Johnson  <[e-mail]>

    * condvar.c (pthread_cond_init): fix possible uninitialised use
    of cv.

Sun Mar 14 21:01:59 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * misc.c (CancelableWait): Undo changes from Mar 8 and 7.

Mon Mar  8 11:18:59 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * implement.h: Undate comments.

Sun Feb 21 1999  Ross Johnson  <[e-mail]>

    * pthread.h (PTHREAD_MUTEX_INITIALIZER): missing braces around
    cs element initialiser.

1999-02-21  Ben Elliston  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * configure: Various temporary changes.
    - Kevin Ruland <[e-mail]>

    * README: Update.

    * pthread.def (pthread_attr_getstackaddr): uncomment
    (pthread_attr_setstackaddr): uncomment

Fri Feb  5 13:42:30 1999  Ross Johnson  <[e-mail]>

    * semaphore.c: Comment format changes.

Thu Feb  4 10:07:28 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * sync.c (pthread_join): Check for NULL value_ptr arg;
    check for detached threads.

Tue Feb  2 18:07:43 1999  Ross Johnson  <[e-mail]>

    * implement.h: Add #include <pthread.h>.
    Change sem_t to ptw32_sem_t.

Tue Feb  2 18:07:43 1999  Kevin Ruland <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * semaphore.c (sem_wait): Remove second arg to
    pthreadCancelableWait() call.

Sat Jan 23 17:36:40 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * condvar.c (cond_timedwait): Remove comment.

Fri Jan 15 15:41:28 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * build.bat: Delete old binaries before compiling/linking.

Tue Jan 12 09:58:38 1999  Tor Lillqvist <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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 <[e-mail]>

    * condvar.c (pthread_cond_init): Invert logic when testing the
    return value from calloc().

Sat Jan  9 14:32:08 1999  Ross Johnson  <[e-mail]>

    * implement.h: Compile-time switch for CYGWIN derived environments
    to use CreateThread instead of _beginthreadex. Ditto for ExitThread.
    Patch provided by Anders Norlander  <[e-mail]>.

Tue Jan  5 16:33:04 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * README: Update info about subscribing to the mailing list.

Mon Jan  4 11:23:40 1999  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * README: Correct cygwin32 compatibility statement.

Sun Nov 15 21:24:06 1998  Ross Johnson  <[e-mail]>

    * cleanup.c (ptw32_destructor_run_all): Declare missing void * arg.
    Fixup CVS merge conflicts.

1998-10-30  Ben Elliston  <[e-mail]>

    * condvar.c (cond_wait): Fix semantic error. Test for equality
    instead of making an assignment.

Fri Oct 30 15:15:50 1998  Ross Johnson  <[e-mail]>

    * cleanup.c (ptw32_handler_push): Fixed bug appending new
    handler to list reported by Peter Slacik
    <[e-mail]>.
    (new_thread): Rename poorly named local variable to
    "new_handler".

Sat Oct 24 18:34:59 1998  Ross Johnson  <[e-mail]>

    * global.c: Add TSD key management array and index declarations.

    * implement.h: Ditto for externs.

Fri Oct 23 00:08:09 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * cleanup.c (ptw32_destructor_run_all): Fix and improve
    stepping through the key table.

Thu Oct 15 14:05:01 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * condvar.c (cond_wait): Use POSIX, not Win32 mutex calls.
    (pthread_cond_broadcast): Likewise.
    (pthread_cond_signal): Likewise.

1998-10-05  Ben Elliston  <[e-mail]>

    * 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  <[e-mail]>

    * pthread.def: New file for building the DLL.

1998-10-05  Ben Elliston  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * COPYING: Remove.

    * COPYING.LIB: Add. This library is under the LGPL.

1998-09-13  Ben Elliston  <[e-mail]>

    * 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  <[e-mail]>

    * windows.h: No longer needed; remove.

    * windows.c: Likewise.

Sat Sep 12 20:09:24 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * {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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * fork.c (fork): Autoconfiscate.

Sat Jul 25 00:00:13 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * pthread.h (pthread_condattr_t): Rename dummy structure member.
    (pthread_mutexattr_t): Likewise.

Fri Jul 24 21:13:55 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * sync.c (pthread_detach): Close the Win32 thread handle to
    emulate detached (or daemon) threads.

Fri Jul 24 03:00:25 1998  Ross Johnson  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * implement.h: Preliminary implementation specific defines.

    * create.c (pthread_create): Preliminary implementation.

1998-07-11  Ben Elliston  <[e-mail]>

    * 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  <[e-mail]>

    * 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  <[e-mail]>

    * create.c (pthread_create): A dummy stub right now.

    * pthread.h (pthread_create): Add function prototype.