My Project: dynamics.mod/NewtonDynamics/source/pthreads.2/pthread.h Source File

My Project

pthread.h
Go to the documentation of this file.
1 /* This is an implementation of the threads API of POSIX 1003.1-2001.
2 *
3 * --------------------------------------------------------------------------
4 *
5 * Pthreads-win32 - POSIX Threads Library for Win32
6 * Copyright(C) 1998 John E. Bossom
7 * Copyright(C) 1999,2005 Pthreads-win32 contributors
8 *
9 * Contact Email: rpj@callisto.canberra.edu.au
10 *
11 * The current list of contributors is contained
12 * in the file CONTRIBUTORS included with the source
13 * code distribution. The list can also be seen at the
14 * following World Wide Web location:
15 * http://sources.redhat.com/pthreads-win32/contributors.html
16 *
17 * This library is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License as published by the Free Software Foundation; either
20 * version 2 of the License, or (at your option) any later version.
21 *
22 * This library is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * Lesser General Public License for more details.
26 *
27 * You should have received a copy of the GNU Lesser General Public
28 * License along with this library in the file COPYING.LIB;
29 * if not, write to the Free Software Foundation, Inc.,
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
31 */
32
33 #if !defined( PTHREAD_H )
34 #define PTHREAD_H
35
36 /*
37 * See the README file for an explanation of the pthreads-win32 version
38 * numbering scheme and how the DLL is named etc.
39 */
40 #define PTW32_VERSION 2,9,1,0
41 #define PTW32_VERSION_STRING "2, 9, 1, 0\0"
42
43 /* There are three implementations of cancel cleanup.
44 * Note that pthread.h is included in both application
45 * compilation units and also internally for the library.
46 * The code here and within the library aims to work
47 * for all reasonable combinations of environments.
48 *
49 * The three implementations are:
50 *
51 * WIN32 SEH
52 * C
53 * C++
54 *
55 * Please note that exiting a push/pop block via
56 * "return", "exit", "break", or "continue" will
57 * lead to different behaviour amongst applications
58 * depending upon whether the library was built
59 * using SEH, C++, or C. For example, a library built
60 * with SEH will call the cleanup routine, while both
61 * C++ and C built versions will not.
62 */
63
64 /*
65 * Define defaults for cleanup code.
66 * Note: Unless the build explicitly defines one of the following, then
67 * we default to standard C style cleanup. This style uses setjmp/longjmp
68 * in the cancelation and thread exit implementations and therefore won't
69 * do stack unwinding if linked to applications that have it (e.g.
70 * C++ apps). This is currently consistent with most/all commercial Unix
71 * POSIX threads implementations.
72 */
73 #if !defined( __CLEANUP_SEH ) && !defined( __CLEANUP_CXX ) && !defined( __CLEANUP_C )
74 # define __CLEANUP_C
75 #endif
76
77 #if defined( __CLEANUP_SEH ) && ( !defined( _MSC_VER ) && !defined(PTW32_RC_MSC))
78 #error ERROR [__FILE__, line __LINE__]: SEH is not supported for this compiler.
79 #endif
80
81 /*
82 * Stop here if we are being included by the resource compiler.
83 */
84 #if !defined(RC_INVOKED)
85
86 #undef PTW32_LEVEL
87
88 #if defined(_POSIX_SOURCE)
89 #define PTW32_LEVEL 0
90 /* Early POSIX */
91 #endif
92
93 #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
94 #undef PTW32_LEVEL
95 #define PTW32_LEVEL 1
96 /* Include 1b, 1c and 1d */
97 #endif
98
99 #if defined(INCLUDE_NP)
100 #undef PTW32_LEVEL
101 #define PTW32_LEVEL 2
102 /* Include Non-Portable extensions */
103 #endif
104
105 #define PTW32_LEVEL_MAX 3
106
107 #if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_LEVEL)
108 #define PTW32_LEVEL PTW32_LEVEL_MAX
109 /* Include everything */
110 #endif
111
112 #if defined(_UWIN)
113 # define HAVE_STRUCT_TIMESPEC 1
114 # define HAVE_SIGNAL_H 1
115 # undef HAVE_PTW32_CONFIG_H
116 # pragma comment(lib, "pthread")
117 #endif
118
119 /*
120 * -------------------------------------------------------------
121 *
122 *
123 * Module: pthread.h
124 *
125 * Purpose:
126 * Provides an implementation of PThreads based upon the
127 * standard:
128 *
129 * POSIX 1003.1-2001
130 * and
131 * The Single Unix Specification version 3
132 *
133 * (these two are equivalent)
134 *
135 * in order to enhance code portability between Windows,
136 * various commercial Unix implementations, and Linux.
137 *
138 * See the ANNOUNCE file for a full list of conforming
139 * routines and defined constants, and a list of missing
140 * routines and constants not defined in this implementation.
141 *
142 * Authors:
143 * There have been many contributors to this library.
144 * The initial implementation was contributed by
145 * John Bossom, and several others have provided major
146 * sections or revisions of parts of the implementation.
147 * Often significant effort has been contributed to
148 * find and fix important bugs and other problems to
149 * improve the reliability of the library, which sometimes
150 * is not reflected in the amount of code which changed as
151 * result.
152 * As much as possible, the contributors are acknowledged
153 * in the ChangeLog file in the source code distribution
154 * where their changes are noted in detail.
155 *
156 * Contributors are listed in the CONTRIBUTORS file.
157 *
158 * As usual, all bouquets go to the contributors, and all
159 * brickbats go to the project maintainer.
160 *
161 * Maintainer:
162 * The code base for this project is coordinated and
163 * eventually pre-tested, packaged, and made available by
164 *
165 * Ross Johnson <rpj@callisto.canberra.edu.au>
166 *
167 * QA Testers:
168 * Ultimately, the library is tested in the real world by
169 * a host of competent and demanding scientists and
170 * engineers who report bugs and/or provide solutions
171 * which are then fixed or incorporated into subsequent
172 * versions of the library. Each time a bug is fixed, a
173 * test case is written to prove the fix and ensure
174 * that later changes to the code don't reintroduce the
175 * same error. The number of test cases is slowly growing
176 * and therefore so is the code reliability.
177 *
178 * Compliance:
179 * See the file ANNOUNCE for the list of implemented
180 * and not-implemented routines and defined options.
181 * Of course, these are all defined is this file as well.
182 *
183 * Web site:
184 * The source code and other information about this library
185 * are available from
186 *
187 * http://sources.redhat.com/pthreads-win32/
188 *
189 * -------------------------------------------------------------
190 */
191
192 /* Try to avoid including windows.h */
193 #if (defined(__MINGW64__) || defined(__MINGW32__)) && defined(__cplusplus)
194 #define PTW32_INCLUDE_WINDOWS_H
195 #endif
196
197 #if defined(PTW32_INCLUDE_WINDOWS_H)
198 #include <windows.h>
199 #endif
200
201 #if defined(_MSC_VER) && _MSC_VER < 1300 || defined(__DMC__)
202 /*
203 * VC++6.0 or early compiler's header has no DWORD_PTR type.
204 */
205 typedef unsigned long DWORD_PTR;
206 typedef unsigned long ULONG_PTR;
207 #endif
208 /*
209 * -----------------
210 * autoconf switches
211 * -----------------
212 */
213
214 #if defined(HAVE_PTW32_CONFIG_H)
215 #include "config.h"
216 #endif /* HAVE_PTW32_CONFIG_H */
217
218 #if !defined(NEED_FTIME)
219 #include <time.h>
220 #else /* NEED_FTIME */
221 /* use native WIN32 time API */
222 #endif /* NEED_FTIME */
223
224 #if defined(HAVE_SIGNAL_H)
225 #include <signal.h>
226 #endif /* HAVE_SIGNAL_H */
227
228 #include <limits.h>
229
230 /*
231 * Boolean values to make us independent of system includes.
232 */
233 enum {
234 PTW32_FALSE = 0,
235 PTW32_TRUE = (! PTW32_FALSE)
236 };
237
238 /*
239 * This is a duplicate of what is in the autoconf config.h,
240 * which is only used when building the pthread-win32 libraries.
241 */
242
243 #if !defined(PTW32_CONFIG_H)
244 # if defined(WINCE)
245 # define NEED_ERRNO
246 # define NEED_SEM
247 # endif
248 # if defined(__MINGW64__)
249 # define HAVE_STRUCT_TIMESPEC
250 # define HAVE_MODE_T
251 # elif defined(_UWIN) || defined(__MINGW32__)
252 # define HAVE_MODE_T
253 # endif
254 #endif
255
256 /*
257 *
258 */
259
260 #if PTW32_LEVEL >= PTW32_LEVEL_MAX
261 #if defined(NEED_ERRNO)
262 #include "need_errno.h"
263 #else
264 #include <errno.h>
265 #endif
266 #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
267
268 /*
269 * Several systems don't define some error numbers.
270 */
271 #if !defined(ENOTSUP)
272 # define ENOTSUP 48 /* This is the value in Solaris. */
273 #endif
274
275 #if !defined(ETIMEDOUT)
276 # define ETIMEDOUT 10060 /* Same as WSAETIMEDOUT */
277 #endif
278
279 #if !defined(ENOSYS)
280 # define ENOSYS 140 /* Semi-arbitrary value */
281 #endif
282
283 #if !defined(EDEADLK)
284 # if defined(EDEADLOCK)
285 # define EDEADLK EDEADLOCK
286 # else
287 # define EDEADLK 36 /* This is the value in MSVC. */
288 # endif
289 #endif
290
291 /* POSIX 2008 - related to robust mutexes */
292 #if !defined(EOWNERDEAD)
293 # define EOWNERDEAD 43
294 #endif
295 #if !defined(ENOTRECOVERABLE)
296 # define ENOTRECOVERABLE 44
297 #endif
298
299 #include <sched.h>
300
301 /*
302 * To avoid including windows.h we define only those things that we
303 * actually need from it.
304 */
305 #if !defined(PTW32_INCLUDE_WINDOWS_H)
306 #if !defined(HANDLE)
307 # define PTW32__HANDLE_DEF
308 # define HANDLE void *
309 #endif
310 #if !defined(DWORD)
311 # define PTW32__DWORD_DEF
312 # define DWORD unsigned long
313 #endif
314 #endif
315
316 #if !defined(HAVE_STRUCT_TIMESPEC)
317 #define HAVE_STRUCT_TIMESPEC
318 #if !defined(_TIMESPEC_DEFINED)
319 #define _TIMESPEC_DEFINED
320 struct timespec {
321 time_t tv_sec;
322 long tv_nsec;
323 };
324 #endif /* _TIMESPEC_DEFINED */
325 #endif /* HAVE_STRUCT_TIMESPEC */
326
327 #if !defined(SIG_BLOCK)
328 #define SIG_BLOCK 0
329 #endif /* SIG_BLOCK */
330
331 #if !defined(SIG_UNBLOCK)
332 #define SIG_UNBLOCK 1
333 #endif /* SIG_UNBLOCK */
334
335 #if !defined(SIG_SETMASK)
336 #define SIG_SETMASK 2
337 #endif /* SIG_SETMASK */
338
339 #if defined(__cplusplus)
340 extern "C"
341 {
342 #endif /* __cplusplus */
343
344 /*
345 * -------------------------------------------------------------
346 *
347 * POSIX 1003.1-2001 Options
348 * =========================
349 *
350 * Options are normally set in <unistd.h>, which is not provided
351 * with pthreads-win32.
352 *
353 * For conformance with the Single Unix Specification (version 3), all of the
354 * options below are defined, and have a value of either -1 (not supported)
355 * or 200112L (supported).
356 *
357 * These options can neither be left undefined nor have a value of 0, because
358 * either indicates that sysconf(), which is not implemented, may be used at
359 * runtime to check the status of the option.
360 *
361 * _POSIX_THREADS (== 200112L)
362 * If == 200112L, you can use threads
363 *
364 * _POSIX_THREAD_ATTR_STACKSIZE (== 200112L)
365 * If == 200112L, you can control the size of a thread's
366 * stack
367 * pthread_attr_getstacksize
368 * pthread_attr_setstacksize
369 *
370 * _POSIX_THREAD_ATTR_STACKADDR (== -1)
371 * If == 200112L, you can allocate and control a thread's
372 * stack. If not supported, the following functions
373 * will return ENOSYS, indicating they are not
374 * supported:
375 * pthread_attr_getstackaddr
376 * pthread_attr_setstackaddr
377 *
378 * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1)
379 * If == 200112L, you can use realtime scheduling.
380 * This option indicates that the behaviour of some
381 * implemented functions conforms to the additional TPS
382 * requirements in the standard. E.g. rwlocks favour
383 * writers over readers when threads have equal priority.
384 *
385 * _POSIX_THREAD_PRIO_INHERIT (== -1)
386 * If == 200112L, you can create priority inheritance
387 * mutexes.
388 * pthread_mutexattr_getprotocol +
389 * pthread_mutexattr_setprotocol +
390 *
391 * _POSIX_THREAD_PRIO_PROTECT (== -1)
392 * If == 200112L, you can create priority ceiling mutexes
393 * Indicates the availability of:
394 * pthread_mutex_getprioceiling
395 * pthread_mutex_setprioceiling
396 * pthread_mutexattr_getprioceiling
397 * pthread_mutexattr_getprotocol +
398 * pthread_mutexattr_setprioceiling
399 * pthread_mutexattr_setprotocol +
400 *
401 * _POSIX_THREAD_PROCESS_SHARED (== -1)
402 * If set, you can create mutexes and condition
403 * variables that can be shared with another
404 * process.If set, indicates the availability
405 * of:
406 * pthread_mutexattr_getpshared
407 * pthread_mutexattr_setpshared
408 * pthread_condattr_getpshared
409 * pthread_condattr_setpshared
410 *
411 * _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L)
412 * If == 200112L you can use the special *_r library
413 * functions that provide thread-safe behaviour
414 *
415 * _POSIX_READER_WRITER_LOCKS (== 200112L)
416 * If == 200112L, you can use read/write locks
417 *
418 * _POSIX_SPIN_LOCKS (== 200112L)
419 * If == 200112L, you can use spin locks
420 *
421 * _POSIX_BARRIERS (== 200112L)
422 * If == 200112L, you can use barriers
423 *
424 * + These functions provide both 'inherit' and/or
425 * 'protect' protocol, based upon these macro
426 * settings.
427 *
428 * -------------------------------------------------------------
429 */
430
431 /*
432 * POSIX Options
433 */
434 #undef _POSIX_THREADS
435 #define _POSIX_THREADS 200809L
436
437 #undef _POSIX_READER_WRITER_LOCKS
438 #define _POSIX_READER_WRITER_LOCKS 200809L
439
440 #undef _POSIX_SPIN_LOCKS
441 #define _POSIX_SPIN_LOCKS 200809L
442
443 #undef _POSIX_BARRIERS
444 #define _POSIX_BARRIERS 200809L
445
446 #undef _POSIX_THREAD_SAFE_FUNCTIONS
447 #define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
448
449 #undef _POSIX_THREAD_ATTR_STACKSIZE
450 #define _POSIX_THREAD_ATTR_STACKSIZE 200809L
451
452 /*
453 * The following options are not supported
454 */
455 #undef _POSIX_THREAD_ATTR_STACKADDR
456 #define _POSIX_THREAD_ATTR_STACKADDR -1
457
458 #undef _POSIX_THREAD_PRIO_INHERIT
459 #define _POSIX_THREAD_PRIO_INHERIT -1
460
461 #undef _POSIX_THREAD_PRIO_PROTECT
462 #define _POSIX_THREAD_PRIO_PROTECT -1
463
464 /* TPS is not fully supported. */
465 #undef _POSIX_THREAD_PRIORITY_SCHEDULING
466 #define _POSIX_THREAD_PRIORITY_SCHEDULING -1
467
468 #undef _POSIX_THREAD_PROCESS_SHARED
469 #define _POSIX_THREAD_PROCESS_SHARED -1
470
471
472 /*
473 * POSIX 1003.1-2001 Limits
474 * ===========================
475 *
476 * These limits are normally set in <limits.h>, which is not provided with
477 * pthreads-win32.
478 *
479 * PTHREAD_DESTRUCTOR_ITERATIONS
480 * Maximum number of attempts to destroy
481 * a thread's thread-specific data on
482 * termination (must be at least 4)
483 *
484 * PTHREAD_KEYS_MAX
485 * Maximum number of thread-specific data keys
486 * available per process (must be at least 128)
487 *
488 * PTHREAD_STACK_MIN
489 * Minimum supported stack size for a thread
490 *
491 * PTHREAD_THREADS_MAX
492 * Maximum number of threads supported per
493 * process (must be at least 64).
494 *
495 * SEM_NSEMS_MAX
496 * The maximum number of semaphores a process can have.
497 * (must be at least 256)
498 *
499 * SEM_VALUE_MAX
500 * The maximum value a semaphore can have.
501 * (must be at least 32767)
502 *
503 */
504 #undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
505 #define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
506
507 #undef PTHREAD_DESTRUCTOR_ITERATIONS
508 #define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
509
510 #undef _POSIX_THREAD_KEYS_MAX
511 #define _POSIX_THREAD_KEYS_MAX 128
512
513 #undef PTHREAD_KEYS_MAX
514 #define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX
515
516 #undef PTHREAD_STACK_MIN
517 #define PTHREAD_STACK_MIN 0
518
519 #undef _POSIX_THREAD_THREADS_MAX
520 #define _POSIX_THREAD_THREADS_MAX 64
521
522 /* Arbitrary value */
523 #undef PTHREAD_THREADS_MAX
524 #define PTHREAD_THREADS_MAX 2019
525
526 #undef _POSIX_SEM_NSEMS_MAX
527 #define _POSIX_SEM_NSEMS_MAX 256
528
529 /* Arbitrary value */
530 #undef SEM_NSEMS_MAX
531 #define SEM_NSEMS_MAX 1024
532
533 #undef _POSIX_SEM_VALUE_MAX
534 #define _POSIX_SEM_VALUE_MAX 32767
535
536 #undef SEM_VALUE_MAX
537 #define SEM_VALUE_MAX INT_MAX
538
539
540 #if defined(__GNUC__) && !defined(__declspec)
541 # error Please upgrade your GNU compiler to one that supports __declspec.
542 #endif
543
544 /*
545 * When building the library, you should define PTW32_BUILD so that
546 * the variables/functions are exported correctly. When using the library,
547 * do NOT define PTW32_BUILD, and then the variables/functions will
548 * be imported correctly.
549 */
550 #if !defined(PTW32_STATIC_LIB)
551 # if defined(PTW32_BUILD)
552 # define PTW32_DLLPORT __declspec (dllexport)
553 # else
554 # define PTW32_DLLPORT __declspec (dllimport)
555 # endif
556 #else
557 # define PTW32_DLLPORT
558 #endif
559
560 /*
561 * The Open Watcom C/C++ compiler uses a non-standard calling convention
562 * that passes function args in registers unless __cdecl is explicitly specified
563 * in exposed function prototypes.
564 *
565 * We force all calls to cdecl even though this could slow Watcom code down
566 * slightly. If you know that the Watcom compiler will be used to build both
567 * the DLL and application, then you can probably define this as a null string.
568 * Remember that pthread.h (this file) is used for both the DLL and application builds.
569 */
570 #define PTW32_CDECL __cdecl
571
572 #if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX
573 # include <sys/types.h>
574 #else
575 /*
576 * Generic handle type - intended to extend uniqueness beyond
577 * that available with a simple pointer. It should scale for either
578 * IA-32 or IA-64.
579 */
580 typedef struct {
581 void * p; /* Pointer to actual object */
582 unsigned int x; /* Extra information - reuse count etc */
583 } ptw32_handle_t;
584
585 typedef ptw32_handle_t pthread_t;
586 typedef struct pthread_attr_t_ * pthread_attr_t;
587 typedef struct pthread_once_t_ pthread_once_t;
588 typedef struct pthread_key_t_ * pthread_key_t;
589 typedef struct pthread_mutex_t_ * pthread_mutex_t;
590 typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t;
591 typedef struct pthread_cond_t_ * pthread_cond_t;
592 typedef struct pthread_condattr_t_ * pthread_condattr_t;
593 #endif
594 typedef struct pthread_rwlock_t_ * pthread_rwlock_t;
595 typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t;
596 typedef struct pthread_spinlock_t_ * pthread_spinlock_t;
597 typedef struct pthread_barrier_t_ * pthread_barrier_t;
598 typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t;
599
600 /*
601 * ====================
602 * ====================
603 * POSIX Threads
604 * ====================
605 * ====================
606 */
607
608 enum {
609 /*
610 * pthread_attr_{get,set}detachstate
611 */
612 PTHREAD_CREATE_JOINABLE = 0, /* Default */
613 PTHREAD_CREATE_DETACHED = 1,
614
615 /*
616 * pthread_attr_{get,set}inheritsched
617 */
618 PTHREAD_INHERIT_SCHED = 0,
619 PTHREAD_EXPLICIT_SCHED = 1, /* Default */
620
621 /*
622 * pthread_{get,set}scope
623 */
624 PTHREAD_SCOPE_PROCESS = 0,
625 PTHREAD_SCOPE_SYSTEM = 1, /* Default */
626
627 /*
628 * pthread_setcancelstate paramters
629 */
630 PTHREAD_CANCEL_ENABLE = 0, /* Default */
631 PTHREAD_CANCEL_DISABLE = 1,
632
633 /*
634 * pthread_setcanceltype parameters
635 */
636 PTHREAD_CANCEL_ASYNCHRONOUS = 0,
637 PTHREAD_CANCEL_DEFERRED = 1, /* Default */
638
639 /*
640 * pthread_mutexattr_{get,set}pshared
641 * pthread_condattr_{get,set}pshared
642 */
643 PTHREAD_PROCESS_PRIVATE = 0,
644 PTHREAD_PROCESS_SHARED = 1,
645
646 /*
647 * pthread_mutexattr_{get,set}robust
648 */
649 PTHREAD_MUTEX_STALLED = 0, /* Default */
650 PTHREAD_MUTEX_ROBUST = 1,
651
652 /*
653 * pthread_barrier_wait
654 */
655 PTHREAD_BARRIER_SERIAL_THREAD = -1
656 };
657
658 /*
659 * ====================
660 * ====================
661 * Cancelation
662 * ====================
663 * ====================
664 */
665 #define PTHREAD_CANCELED ((void *)(size_t) -1)
666
667
668 /*
669 * ====================
670 * ====================
671 * Once Key
672 * ====================
673 * ====================
674 */
675 #define PTHREAD_ONCE_INIT { PTW32_FALSE, 0, 0, 0}
676
677 struct pthread_once_t_
678 {
679 int done; /* indicates if user function has been executed */
680 void * lock;
681 int reserved1;
682 int reserved2;
683 };
684
685
686 /*
687 * ====================
688 * ====================
689 * Object initialisers
690 * ====================
691 * ====================
692 */
693 #define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -1)
694 #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -2)
695 #define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -3)
696
697 /*
698 * Compatibility with LinuxThreads
699 */
700 #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER
701 #define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
702
703 #define PTHREAD_COND_INITIALIZER ((pthread_cond_t)(size_t) -1)
704
705 #define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t)(size_t) -1)
706
707 #define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t)(size_t) -1)
708
709
710 /*
711 * Mutex types.
712 */
713 enum
714 {
715 /* Compatibility with LinuxThreads */
716 PTHREAD_MUTEX_FAST_NP,
717 PTHREAD_MUTEX_RECURSIVE_NP,
718 PTHREAD_MUTEX_ERRORCHECK_NP,
719 PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
720 PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
721 /* For compatibility with POSIX */
722 PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
723 PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
724 PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
725 PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
726 };
727
728
729 typedef struct ptw32_cleanup_t ptw32_cleanup_t;
730
731 #if defined(_MSC_VER)
732 /* Disable MSVC 'anachronism used' warning */
733 #pragma warning( disable : 4229 )
734 #endif
735
736 typedef void (* PTW32_CDECL ptw32_cleanup_callback_t)(void *);
737
738 #if defined(_MSC_VER)
739 #pragma warning( default : 4229 )
740 #endif
741
742 struct ptw32_cleanup_t
743 {
744 ptw32_cleanup_callback_t routine;
745 void *arg;
746 struct ptw32_cleanup_t *prev;
747 };
748
749 #if defined(__CLEANUP_SEH)
750 /*
751 * WIN32 SEH version of cancel cleanup.
752 */
753
754 #define pthread_cleanup_push( _rout, _arg ) \
755 { \
756 ptw32_cleanup_t _cleanup; \
757 \
758 _cleanup.routine = (ptw32_cleanup_callback_t)(_rout); \
759 _cleanup.arg = (_arg); \
760 __try \
761 { \
762
763 #define pthread_cleanup_pop( _execute ) \
764 } \
765 __finally \
766 { \
767 if( _execute || AbnormalTermination()) \
768 { \
769 (*(_cleanup.routine))( _cleanup.arg ); \
770 } \
771 } \
772 }
773
774 #else /* __CLEANUP_SEH */
775
776 #if defined(__CLEANUP_C)
777
778 /*
779 * C implementation of PThreads cancel cleanup
780 */
781
782 #define pthread_cleanup_push( _rout, _arg ) \
783 { \
784 ptw32_cleanup_t _cleanup; \
785 \
786 ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \
787
788 #define pthread_cleanup_pop( _execute ) \
789 (void) ptw32_pop_cleanup( _execute ); \
790 }
791
792 #else /* __CLEANUP_C */
793
794 #if defined(__CLEANUP_CXX)
795
796 /*
797 * C++ version of cancel cleanup.
798 * - John E. Bossom.
799 */
800
801 class PThreadCleanup {
802 /*
803 * PThreadCleanup
804 *
805 * Purpose
806 * This class is a C++ helper class that is
807 * used to implement pthread_cleanup_push/
808 * pthread_cleanup_pop.
809 * The destructor of this class automatically
810 * pops the pushed cleanup routine regardless
811 * of how the code exits the scope
812 * (i.e. such as by an exception)
813 */
814 ptw32_cleanup_callback_t cleanUpRout;
815 void * obj;
816 int executeIt;
817
818 public:
819 PThreadCleanup() :
820 cleanUpRout( 0 ),
821 obj( 0 ),
822 executeIt( 0 )
823 /*
824 * No cleanup performed
825 */
826 {
827 }
828
829 PThreadCleanup(
830 ptw32_cleanup_callback_t routine,
831 void * arg ) :
832 cleanUpRout( routine ),
833 obj( arg ),
834 executeIt( 1 )
835 /*
836 * Registers a cleanup routine for 'arg'
837 */
838 {
839 }
840
841 ~PThreadCleanup()
842 {
843 if ( executeIt && ((void *) cleanUpRout != (void *) 0) )
844 {
845 (void) (*cleanUpRout)( obj );
846 }
847 }
848
849 void execute( int exec )
850 {
851 executeIt = exec;
852 }
853 };
854
855 /*
856 * C++ implementation of PThreads cancel cleanup;
857 * This implementation takes advantage of a helper
858 * class who's destructor automatically calls the
859 * cleanup routine if we exit our scope weirdly
860 */
861 #define pthread_cleanup_push( _rout, _arg ) \
862 { \
863 PThreadCleanup cleanup((ptw32_cleanup_callback_t)(_rout), \
864 (void *) (_arg) );
865
866 #define pthread_cleanup_pop( _execute ) \
867 cleanup.execute( _execute ); \
868 }
869
870 #else
871
872 #error ERROR [__FILE__, line __LINE__]: Cleanup type undefined.
873
874 #endif /* __CLEANUP_CXX */
875
876 #endif /* __CLEANUP_C */
877
878 #endif /* __CLEANUP_SEH */
879
880 /*
881 * ===============
882 * ===============
883 * Methods
884 * ===============
885 * ===============
886 */
887
888 /*
889 * PThread Attribute Functions
890 */
891 PTW32_DLLPORT int PTW32_CDECL pthread_attr_init (pthread_attr_t * attr);
892
893 PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr);
894
895 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr,
896 int *detachstate);
897
898 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr,
899 void **stackaddr);
900
901 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr,
902 size_t * stacksize);
903
904 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr,
905 int detachstate);
906
907 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr,
908 void *stackaddr);
909
910 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr,
911 size_t stacksize);
912
913 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr,
914 struct sched_param *param);
915
916 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr,
917 const struct sched_param *param);
918
919 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *,
920 int);
921
922 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy (const pthread_attr_t *,
923 int *);
924
925 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr,
926 int inheritsched);
927
928 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(const pthread_attr_t * attr,
929 int * inheritsched);
930
931 PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope (pthread_attr_t *,
932 int);
933
934 PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *,
935 int *);
936
937 /*
938 * PThread Functions
939 */
940 PTW32_DLLPORT int PTW32_CDECL pthread_create (pthread_t * tid,
941 const pthread_attr_t * attr,
942 void *(PTW32_CDECL *start) (void *),
943 void *arg);
944
945 PTW32_DLLPORT int PTW32_CDECL pthread_detach (pthread_t tid);
946
947 PTW32_DLLPORT int PTW32_CDECL pthread_equal (pthread_t t1,
948 pthread_t t2);
949
950 PTW32_DLLPORT void PTW32_CDECL pthread_exit (void *value_ptr);
951
952 PTW32_DLLPORT int PTW32_CDECL pthread_join (pthread_t thread,
953 void **value_ptr);
954
955 PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self (void);
956
957 PTW32_DLLPORT int PTW32_CDECL pthread_cancel (pthread_t thread);
958
959 PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate (int state,
960 int *oldstate);
961
962 PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype (int type,
963 int *oldtype);
964
965 PTW32_DLLPORT void PTW32_CDECL pthread_testcancel (void);
966
967 PTW32_DLLPORT int PTW32_CDECL pthread_once (pthread_once_t * once_control,
968 void (PTW32_CDECL *init_routine) (void));
969
970 #if PTW32_LEVEL >= PTW32_LEVEL_MAX
971 PTW32_DLLPORT ptw32_cleanup_t * PTW32_CDECL ptw32_pop_cleanup (int execute);
972
973 PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
974 ptw32_cleanup_callback_t routine,
975 void *arg);
976 #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
977
978 /*
979 * Thread Specific Data Functions
980 */
981 PTW32_DLLPORT int PTW32_CDECL pthread_key_create (pthread_key_t * key,
982 void (PTW32_CDECL *destructor) (void *));
983
984 PTW32_DLLPORT int PTW32_CDECL pthread_key_delete (pthread_key_t key);
985
986 PTW32_DLLPORT int PTW32_CDECL pthread_setspecific (pthread_key_t key,
987 const void *value);
988
989 PTW32_DLLPORT void * PTW32_CDECL pthread_getspecific (pthread_key_t key);
990
991
992 /*
993 * Mutex Attribute Functions
994 */
995 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr);
996
997 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
998
999 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t
1000 * attr,
1001 int *pshared);
1002
1003 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
1004 int pshared);
1005
1006 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
1007 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *kind);
1008
1009 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setrobust(
1010 pthread_mutexattr_t *attr,
1011 int robust);
1012 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getrobust(
1013 const pthread_mutexattr_t * attr,
1014 int * robust);
1015
1016 /*
1017 * Barrier Attribute Functions
1018 */
1019 PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr);
1020
1021 PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
1022
1023 PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t
1024 * attr,
1025 int *pshared);
1026
1027 PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
1028 int pshared);
1029
1030 /*
1031 * Mutex Functions
1032 */
1033 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex,
1034 const pthread_mutexattr_t * attr);
1035
1036 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex);
1037
1038 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex);
1039
1040 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t * mutex,
1041 const struct timespec *abstime);
1042
1043 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex);
1044
1045 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex);
1046
1047 PTW32_DLLPORT int PTW32_CDECL pthread_mutex_consistent (pthread_mutex_t * mutex);
1048
1049 /*
1050 * Spinlock Functions
1051 */
1052 PTW32_DLLPORT int PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared);
1053
1054 PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock);
1055
1056 PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock);
1057
1058 PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock);
1059
1060 PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock);
1061
1062 /*
1063 * Barrier Functions
1064 */
1065 PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier,
1066 const pthread_barrierattr_t * attr,
1067 unsigned int count);
1068
1069 PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier);
1070
1071 PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier);
1072
1073 /*
1074 * Condition Variable Attribute Functions
1075 */
1076 PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr);
1077
1078 PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr);
1079
1080 PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr,
1081 int *pshared);
1082
1083 PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr,
1084 int pshared);
1085
1086 /*
1087 * Condition Variable Functions
1088 */
1089 PTW32_DLLPORT int PTW32_CDECL pthread_cond_init (pthread_cond_t * cond,
1090 const pthread_condattr_t * attr);
1091
1092 PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond);
1093
1094 PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond,
1095 pthread_mutex_t * mutex);
1096
1097 PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond,
1098 pthread_mutex_t * mutex,
1099 const struct timespec *abstime);
1100
1101 PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond);
1102
1103 PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond);
1104
1105 /*
1106 * Scheduling
1107 */
1108 PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam (pthread_t thread,
1109 int policy,
1110 const struct sched_param *param);
1111
1112 PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam (pthread_t thread,
1113 int *policy,
1114 struct sched_param *param);
1115
1116 PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency (int);
1117
1118 PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency (void);
1119
1120 /*
1121 * Read-Write Lock Functions
1122 */
1123 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock,
1124 const pthread_rwlockattr_t *attr);
1125
1126 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock);
1127
1128 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *);
1129
1130 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *);
1131
1132 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock);
1133
1134 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
1135 const struct timespec *abstime);
1136
1137 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock);
1138
1139 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
1140 const struct timespec *abstime);
1141
1142 PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock);
1143
1144 PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
1145
1146 PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
1147
1148 PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr,
1149 int *pshared);
1150
1151 PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr,
1152 int pshared);
1153
1154 #if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1
1155
1156 /*
1157 * Signal Functions. Should be defined in <signal.h> but MSVC and MinGW32
1158 * already have signal.h that don't define these.
1159 */
1160 PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig);
1161
1162 /*
1163 * Non-portable functions
1164 */
1165
1166 /*
1167 * Compatibility with Linux.
1168 */
1169 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr,
1170 int kind);
1171 PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr,
1172 int *kind);
1173
1174 /*
1175 * Possibly supported by other POSIX threads implementations
1176 */
1177 PTW32_DLLPORT int PTW32_CDECL pthread_delay_np (struct timespec * interval);
1178 PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void);
1179 PTW32_DLLPORT unsigned __int64 PTW32_CDECL pthread_getunique_np(pthread_t thread);
1180
1181 /*
1182 * Useful if an application wants to statically link
1183 * the lib rather than load the DLL at run-time.
1184 */
1185 PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void);
1186 PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void);
1187 PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void);
1188 PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void);
1189
1190 /*
1191 * Features that are auto-detected at load/run time.
1192 */
1193 PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int);
1194 enum ptw32_features {
1195 PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001, /* System provides it. */
1196 PTW32_ALERTABLE_ASYNC_CANCEL = 0x0002 /* Can cancel blocked threads. */
1197 };
1198
1199 /*
1200 * Register a system time change with the library.
1201 * Causes the library to perform various functions
1202 * in response to the change. Should be called whenever
1203 * the application's top level window receives a
1204 * WM_TIMECHANGE message. It can be passed directly to
1205 * pthread_create() as a new thread if desired.
1206 */
1207 PTW32_DLLPORT void * PTW32_CDECL pthread_timechange_handler_np(void *);
1208
1209 #endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */
1210
1211 #if PTW32_LEVEL >= PTW32_LEVEL_MAX
1212
1213 /*
1214 * Returns the Win32 HANDLE for the POSIX thread.
1215 */
1216 PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread);
1217 /*
1218 * Returns the win32 thread ID for POSIX thread.
1219 */
1220 PTW32_DLLPORT DWORD PTW32_CDECL pthread_getw32threadid_np (pthread_t thread);
1221
1222
1223 /*
1224 * Protected Methods
1225 *
1226 * This function blocks until the given WIN32 handle
1227 * is signaled or pthread_cancel had been called.
1228 * This function allows the caller to hook into the
1229 * PThreads cancel mechanism. It is implemented using
1230 *
1231 * WaitForMultipleObjects
1232 *
1233 * on 'waitHandle' and a manually reset WIN32 Event
1234 * used to implement pthread_cancel. The 'timeout'
1235 * argument to TimedWait is simply passed to
1236 * WaitForMultipleObjects.
1237 */
1238 PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait (HANDLE waitHandle);
1239 PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait (HANDLE waitHandle,
1240 DWORD timeout);
1241
1242 #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
1243
1244 /*
1245 * Thread-Safe C Runtime Library Mappings.
1246 */
1247 #if !defined(_UWIN)
1248 # if defined(NEED_ERRNO)
1249 PTW32_DLLPORT int * PTW32_CDECL _errno( void );
1250 # else
1251 # if !defined(errno)
1252 # if (defined(_MT) || defined(_DLL))
1253 __declspec(dllimport) extern int * __cdecl _errno(void);
1254 # define errno (*_errno())
1255 # endif
1256 # endif
1257 # endif
1258 #endif
1259
1260 /*
1261 * Some compiler environments don't define some things.
1262 */
1263 #if defined(__BORLANDC__)
1264 # define _ftime ftime
1265 # define _timeb timeb
1266 #endif
1267
1268 #if defined(__cplusplus)
1269
1270 /*
1271 * Internal exceptions
1272 */
1273 class ptw32_exception {};
1274 class ptw32_exception_cancel : public ptw32_exception {};
1275 class ptw32_exception_exit : public ptw32_exception {};
1276
1277 #endif
1278
1279 #if PTW32_LEVEL >= PTW32_LEVEL_MAX
1280
1281 /* FIXME: This is only required if the library was built using SEH */
1282 /*
1283 * Get internal SEH tag
1284 */
1285 PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void);
1286
1287 #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
1288
1289 #if !defined(PTW32_BUILD)
1290
1291 #if defined(__CLEANUP_SEH)
1292
1293 /*
1294 * Redefine the SEH __except keyword to ensure that applications
1295 * propagate our internal exceptions up to the library's internal handlers.
1296 */
1297 #define __except( E ) \
1298 __except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) \
1299 ? EXCEPTION_CONTINUE_SEARCH : ( E ) )
1300
1301 #endif /* __CLEANUP_SEH */
1302
1303 #if defined(__CLEANUP_CXX)
1304
1305 /*
1306 * Redefine the C++ catch keyword to ensure that applications
1307 * propagate our internal exceptions up to the library's internal handlers.
1308 */
1309 #if defined(_MSC_VER)
1310 /*
1311 * WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll'
1312 * if you want Pthread-Win32 cancelation and pthread_exit to work.
1313 */
1314
1315 #if !defined(PtW32NoCatchWarn)
1316
1317 #pragma message("Specify \"/DPtW32NoCatchWarn\" compiler flag to skip this message.")
1318 #pragma message("------------------------------------------------------------------")
1319 #pragma message("When compiling applications with MSVC++ and C++ exception handling:")
1320 #pragma message(" Replace any 'catch( ... )' in routines called from POSIX threads")
1321 #pragma message(" with 'PtW32CatchAll' or 'CATCHALL' if you want POSIX thread")
1322 #pragma message(" cancelation and pthread_exit to work. For example:")
1323 #pragma message("")
1324 #pragma message(" #if defined(PtW32CatchAll)")
1325 #pragma message(" PtW32CatchAll")
1326 #pragma message(" #else")
1327 #pragma message(" catch(...)")
1328 #pragma message(" #endif")
1329 #pragma message(" {")
1330 #pragma message(" /* Catchall block processing */")
1331 #pragma message(" }")
1332 #pragma message("------------------------------------------------------------------")
1333
1334 #endif
1335
1336 #define PtW32CatchAll \
1337 catch( ptw32_exception & ) { throw; } \
1338 catch( ... )
1339
1340 #else /* _MSC_VER */
1341
1342 #define catch( E ) \
1343 catch( ptw32_exception & ) { throw; } \
1344 catch( E )
1345
1346 #endif /* _MSC_VER */
1347
1348 #endif /* __CLEANUP_CXX */
1349
1350 #endif /* ! PTW32_BUILD */
1351
1352 #if defined(__cplusplus)
1353 } /* End of extern "C" */
1354 #endif /* __cplusplus */
1355
1356 #if defined(PTW32__HANDLE_DEF)
1357 # undef HANDLE
1358 #endif
1359 #if defined(PTW32__DWORD_DEF)
1360 # undef DWORD
1361 #endif
1362
1363 #undef PTW32_LEVEL
1364 #undef PTW32_LEVEL_MAX
1365
1366 #endif /* ! RC_INVOKED */
1367
1368 #endif /* PTHREAD_H */
pthread_attr_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy(pthread_attr_t *attr)
Definition: pthread_attr_destroy.c:42
pthread_rwlock_unlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock)
Definition: pthread_rwlock_unlock.c:43
pthread_mutex_lock
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock(pthread_mutex_t *mutex)
Definition: pthread_mutex_lock.c:44
pthread_rwlock_timedrdlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, const struct timespec *abstime)
Definition: pthread_rwlock_timedrdlock.c:43
PTHREAD_MUTEX_RECURSIVE_NP
Definition: pthread.h:717
pthread_attr_getstackaddr
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
Definition: pthread_attr_getstackaddr.c:46
PTHREAD_MUTEX_TIMED_NP
Definition: pthread.h:719
PTHREAD_MUTEX_ERRORCHECK_NP
Definition: pthread.h:718
pthread_mutex_consistent
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_consistent(pthread_mutex_t *mutex)
Definition: pthread_mutex_consistent.c:166
pthread_rwlock_wrlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock)
Definition: pthread_rwlock_wrlock.c:43
pthread_setcancelstate
PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate(int state, int *oldstate)
Definition: pthread_setcancelstate.c:42
pthread_win32_process_detach_np
PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void)
Definition: pthread_win32_attach_detach_np.c:143
pthread_spin_unlock
PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock(pthread_spinlock_t *lock)
Definition: pthread_spin_unlock.c:42
DWORD
#define DWORD
Definition: pthread.h:312
pthread_mutex_init
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: pthread_mutex_init.c:42
pthread_t
ptw32_handle_t pthread_t
Definition: pthread.h:585
barrier
pthread_barrier_t barrier
Definition: barrier1.c:42
pthread_spin_lock
PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock(pthread_spinlock_t *lock)
Definition: pthread_spin_lock.c:42
pthread_mutexattr_settype
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind)
Definition: pthread_mutexattr_settype.c:42
PTHREAD_MUTEX_ERRORCHECK
Definition: pthread.h:724
pthread_barrier_init
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
Definition: pthread_barrier_init.c:42
pthread_once_t_::done
int done
Definition: pthread.h:679
pthread_self
PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self(void)
Definition: pthread_self.c:41
pthread_barrierattr_t_
Definition: implement.h:324
PTHREAD_CREATE_JOINABLE
Definition: pthread.h:612
pthread_attr_setdetachstate
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
Definition: pthread_attr_setdetachstate.c:42
pthread_attr_getschedparam
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param)
Definition: pthread_attr_getschedparam.c:42
pthread_getw32threadhandle_np
PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread)
Definition: pthread_getw32threadhandle_np.c:50
void
typedef void(dgApi *ConstraintsForceFeeback)(const dgConstraint &me
PTHREAD_MUTEX_DEFAULT
Definition: pthread.h:725
pthread_cond_signal
PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal(pthread_cond_t *cond)
Definition: pthread_cond_signal.c:153
pthread_cond_t_
Definition: implement.h:348
pthread_condattr_t
struct pthread_condattr_t_ * pthread_condattr_t
Definition: pthread.h:592
config.h
pthread_mutex_t_
Definition: implement.h:222
pthread_once_t_
Definition: pthread.h:677
sched_param
Definition: sched.h:142
HANDLE
#define HANDLE
Definition: pthread.h:308
pthread_barrier_t_
Definition: implement.h:314
pthread_mutexattr_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
Definition: pthread_mutexattr_destroy.c:42
ptw32_handle_t::x
unsigned int x
Definition: pthread.h:582
mutex
pthread_mutex_t mutex
Definition: condvar2.c:82
pthread_barrier_wait
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait(pthread_barrier_t *barrier)
Definition: pthread_barrier_wait.c:42
pthread_key_delete
PTW32_DLLPORT int PTW32_CDECL pthread_key_delete(pthread_key_t key)
Definition: pthread_key_delete.c:42
pthread_mutex_trylock
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock(pthread_mutex_t *mutex)
Definition: pthread_mutex_trylock.c:42
PTHREAD_MUTEX_RECURSIVE
Definition: pthread.h:723
PTHREAD_MUTEX_FAST_NP
Definition: pthread.h:716
PTHREAD_INHERIT_SCHED
Definition: pthread.h:618
pthread_condattr_getpshared
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared)
Definition: pthread_condattr_getpshared.c:43
PTW32_CDECL
#define PTW32_CDECL
Definition: pthread.h:570
pthread_detach
PTW32_DLLPORT int PTW32_CDECL pthread_detach(pthread_t tid)
Definition: pthread_detach.c:51
pthread_kill
PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig)
Definition: pthread_kill.c:49
pthread_attr_getschedpolicy
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy(const pthread_attr_t *, int *)
Definition: pthread_attr_getschedpolicy.c:42
timespec::tv_sec
time_t tv_sec
Definition: pthread.h:321
pthread_attr_setschedparam
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param)
Definition: pthread_attr_setschedparam.c:42
pthread_condattr_init
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init(pthread_condattr_t *attr)
Definition: pthread_condattr_init.c:43
ptw32_handle_t
Definition: pthread.h:580
pthread_attr_setinheritsched
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched)
Definition: pthread_attr_setinheritsched.c:42
PTHREAD_MUTEX_ROBUST
Definition: pthread.h:650
pthread_setcanceltype
PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype(int type, int *oldtype)
Definition: pthread_setcanceltype.c:42
pthread_getspecific
PTW32_DLLPORT void *PTW32_CDECL pthread_getspecific(pthread_key_t key)
Definition: pthread_getspecific.c:42
__cdecl
#define __cdecl
Definition: need_errno.h:49
PTHREAD_PROCESS_PRIVATE
Definition: pthread.h:643
pthread_condattr_setpshared
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared)
Definition: pthread_condattr_setpshared.c:43
ptw32_handle_t::p
void * p
Definition: pthread.h:581
pthread_rwlockattr_init
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init(pthread_rwlockattr_t *attr)
Definition: pthread_rwlockattr_init.c:43
pthread_condattr_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy(pthread_condattr_t *attr)
Definition: pthread_condattr_destroy.c:43
pthread_barrierattr_t
struct pthread_barrierattr_t_ * pthread_barrierattr_t
Definition: pthread.h:598
pthread_setschedparam
PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
Definition: pthread_setschedparam.c:42
pthread_attr_setstackaddr
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
Definition: pthread_attr_setstackaddr.c:42
PTHREAD_PROCESS_SHARED
Definition: pthread.h:644
pthread_cond_init
PTW32_DLLPORT int PTW32_CDECL pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: pthread_cond_init.c:43
pthread_rwlock_t
struct pthread_rwlock_t_ * pthread_rwlock_t
Definition: pthread.h:594
pthread_barrierattr_getpshared
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr, int *pshared)
Definition: pthread_barrierattr_getpshared.c:42
pthread_mutexattr_getpshared
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared)
Definition: pthread_mutexattr_getpshared.c:42
pthread_rwlock_trywrlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *)
Definition: pthread_rwlock_trywrlock.c:43
pthread_attr_getstacksize
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
Definition: pthread_attr_getstacksize.c:46
dgJointCallbackParam
Definition: dgConstraint.h:63
timespec::tv_nsec
long tv_nsec
Definition: pthread.h:322
ptw32_cleanup_t
Definition: pthread.h:742
pthread_mutex_unlock
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock(pthread_mutex_t *mutex)
Definition: pthread_mutex_unlock.c:42
pthread_rwlock_t_
Definition: implement.h:373
sched.h
pthread_getschedparam
PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param)
Definition: pthread_getschedparam.c:42
lock
pthread_spinlock_t lock
Definition: spin1.c:43
pthread_win32_thread_attach_np
PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void)
Definition: pthread_win32_attach_detach_np.c:192
pthread_barrier_t
struct pthread_barrier_t_ * pthread_barrier_t
Definition: pthread.h:597
pthread_num_processors_np
PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void)
Definition: pthread_num_processors_np.c:46
pthread_cond_broadcast
PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast(pthread_cond_t *cond)
Definition: pthread_cond_signal.c:195
ptw32_get_exception_services_code
PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void)
Definition: ptw32_throw.c:178
PTHREAD_CREATE_DETACHED
Definition: pthread.h:613
pthread_rwlockattr_getpshared
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr, int *pshared)
Definition: pthread_rwlockattr_getpshared.c:43
PTHREAD_BARRIER_SERIAL_THREAD
Definition: pthread.h:655
pthreadCancelableTimedWait
PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait(HANDLE waitHandle, DWORD timeout)
Definition: w32_CancelableWait.c:158
pthread_barrierattr_setpshared
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared)
Definition: pthread_barrierattr_setpshared.c:42
PTHREAD_CANCEL_DEFERRED
Definition: pthread.h:637
pthread_key_t
struct pthread_key_t_ * pthread_key_t
Definition: pthread.h:588
ptw32_cleanup_t::prev
struct ptw32_cleanup_t * prev
Definition: pthread.h:746
pthread_once_t_::reserved1
int reserved1
Definition: pthread.h:681
pthread_barrier_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy(pthread_barrier_t *barrier)
Definition: pthread_barrier_destroy.c:41
PTW32_TRUE
Definition: pthread.h:235
abstime
struct timespec abstime
Definition: rwlock6_t2.c:50
pthread_cond_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy(pthread_cond_t *cond)
Definition: pthread_cond_destroy.c:42
pthread_attr_getdetachstate
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
Definition: pthread_attr_getdetachstate.c:42
pthread_mutexattr_setkind_np
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
Definition: pthread_mutexattr_setkind_np.c:41
PTW32_DLLPORT
#define PTW32_DLLPORT
Definition: pthread.h:554
pthread_attr_getscope
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope(const pthread_attr_t *, int *)
Definition: pthread_attr_getscope.c:46
PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE
Definition: pthread.h:1195
pthread_getunique_np
PTW32_DLLPORT unsigned __int64 PTW32_CDECL pthread_getunique_np(pthread_t thread)
Definition: pthread_getunique_np.c:44
need_errno.h
ptw32_cleanup_t::arg
void * arg
Definition: pthread.h:745
PTW32_ALERTABLE_ASYNC_CANCEL
Definition: pthread.h:1196
ptw32_cleanup_t::routine
ptw32_cleanup_callback_t routine
Definition: pthread.h:744
pthread_key_create
PTW32_DLLPORT int PTW32_CDECL pthread_key_create(pthread_key_t *key, void(PTW32_CDECL *destructor)(void *))
Definition: pthread_key_create.c:47
pthread_rwlockattr_setpshared
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared)
Definition: pthread_rwlockattr_setpshared.c:43
PTHREAD_CANCEL_ENABLE
Definition: pthread.h:630
pthread_mutexattr_getrobust
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robust)
Definition: pthread_mutexattr_getrobust.c:42
pthread_setspecific
PTW32_DLLPORT int PTW32_CDECL pthread_setspecific(pthread_key_t key, const void *value)
Definition: pthread_setspecific.c:42
pthread_win32_process_attach_np
PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void)
Definition: pthread_win32_attach_detach_np.c:46
pthread_spinlock_t_
Definition: implement.h:290
ptw32_pop_cleanup
PTW32_DLLPORT ptw32_cleanup_t *PTW32_CDECL ptw32_pop_cleanup(int execute)
Definition: cleanup.c:50
pthread_attr_setschedpolicy
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy(pthread_attr_t *, int)
Definition: pthread_attr_setschedpolicy.c:42
pthread_condattr_t_
Definition: implement.h:366
pthread_once_t_::lock
void * lock
Definition: pthread.h:680
pthread_spinlock_t
struct pthread_spinlock_t_ * pthread_spinlock_t
Definition: pthread.h:596
pthread_cancel
PTW32_DLLPORT int PTW32_CDECL pthread_cancel(pthread_t thread)
Definition: pthread_cancel.c:75
pthread_join
PTW32_DLLPORT int PTW32_CDECL pthread_join(pthread_t thread, void **value_ptr)
Definition: pthread_join.c:51
pthreadCancelableWait
PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait(HANDLE waitHandle)
Definition: w32_CancelableWait.c:152
pthread_spin_trylock
PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock(pthread_spinlock_t *lock)
Definition: pthread_spin_trylock.c:42
pthread_mutexattr_init
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init(pthread_mutexattr_t *attr)
Definition: pthread_mutexattr_init.c:42
PTHREAD_EXPLICIT_SCHED
Definition: pthread.h:619
PTHREAD_MUTEX_ADAPTIVE_NP
Definition: pthread.h:720
PTHREAD_SCOPE_PROCESS
Definition: pthread.h:624
pthread_mutexattr_setrobust
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust)
Definition: pthread_mutexattr_setrobust.c:42
pthread_cond_t
struct pthread_cond_t_ * pthread_cond_t
Definition: pthread.h:591
pthread_rwlock_tryrdlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *)
Definition: pthread_rwlock_tryrdlock.c:43
pthread_attr_t
struct pthread_attr_t_ * pthread_attr_t
Definition: pthread.h:586
pthread_setconcurrency
PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency(int)
Definition: pthread_setconcurrency.c:42
pthread_attr_t_
Definition: implement.h:186
ptw32_push_cleanup
PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup(ptw32_cleanup_t *cleanup, ptw32_cleanup_callback_t routine, void *arg)
Definition: cleanup.c:99
PTHREAD_MUTEX_NORMAL
Definition: pthread.h:722
PTHREAD_CANCEL_ASYNCHRONOUS
Definition: pthread.h:636
ptw32_features
ptw32_features
Definition: pthread.h:1194
pthread_barrierattr_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy(pthread_barrierattr_t *attr)
Definition: pthread_barrierattr_destroy.c:42
pthread_barrierattr_init
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init(pthread_barrierattr_t *attr)
Definition: pthread_barrierattr_init.c:42
pthread_timechange_handler_np
PTW32_DLLPORT void *PTW32_CDECL pthread_timechange_handler_np(void *)
Definition: pthread_timechange_handler_np.c:65
timespec
Definition: pthread.h:320
pthread_mutex_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: pthread_mutex_destroy.c:42
pthread_spin_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy(pthread_spinlock_t *lock)
Definition: pthread_spin_destroy.c:42
pthread_equal
PTW32_DLLPORT int PTW32_CDECL pthread_equal(pthread_t t1, pthread_t t2)
Definition: pthread_equal.c:42
pthread_attr_getinheritsched
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched)
Definition: pthread_attr_getinheritsched.c:42
pthread_mutexattr_setpshared
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
Definition: pthread_mutexattr_setpshared.c:42
pthread_rwlock_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock)
Definition: pthread_rwlock_destroy.c:43
pthread_attr_setstacksize
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
Definition: pthread_attr_setstacksize.c:42
pthread_rwlock_rdlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock)
Definition: pthread_rwlock_rdlock.c:43
pthread_mutex_t
struct pthread_mutex_t_ * pthread_mutex_t
Definition: pthread.h:589
pthread_rwlock_timedwrlock
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, const struct timespec *abstime)
Definition: pthread_rwlock_timedwrlock.c:43
pthread_mutex_timedlock
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime)
Definition: pthread_mutex_timedlock.c:109
pthread_win32_thread_detach_np
PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void)
Definition: pthread_win32_attach_detach_np.c:198
PTHREAD_MUTEX_STALLED
Definition: pthread.h:649
pthread_testcancel
PTW32_DLLPORT void PTW32_CDECL pthread_testcancel(void)
Definition: pthread_testcancel.c:42
pthread_rwlockattr_destroy
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr)
Definition: pthread_rwlockattr_destroy.c:43
pthread_once
PTW32_DLLPORT int PTW32_CDECL pthread_once(pthread_once_t *once_control, void(PTW32_CDECL *init_routine)(void))
Definition: pthread_once.c:41
pthread_getconcurrency
PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency(void)
Definition: pthread_getconcurrency.c:42
pthread_delay_np
PTW32_DLLPORT int PTW32_CDECL pthread_delay_np(struct timespec *interval)
Definition: pthread_delay_np.c:82
pthread_mutexattr_t
struct pthread_mutexattr_t_ * pthread_mutexattr_t
Definition: pthread.h:590
PTHREAD_SCOPE_SYSTEM
Definition: pthread.h:625
pthread_attr_init
PTW32_DLLPORT int PTW32_CDECL pthread_attr_init(pthread_attr_t *attr)
Definition: pthread_attr_init.c:42
pthread_once_t_::reserved2
int reserved2
Definition: pthread.h:682
pthread_create
PTW32_DLLPORT int PTW32_CDECL pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(PTW32_CDECL *start)(void *), void *arg)
Definition: create.c:45
pthread_rwlock_init
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock, const pthread_rwlockattr_t *attr)
Definition: pthread_rwlock_init.c:43
pthread_rwlockattr_t_
Definition: implement.h:384
pthread_rwlockattr_t
struct pthread_rwlockattr_t_ * pthread_rwlockattr_t
Definition: pthread.h:595
pthread_win32_test_features_np
PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int)
Definition: pthread_win32_attach_detach_np.c:253
pthread_mutexattr_t_
Definition: implement.h:261
pthread_spin_init
PTW32_DLLPORT int PTW32_CDECL pthread_spin_init(pthread_spinlock_t *lock, int pshared)
Definition: pthread_spin_init.c:42
pthread_exit
PTW32_DLLPORT void PTW32_CDECL pthread_exit(void *value_ptr)
Definition: pthread_exit.c:45
pthread_key_t_
Definition: implement.h:329
pthread_mutexattr_getkind_np
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t *attr, int *kind)
Definition: pthread_mutexattr_getkind_np.c:41
PTHREAD_CANCEL_DISABLE
Definition: pthread.h:631
pthread_cond_wait
PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: pthread_cond_wait.c:454
pthread_getw32threadid_np
PTW32_DLLPORT DWORD PTW32_CDECL pthread_getw32threadid_np(pthread_t thread)
Definition: pthread_getw32threadhandle_np.c:62
pthread_cond_timedwait
PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
Definition: pthread_cond_wait.c:512
pthread_mutexattr_gettype
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind)
Definition: pthread_mutexattr_gettype.c:42
PTW32_FALSE
Definition: pthread.h:234
pthread_attr_setscope
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope(pthread_attr_t *, int)
Definition: pthread_attr_setscope.c:46