repositories / deb_libcec.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
win32: fix compilation after the last commit
[deb_libcec.git] / src / lib / platform / pthread_win32 / pthread.h
CommitLineData
abbca718
LOK		 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,8,0,0
41#define PTW32_VERSION_STRING "2, 8, 0, 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#ifndef 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(PTW32_LEVEL)
108#define PTW32_LEVEL PTW32_LEVEL_MAX
109/* Include everything */
110#endif
111
112#ifdef _UWIN
113# define HAVE_STRUCT_TIMESPEC 1
114# define HAVE_SIGNAL_H 1
115# undef HAVE_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(__MINGW32__) && defined(__cplusplus)
194#define PTW32_INCLUDE_WINDOWS_H
195#endif
196
197#ifdef 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 */
205typedef unsigned long DWORD_PTR;
206#endif
207/*
208 * -----------------
209 * autoconf switches
210 * -----------------
211 */
212
213#if HAVE_CONFIG_H
214#include "config.h"
215#endif /* HAVE_CONFIG_H */
216
217#ifndef NEED_FTIME
218#include <time.h>
219#else /* NEED_FTIME */
220/* use native WIN32 time API */
221#endif /* NEED_FTIME */
222
223#if HAVE_SIGNAL_H
224#include <signal.h>
225#endif /* HAVE_SIGNAL_H */
226
227#include <setjmp.h>
228#include <limits.h>
229
230/*
231 * Boolean values to make us independent of system includes.
232 */
233enum {
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#ifndef PTW32_CONFIG_H
244# if defined(WINCE)
245# define NEED_ERRNO
246# define NEED_SEM
247# endif
248# if defined(_UWIN) || defined(__MINGW32__)
249# define HAVE_MODE_T
250# endif
251#endif
252
253/*
254 *
255 */
256
257#if PTW32_LEVEL >= PTW32_LEVEL_MAX
258#ifdef NEED_ERRNO
259#include "need_errno.h"
260#else
261#include <errno.h>
262#endif
263#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
264
265/*
266 * Several systems don't define some error numbers.
267 */
268#ifndef ENOTSUP
269# define ENOTSUP 48 /* This is the value in Solaris. */
270#endif
271
272#ifndef ETIMEDOUT
273# define ETIMEDOUT 10060 /* This is the value in winsock.h. */
274#endif
275
276#ifndef ENOSYS
277# define ENOSYS 140 /* Semi-arbitrary value */
278#endif
279
280#ifndef EDEADLK
281# ifdef EDEADLOCK
282# define EDEADLK EDEADLOCK
283# else
284# define EDEADLK 36 /* This is the value in MSVC. */
285# endif
286#endif
287
288#include "sched.h"
289
290/*
291 * To avoid including windows.h we define only those things that we
292 * actually need from it.
293 */
294#ifndef PTW32_INCLUDE_WINDOWS_H
295#ifndef HANDLE
296# define PTW32__HANDLE_DEF
297# define HANDLE void *
298#endif
299#ifndef DWORD
300# define PTW32__DWORD_DEF
301# define DWORD unsigned long
302#endif
303#endif
304
305#ifndef HAVE_STRUCT_TIMESPEC
306#define HAVE_STRUCT_TIMESPEC 1
307struct timespec {
308 long tv_sec;
309 long tv_nsec;
310};
311#endif /* HAVE_STRUCT_TIMESPEC */
312
313#ifndef SIG_BLOCK
314#define SIG_BLOCK 0
315#endif /* SIG_BLOCK */
316
317#ifndef SIG_UNBLOCK
318#define SIG_UNBLOCK 1
319#endif /* SIG_UNBLOCK */
320
321#ifndef SIG_SETMASK
322#define SIG_SETMASK 2
323#endif /* SIG_SETMASK */
324
325#ifdef __cplusplus
326extern "C"
327{
328#endif /* __cplusplus */
329
330/*
331 * -------------------------------------------------------------
332 *
333 * POSIX 1003.1-2001 Options
334 * =========================
335 *
336 * Options are normally set in <unistd.h>, which is not provided
337 * with pthreads-win32.
338 *
339 * For conformance with the Single Unix Specification (version 3), all of the
340 * options below are defined, and have a value of either -1 (not supported)
341 * or 200112L (supported).
342 *
343 * These options can neither be left undefined nor have a value of 0, because
344 * either indicates that sysconf(), which is not implemented, may be used at
345 * runtime to check the status of the option.
346 *
347 * _POSIX_THREADS (== 200112L)
348 * If == 200112L, you can use threads
349 *
350 * _POSIX_THREAD_ATTR_STACKSIZE (== 200112L)
351 * If == 200112L, you can control the size of a thread's
352 * stack
353 * pthread_attr_getstacksize
354 * pthread_attr_setstacksize
355 *
356 * _POSIX_THREAD_ATTR_STACKADDR (== -1)
357 * If == 200112L, you can allocate and control a thread's
358 * stack. If not supported, the following functions
359 * will return ENOSYS, indicating they are not
360 * supported:
361 * pthread_attr_getstackaddr
362 * pthread_attr_setstackaddr
363 *
364 * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1)
365 * If == 200112L, you can use realtime scheduling.
366 * This option indicates that the behaviour of some
367 * implemented functions conforms to the additional TPS
368 * requirements in the standard. E.g. rwlocks favour
369 * writers over readers when threads have equal priority.
370 *
371 * _POSIX_THREAD_PRIO_INHERIT (== -1)
372 * If == 200112L, you can create priority inheritance
373 * mutexes.
374 * pthread_mutexattr_getprotocol +
375 * pthread_mutexattr_setprotocol +
376 *
377 * _POSIX_THREAD_PRIO_PROTECT (== -1)
378 * If == 200112L, you can create priority ceiling mutexes
379 * Indicates the availability of:
380 * pthread_mutex_getprioceiling
381 * pthread_mutex_setprioceiling
382 * pthread_mutexattr_getprioceiling
383 * pthread_mutexattr_getprotocol +
384 * pthread_mutexattr_setprioceiling
385 * pthread_mutexattr_setprotocol +
386 *
387 * _POSIX_THREAD_PROCESS_SHARED (== -1)
388 * If set, you can create mutexes and condition
389 * variables that can be shared with another
390 * process.If set, indicates the availability
391 * of:
392 * pthread_mutexattr_getpshared
393 * pthread_mutexattr_setpshared
394 * pthread_condattr_getpshared
395 * pthread_condattr_setpshared
396 *
397 * _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L)
398 * If == 200112L you can use the special *_r library
399 * functions that provide thread-safe behaviour
400 *
401 * _POSIX_READER_WRITER_LOCKS (== 200112L)
402 * If == 200112L, you can use read/write locks
403 *
404 * _POSIX_SPIN_LOCKS (== 200112L)
405 * If == 200112L, you can use spin locks
406 *
407 * _POSIX_BARRIERS (== 200112L)
408 * If == 200112L, you can use barriers
409 *
410 * + These functions provide both 'inherit' and/or
411 * 'protect' protocol, based upon these macro
412 * settings.
413 *
414 * -------------------------------------------------------------
415 */
416
417/*
418 * POSIX Options
419 */
420#undef _POSIX_THREADS
421#define _POSIX_THREADS 200112L
422
423#undef _POSIX_READER_WRITER_LOCKS
424#define _POSIX_READER_WRITER_LOCKS 200112L
425
426#undef _POSIX_SPIN_LOCKS
427#define _POSIX_SPIN_LOCKS 200112L
428
429#undef _POSIX_BARRIERS
430#define _POSIX_BARRIERS 200112L
431
432#undef _POSIX_THREAD_SAFE_FUNCTIONS
433#define _POSIX_THREAD_SAFE_FUNCTIONS 200112L
434
435#undef _POSIX_THREAD_ATTR_STACKSIZE
436#define _POSIX_THREAD_ATTR_STACKSIZE 200112L
437
438/*
439 * The following options are not supported
440 */
441#undef _POSIX_THREAD_ATTR_STACKADDR
442#define _POSIX_THREAD_ATTR_STACKADDR -1
443
444#undef _POSIX_THREAD_PRIO_INHERIT
445#define _POSIX_THREAD_PRIO_INHERIT -1
446
447#undef _POSIX_THREAD_PRIO_PROTECT
448#define _POSIX_THREAD_PRIO_PROTECT -1
449
450/* TPS is not fully supported. */
451#undef _POSIX_THREAD_PRIORITY_SCHEDULING
452#define _POSIX_THREAD_PRIORITY_SCHEDULING -1
453
454#undef _POSIX_THREAD_PROCESS_SHARED
455#define _POSIX_THREAD_PROCESS_SHARED -1
456
457
458/*
459 * POSIX 1003.1-2001 Limits
460 * ===========================
461 *
462 * These limits are normally set in <limits.h>, which is not provided with
463 * pthreads-win32.
464 *
465 * PTHREAD_DESTRUCTOR_ITERATIONS
466 * Maximum number of attempts to destroy
467 * a thread's thread-specific data on
468 * termination (must be at least 4)
469 *
470 * PTHREAD_KEYS_MAX
471 * Maximum number of thread-specific data keys
472 * available per process (must be at least 128)
473 *
474 * PTHREAD_STACK_MIN
475 * Minimum supported stack size for a thread
476 *
477 * PTHREAD_THREADS_MAX
478 * Maximum number of threads supported per
479 * process (must be at least 64).
480 *
481 * SEM_NSEMS_MAX
482 * The maximum number of semaphores a process can have.
483 * (must be at least 256)
484 *
485 * SEM_VALUE_MAX
486 * The maximum value a semaphore can have.
487 * (must be at least 32767)
488 *
489 */
490#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
491#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
492
493#undef PTHREAD_DESTRUCTOR_ITERATIONS
494#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
495
496#undef _POSIX_THREAD_KEYS_MAX
497#define _POSIX_THREAD_KEYS_MAX 128
498
499#undef PTHREAD_KEYS_MAX
500#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX
501
502#undef PTHREAD_STACK_MIN
503#define PTHREAD_STACK_MIN 0
504
505#undef _POSIX_THREAD_THREADS_MAX
506#define _POSIX_THREAD_THREADS_MAX 64
507
508 /* Arbitrary value */
509#undef PTHREAD_THREADS_MAX
510#define PTHREAD_THREADS_MAX 2019
511
512#undef _POSIX_SEM_NSEMS_MAX
513#define _POSIX_SEM_NSEMS_MAX 256
514
515 /* Arbitrary value */
516#undef SEM_NSEMS_MAX
517#define SEM_NSEMS_MAX 1024
518
519#undef _POSIX_SEM_VALUE_MAX
520#define _POSIX_SEM_VALUE_MAX 32767
521
522#undef SEM_VALUE_MAX
523#define SEM_VALUE_MAX INT_MAX
524
525
526#if __GNUC__ && ! defined (__declspec)
527# error Please upgrade your GNU compiler to one that supports __declspec.
528#endif
529
530/*
531 * When building the DLL code, you should define PTW32_BUILD so that
532 * the variables/functions are exported correctly. When using the DLL,
533 * do NOT define PTW32_BUILD, and then the variables/functions will
534 * be imported correctly.
535 */
536#ifndef PTW32_STATIC_LIB
537# ifdef PTW32_BUILD
538# define PTW32_DLLPORT __declspec (dllexport)
539# else
540# define PTW32_DLLPORT __declspec (dllimport)
541# endif
542#else
543# define PTW32_DLLPORT
544#endif
545
546/*
547 * The Open Watcom C/C++ compiler uses a non-standard calling convention
548 * that passes function args in registers unless __cdecl is explicitly specified
549 * in exposed function prototypes.
550 *
551 * We force all calls to cdecl even though this could slow Watcom code down
552 * slightly. If you know that the Watcom compiler will be used to build both
553 * the DLL and application, then you can probably define this as a null string.
554 * Remember that pthread.h (this file) is used for both the DLL and application builds.
555 */
556#define PTW32_CDECL __cdecl
557
558#if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX
559# include <sys/types.h>
560#else
561/*
562 * Generic handle type - intended to extend uniqueness beyond
563 * that available with a simple pointer. It should scale for either
564 * IA-32 or IA-64.
565 */
566typedef struct {
567 void * p; /* Pointer to actual object */
568 unsigned int x; /* Extra information - reuse count etc */
569} ptw32_handle_t;
570
571typedef ptw32_handle_t pthread_t;
572typedef struct pthread_attr_t_ * pthread_attr_t;
573typedef struct pthread_once_t_ pthread_once_t;
574typedef struct pthread_key_t_ * pthread_key_t;
575typedef struct pthread_mutex_t_ * pthread_mutex_t;
576typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t;
577typedef struct pthread_cond_t_ * pthread_cond_t;
578typedef struct pthread_condattr_t_ * pthread_condattr_t;
579#endif
580typedef struct pthread_rwlock_t_ * pthread_rwlock_t;
581typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t;
582typedef struct pthread_spinlock_t_ * pthread_spinlock_t;
583typedef struct pthread_barrier_t_ * pthread_barrier_t;
584typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t;
585
586/*
587 * ====================
588 * ====================
589 * POSIX Threads
590 * ====================
591 * ====================
592 */
593
594enum {
595/*
596 * pthread_attr_{get,set}detachstate
597 */
598 PTHREAD_CREATE_JOINABLE = 0, /* Default */
599 PTHREAD_CREATE_DETACHED = 1,
600
601/*
602 * pthread_attr_{get,set}inheritsched
603 */
604 PTHREAD_INHERIT_SCHED = 0,
605 PTHREAD_EXPLICIT_SCHED = 1, /* Default */
606
607/*
608 * pthread_{get,set}scope
609 */
610 PTHREAD_SCOPE_PROCESS = 0,
611 PTHREAD_SCOPE_SYSTEM = 1, /* Default */
612
613/*
614 * pthread_setcancelstate paramters
615 */
616 PTHREAD_CANCEL_ENABLE = 0, /* Default */
617 PTHREAD_CANCEL_DISABLE = 1,
618
619/*
620 * pthread_setcanceltype parameters
621 */
622 PTHREAD_CANCEL_ASYNCHRONOUS = 0,
623 PTHREAD_CANCEL_DEFERRED = 1, /* Default */
624
625/*
626 * pthread_mutexattr_{get,set}pshared
627 * pthread_condattr_{get,set}pshared
628 */
629 PTHREAD_PROCESS_PRIVATE = 0,
630 PTHREAD_PROCESS_SHARED = 1,
631
632/*
633 * pthread_barrier_wait
634 */
635 PTHREAD_BARRIER_SERIAL_THREAD = -1
636};
637
638/*
639 * ====================
640 * ====================
641 * Cancelation
642 * ====================
643 * ====================
644 */
645#define PTHREAD_CANCELED ((void *) -1)
646
647
648/*
649 * ====================
650 * ====================
651 * Once Key
652 * ====================
653 * ====================
654 */
655#define PTHREAD_ONCE_INIT { PTW32_FALSE, 0, 0, 0}
656
657struct pthread_once_t_
658{
659 int done; /* indicates if user function has been executed */
660 void * lock;
661 int reserved1;
662 int reserved2;
663};
664
665
666/*
667 * ====================
668 * ====================
669 * Object initialisers
670 * ====================
671 * ====================
672 */
673#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)
674#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t) -2)
675#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t) -3)
676
677/*
678 * Compatibility with LinuxThreads
679 */
680#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER
681#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
682
683#define PTHREAD_COND_INITIALIZER ((pthread_cond_t) -1)
684
685#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) -1)
686
687#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t) -1)
688
689
690/*
691 * Mutex types.
692 */
693enum
694{
695 /* Compatibility with LinuxThreads */
696 PTHREAD_MUTEX_FAST_NP,
697 PTHREAD_MUTEX_RECURSIVE_NP,
698 PTHREAD_MUTEX_ERRORCHECK_NP,
699 PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
700 PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
701 /* For compatibility with POSIX */
702 PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
703 PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
704 PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
705 PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
706};
707
708
709typedef struct ptw32_cleanup_t ptw32_cleanup_t;
710
711#if defined(_MSC_VER)
712/* Disable MSVC 'anachronism used' warning */
713#pragma warning( disable : 4229 )
714#endif
715
716typedef void (* PTW32_CDECL ptw32_cleanup_callback_t)(void *);
717
718#if defined(_MSC_VER)
719#pragma warning( default : 4229 )
720#endif
721
722struct ptw32_cleanup_t
723{
724 ptw32_cleanup_callback_t routine;
725 void *arg;
726 struct ptw32_cleanup_t *prev;
727};
728
729#ifdef __CLEANUP_SEH
730 /*
731 * WIN32 SEH version of cancel cleanup.
732 */
733
734#define pthread_cleanup_push( _rout, _arg ) \
735 { \
736 ptw32_cleanup_t _cleanup; \
737 \
738 _cleanup.routine = (ptw32_cleanup_callback_t)(_rout); \
739 _cleanup.arg = (_arg); \
740 __try \
741 { \
742
743#define pthread_cleanup_pop( _execute ) \
744 } \
745 __finally \
746 { \
747 if( _execute || AbnormalTermination()) \
748 { \
749 (*(_cleanup.routine))( _cleanup.arg ); \
750 } \
751 } \
752 }
753
754#else /* __CLEANUP_SEH */
755
756#ifdef __CLEANUP_C
757
758 /*
759 * C implementation of PThreads cancel cleanup
760 */
761
762#define pthread_cleanup_push( _rout, _arg ) \
763 { \
764 ptw32_cleanup_t _cleanup; \
765 \
766 ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \
767
768#define pthread_cleanup_pop( _execute ) \
769 (void) ptw32_pop_cleanup( _execute ); \
770 }
771
772#else /* __CLEANUP_C */
773
774#ifdef __CLEANUP_CXX
775
776 /*
777 * C++ version of cancel cleanup.
778 * - John E. Bossom.
779 */
780
781 class PThreadCleanup {
782 /*
783 * PThreadCleanup
784 *
785 * Purpose
786 * This class is a C++ helper class that is
787 * used to implement pthread_cleanup_push/
788 * pthread_cleanup_pop.
789 * The destructor of this class automatically
790 * pops the pushed cleanup routine regardless
791 * of how the code exits the scope
792 * (i.e. such as by an exception)
793 */
794 ptw32_cleanup_callback_t cleanUpRout;
795 void * obj;
796 int executeIt;
797
798 public:
799 PThreadCleanup() :
800 cleanUpRout( 0 ),
801 obj( 0 ),
802 executeIt( 0 )
803 /*
804 * No cleanup performed
805 */
806 {
807 }
808
809 PThreadCleanup(
810 ptw32_cleanup_callback_t routine,
811 void * arg ) :
812 cleanUpRout( routine ),
813 obj( arg ),
814 executeIt( 1 )
815 /*
816 * Registers a cleanup routine for 'arg'
817 */
818 {
819 }
820
821 ~PThreadCleanup()
822 {
823 if ( executeIt && ((void *) cleanUpRout != (void *) 0) )
824 {
825 (void) (*cleanUpRout)( obj );
826 }
827 }
828
829 void execute( int exec )
830 {
831 executeIt = exec;
832 }
833 };
834
835 /*
836 * C++ implementation of PThreads cancel cleanup;
837 * This implementation takes advantage of a helper
838 * class who's destructor automatically calls the
839 * cleanup routine if we exit our scope weirdly
840 */
841#define pthread_cleanup_push( _rout, _arg ) \
842 { \
843 PThreadCleanup cleanup((ptw32_cleanup_callback_t)(_rout), \
844 (void *) (_arg) );
845
846#define pthread_cleanup_pop( _execute ) \
847 cleanup.execute( _execute ); \
848 }
849
850#else
851
852#error ERROR [__FILE__, line __LINE__]: Cleanup type undefined.
853
854#endif /* __CLEANUP_CXX */
855
856#endif /* __CLEANUP_C */
857
858#endif /* __CLEANUP_SEH */
859
860/*
861 * ===============
862 * ===============
863 * Methods
864 * ===============
865 * ===============
866 */
867
868/*
869 * PThread Attribute Functions
870 */
871PTW32_DLLPORT int PTW32_CDECL pthread_attr_init (pthread_attr_t * attr);
872
873PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr);
874
875PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr,
876 int *detachstate);
877
878PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr,
879 void **stackaddr);
880
881PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr,
882 size_t * stacksize);
883
884PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr,
885 int detachstate);
886
887PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr,
888 void *stackaddr);
889
890PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr,
891 size_t stacksize);
892
893PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr,
894 struct sched_param *param);
895
896PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr,
897 const struct sched_param *param);
898
899PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *,
900 int);
901
902PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy (pthread_attr_t *,
903 int *);
904
905PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr,
906 int inheritsched);
907
908PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(pthread_attr_t * attr,
909 int * inheritsched);
910
911PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope (pthread_attr_t *,
912 int);
913
914PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *,
915 int *);
916
917/*
918 * PThread Functions
919 */
920PTW32_DLLPORT int PTW32_CDECL pthread_create (pthread_t * tid,
921 const pthread_attr_t * attr,
922 void *(*start) (void *),
923 void *arg);
924
925PTW32_DLLPORT int PTW32_CDECL pthread_detach (pthread_t tid);
926
927PTW32_DLLPORT int PTW32_CDECL pthread_equal (pthread_t t1,
928 pthread_t t2);
929
930PTW32_DLLPORT void PTW32_CDECL pthread_exit (void *value_ptr);
931
932PTW32_DLLPORT int PTW32_CDECL pthread_join (pthread_t thread,
933 void **value_ptr);
934
935PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self (void);
936
937PTW32_DLLPORT int PTW32_CDECL pthread_cancel (pthread_t thread);
938
939PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate (int state,
940 int *oldstate);
941
942PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype (int type,
943 int *oldtype);
944
945PTW32_DLLPORT void PTW32_CDECL pthread_testcancel (void);
946
947PTW32_DLLPORT int PTW32_CDECL pthread_once (pthread_once_t * once_control,
948 void (*init_routine) (void));
949
950#if PTW32_LEVEL >= PTW32_LEVEL_MAX
951PTW32_DLLPORT ptw32_cleanup_t * PTW32_CDECL ptw32_pop_cleanup (int execute);
952
953PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
954 void (*routine) (void *),
955 void *arg);
956#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
957
958/*
959 * Thread Specific Data Functions
960 */
961PTW32_DLLPORT int PTW32_CDECL pthread_key_create (pthread_key_t * key,
962 void (*destructor) (void *));
963
964PTW32_DLLPORT int PTW32_CDECL pthread_key_delete (pthread_key_t key);
965
966PTW32_DLLPORT int PTW32_CDECL pthread_setspecific (pthread_key_t key,
967 const void *value);
968
969PTW32_DLLPORT void * PTW32_CDECL pthread_getspecific (pthread_key_t key);
970
971
972/*
973 * Mutex Attribute Functions
974 */
975PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr);
976
977PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
978
979PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t
980 * attr,
981 int *pshared);
982
983PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
984 int pshared);
985
986PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
987PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *kind);
988
989/*
990 * Barrier Attribute Functions
991 */
992PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr);
993
994PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
995
996PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t
997 * attr,
998 int *pshared);
999
1000PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
1001 int pshared);
1002
1003/*
1004 * Mutex Functions
1005 */
1006PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex,
1007 const pthread_mutexattr_t * attr);
1008
1009PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex);
1010
1011PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex);
1012
1013PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t *mutex,
1014 const struct timespec *abstime);
1015
1016PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex);
1017
1018PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex);
1019
1020/*
1021 * Spinlock Functions
1022 */
1023PTW32_DLLPORT int PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared);
1024
1025PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock);
1026
1027PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock);
1028
1029PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock);
1030
1031PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock);
1032
1033/*
1034 * Barrier Functions
1035 */
1036PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier,
1037 const pthread_barrierattr_t * attr,
1038 unsigned int count);
1039
1040PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier);
1041
1042PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier);
1043
1044/*
1045 * Condition Variable Attribute Functions
1046 */
1047PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr);
1048
1049PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr);
1050
1051PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr,
1052 int *pshared);
1053
1054PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr,
1055 int pshared);
1056
1057/*
1058 * Condition Variable Functions
1059 */
1060PTW32_DLLPORT int PTW32_CDECL pthread_cond_init (pthread_cond_t * cond,
1061 const pthread_condattr_t * attr);
1062
1063PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond);
1064
1065PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond,
1066 pthread_mutex_t * mutex);
1067
1068PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond,
1069 pthread_mutex_t * mutex,
1070 const struct timespec *abstime);
1071
1072PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond);
1073
1074PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond);
1075
1076/*
1077 * Scheduling
1078 */
1079PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam (pthread_t thread,
1080 int policy,
1081 const struct sched_param *param);
1082
1083PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam (pthread_t thread,
1084 int *policy,
1085 struct sched_param *param);
1086
1087PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency (int);
1088
1089PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency (void);
1090
1091/*
1092 * Read-Write Lock Functions
1093 */
1094PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock,
1095 const pthread_rwlockattr_t *attr);
1096
1097PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock);
1098
1099PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *);
1100
1101PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *);
1102
1103PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock);
1104
1105PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
1106 const struct timespec *abstime);
1107
1108PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock);
1109
1110PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
1111 const struct timespec *abstime);
1112
1113PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock);
1114
1115PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
1116
1117PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
1118
1119PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr,
1120 int *pshared);
1121
1122PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr,
1123 int pshared);
1124
1125#if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1
1126
1127/*
1128 * Signal Functions. Should be defined in <signal.h> but MSVC and MinGW32
1129 * already have signal.h that don't define these.
1130 */
1131PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig);
1132
1133/*
1134 * Non-portable functions
1135 */
1136
1137/*
1138 * Compatibility with Linux.
1139 */
1140PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr,
1141 int kind);
1142PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr,
1143 int *kind);
1144
1145/*
1146 * Possibly supported by other POSIX threads implementations
1147 */
1148PTW32_DLLPORT int PTW32_CDECL pthread_delay_np (struct timespec * interval);
1149PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void);
1150
1151/*
1152 * Useful if an application wants to statically link
1153 * the lib rather than load the DLL at run-time.
1154 */
1155PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void);
1156PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void);
1157PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void);
1158PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void);
1159
1160/*
1161 * Features that are auto-detected at load/run time.
1162 */
1163PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int);
1164enum ptw32_features {
1165 PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001, /* System provides it. */
1166 PTW32_ALERTABLE_ASYNC_CANCEL = 0x0002 /* Can cancel blocked threads. */
1167};
1168
1169/*
1170 * Register a system time change with the library.
1171 * Causes the library to perform various functions
1172 * in response to the change. Should be called whenever
1173 * the application's top level window receives a
1174 * WM_TIMECHANGE message. It can be passed directly to
1175 * pthread_create() as a new thread if desired.
1176 */
1177PTW32_DLLPORT void * PTW32_CDECL pthread_timechange_handler_np(void *);
1178
1179#endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */
1180
1181#if PTW32_LEVEL >= PTW32_LEVEL_MAX
1182
1183/*
1184 * Returns the Win32 HANDLE for the POSIX thread.
1185 */
1186PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread);
1187
1188
1189/*
1190 * Protected Methods
1191 *
1192 * This function blocks until the given WIN32 handle
1193 * is signaled or pthread_cancel had been called.
1194 * This function allows the caller to hook into the
1195 * PThreads cancel mechanism. It is implemented using
1196 *
1197 * WaitForMultipleObjects
1198 *
1199 * on 'waitHandle' and a manually reset WIN32 Event
1200 * used to implement pthread_cancel. The 'timeout'
1201 * argument to TimedWait is simply passed to
1202 * WaitForMultipleObjects.
1203 */
1204PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait (HANDLE waitHandle);
1205PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait (HANDLE waitHandle,
1206 DWORD timeout);
1207
1208#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
1209
1210/*
1211 * Thread-Safe C Runtime Library Mappings.
1212 */
1213#ifndef _UWIN
1214# if defined(NEED_ERRNO)
1215 PTW32_DLLPORT int * PTW32_CDECL _errno( void );
1216# else
1217# ifndef errno
1218# if (defined(_MT) || defined(_DLL))
1219 __declspec(dllimport) extern int * __cdecl _errno(void);
1220# define errno (*_errno())
1221# endif
1222# endif
1223# endif
1224#endif
1225
1226/*
1227 * WIN32 C runtime library had been made thread-safe
1228 * without affecting the user interface. Provide
1229 * mappings from the UNIX thread-safe versions to
1230 * the standard C runtime library calls.
1231 * Only provide function mappings for functions that
1232 * actually exist on WIN32.
1233 */
1234
1235#if !defined(__MINGW32__)
1236#define strtok_r( _s, _sep, _lasts ) \
1237 ( *(_lasts) = strtok( (_s), (_sep) ) )
1238#endif /* !__MINGW32__ */
1239
1240#define asctime_r( _tm, _buf ) \
1241 ( strcpy( (_buf), asctime( (_tm) ) ), \
1242 (_buf) )
1243
1244#define ctime_r( _clock, _buf ) \
1245 ( strcpy( (_buf), ctime( (_clock) ) ), \
1246 (_buf) )
1247
1248#define gmtime_r( _clock, _result ) \
1249 ( *(_result) = *gmtime( (_clock) ), \
1250 (_result) )
1251
1252#define localtime_r( _clock, _result ) \
1253 ( *(_result) = *localtime( (_clock) ), \
1254 (_result) )
1255
1256#define rand_r( _seed ) \
1257 ( _seed == _seed? rand() : rand() )
1258
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#ifdef __cplusplus
1269
1270/*
1271 * Internal exceptions
1272 */
1273class ptw32_exception {};
1274class ptw32_exception_cancel : public ptw32_exception {};
1275class 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 */
1285PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void);
1286
1287#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
1288
1289#ifndef PTW32_BUILD
1290
1291#ifdef __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#ifdef __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#ifdef _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#ifndef 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(" #ifdef 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#ifdef __cplusplus
1353} /* End of extern "C" */
1354#endif /* __cplusplus */
1355
1356#ifdef PTW32__HANDLE_DEF
1357# undef HANDLE
1358#endif
1359#ifdef 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 */
libcec Piment Noir Debian package repository