开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
pthread.h
资源名称：200731318535356.rar　[点击查看]
上传用户：fzchengxin
上传日期：2013-10-17
资源大小：2070k
文件大小：34k
源码类别：

Windows编程

开发平台：

Visual C++

pthread.h：源码内容
  1. /* This is the POSIX thread API (POSIX 1003).
  2.  *
  3.  * --------------------------------------------------------------------------
  4.  *
  5.  * Pthreads-win32 - POSIX Threads Library for Win32
  6.  * Copyright(C) 1998 John E. Bossom
  7.  * Copyright(C) 1999,2002 Pthreads-win32 contributors
  8.  * 
  9.  * Contact Email: rpj@ise.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. #if !defined( PTHREAD_H )
  33. #define PTHREAD_H
  34. #undef PTW32_LEVEL
  35. #if defined(_POSIX_SOURCE)
  36. #define PTW32_LEVEL 0
  37. /* Early POSIX */
  38. #endif
  39. #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
  40. #undef PTW32_LEVEL
  41. #define PTW32_LEVEL 1
  42. /* Include 1b, 1c and 1d */
  43. #endif
  44. #if defined(INCLUDE_NP)
  45. #undef PTW32_LEVEL
  46. #define PTW32_LEVEL 2
  47. /* Include Non-Portable extensions */
  48. #endif
  49. #define PTW32_LEVEL_MAX 3
  50. #if !defined(PTW32_LEVEL)
  51. #define PTW32_LEVEL PTW32_LEVEL_MAX
  52. /* Include everything */
  53. #endif
  54. #ifdef _UWIN
  55. #   define HAVE_STRUCT_TIMESPEC 1
  56. #   define HAVE_SIGNAL_H 1
  57. #   undef HAVE_CONFIG_H
  58. #   pragma comment(lib, "pthread")
  59. #endif
  60. /*
  61.  * -------------------------------------------------------------
  62.  *
  63.  *
  64.  * Module: pthread.h
  65.  *
  66.  * Purpose:
  67.  * Provides an implementation of PThreads based upon the
  68.  * standard:
  69.  *
  70.  * POSIX 1003.1c-1995 (POSIX.1c)
  71.  *
  72.  * Parts of the implementation also comply with the
  73.  * Open Group Unix 98 specification in order to enhance
  74.  * code portability between Windows, various commercial
  75.  * Unix implementations, and Linux.
  76.  *
  77.  * See the ANNOUNCE file for a full list of conforming
  78.  * routines and defined constants, and a list of missing
  79.  * routines and constants not defined in this implementation.
  80.  *
  81.  * Authors:
  82.  * There have been many contributors to this library.
  83.  * The initial implementation was contributed by
  84.  * John Bossom, and several others have provided major
  85.  * sections or revisions of parts of the implementation.
  86.  * Often significant effort has been contributed to
  87.  * find and fix important bugs and other problems to
  88.  * improve the reliability of the library, which sometimes
  89.  * is not reflected in the amount of code which changed as
  90.  * result.
  91.  * As much as possible, the contributors are acknowledged
  92.  * in the ChangeLog file in the source code distribution
  93.  * where their changes are noted in detail.
  94.  *
  95.  * Contributors are listed in the CONTRIBUTORS file.
  96.  *
  97.  * As usual, all bouquets go to the contributors, and all
  98.  * brickbats go to the project maintainer.
  99.  *
  100.  * Maintainer:
  101.  * The code base for this project is coordinated and
  102.  * eventually pre-tested, packaged, and made available by
  103.  *
  104.  * Ross Johnson <rpj@ise.canberra.edu.au>
  105.  *
  106.  * QA Testers:
  107.  * Ultimately, the library is tested in the real world by
  108.  * a host of competent and demanding scientists and
  109.  * engineers who report bugs and/or provide solutions
  110.  * which are then fixed or incorporated into subsequent
  111.  * versions of the library. Each time a bug is fixed, a
  112.  * test case is written to prove the fix and ensure
  113.  * that later changes to the code don't reintroduce the
  114.  * same error. The number of test cases is slowly growing
  115.  * and therefore so is the code reliability.
  116.  *
  117.  * Compliance:
  118.  * See the file ANNOUNCE for the list of implemented
  119.  * and not-implemented routines and defined options.
  120.  * Of course, these are all defined is this file as well.
  121.  *
  122.  * Web site:
  123.  * The source code and other information about this library
  124.  * are available from
  125.  *
  126.  * http://sources.redhat.com/pthreads-win32/
  127.  *
  128.  * -------------------------------------------------------------
  129.  */
  130. /* Try to avoid including windows.h */
  131. #if defined(__MINGW32__) && defined(__cplusplus)
  132. /*
  133.  * FIXME: The pthreadGCE.dll build gets linker unresolved errors
  134.  * on pthread_key_create() unless windows.h is included here.
  135.  * It appears to have something to do with an argument type mismatch.
  136.  * Looking at tsd.o with 'nm' shows this line:
  137.  * 00000000 T _pthread_key_create__FPP14pthread_key_t_PFPv_v
  138.  * instead of
  139.  * 00000000 T _pthread_key_create
  140.  */
  141. #define PTW32_INCLUDE_WINDOWS_H
  142. #endif
  143. #ifdef PTW32_INCLUDE_WINDOWS_H
  144. #include <windows.h>
  145. #endif
  146. /*
  147.  * -----------------
  148.  * autoconf switches
  149.  * -----------------
  150.  */
  151. #if HAVE_CONFIG_H
  152. #include "config.h"
  153. #endif /* HAVE_CONFIG_H */
  154. #if PTW32_LEVEL >= PTW32_LEVEL_MAX
  155. /* Try to avoid including windows.h */
  156. #if defined(__MINGW32__) && defined(__cplusplus)
  157. /*
  158.  * FIXME: The pthreadGCE.dll build gets linker unresolved errors
  159.  * on pthread_key_create() unless windows.h is included here.
  160.  * It appears to have something to do with an argument type mismatch.
  161.  * Looking at tsd.o with 'nm' shows this line:
  162.  * 00000000 T _pthread_key_create__FPP14pthread_key_t_PFPv_v
  163.  * instead of
  164.  * 00000000 T _pthread_key_create
  165.  */
  166. #define PTW32_INCLUDE_WINDOWS_H
  167. #endif
  168. #ifdef PTW32_INCLUDE_WINDOWS_H
  169. #include <windows.h>
  170. #endif
  171. #ifndef NEED_FTIME
  172. #include <time.h>
  173. #else /* NEED_FTIME */
  174. /* use native WIN32 time API */
  175. #endif /* NEED_FTIME */
  176. #if HAVE_SIGNAL_H
  177. #include <signal.h>
  178. #endif /* HAVE_SIGNAL_H */
  179. #include <setjmp.h>
  180. /*
  181.  * This is a duplicate of what is in the autoconf config.h,
  182.  * which is only used when building the pthread-win32 libraries.
  183.  */
  184. #ifndef PTW32_CONFIG_H
  185. #  if defined(WINCE)
  186. #    define NEED_ERRNO
  187. #    define NEED_SEM
  188. #  endif
  189. #  if defined(_UWIN) || defined(__MINGW32__)
  190. #    define HAVE_MODE_T
  191. #  endif
  192. #endif
  193. /*
  194.  *
  195.  */
  196. #if PTW32_LEVEL >= PTW32_LEVEL_MAX
  197. #ifdef NEED_ERRNO
  198. #include "need_errno.h"
  199. #else
  200. #include <errno.h>
  201. #endif
  202. #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
  203. /*
  204.  * Several systems don't define ENOTSUP. If not, we use
  205.  * the same value as Solaris.
  206.  */
  207. #ifndef ENOTSUP
  208. #  define ENOTSUP 48
  209. #endif
  210. #ifndef ETIMEDOUT
  211. #  define ETIMEDOUT 10060     /* This is the value in winsock.h. */
  212. #endif
  213. #include <sched.h>
  214. /*
  215.  * To avoid including windows.h we define only those things that we
  216.  * actually need from it. I don't like the potential incompatibility that
  217.  * this creates with future versions of windows.
  218.  */
  219. #ifndef PTW32_INCLUDE_WINDOWS_H
  220. #ifndef HANDLE
  221. # define PTW32__HANDLE_DEF
  222. # define HANDLE void *
  223. #endif
  224. #ifndef DWORD
  225. # define PTW32__DWORD_DEF
  226. # define DWORD unsigned long
  227. #endif
  228. #endif
  229. #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
  230. #ifndef HAVE_STRUCT_TIMESPEC
  231. struct timespec {
  232. long tv_sec;
  233. long tv_nsec;
  234. };
  235. #endif /* HAVE_STRUCT_TIMESPEC */
  236. #ifndef SIG_BLOCK
  237. #define SIG_BLOCK 0
  238. #endif /* SIG_BLOCK */
  239. #ifndef SIG_UNBLOCK 
  240. #define SIG_UNBLOCK 1
  241. #endif /* SIG_UNBLOCK */
  242. #ifndef SIG_SETMASK
  243. #define SIG_SETMASK 2
  244. #endif /* SIG_SETMASK */
  245. #ifdef __cplusplus
  246. extern "C"
  247. {
  248. #endif /* __cplusplus */
  249. /*
  250.  * -------------------------------------------------------------
  251.  *
  252.  * POSIX 1003.1c-1995 Options
  253.  * ===========================
  254.  *
  255.  * _POSIX_THREADS (set)
  256.  * If set, you can use threads
  257.  *
  258.  * _POSIX_THREAD_ATTR_STACKSIZE (set)
  259.  * If set, you can control the size of a thread's
  260.  * stack
  261.  * pthread_attr_getstacksize
  262.  * pthread_attr_setstacksize
  263.  *
  264.  * _POSIX_THREAD_ATTR_STACKADDR (not set)
  265.  * If set, you can allocate and control a thread's
  266.  * stack. If not supported, the following functions
  267.  * will return ENOSYS, indicating they are not
  268.  * supported:
  269.  * pthread_attr_getstackaddr
  270.  * pthread_attr_setstackaddr
  271.  *
  272.  * _POSIX_THREAD_PRIORITY_SCHEDULING (set)
  273.  * If set, you can use realtime scheduling.
  274.  * Indicates the availability of:
  275.  * pthread_attr_getinheritsched
  276.  * pthread_attr_getschedparam
  277.  * pthread_attr_getschedpolicy
  278.  * pthread_attr_getscope
  279.  * pthread_attr_setinheritsched
  280.  * pthread_attr_setschedparam
  281.  * pthread_attr_setschedpolicy
  282.  * pthread_attr_setscope
  283.  * pthread_getschedparam
  284.  * pthread_setschedparam
  285.  * sched_get_priority_max
  286.  * sched_get_priority_min
  287.  * sched_rr_set_interval
  288.  *
  289.  * _POSIX_THREAD_PRIO_INHERIT (not set)
  290.  * If set, you can create priority inheritance
  291.  * mutexes.
  292.  * pthread_mutexattr_getprotocol +
  293.  * pthread_mutexattr_setprotocol +
  294.  *
  295.  * _POSIX_THREAD_PRIO_PROTECT (not set)
  296.  * If set, you can create priority ceiling mutexes
  297.  * Indicates the availability of:
  298.  * pthread_mutex_getprioceiling
  299.  * pthread_mutex_setprioceiling
  300.  * pthread_mutexattr_getprioceiling
  301.  * pthread_mutexattr_getprotocol   +
  302.  * pthread_mutexattr_setprioceiling
  303.  * pthread_mutexattr_setprotocol   +
  304.  *
  305.  * _POSIX_THREAD_PROCESS_SHARED (not set)
  306.  * If set, you can create mutexes and condition
  307.  * variables that can be shared with another
  308.  * process.If set, indicates the availability
  309.  * of:
  310.  * pthread_mutexattr_getpshared
  311.  * pthread_mutexattr_setpshared
  312.  * pthread_condattr_getpshared
  313.  * pthread_condattr_setpshared
  314.  *
  315.  * _POSIX_THREAD_SAFE_FUNCTIONS (set)
  316.  * If set you can use the special *_r library
  317.  * functions that provide thread-safe behaviour
  318.  *
  319.  * + These functions provide both 'inherit' and/or
  320.  *   'protect' protocol, based upon these macro
  321.  *   settings.
  322.  *
  323.  * POSIX 1003.1c-1995 Limits
  324.  * ===========================
  325.  *
  326.  * PTHREAD_DESTRUCTOR_ITERATIONS
  327.  * Maximum number of attempts to destroy
  328.  * a thread's thread-specific data on
  329.  * termination (must be at least 4)
  330.  *
  331.  * PTHREAD_KEYS_MAX
  332.  * Maximum number of thread-specific data keys
  333.  * available per process (must be at least 128)
  334.  *
  335.  * PTHREAD_STACK_MIN
  336.  * Minimum supported stack size for a thread
  337.  *
  338.  * PTHREAD_THREADS_MAX
  339.  * Maximum number of threads supported per
  340.  * process (must be at least 64).
  341.  *
  342.  *
  343.  * POSIX 1003.1j/D10-1999 Options
  344.  * ==============================
  345.  *
  346.  * _POSIX_READER_WRITER_LOCKS (set)
  347.  * If set, you can use read/write locks
  348.  *
  349.  * _POSIX_SPIN_LOCKS (set)
  350.  * If set, you can use spin locks
  351.  *
  352.  * _POSIX_BARRIERS (set)
  353.  * If set, you can use barriers
  354.  *
  355.  * -------------------------------------------------------------
  356.  */
  357. /*
  358.  * POSIX Options
  359.  */
  360. #ifndef _POSIX_THREADS
  361. #define _POSIX_THREADS
  362. #endif
  363. #ifndef _POSIX_READER_WRITER_LOCKS
  364. #define _POSIX_READER_WRITER_LOCKS
  365. #endif
  366. #ifndef _POSIX_SPIN_LOCKS
  367. #define _POSIX_SPIN_LOCKS
  368. #endif
  369. #ifndef _POSIX_BARRIERS
  370. #define _POSIX_BARRIERS
  371. #endif
  372. #define _POSIX_THREAD_SAFE_FUNCTIONS
  373. #define _POSIX_THREAD_ATTR_STACKSIZE
  374. #define _POSIX_THREAD_PRIORITY_SCHEDULING
  375. #if defined( KLUDGE )
  376. /*
  377.  * The following are not supported
  378.  */
  379. #define _POSIX_THREAD_ATTR_STACKADDR
  380. #define _POSIX_THREAD_PRIO_INHERIT
  381. #define _POSIX_THREAD_PRIO_PROTECT
  382. #define _POSIX_THREAD_PROCESS_SHARED
  383. #endif /* KLUDGE */
  384. /*
  385.  * POSIX Limits
  386.  *
  387.  * PTHREAD_DESTRUCTOR_ITERATIONS
  388.  * Standard states this must be at least
  389.  * 4.
  390.  *
  391.  * PTHREAD_KEYS_MAX
  392.  * WIN32 permits only 64 TLS keys per process.
  393.  * This limitation could be worked around by
  394.  * simply simulating keys.
  395.  *
  396.  * PTHREADS_STACK_MIN
  397.  * POSIX specifies 0 which is also the value WIN32
  398.  * interprets as allowing the system to
  399.  * set the size to that of the main thread. The
  400.  * maximum stack size in Win32 is 1Meg. WIN32
  401.  * allocates more stack as required up to the 1Meg
  402.  * limit.
  403.  *
  404.  * PTHREAD_THREADS_MAX
  405.  * Not documented by WIN32. Wrote a test program
  406.  * that kept creating threads until it failed
  407.  * revealed this approximate number (Windows NT).
  408.  * This number is somewhat less for Windows 9x
  409.  * and is effectively less than 64. Perhaps this
  410.  * constant should be set at DLL load time.
  411.  *
  412.  */
  413. #define PTHREAD_DESTRUCTOR_ITERATIONS    4
  414. #define PTHREAD_KEYS_MAX   64
  415. #define PTHREAD_STACK_MIN    0
  416. #define PTHREAD_THREADS_MAX 2019
  417. #if __GNUC__ && ! defined (__declspec)
  418. # error Please upgrade your GNU compiler to one that supports __declspec.
  419. #endif
  420. /*
  421.  * When building the DLL code, you should define PTW32_BUILD so that
  422.  * the variables/functions are exported correctly. When using the DLL,
  423.  * do NOT define PTW32_BUILD, and then the variables/functions will
  424.  * be imported correctly.
  425.  */
  426. #ifdef _DLL
  427. #  ifdef PTW32_BUILD
  428. #    define PTW32_DLLPORT __declspec (dllexport)
  429. #  else
  430. #    define PTW32_DLLPORT __declspec (dllimport)
  431. #  endif
  432. #endif
  433. #if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX
  434. #   include <sys/types.h>
  435. #else
  436. typedef struct pthread_t_ *pthread_t;
  437. typedef struct pthread_attr_t_ *pthread_attr_t;
  438. typedef struct pthread_once_t_ pthread_once_t;
  439. typedef struct pthread_key_t_ *pthread_key_t;
  440. typedef struct pthread_mutex_t_ *pthread_mutex_t;
  441. typedef struct pthread_mutexattr_t_ *pthread_mutexattr_t;
  442. typedef struct pthread_cond_t_ *pthread_cond_t;
  443. typedef struct pthread_condattr_t_ *pthread_condattr_t;
  444. #endif
  445. typedef struct pthread_rwlock_t_ *pthread_rwlock_t;
  446. typedef struct pthread_rwlockattr_t_ *pthread_rwlockattr_t;
  447. typedef struct pthread_spinlock_t_ *pthread_spinlock_t;
  448. typedef struct pthread_barrier_t_ *pthread_barrier_t;
  449. typedef struct pthread_barrierattr_t_ *pthread_barrierattr_t;
  450. /*
  451.  * ====================
  452.  * ====================
  453.  * POSIX Threads
  454.  * ====================
  455.  * ====================
  456.  */
  457. enum {
  458. /*
  459.  * pthread_attr_{get,set}detachstate
  460.  */
  461.   PTHREAD_CREATE_JOINABLE = 0,  /* Default */
  462.   PTHREAD_CREATE_DETACHED = 1,
  463. /*
  464.  * pthread_attr_{get,set}inheritsched
  465.  */
  466.   PTHREAD_INHERIT_SCHED  = 0,
  467.   PTHREAD_EXPLICIT_SCHED = 1,  /* Default */
  468. /*
  469.  * pthread_{get,set}scope
  470.  */
  471.   PTHREAD_SCOPE_PROCESS  = 0,
  472.   PTHREAD_SCOPE_SYSTEM = 1,  /* Default */
  473. /*
  474.  * pthread_setcancelstate paramters
  475.  */
  476.   PTHREAD_CANCEL_ENABLE  = 0,  /* Default */
  477.   PTHREAD_CANCEL_DISABLE = 1,
  478. /*
  479.  * pthread_setcanceltype parameters
  480.  */
  481.   PTHREAD_CANCEL_ASYNCHRONOUS = 0,
  482.   PTHREAD_CANCEL_DEFERRED = 1,  /* Default */
  483. /*
  484.  * pthread_mutexattr_{get,set}pshared
  485.  * pthread_condattr_{get,set}pshared
  486.  */
  487.   PTHREAD_PROCESS_PRIVATE = 0,
  488.   PTHREAD_PROCESS_SHARED = 1,
  489. /*
  490.  * pthread_barrier_wait
  491.  */
  492.   PTHREAD_BARRIER_SERIAL_THREAD = -1
  493. };
  494. /*
  495.  * ====================
  496.  * ====================
  497.  * Cancelation
  498.  * ====================
  499.  * ====================
  500.  */
  501. #define PTHREAD_CANCELED       ((void *) -1)
  502. /*
  503.  * ====================
  504.  * ====================
  505.  * Once Key
  506.  * ====================
  507.  * ====================
  508.  */
  509. #define PTHREAD_ONCE_INIT { FALSE, -1 }
  510. struct pthread_once_t_
  511. {
  512.   int done;     /* indicates if user function executed  */
  513.   long started;      /* First thread to increment this value */
  514.     /* to zero executes the user function   */
  515. };
  516. /*
  517.  * ====================
  518.  * ====================
  519.  * Object initialisers
  520.  * ====================
  521.  * ====================
  522.  */
  523. #define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)
  524. #define PTHREAD_COND_INITIALIZER ((pthread_cond_t) -1)
  525. #define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) -1)
  526. #define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t) -1)
  527. /*
  528.  * Mutex types.
  529.  */
  530. enum
  531. {
  532.   /* Compatibility with LinuxThreads */
  533.   PTHREAD_MUTEX_FAST_NP,
  534.   PTHREAD_MUTEX_RECURSIVE_NP,
  535.   PTHREAD_MUTEX_ERRORCHECK_NP,
  536.   PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
  537.   PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
  538.   /* For compatibility with POSIX */
  539.   PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
  540.   PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  541.   PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  542.   PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
  543. };
  544. /* There are three implementations of cancel cleanup.
  545.  * Note that pthread.h is included in both application
  546.  * compilation units and also internally for the library.
  547.  * The code here and within the library aims to work
  548.  * for all reasonable combinations of environments.
  549.  *
  550.  * The three implementations are:
  551.  *
  552.  *   WIN32 SEH
  553.  *   C
  554.  *   C++
  555.  *
  556.  * Please note that exiting a push/pop block via
  557.  * "return", "exit", "break", or "continue" will
  558.  * lead to different behaviour amongst applications
  559.  * depending upon whether the library was built
  560.  * using SEH, C++, or C. For example, a library built
  561.  * with SEH will call the cleanup routine, while both
  562.  * C++ and C built versions will not.
  563.  */
  564. /*
  565.  * Define defaults for cleanup code.
  566.  * Note: Unless the build explicitly defines one of the following, then
  567.  * we default to standard C style cleanup. This style uses setjmp/longjmp
  568.  * in the cancelation and thread exit implementations and therefore won't
  569.  * do stack unwinding if linked to applications that have it (e.g.
  570.  * C++ apps). This is currently consistent with most/all commercial Unix
  571.  * POSIX threads implementations.
  572.  */
  573. #if !defined( __CLEANUP_SEH ) && !defined( __CLEANUP_CXX ) && !defined( __CLEANUP_C )
  574. # define __CLEANUP_C
  575. #endif
  576. #if defined( __CLEANUP_SEH ) && defined(__GNUC__)
  577. #error ERROR [__FILE__, line __LINE__]: GNUC does not support SEH.
  578. #endif
  579. typedef struct ptw32_cleanup_t ptw32_cleanup_t;
  580. typedef void (__cdecl *ptw32_cleanup_callback_t)(void *);
  581. struct ptw32_cleanup_t
  582. {
  583.   ptw32_cleanup_callback_t routine;
  584.   void *arg;
  585.   struct ptw32_cleanup_t *prev;
  586. };
  587. #ifdef __CLEANUP_SEH
  588. /*
  589.  * WIN32 SEH version of cancel cleanup.
  590.  */
  591. #define pthread_cleanup_push( _rout, _arg ) 
  592. { 
  593.     ptw32_cleanup_t _cleanup; 
  594.     
  595. _cleanup.routine = (ptw32_cleanup_callback_t)(_rout); 
  596.     _cleanup.arg = (_arg); 
  597.     __try 
  598.       { 
  599. #define pthread_cleanup_pop( _execute ) 
  600.       } 
  601.     __finally 
  602. { 
  603.     if( _execute || AbnormalTermination()) 
  604.       { 
  605.   (*(_cleanup.routine))( _cleanup.arg ); 
  606.       } 
  607. } 
  608. }
  609. #else /* __CLEANUP_SEH */
  610. #ifdef __CLEANUP_C
  611. /*
  612.  * C implementation of PThreads cancel cleanup
  613.  */
  614. #define pthread_cleanup_push( _rout, _arg ) 
  615. { 
  616.     ptw32_cleanup_t _cleanup; 
  617.     
  618.     ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); 
  619. #define pthread_cleanup_pop( _execute ) 
  620.     (void) ptw32_pop_cleanup( _execute ); 
  621. }
  622. #else /* __CLEANUP_C */
  623. #ifdef __CLEANUP_CXX
  624. /*
  625.  * C++ version of cancel cleanup.
  626.  * - John E. Bossom.
  627.  */
  628. class PThreadCleanup {
  629.   /*
  630.    * PThreadCleanup
  631.    *
  632.    * Purpose
  633.    *   This class is a C++ helper class that is
  634.    *   used to implement pthread_cleanup_push/
  635.    *   pthread_cleanup_pop.
  636.    *   The destructor of this class automatically
  637.    *   pops the pushed cleanup routine regardless
  638.    *   of how the code exits the scope
  639.    *   (i.e. such as by an exception)
  640.    */
  641.       ptw32_cleanup_callback_t cleanUpRout;
  642.   void   *   obj;
  643.   int   executeIt;
  644. public:
  645.   PThreadCleanup() :
  646.     cleanUpRout( 0 ),
  647.     obj( 0 ),
  648.     executeIt( 0 )
  649.     /*
  650.      * No cleanup performed
  651.      */
  652.     {
  653.     }
  654.   PThreadCleanup(
  655.      ptw32_cleanup_callback_t routine,
  656.  void  *  arg ) :
  657.     cleanUpRout( routine ),
  658.     obj( arg ),
  659.     executeIt( 1 )
  660.     /*
  661.      * Registers a cleanup routine for 'arg'
  662.      */
  663.     {
  664.     }
  665.   ~PThreadCleanup()
  666.     {
  667.       if ( executeIt && ((void *) cleanUpRout != (void *) 0) )
  668. {
  669.   (void) (*cleanUpRout)( obj );
  670. }
  671.     }
  672.   void execute( int exec )
  673.     {
  674.       executeIt = exec;
  675.     }
  676. };
  677. /*
  678.  * C++ implementation of PThreads cancel cleanup;
  679.  * This implementation takes advantage of a helper
  680.  * class who's destructor automatically calls the
  681.  * cleanup routine if we exit our scope weirdly
  682.  */
  683. #define pthread_cleanup_push( _rout, _arg ) 
  684. { 
  685.     PThreadCleanup  cleanup((ptw32_cleanup_callback_t)(_rout), 
  686.     (void *) (_arg) );
  687. #define pthread_cleanup_pop( _execute ) 
  688.     cleanup.execute( _execute ); 
  689. }
  690. #else
  691. #error ERROR [__FILE__, line __LINE__]: Cleanup type undefined.
  692. #endif /* __CLEANUP_CXX */
  693. #endif /* __CLEANUP_C */
  694. #endif /* __CLEANUP_SEH */
  695. /*
  696.  * ===============
  697.  * ===============
  698.  * Methods
  699.  * ===============
  700.  * ===============
  701.  */
  702. /*
  703.  * PThread Attribute Functions
  704.  */
  705. PTW32_DLLPORT int pthread_attr_init (pthread_attr_t * attr);
  706. PTW32_DLLPORT int pthread_attr_destroy (pthread_attr_t * attr);
  707. PTW32_DLLPORT int pthread_attr_getdetachstate (const pthread_attr_t * attr,
  708.  int *detachstate);
  709. PTW32_DLLPORT int pthread_attr_getstackaddr (const pthread_attr_t * attr,
  710.        void **stackaddr);
  711. PTW32_DLLPORT int pthread_attr_getstacksize (const pthread_attr_t * attr,
  712.        size_t * stacksize);
  713. PTW32_DLLPORT int pthread_attr_setdetachstate (pthread_attr_t * attr,
  714.  int detachstate);
  715. PTW32_DLLPORT int pthread_attr_setstackaddr (pthread_attr_t * attr,
  716.        void *stackaddr);
  717. PTW32_DLLPORT int pthread_attr_setstacksize (pthread_attr_t * attr,
  718.        size_t stacksize);
  719. PTW32_DLLPORT int pthread_attr_getschedparam (const pthread_attr_t *attr,
  720. struct sched_param *param);
  721. PTW32_DLLPORT int pthread_attr_setschedparam (pthread_attr_t *attr,
  722. const struct sched_param *param);
  723. PTW32_DLLPORT int pthread_attr_setschedpolicy (pthread_attr_t *,
  724.  int);
  725. PTW32_DLLPORT int pthread_attr_getschedpolicy (pthread_attr_t *,
  726.  int *);
  727. PTW32_DLLPORT int pthread_attr_setinheritsched(pthread_attr_t * attr,
  728.  int inheritsched);
  729. PTW32_DLLPORT int pthread_attr_getinheritsched(pthread_attr_t * attr,
  730.  int * inheritsched);
  731. PTW32_DLLPORT int pthread_attr_setscope (pthread_attr_t *,
  732.    int);
  733. PTW32_DLLPORT int pthread_attr_getscope (const pthread_attr_t *,
  734.    int *);
  735. /*
  736.  * PThread Functions
  737.  */
  738. PTW32_DLLPORT int pthread_create (pthread_t * tid,
  739.     const pthread_attr_t * attr,
  740.     void *(*start) (void *),
  741.     void *arg);
  742. PTW32_DLLPORT int pthread_detach (pthread_t tid);
  743. PTW32_DLLPORT int pthread_equal (pthread_t t1,
  744.    pthread_t t2);
  745. PTW32_DLLPORT void pthread_exit (void *value_ptr);
  746. PTW32_DLLPORT int pthread_join (pthread_t thread,
  747.   void **value_ptr);
  748. PTW32_DLLPORT pthread_t pthread_self (void);
  749. PTW32_DLLPORT int pthread_cancel (pthread_t thread);
  750. PTW32_DLLPORT int pthread_setcancelstate (int state,
  751.     int *oldstate);
  752. PTW32_DLLPORT int pthread_setcanceltype (int type,
  753.    int *oldtype);
  754. PTW32_DLLPORT void pthread_testcancel (void);
  755. PTW32_DLLPORT int pthread_once (pthread_once_t * once_control,
  756.   void (*init_routine) (void));
  757. #if PTW32_LEVEL >= PTW32_LEVEL_MAX
  758. PTW32_DLLPORT ptw32_cleanup_t *ptw32_pop_cleanup (int execute);
  759. PTW32_DLLPORT void ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
  760.  void (*routine) (void *),
  761.  void *arg);
  762. #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
  763. /*
  764.  * Thread Specific Data Functions
  765.  */
  766. PTW32_DLLPORT int pthread_key_create (pthread_key_t * key,
  767. void (*destructor) (void *));
  768. PTW32_DLLPORT int pthread_key_delete (pthread_key_t key);
  769. PTW32_DLLPORT int pthread_setspecific (pthread_key_t key,
  770.  const void *value);
  771. PTW32_DLLPORT void *pthread_getspecific (pthread_key_t key);
  772. /*
  773.  * Mutex Attribute Functions
  774.  */
  775. PTW32_DLLPORT int pthread_mutexattr_init (pthread_mutexattr_t * attr);
  776. PTW32_DLLPORT int pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
  777. PTW32_DLLPORT int pthread_mutexattr_getpshared (const pthread_mutexattr_t
  778.   * attr,
  779.   int *pshared);
  780. PTW32_DLLPORT int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
  781.   int pshared);
  782. PTW32_DLLPORT int pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
  783. PTW32_DLLPORT int pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *kind);
  784. /*
  785.  * Barrier Attribute Functions
  786.  */
  787. PTW32_DLLPORT int pthread_barrierattr_init (pthread_barrierattr_t * attr);
  788. PTW32_DLLPORT int pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
  789. PTW32_DLLPORT int pthread_barrierattr_getpshared (const pthread_barrierattr_t
  790.     * attr,
  791.     int *pshared);
  792. PTW32_DLLPORT int pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
  793.     int pshared);
  794. /*
  795.  * Mutex Functions
  796.  */
  797. PTW32_DLLPORT int pthread_mutex_init (pthread_mutex_t * mutex,
  798. const pthread_mutexattr_t * attr);
  799. PTW32_DLLPORT int pthread_mutex_destroy (pthread_mutex_t * mutex);
  800. PTW32_DLLPORT int pthread_mutex_lock (pthread_mutex_t * mutex);
  801. PTW32_DLLPORT int pthread_mutex_timedlock(pthread_mutex_t *mutex,
  802.     const struct timespec *abstime);
  803. PTW32_DLLPORT int pthread_mutex_trylock (pthread_mutex_t * mutex);
  804. PTW32_DLLPORT int pthread_mutex_unlock (pthread_mutex_t * mutex);
  805. /*
  806.  * Spinlock Functions
  807.  */
  808. PTW32_DLLPORT int pthread_spin_init (pthread_spinlock_t * lock, int pshared);
  809. PTW32_DLLPORT int pthread_spin_destroy (pthread_spinlock_t * lock);
  810. PTW32_DLLPORT int pthread_spin_lock (pthread_spinlock_t * lock);
  811. PTW32_DLLPORT int pthread_spin_trylock (pthread_spinlock_t * lock);
  812. PTW32_DLLPORT int pthread_spin_unlock (pthread_spinlock_t * lock);
  813. /*
  814.  * Barrier Functions
  815.  */
  816. PTW32_DLLPORT int pthread_barrier_init (pthread_barrier_t * barrier,
  817.   const pthread_barrierattr_t * attr,
  818.   unsigned int count);
  819. PTW32_DLLPORT int pthread_barrier_destroy (pthread_barrier_t * barrier);
  820. PTW32_DLLPORT int pthread_barrier_wait (pthread_barrier_t * barrier);
  821. /*
  822.  * Condition Variable Attribute Functions
  823.  */
  824. PTW32_DLLPORT int pthread_condattr_init (pthread_condattr_t * attr);
  825. PTW32_DLLPORT int pthread_condattr_destroy (pthread_condattr_t * attr);
  826. PTW32_DLLPORT int pthread_condattr_getpshared (const pthread_condattr_t * attr,
  827.  int *pshared);
  828. PTW32_DLLPORT int pthread_condattr_setpshared (pthread_condattr_t * attr,
  829.  int pshared);
  830. /*
  831.  * Condition Variable Functions
  832.  */
  833. PTW32_DLLPORT int pthread_cond_init (pthread_cond_t * cond,
  834.        const pthread_condattr_t * attr);
  835. PTW32_DLLPORT int pthread_cond_destroy (pthread_cond_t * cond);
  836. PTW32_DLLPORT int pthread_cond_wait (pthread_cond_t * cond,
  837.        pthread_mutex_t * mutex);
  838. PTW32_DLLPORT int pthread_cond_timedwait (pthread_cond_t * cond,
  839.     pthread_mutex_t * mutex,
  840.     const struct timespec *abstime);
  841. PTW32_DLLPORT int pthread_cond_signal (pthread_cond_t * cond);
  842. PTW32_DLLPORT int pthread_cond_broadcast (pthread_cond_t * cond);
  843. /*
  844.  * Scheduling
  845.  */
  846. PTW32_DLLPORT int pthread_setschedparam (pthread_t thread,
  847.    int policy,
  848.    const struct sched_param *param);
  849. PTW32_DLLPORT int pthread_getschedparam (pthread_t thread,
  850.    int *policy,
  851.    struct sched_param *param);
  852. PTW32_DLLPORT int pthread_setconcurrency (int);
  853.  
  854. PTW32_DLLPORT int pthread_getconcurrency (void);
  855. /*
  856.  * Read-Write Lock Functions
  857.  */
  858. PTW32_DLLPORT int pthread_rwlock_init(pthread_rwlock_t *lock,
  859. const pthread_rwlockattr_t *attr);
  860. PTW32_DLLPORT int pthread_rwlock_destroy(pthread_rwlock_t *lock);
  861. PTW32_DLLPORT int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
  862. PTW32_DLLPORT int pthread_rwlock_trywrlock(pthread_rwlock_t *);
  863. PTW32_DLLPORT int pthread_rwlock_rdlock(pthread_rwlock_t *lock);
  864. PTW32_DLLPORT int pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
  865.        const struct timespec *abstime);
  866. PTW32_DLLPORT int pthread_rwlock_wrlock(pthread_rwlock_t *lock);
  867. PTW32_DLLPORT int pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
  868.        const struct timespec *abstime);
  869. PTW32_DLLPORT int pthread_rwlock_unlock(pthread_rwlock_t *lock);
  870. PTW32_DLLPORT int pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
  871. PTW32_DLLPORT int pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
  872. PTW32_DLLPORT int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr,
  873.    int *pshared);
  874. PTW32_DLLPORT int pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr,
  875.    int pshared);
  876. #if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1
  877. /*
  878.  * Non-portable functions
  879.  */
  880. /*
  881.  * Compatibility with Linux.
  882.  */
  883. PTW32_DLLPORT int pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr,
  884.  int kind);
  885. PTW32_DLLPORT int pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr,
  886.  int *kind);
  887. /*
  888.  * Possibly supported by other POSIX threads implementations
  889.  */
  890. PTW32_DLLPORT int pthread_delay_np (struct timespec * interval);
  891. PTW32_DLLPORT int pthread_num_processors_np(void);
  892. /*
  893.  * Useful if an application wants to statically link
  894.  * the lib rather than load the DLL at run-time.
  895.  */
  896. PTW32_DLLPORT int pthread_win32_process_attach_np(void);
  897. PTW32_DLLPORT int pthread_win32_process_detach_np(void);
  898. PTW32_DLLPORT int pthread_win32_thread_attach_np(void);
  899. PTW32_DLLPORT int pthread_win32_thread_detach_np(void);
  900. /*
  901.  * Register a system time change with the library.
  902.  * Causes the library to perform various functions
  903.  * in response to the change. Should be called whenever
  904.  * the application's top level window receives a
  905.  * WM_TIMECHANGE message. It can be passed directly to
  906.  * pthread_create() as a new thread if desired.
  907.  */
  908. PTW32_DLLPORT void * pthread_timechange_handler_np(void *);
  909. #endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */
  910. #if PTW32_LEVEL >= PTW32_LEVEL_MAX
  911. /*
  912.  * Returns the Win32 HANDLE for the POSIX thread.
  913.  */
  914. PTW32_DLLPORT HANDLE pthread_getw32threadhandle_np(pthread_t thread);
  915. /*
  916.  * Protected Methods
  917.  *
  918.  * This function blocks until the given WIN32 handle
  919.  * is signaled or pthread_cancel had been called.
  920.  * This function allows the caller to hook into the
  921.  * PThreads cancel mechanism. It is implemented using
  922.  *
  923.  * WaitForMultipleObjects
  924.  *
  925.  * on 'waitHandle' and a manually reset WIN32 Event
  926.  * used to implement pthread_cancel. The 'timeout'
  927.  * argument to TimedWait is simply passed to
  928.  * WaitForMultipleObjects.
  929.  */
  930. PTW32_DLLPORT int pthreadCancelableWait (HANDLE waitHandle);
  931. PTW32_DLLPORT int pthreadCancelableTimedWait (HANDLE waitHandle,
  932. DWORD timeout);
  933. #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
  934. /*
  935.  * Thread-Safe C Runtime Library Mappings.
  936.  */
  937. #ifndef _UWIN
  938. #  if defined(NEED_ERRNO)
  939.      PTW32_DLLPORT int * _errno( void );
  940. #  else
  941. #    ifndef errno
  942. #      if (defined(_MT) || defined(_DLL))
  943.  __declspec(dllimport) extern int * __cdecl _errno(void);
  944. #  define errno (*_errno())
  945. #      endif
  946. #    endif
  947. #  endif
  948. #endif
  949. /*
  950.  * WIN32 C runtime library had been made thread-safe
  951.  * without affecting the user interface. Provide
  952.  * mappings from the UNIX thread-safe versions to
  953.  * the standard C runtime library calls.
  954.  * Only provide function mappings for functions that
  955.  * actually exist on WIN32.
  956.  */
  957. #if !defined(__MINGW32__)
  958. #define strtok_r( _s, _sep, _lasts ) 
  959. ( *(_lasts) = strtok( (_s), (_sep) ) )
  960. #endif /* !__MINGW32__ */
  961. #define asctime_r( _tm, _buf ) 
  962. ( strcpy( (_buf), asctime( (_tm) ) ), 
  963.   (_buf) )
  964. #define ctime_r( _clock, _buf ) 
  965. ( strcpy( (_buf), ctime( (_clock) ) ),
  966.   (_buf) )
  967. #define gmtime_r( _clock, _result ) 
  968. ( *(_result) = *gmtime( (_clock) ), 
  969.   (_result) )
  970. #define localtime_r( _clock, _result ) 
  971. ( *(_result) = *localtime( (_clock) ), 
  972.   (_result) )
  973. #define rand_r( _seed ) 
  974. ( _seed == _seed? rand() : rand() )
  975. #ifdef __cplusplus
  976. /*
  977.  * Internal exceptions
  978.  */
  979. class ptw32_exception {};
  980. class ptw32_exception_cancel : public ptw32_exception {};
  981. class ptw32_exception_exit   : public ptw32_exception {};
  982. #endif
  983. #if PTW32_LEVEL >= PTW32_LEVEL_MAX
  984. /* FIXME: This is only required if the library was built using SEH */
  985. /*
  986.  * Get internal SEH tag
  987.  */
  988. PTW32_DLLPORT DWORD ptw32_get_exception_services_code(void);
  989. #endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
  990. #ifndef PTW32_BUILD
  991. #ifdef __CLEANUP_SEH
  992. /*
  993.  * Redefine the SEH __except keyword to ensure that applications
  994.  * propagate our internal exceptions up to the library's internal handlers.
  995.  */
  996. #define __except( E ) 
  997. __except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) 
  998.  ? EXCEPTION_CONTINUE_SEARCH : ( E ) )
  999. #endif /* __CLEANUP_SEH */
  1000. #ifdef __CLEANUP_CXX
  1001. /*
  1002.  * Redefine the C++ catch keyword to ensure that applications
  1003.  * propagate our internal exceptions up to the library's internal handlers.
  1004.  */
  1005. #ifdef _MSC_VER
  1006. /*
  1007.  * WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll'
  1008.  * if you want Pthread-Win32 cancelation and pthread_exit to work.
  1009.  */
  1010. #ifndef PtW32NoCatchWarn
  1011. #pragma message("Specify "/DPtW32NoCatchWarn" compiler flag to skip this message.")
  1012. #pragma message("------------------------------------------------------------------")
  1013. #pragma message("When compiling applications with MSVC++ and C++ exception handling:")
  1014. #pragma message("  Replace any 'catch( ... )' in routines called from POSIX threads")
  1015. #pragma message("  with 'PtW32CatchAll' or 'CATCHALL' if you want POSIX thread")
  1016. #pragma message("  cancelation and pthread_exit to work. For example:")
  1017. #pragma message("")
  1018. #pragma message("    #ifdef PtW32CatchAll")
  1019. #pragma message("      PtW32CatchAll")
  1020. #pragma message("    #else")
  1021. #pragma message("      catch(...)")
  1022. #pragma message("    #endif")
  1023. #pragma message("  {")
  1024. #pragma message("    /* Catchall block processing */")
  1025. #pragma message("  }")
  1026. #pragma message("------------------------------------------------------------------")
  1027. #endif
  1028. #define PtW32CatchAll 
  1029. catch( ptw32_exception & ) { throw; } 
  1030. catch( ... )
  1031. #else /* _MSC_VER */
  1032. #define catch( E ) 
  1033. catch( ptw32_exception & ) { throw; } 
  1034. catch( E )
  1035. #endif /* _MSC_VER */
  1036. #endif /* __CLEANUP_CXX */
  1037. #endif /* ! PTW32_BUILD */
  1038. #ifdef __cplusplus
  1039. } /* End of extern "C" */
  1040. #endif /* __cplusplus */
  1041. #ifdef PTW32__HANDLE_DEF
  1042. # undef HANDLE
  1043. #endif
  1044. #ifdef PTW32__DWORD_DEF
  1045. # undef DWORD
  1046. #endif
  1047. #undef PTW32_LEVEL
  1048. #undef PTW32_LEVEL_MAX
  1049. #endif /* PTHREAD_H */